WIP name analysis.

ast-generator/src/ast_node/struct_ast_node.rs

@@ -36,6 +36,7 @@ pub fn make_struct_ast_node_impl(spec: &StructSpec) -> TokenStream {
                     }
                 }
                 MemberChildBuild::Boolean(_) => None,
+                MemberChildBuild::Special(_) => None,
             },
         })
         .filter(Option::is_some)

ast-generator/src/build_fn/struct_build_fn.rs

@@ -1,8 +1,6 @@
 use crate::deserialize::util::{make_build_fn_name, make_build_pair};
-use crate::spec::struct_spec::{
+use crate::spec::struct_spec::{MemberChildBuild, NodeMemberBuild, SpecialMemberBuild, StructChild, StructSpec, VecChild, VecChildBuild};
-    MemberChildBuild, NodeMemberBuild, StructChild, StructSpec, VecChild, VecChildBuild,
+use proc_macro2::{Ident, TokenStream};
-};
-use proc_macro2::TokenStream;
 use quote::{format_ident, quote};
 
 fn make_vec_child_holder(vec_child: &VecChild) -> TokenStream {
@@ -46,6 +44,7 @@ fn make_child_holder(child_spec: &StructChild) -> Option<TokenStream> {
                 Some(make_node_child_holder(member_child.name(), node_child))
             }
             MemberChildBuild::Boolean(_) => Some(make_boolean_child_holder(member_child.name())),
+            MemberChildBuild::Special(_) => None,
         },
     }
 }
@@ -83,33 +82,38 @@ fn make_boolean_member_child_match_action(name: &str) -> TokenStream {
     }
 }
 
-fn make_match_action(child_spec: &StructChild) -> TokenStream {
+fn make_rule_matcher(child_spec: &StructChild) -> Option<TokenStream> {    
     match child_spec {
-        StructChild::SkipChild(_) => quote! {},
+        StructChild::SkipChild(_) => None,
-        StructChild::VecChild(vec_child) => make_vec_child_match_action(vec_child),
+        StructChild::VecChild(vec_child) => {
-        StructChild::MemberChild(member_child) => match member_child.build() {
+            let rule_ident = format_ident!("{}", vec_child.rule());
-            MemberChildBuild::Node(node_child) => {
+            let action = make_vec_child_match_action(vec_child);
-                make_node_member_child_match_action(member_child.name(), node_child)
+            Some(quote! {
+                Rule::#rule_ident => { #action }
+            })
+        }
+        StructChild::MemberChild(member_child) => {
+            match member_child.build() {
+                MemberChildBuild::Node(node_member_build) => {
+                    let rule_ident = format_ident!("{}", member_child.rule());
+                    let action = make_node_member_child_match_action(
+                        member_child.name(),
+                        node_member_build
+                    );
+                    Some(quote! {
+                        Rule::#rule_ident => { #action }
+                    })
                 }
                 MemberChildBuild::Boolean(_) => {
-                make_boolean_member_child_match_action(member_child.name())
+                    let rule_ident = format_ident!("{}", member_child.rule());
+                    let action = make_boolean_member_child_match_action(member_child.name());
+                    Some(quote! {
+                        Rule::#rule_ident => { #action }
+                    })
                 }
-        },
+                MemberChildBuild::Special(_) => None
             }
         }
-
-fn make_rule_matcher(child_spec: &StructChild) -> TokenStream {
-    let rule_ident = match child_spec {
-        StructChild::SkipChild(skip_child) => format_ident!("{}", skip_child.rule()),
-        StructChild::VecChild(vec_child) => format_ident!("{}", vec_child.rule()),
-        StructChild::MemberChild(single_child) => format_ident!("{}", single_child.rule()),
-    };
-    let action = make_match_action(child_spec);
-
-    quote! {
-        Rule::#rule_ident => {
-            #action;
-        }
     }
 }
 
@@ -142,7 +146,7 @@ fn make_boolean_member_child_arg(name: &str) -> TokenStream {
     quote! { #child_ident }
 }
 
-fn make_child_arg(child_spec: &StructChild) -> Option<TokenStream> {
+fn make_child_arg(child_spec: &StructChild, pair_ident: &Ident) -> Option<TokenStream> {
     match child_spec {
         StructChild::SkipChild(_) => None,
         StructChild::VecChild(vec_child) => Some(make_vec_child_arg(vec_child)),
@@ -154,16 +158,31 @@ fn make_child_arg(child_spec: &StructChild) -> Option<TokenStream> {
             )),
             MemberChildBuild::Boolean(_) => {
                 Some(make_boolean_member_child_arg(member_child.name()))
+            },
+            MemberChildBuild::Special(special_member_build) => {
+                match special_member_build {
+                    SpecialMemberBuild::FileId => {
+                        Some(quote! { file_id })
                     }
+                    SpecialMemberBuild::Range => {
+                        Some(quote! { 
+                            Range {
+                                start: #pair_ident.as_span().start(),
+                                end: #pair_ident.as_span().end(),
+                            }
+                        })
+                    }
+                }
+            },
         },
     }
 }
 
-fn make_return_value_stream(build_spec: &StructSpec) -> TokenStream {
+fn make_return_value_stream(build_spec: &StructSpec, pair_ident: &Ident) -> TokenStream {
     let type_ident = format_ident!("{}", build_spec.build());
     let child_args = build_spec
         .children()
-        .map(|child| make_child_arg(child))
+        .map(|child| make_child_arg(child, pair_ident))
         .filter(|child_arg| child_arg.is_some())
         .map(|child_arg| child_arg.unwrap())
         .collect::<Vec<_>>();
@@ -201,7 +220,7 @@ pub fn make_struct_build_fn(build_spec: &StructSpec) -> TokenStream {
         }
     };
 
-    let new_stream = make_return_value_stream(build_spec);
+    let new_stream = make_return_value_stream(build_spec, &pair_ident);
 
     quote! {
         fn #build_fn_ident(file_id: usize, #pair_ident: Pair<Rule>) -> #return_type_ident {

ast-generator/src/deserialize/struct_spec.rs

@@ -12,22 +12,12 @@ fn deserialize_skip_child(props: &Yaml) -> StructChild {
 
 fn deserialize_vec_child(child_name: &str, props: &Yaml) -> StructChild {
     let rule = props["rule"].as_str().unwrap();
-    let kind = props["kind"].as_str()
+    let kind = props["kind"].as_str().unwrap_or(rule);
-        .unwrap_or(rule);
     if kind == "string" {
-        let build = VecChildBuild::String(VecChildStringBuild::new(
+        let build = VecChildBuild::String(VecChildStringBuild::new(&make_build_fn_name(rule)));
-            &make_build_fn_name(rule)
+        StructChild::VecChild(VecChild::new(child_name, rule, Box::new(build)))
-        ));
-        StructChild::VecChild(VecChild::new(
-            child_name,
-            rule,
-            Box::new(build),
-        ))
     } else {
-        let build = VecChildBuild::Node(VecChildNodeBuild::new(
+        let build = VecChildBuild::Node(VecChildNodeBuild::new(rule, &make_build_fn_name(rule)));
-            rule,
-            &make_build_fn_name(rule)
-        ));
         StructChild::VecChild(VecChild::new(child_name, rule, Box::new(build)))
     }
 }
@@ -66,9 +56,15 @@ fn deserialize_member_build(child_name: &str, rule: &str, props: &Yaml) -> Membe
         } else {
             panic!("Expected 'on' in 'boolean' in 'build' in {}", child_name);
         }
+    } else if props["special"].is_hash() {
+        match props["special"]["kind"].as_str().unwrap() {
+            "file_id" => MemberChildBuild::Special(SpecialMemberBuild::FileId),
+            "range" => MemberChildBuild::Special(SpecialMemberBuild::Range),
+            _ => panic!(),
+        }
     } else {
         panic!(
-            "Expected either of 'node' or 'boolean' in 'build' in {}",
+            "Expected one of 'node', 'boolean', or 'special' in 'build' in {}",
             child_name
         );
     }

ast-generator/src/pretty_print.rs

@@ -231,6 +231,7 @@ fn make_struct_p2_impl(struct_build_spec: &StructSpec) -> TokenStream {
                         writer.writeln_indented(&format!(#format_string, self.#child_ident()))?;
                     })
                 }
+                MemberChildBuild::Special(_) => None
             },
         })
         .filter(Option::is_some)

ast-generator/src/spec/struct_spec.rs

@@ -48,7 +48,7 @@ impl SkipChild {
 pub struct VecChild {
     name: String,
     rule: String,
-    build: Box<VecChildBuild>
+    build: Box<VecChildBuild>,
 }
 
 impl VecChild {
@@ -56,7 +56,7 @@ impl VecChild {
         Self {
             name: name.to_string(),
             rule: rule.to_string(),
-            build
+            build,
         }
     }
 
@@ -77,16 +77,18 @@ impl VecChild {
 
 pub enum VecChildBuild {
     String(VecChildStringBuild),
-    Node(VecChildNodeBuild)
+    Node(VecChildNodeBuild),
 }
 
 pub struct VecChildStringBuild {
-    with: String
+    with: String,
 }
 
 impl VecChildStringBuild {
     pub fn new(with: &str) -> Self {
-        Self { with: with.to_string() }
+        Self {
+            with: with.to_string(),
+        }
     }
 
     pub fn with(&self) -> &str {
@@ -96,14 +98,14 @@ impl VecChildStringBuild {
 
 pub struct VecChildNodeBuild {
     kind: String,
-    with: String
+    with: String,
 }
 
 impl VecChildNodeBuild {
     pub fn new(kind: &str, with: &str) -> Self {
         Self {
             kind: kind.to_string(),
-            with: with.to_string()
+            with: with.to_string(),
         }
     }
 
@@ -158,6 +160,7 @@ impl MemberChild {
 pub enum MemberChildBuild {
     Node(NodeMemberBuild),
     Boolean(BooleanMemberBuild),
+    Special(SpecialMemberBuild),
 }
 
 #[derive(Debug)]
@@ -208,5 +211,11 @@ impl BooleanMemberBuild {
 
 #[derive(Debug)]
 pub enum BooleanMemberBuildOn {
-    RulePresent
+    RulePresent,
+}
+
+#[derive(Debug)]
+pub enum SpecialMemberBuild {
+    FileId,
+    Range,
 }

ast-generator/src/type_gen/struct_type.rs

@@ -1,5 +1,6 @@
 use crate::spec::struct_spec::{
-    MemberChild, MemberChildBuild, StructChild, StructSpec, VecChild, VecChildBuild,
+    MemberChild, MemberChildBuild, SpecialMemberBuild, StructChild, StructSpec, VecChild,
+    VecChildBuild,
 };
 use proc_macro2::{Ident, TokenStream};
 use quote::{format_ident, quote};
@@ -75,6 +76,22 @@ fn make_member_child_accessors(member_child: &MemberChild) -> TokenStream {
                 }
             }
         }
+        MemberChildBuild::Special(special_member_build) => match special_member_build {
+            SpecialMemberBuild::FileId => {
+                quote! {
+                    pub fn file_id(&self) -> usize {
+                        self.file_id
+                    }
+                }
+            }
+            SpecialMemberBuild::Range => {
+                quote! {
+                    pub fn range(&self) -> Range<usize> {
+                        self.range
+                    }
+                }
+            }
+        },
     }
 }
 
@@ -118,6 +135,10 @@ fn make_member_child_type_ident(member_child: &MemberChild) -> TokenStream {
         MemberChildBuild::Boolean(_) => {
             quote! { bool }
         }
+        MemberChildBuild::Special(special_member_build) => match special_member_build {
+            SpecialMemberBuild::FileId => quote! { usize },
+            SpecialMemberBuild::Range => quote! { Range<usize> },
+        },
     }
 }
 

src/name_analysis/gather.rs

@@ -1,25 +1,62 @@
-use std::collections::HashMap;
+use crate::ast::ast_node::{AstNode, AstNodeRef};
-use crate::ast::ast_node::AstNodeRef;
+use crate::ast::node::{CompilationUnit, Identifier, UseStatement, UseStatementSuffix};
-use crate::ast::node::{CompilationUnit, Identifier};
-use crate::ast::walk::walk_depth_first;
 use crate::diagnostic::DmDiagnostic;
+use crate::name_analysis::symbol::source_definition::SourceDefinition;
+use crate::name_analysis::symbol::use_symbol::StarUseStatementSymbol;
+use crate::name_analysis::symbol::UseStatementSymbol;
 use crate::name_analysis::symbol_table::SymbolTable;
+use std::collections::HashMap;
 
-fn gather_identifier(identifier: &Identifier, symbol_table: &SymbolTable, identifier_scope_ids: &mut HashMap<Identifier, usize>) {
+fn gather_identifier(
+    identifier: &Identifier,
+    symbol_table: &SymbolTable,
+    identifier_scope_ids: &mut HashMap<Identifier, usize>,
+) {
     identifier_scope_ids.insert(identifier.clone(), symbol_table.current_scope_id());
 }
 
-pub fn gather_compilation_unit(
+fn gather_use_statement(
-    compilation_unit: &mut CompilationUnit,
+    use_statement: &UseStatement,
     symbol_table: &mut SymbolTable,
-    identifier_scope_ids: &mut HashMap<Identifier, usize>,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    walk_depth_first(compilation_unit, &mut |child| match child {
+    let mut fully_qualified_name = String::new();
-        AstNodeRef::Operator(_) => {}
+    for prefix in use_statement.prefixes() {
-        AstNodeRef::Identifier(identifier) => {
+        fully_qualified_name.push_str(&format!("{}::", prefix.identifier().name()));
-            gather_identifier(&identifier, symbol_table, identifier_scope_ids);
     }
+    match use_statement.suffix() {
+        UseStatementSuffix::Identifier(identifier) => {}
+        UseStatementSuffix::Star => {
+            let symbol_inner = StarUseStatementSymbol::new(
+                &fully_qualified_name,
+                Some(SourceDefinition::from_use_statement(use_statement)),
+            );
+            let symbol = UseStatementSymbol::Star(symbol_inner);
+            symbol_table.insert_use_statement_symbol(symbol);
+            todo!()
+        }
+        UseStatementSuffix::UseList(use_list) => {}
+    }
+}
+
+fn gather_node_children(
+    node: &impl AstNode,
+    symbol_table: &mut SymbolTable,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    for child in node.children() {
+        gather_node(child, symbol_table, diagnostics);
+    }
+}
+
+fn gather_node(
+    node: AstNodeRef,
+    symbol_table: &mut SymbolTable,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    match node {
+        AstNodeRef::Operator(_) => {}
+        AstNodeRef::Identifier(_) => {}
         AstNodeRef::FullyQualifiedName(_) => {}
         AstNodeRef::TypeUseList(_) => {}
         AstNodeRef::IdentifierList(_) => {}
@@ -37,9 +74,13 @@ pub fn gather_compilation_unit(
         AstNodeRef::Parameters(_) => {}
         AstNodeRef::Parameter(_) => {}
         AstNodeRef::ReturnType(_) => {}
-        AstNodeRef::CompilationUnit(_) => {}
+        AstNodeRef::CompilationUnit(compilation_unit) => {
+            gather_node_children(compilation_unit, symbol_table, diagnostics);
+        }
         AstNodeRef::ParentMod(_) => {}
-        AstNodeRef::UseStatement(_) => {}
+        AstNodeRef::UseStatement(use_statement) => {
+            gather_use_statement(use_statement, symbol_table, diagnostics);
+        }
         AstNodeRef::UseStatementPrefix(_) => {}
         AstNodeRef::UseStatementSuffix(_) => {}
         AstNodeRef::UseList(_) => {}
@@ -111,5 +152,14 @@ pub fn gather_compilation_unit(
         AstNodeRef::DString(_) => {}
         AstNodeRef::DStringExpression(_) => {}
         AstNodeRef::BacktickString(_) => {}
-    });
+    }
+}
+
+pub fn gather_compilation_unit(
+    compilation_unit: &mut CompilationUnit,
+    symbol_table: &mut SymbolTable,
+    identifier_scope_ids: &mut HashMap<Identifier, usize>,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    gather_node(compilation_unit.as_node_ref(), symbol_table, diagnostics);
 }

src/name_analysis/symbol/mod.rs

@@ -1,41 +1,13 @@
+pub(super) mod source_definition;
+pub(super) mod use_symbol;
+
 use crate::ast::node::Identifier;
+use source_definition::SourceDefinition;
 use std::cell::RefCell;
 use std::fmt::{Debug, Display, Formatter};
 use std::ops::Deref;
-use std::range::Range;
 use std::rc::Rc;
 
-#[derive(Clone, Debug)]
-pub struct SourceDefinition {
-    file_id: usize,
-    range: Range<usize>,
-}
-
-impl SourceDefinition {
-    pub fn from_identifier(identifier: &Identifier) -> Self {
-        SourceDefinition {
-            file_id: identifier.file_id(),
-            range: identifier.range(),
-        }
-    }
-
-    pub fn from_identifier_rc(identifier: Rc<RefCell<Identifier>>) -> Self {
-        let borrowed = identifier.borrow();
-        SourceDefinition {
-            file_id: borrowed.file_id(),
-            range: borrowed.range(),
-        }
-    }
-
-    pub fn file_id(&self) -> usize {
-        self.file_id
-    }
-
-    pub fn range(&self) -> Range<usize> {
-        self.range.clone()
-    }
-}
-
 pub trait SymbolInner {
     fn declared_name(&self) -> &str;
     fn definition(&self) -> Option<SourceDefinition>;

src/name_analysis/symbol/source_definition.rs

@@ -0,0 +1,42 @@
+use std::cell::RefCell;
+use std::range::Range;
+use std::rc::Rc;
+use crate::ast::node::{Identifier, UseStatement};
+
+#[derive(Clone, Debug)]
+pub struct SourceDefinition {
+    file_id: usize,
+    range: Range<usize>,
+}
+
+impl SourceDefinition {
+    pub fn from_identifier(identifier: &Identifier) -> Self {
+        SourceDefinition {
+            file_id: identifier.file_id(),
+            range: identifier.range(),
+        }
+    }
+
+    pub fn from_identifier_rc(identifier: Rc<RefCell<Identifier>>) -> Self {
+        let borrowed = identifier.borrow();
+        SourceDefinition {
+            file_id: borrowed.file_id(),
+            range: borrowed.range(),
+        }
+    }
+    
+    pub fn from_use_statement(use_statement: &UseStatement) -> Self {
+        Self {
+            file_id: use_statement.file_id(),
+            range: use_statement.range(),
+        }
+    }
+
+    pub fn file_id(&self) -> usize {
+        self.file_id
+    }
+
+    pub fn range(&self) -> Range<usize> {
+        self.range.clone()
+    }
+}

src/name_analysis/symbol/use_symbol.rs

@@ -0,0 +1,28 @@
+use crate::name_analysis::symbol::source_definition::SourceDefinition;
+
+pub enum UseStatementSymbol {
+    Concrete,
+    Star(StarUseStatementSymbol),
+}
+
+pub struct StarUseStatementSymbol {
+    base_fqn: String,
+    source_definition: Option<SourceDefinition>,
+}
+
+impl StarUseStatementSymbol {
+    pub fn new(base_fqn: &str, source_definition: Option<SourceDefinition>) -> Self {
+        Self {
+            base_fqn: base_fqn.to_string(),
+            source_definition,
+        }
+    }
+
+    pub fn base_fqn(&self) -> &str {
+        &self.base_fqn
+    }
+
+    pub fn source_definition(&self) -> Option<&SourceDefinition> {
+        self.source_definition.as_ref()
+    }
+}

src/parser/ast.schema.yaml

@@ -148,6 +148,7 @@ $defs:
     oneOf:
       - $ref: "#/$defs/StructChildMemberBuildNodeHash"
       - $ref: "#/$defs/StructChildMemberBuildBooleanHash"
+      - $ref: "#/$defs/StructChildMemberBuildSpecialHash"
   StructChildMemberBuildNodeHash:
     type: object
     additionalProperties: false
@@ -190,6 +191,24 @@ $defs:
           - rule_present
     required:
       - on
+  StructChildMemberBuildSpecialHash:
+    type: object
+    additionalProperties: false
+    description: A special member to be built.
+    properties: 
+      special:
+        type: object
+        additionalProperties: false
+        properties: 
+          kind:
+            type: string
+            enum:
+              - file_id
+              - range
+        required:
+          - kind
+    required:
+      - special
 
   # Leaf Struct Node
   LeafStructNodeDefinition:

src/parser/ast.yaml

@@ -214,6 +214,16 @@ UseStatement:
       - suffix:
           member:
             rule: UseStatementSuffix
+      - file_id:
+          member: 
+            build:
+              special:
+                kind: file_id
+      - range:
+          member: 
+            build:
+              special:
+                kind: range
 UseStatementPrefix:
   struct:
     children: