Add owned Rust AST types

Author: soutaro

rust/ruby-rbs/src/ast/annotation.rs

@@ -0,0 +1,8 @@
+use crate::ast::location::LocationRange;
+use crate::ids::SymbolId;
+
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub struct Annotation {
+    pub string: SymbolId,
+    pub location: Option<LocationRange>,
+}

rust/ruby-rbs/src/ast/comment.rs

@@ -0,0 +1,8 @@
+use crate::ast::location::LocationRange;
+use crate::ids::SymbolId;
+
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub struct Comment {
+    pub string: SymbolId,
+    pub location: Option<LocationRange>,
+}

rust/ruby-rbs/src/ast/convert.rs

@@ -0,0 +1,124 @@
+/// A byte and character range in the source buffer.
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
+pub struct LocationRange {
+    pub start_char: u32,
+    pub start_byte: u32,
+    pub end_char: u32,
+    pub end_byte: u32,
+}
+
+impl LocationRange {
+    #[must_use]
+    pub fn new(start_char: u32, start_byte: u32, end_char: u32, end_byte: u32) -> Self {
+        Self {
+            start_char,
+            start_byte,
+            end_char,
+            end_byte,
+        }
+    }
+}
+
+/// ```rbs
+/// foo
+/// ^^^ name
+///
+/// foo[bar, baz]
+/// ^^^           name
+///    ^^^^^^^^^^ args
+/// ```
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub struct AliasLocation {
+    pub range: LocationRange,
+    pub name_range: LocationRange,
+    pub args_range: Option<LocationRange>,
+}
+
+/// ```rbs
+/// Foo
+/// ^^^ name
+///
+/// Foo[Bar, Baz]
+/// ^^^           name
+///    ^^^^^^^^^^ args
+/// ```
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub struct ClassInstanceLocation {
+    pub range: LocationRange,
+    pub name_range: LocationRange,
+    pub args_range: Option<LocationRange>,
+}
+
+/// ```rbs
+/// singleton(::Foo)
+///           ^^^^^  name
+/// ```
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub struct ClassSingletonLocation {
+    pub range: LocationRange,
+    pub name_range: LocationRange,
+    pub args_range: Option<LocationRange>,
+}
+
+/// ```rbs
+/// String name
+///        ^^^^ name
+/// ```
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub struct FunctionParamLocation {
+    pub range: LocationRange,
+    pub name_range: Option<LocationRange>,
+}
+
+/// ```rbs
+/// _Foo
+/// ^^^^ name
+///
+/// _Foo[Bar, Baz]
+/// ^^^^           name
+///     ^^^^^^^^^^ args
+/// ```
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub struct InterfaceLocation {
+    pub range: LocationRange,
+    pub name_range: LocationRange,
+    pub args_range: Option<LocationRange>,
+}
+
+/// ```rbs
+/// () -> void
+/// ^^^^^^^^^^     type
+///
+/// [A] () { () -> A } -> A
+/// ^^^                      type_params
+///     ^^^^^^^^^^^^^^^^^^^  type
+/// ```
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub struct MethodTypeLocation {
+    pub range: LocationRange,
+    pub type_range: LocationRange,
+    pub type_params_range: Option<LocationRange>,
+}
+
+/// ```rbs
+/// Key
+/// ^^^ name
+///
+/// unchecked out Elem < _ToJson > bot = untyped
+/// ^^^^^^^^^                                        unchecked
+///           ^^^                                    variance
+///               ^^^^                               name
+///                    ^^^^^^^^^                     upper_bound
+///                              ^^^^^               lower_bound
+///                                      ^^^^^^^^    default
+/// ```
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub struct TypeParamLocation {
+    pub range: LocationRange,
+    pub name_range: LocationRange,
+    pub variance_range: Option<LocationRange>,
+    pub unchecked_range: Option<LocationRange>,
+    pub upper_bound_range: Option<LocationRange>,
+    pub lower_bound_range: Option<LocationRange>,
+    pub default_range: Option<LocationRange>,
+}

rust/ruby-rbs/src/ast/location.rs

@@ -0,0 +1,11 @@
+use crate::ast::location::MethodTypeLocation;
+use crate::ast::type_param::TypeParam;
+use crate::ast::types::{BlockType, Function};
+
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub struct MethodType {
+    pub type_params: Vec<TypeParam>,
+    pub function: Function,
+    pub block: Option<BlockType>,
+    pub location: Option<MethodTypeLocation>,
+}

rust/ruby-rbs/src/ast/method_type.rs

@@ -0,0 +1,105 @@
+//! Owned pure-Rust AST data structures.
+//!
+//! The [`node`] module exposes borrowed wrappers over the C parser AST. This
+//! module is the Rust-owned representation that can be built from parser nodes,
+//! generated directly, or transformed without keeping the parser allocation
+//! alive.
+//!
+//! [`node`]: crate::node
+
+pub mod annotation;
+pub mod comment;
+pub mod convert;
+pub mod location;
+pub mod method_type;
+pub mod type_param;
+pub mod types;
+
+pub use annotation::Annotation;
+pub use comment::Comment;
+pub use convert::AstConverter;
+pub use location::{
+    AliasLocation, ClassInstanceLocation, ClassSingletonLocation, FunctionParamLocation,
+    InterfaceLocation, LocationRange, MethodTypeLocation, TypeParamLocation,
+};
+pub use method_type::MethodType;
+pub use type_param::{TypeParam, Variance};
+pub use types::{
+    AliasType, BaseType, BaseTypeKind, BlockType, ClassInstanceType, ClassSingletonType, Function,
+    FunctionParam, FunctionType, InterfaceType, IntersectionType, KeywordParam, Literal,
+    LiteralType, OptionalType, ProcType, RecordField, RecordKey, RecordType, TupleType, Type,
+    UnionType, UntypedFunctionType, VariableType,
+};
+
+#[cfg(test)]
+mod tests {
+    use crate::ast::{AstConverter, BaseType, BaseTypeKind, Literal, RecordKey, Type};
+    use crate::interner::StringInterner;
+    use crate::node::{Node, parse};
+    use crate::type_name::TypeNameInterner;
+
+    #[test]
+    fn builds_owned_type_ast() {
+        let ty = Type::Base(BaseType {
+            kind: BaseTypeKind::Any { todo: false },
+            location: None,
+        });
+
+        assert_eq!(
+            ty,
+            Type::Base(BaseType {
+                kind: BaseTypeKind::Any { todo: false },
+                location: None,
+            })
+        );
+    }
+
+    #[test]
+    fn converts_type_node_to_owned_ast() {
+        let signature = parse(
+            r#"type foo = {
+                name: String,
+                ?age: Integer,
+                active: true,
+                tags: Array[String | Symbol]
+            }"#,
+        )
+        .unwrap();
+
+        let Node::TypeAlias(alias) = signature.declarations().iter().next().unwrap() else {
+            panic!("expected type alias");
+        };
+
+        let mut strings = StringInterner::new();
+        let mut type_names = TypeNameInterner::new();
+        let mut converter = AstConverter::new(&mut strings, &mut type_names);
+        let ty = converter.convert_type(&alias.type_());
+
+        let Type::Record(record) = ty else {
+            panic!("expected record type");
+        };
+
+        assert_eq!(record.fields.len(), 4);
+        assert_eq!(
+            record.fields[0].key,
+            RecordKey::Symbol(strings.intern("name"))
+        );
+        assert!(record.fields[0].required);
+        assert_eq!(
+            record.fields[1].key,
+            RecordKey::Symbol(strings.intern("age"))
+        );
+        assert!(!record.fields[1].required);
+
+        let Type::Literal(literal) = &record.fields[2].ty else {
+            panic!("expected literal type");
+        };
+        assert_eq!(literal.literal, Literal::Bool(true));
+
+        let Type::ClassInstance(array) = &record.fields[3].ty else {
+            panic!("expected Array class instance");
+        };
+        assert_eq!(type_names.display(array.name, &strings), "Array");
+        assert_eq!(array.args.len(), 1);
+    }
+}

rust/ruby-rbs/src/ast/mod.rs

@@ -0,0 +1,21 @@
+use crate::ast::location::TypeParamLocation;
+use crate::ast::types::Type;
+use crate::ids::SymbolId;
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
+pub enum Variance {
+    Invariant,
+    Covariant,
+    Contravariant,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub struct TypeParam {
+    pub name: SymbolId,
+    pub variance: Variance,
+    pub upper_bound: Option<Type>,
+    pub lower_bound: Option<Type>,
+    pub default_type: Option<Type>,
+    pub unchecked: bool,
+    pub location: Option<TypeParamLocation>,
+}