Add owned AST directives

soutaro · soutaro · commit 17ea0ed520e8 · 2026-06-06T12:18:49.000+09:00
diff --git a/rust/ruby-rbs/src/ast/convert.rs b/rust/ruby-rbs/src/ast/convert.rs
@@ -5,13 +5,17 @@ use crate::ast::declarations::{
     Declaration, GlobalDeclaration, InterfaceDeclaration, ModuleAliasDeclaration,
     ModuleDeclaration, ModuleMember, ModuleSelf, TypeAliasDeclaration,
 };
+use crate::ast::directives::{
+    Directive, UseClause, UseDirective, UseSingleClause, UseWildcardClause,
+};
 use crate::ast::location::{
     AliasDeclarationLocation, AliasLocation, AliasMemberLocation, AttributeMemberLocation,
     ClassDeclarationLocation, ClassInstanceLocation, ClassSingletonLocation, ClassSuperLocation,
     ConstantDeclarationLocation, FunctionParamLocation, GlobalDeclarationLocation,
     InterfaceDeclarationLocation, InterfaceLocation, LocationRange, MethodDefinitionLocation,
     MethodTypeLocation, MixinMemberLocation, ModuleDeclarationLocation, ModuleSelfLocation,
-    TypeAliasDeclarationLocation, TypeParamLocation, VariableMemberLocation,
+    TypeAliasDeclarationLocation, TypeParamLocation, UseDirectiveLocation, UseSingleClauseLocation,
+    UseWildcardClauseLocation, VariableMemberLocation,
 };
 use crate::ast::members::{
     AliasKind, AliasMember, AttrAccessorMember, AttrReaderMember, AttrWriterMember, AttributeKind,
@@ -38,9 +42,10 @@ use crate::node::{
     FunctionTypeNode, GlobalNode, IncludeNode, InstanceVariableNode, InterfaceNode,
     InterfaceTypeNode, MethodDefinitionKind as NodeMethodDefinitionKind, MethodDefinitionNode,
     MethodDefinitionOverloadNode, MethodDefinitionVisibility as NodeMethodDefinitionVisibility,
-    MethodTypeNode, ModuleAliasNode, ModuleNode, ModuleSelfNode, Node, PrependNode, PrivateNode,
-    PublicNode, RBSLocationRange, SymbolNode, TypeAliasNode, TypeNameNode, TypeParamNode,
-    TypeParamVariance, UntypedFunctionTypeNode,
+    MethodTypeNode, ModuleAliasNode, ModuleNode, ModuleSelfNode, NamespaceNode, Node, PrependNode,
+    PrivateNode, PublicNode, RBSLocationRange, SymbolNode, TypeAliasNode, TypeNameNode,
+    TypeParamNode, TypeParamVariance, UntypedFunctionTypeNode, UseNode, UseSingleClauseNode,
+    UseWildcardClauseNode,
 };
 use crate::type_name::TypeNameInterner;
 
@@ -108,6 +113,13 @@ impl<'a> AstConverter<'a> {
         }
     }
 
+    pub fn convert_directive(&mut self, node: &Node<'_>) -> Directive {
+        match node {
+            Node::Use(node) => Directive::Use(self.convert_use_directive(node)),
+            _ => panic_expected("directive node while converting directive", node),
+        }
+    }
+
     pub fn convert_type(&mut self, node: &Node<'_>) -> Type {
         match node {
             Node::AliasType(node) => Type::Alias(self.convert_alias_type(node)),
@@ -245,6 +257,53 @@ impl<'a> AstConverter<'a> {
         }
     }
 
+    fn convert_use_directive(&mut self, node: &UseNode<'_>) -> UseDirective {
+        UseDirective {
+            clauses: self.convert_use_clauses(node.clauses()),
+            location: Some(UseDirectiveLocation {
+                range: convert_range(node.location()),
+                keyword_range: convert_range(node.keyword_location()),
+            }),
+        }
+    }
+
+    fn convert_use_clause(&mut self, node: &Node<'_>) -> UseClause {
+        match node {
+            Node::UseSingleClause(node) => UseClause::Single(self.convert_use_single_clause(node)),
+            Node::UseWildcardClause(node) => {
+                UseClause::Wildcard(self.convert_use_wildcard_clause(node))
+            }
+            _ => panic_expected("use clause node while converting use directive", node),
+        }
+    }
+
+    fn convert_use_single_clause(&mut self, node: &UseSingleClauseNode<'_>) -> UseSingleClause {
+        UseSingleClause {
+            type_name: self.convert_type_name(&node.type_name()),
+            new_name: node.new_name().map(|name| self.intern_symbol(&name)),
+            location: Some(UseSingleClauseLocation {
+                range: convert_range(node.location()),
+                type_name_range: convert_range(node.type_name_location()),
+                keyword_range: convert_optional_range(node.keyword_location()),
+                new_name_range: convert_optional_range(node.new_name_location()),
+            }),
+        }
+    }
+
+    fn convert_use_wildcard_clause(
+        &mut self,
+        node: &UseWildcardClauseNode<'_>,
+    ) -> UseWildcardClause {
+        UseWildcardClause {
+            namespace: self.convert_namespace(&node.namespace()),
+            location: Some(UseWildcardClauseLocation {
+                range: convert_range(node.location()),
+                namespace_range: convert_range(node.namespace_location()),
+                star_range: convert_range(node.star_location()),
+            }),
+        }
+    }
+
     fn convert_module_declaration(&mut self, node: &ModuleNode<'_>) -> ModuleDeclaration {
         ModuleDeclaration {
             name: self.convert_type_name(&node.name()),
@@ -757,6 +816,12 @@ impl<'a> AstConverter<'a> {
             .collect()
     }
 
+    fn convert_use_clauses(&mut self, list: crate::node::NodeList<'_>) -> Vec<UseClause> {
+        list.iter()
+            .map(|node| self.convert_use_clause(&node))
+            .collect()
+    }
+
     fn convert_class_members(&mut self, list: crate::node::NodeList<'_>) -> Vec<ClassMember> {
         list.iter()
             .map(|node| match node {
@@ -946,9 +1011,14 @@ impl<'a> AstConverter<'a> {
     }
 
     fn convert_type_name(&mut self, node: &TypeNameNode<'_>) -> TypeName {
-        let namespace = node.namespace();
-        let mut name = self.type_names.root(namespace.absolute());
-        for segment_node in namespace.path().iter() {
+        let name = self.convert_namespace(&node.namespace());
+        let final_segment = self.intern_symbol(&node.name());
+        self.type_names.append(name, final_segment)
+    }
+
+    fn convert_namespace(&mut self, node: &NamespaceNode<'_>) -> TypeName {
+        let mut name = self.type_names.root(node.absolute());
+        for segment_node in node.path().iter() {
             match segment_node {
                 Node::Symbol(segment) => {
                     let segment = self.intern_symbol(&segment);
@@ -960,8 +1030,7 @@ impl<'a> AstConverter<'a> {
                 ),
             }
         }
-        let final_segment = self.intern_symbol(&node.name());
-        self.type_names.append(name, final_segment)
+        name
     }
 
     fn intern_symbol(&mut self, node: &SymbolNode<'_>) -> SymbolId {
diff --git a/rust/ruby-rbs/src/ast/directives.rs b/rust/ruby-rbs/src/ast/directives.rs
@@ -0,0 +1,42 @@
+use crate::ast::location::{
+    ResolveTypeNamesDirectiveLocation, UseDirectiveLocation, UseSingleClauseLocation,
+    UseWildcardClauseLocation,
+};
+use crate::ids::{SymbolId, TypeName};
+
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub enum Directive {
+    Use(UseDirective),
+    ResolveTypeNames(ResolveTypeNamesDirective),
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub struct UseDirective {
+    pub clauses: Vec<UseClause>,
+    pub location: Option<UseDirectiveLocation>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub enum UseClause {
+    Single(UseSingleClause),
+    Wildcard(UseWildcardClause),
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub struct UseSingleClause {
+    pub type_name: TypeName,
+    pub new_name: Option<SymbolId>,
+    pub location: Option<UseSingleClauseLocation>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub struct UseWildcardClause {
+    pub namespace: TypeName,
+    pub location: Option<UseWildcardClauseLocation>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub struct ResolveTypeNamesDirective {
+    pub value: bool,
+    pub location: Option<ResolveTypeNamesDirectiveLocation>,
+}
diff --git a/rust/ruby-rbs/src/ast/location.rs b/rust/ruby-rbs/src/ast/location.rs
@@ -385,3 +385,55 @@ pub struct AliasMemberLocation {
     pub new_kind_range: Option<LocationRange>,
     pub old_kind_range: Option<LocationRange>,
 }
+
+/// ```rbs
+/// use Foo
+/// ^^^       keyword
+/// ```
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub struct UseDirectiveLocation {
+    pub range: LocationRange,
+    pub keyword_range: LocationRange,
+}
+
+/// ```rbs
+/// Foo::Bar
+/// ^^^^^^^^       type_name
+///
+/// Foo::Bar as X
+///          ^^    keyword
+///             ^  new_name
+/// ```
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub struct UseSingleClauseLocation {
+    pub range: LocationRange,
+    pub type_name_range: LocationRange,
+    pub keyword_range: Option<LocationRange>,
+    pub new_name_range: Option<LocationRange>,
+}
+
+/// ```rbs
+/// Foo::Bar::*
+/// ^^^^^^^^^^    namespace
+///           ^   star
+/// ```
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub struct UseWildcardClauseLocation {
+    pub range: LocationRange,
+    pub namespace_range: LocationRange,
+    pub star_range: LocationRange,
+}
+
+/// ```rbs
+/// # resolve-type-names: false
+///   ^^^^^^^^^^^^^^^^^^          keyword
+///                     ^         colon
+///                       ^^^^^   value
+/// ```
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub struct ResolveTypeNamesDirectiveLocation {
+    pub range: LocationRange,
+    pub keyword_range: LocationRange,
+    pub colon_range: LocationRange,
+    pub value_range: LocationRange,
+}
diff --git a/rust/ruby-rbs/src/ast/mod.rs b/rust/ruby-rbs/src/ast/mod.rs
@@ -11,6 +11,7 @@ pub mod annotation;
 pub mod comment;
 pub mod convert;
 pub mod declarations;
+pub mod directives;
 pub mod location;
 pub mod members;
 pub mod method_type;
@@ -25,13 +26,19 @@ pub use declarations::{
     Declaration, GlobalDeclaration, InterfaceDeclaration, ModuleAliasDeclaration,
     ModuleDeclaration, ModuleMember, ModuleSelf, TypeAliasDeclaration,
 };
+pub use directives::{
+    Directive, ResolveTypeNamesDirective, UseClause, UseDirective, UseSingleClause,
+    UseWildcardClause,
+};
 pub use location::{
     AliasDeclarationLocation, AliasLocation, AliasMemberLocation, AttributeMemberLocation,
     ClassDeclarationLocation, ClassInstanceLocation, ClassSingletonLocation, ClassSuperLocation,
     ConstantDeclarationLocation, FunctionParamLocation, GlobalDeclarationLocation,
     InterfaceDeclarationLocation, InterfaceLocation, LocationRange, MethodDefinitionLocation,
     MethodTypeLocation, MixinMemberLocation, ModuleDeclarationLocation, ModuleSelfLocation,
-    TypeAliasDeclarationLocation, TypeParamLocation, VariableMemberLocation,
+    ResolveTypeNamesDirectiveLocation, TypeAliasDeclarationLocation, TypeParamLocation,
+    UseDirectiveLocation, UseSingleClauseLocation, UseWildcardClauseLocation,
+    VariableMemberLocation,
 };
 pub use members::{
     AliasKind, AliasMember, AttrAccessorMember, AttrReaderMember, AttrWriterMember, AttributeKind,
@@ -51,8 +58,8 @@ pub use types::{
 #[cfg(test)]
 mod tests {
     use crate::ast::{
-        AstConverter, BaseType, BaseTypeKind, ClassMember, Declaration, IvarName, Literal, Member,
-        MethodKind, ModuleMember, RecordKey, Type,
+        AstConverter, BaseType, BaseTypeKind, ClassMember, Declaration, Directive, IvarName,
+        Literal, Member, MethodKind, ModuleMember, RecordKey, Type, UseClause,
     };
     use crate::interner::StringInterner;
     use crate::node::{Node, parse};
@@ -267,4 +274,54 @@ mod tests {
         };
         assert_eq!(type_names.display(module_alias.old_name, &strings), "NewM");
     }
+
+    #[test]
+    fn converts_directives_to_owned_ast() {
+        let signature = parse(
+            r#"
+                use Foo, Foo::Bar as FBar, Foo::Baz::*
+
+                class Foo
+                end
+            "#,
+        )
+        .unwrap();
+
+        let mut strings = StringInterner::new();
+        let mut type_names = TypeNameInterner::new();
+        let mut converter = AstConverter::new(&mut strings, &mut type_names);
+        let directives = signature
+            .directives()
+            .iter()
+            .map(|node| converter.convert_directive(&node))
+            .collect::<Vec<_>>();
+
+        assert_eq!(directives.len(), 1);
+
+        let Directive::Use(use_directive) = &directives[0] else {
+            panic!("expected use directive");
+        };
+        assert_eq!(use_directive.clauses.len(), 3);
+        assert!(use_directive.location.is_some());
+
+        let UseClause::Single(single) = &use_directive.clauses[0] else {
+            panic!("expected single use clause");
+        };
+        assert_eq!(type_names.display(single.type_name, &strings), "Foo");
+        assert_eq!(single.new_name, None);
+
+        let UseClause::Single(aliased) = &use_directive.clauses[1] else {
+            panic!("expected aliased single use clause");
+        };
+        assert_eq!(type_names.display(aliased.type_name, &strings), "Foo::Bar");
+        assert_eq!(aliased.new_name, Some(strings.intern("FBar")));
+        assert!(aliased.location.as_ref().unwrap().keyword_range.is_some());
+        assert!(aliased.location.as_ref().unwrap().new_name_range.is_some());
+
+        let UseClause::Wildcard(wildcard) = &use_directive.clauses[2] else {
+            panic!("expected wildcard use clause");
+        };
+        assert_eq!(type_names.display(wildcard.namespace, &strings), "Foo::Baz");
+        assert!(wildcard.location.is_some());
+    }
 }
