raise error for package referecne before defnition

(refs: #1166)

crates/analyzer/src/analyzer_error.rs

@@ -758,6 +758,21 @@ pub enum AnalyzerError {
         error_location: SourceSpan,
     },
 
+    #[diagnostic(
+        severity(Error),
+        code(referring_package_before_definition),
+        help("change order of package definitions"),
+        url("")
+    )]
+    #[error("pakcakge {identifier} is referred before it is defined.")]
+    ReferringPackageBeforeDefinition {
+        identifier: String,
+        #[source_code]
+        input: NamedSource<String>,
+        #[label("Error location")]
+        error_location: SourceSpan,
+    },
+
     #[diagnostic(
         severity(Error),
         code(unresolvable_generic_argument),
@@ -1569,6 +1584,18 @@ impl AnalyzerError {
         }
     }
 
+    pub fn referring_package_before_definition(
+        identifier: &str,
+        source: &str,
+        token: &TokenRange,
+    ) -> Self {
+        AnalyzerError::ReferringPackageBeforeDefinition {
+            identifier: identifier.to_string(),
+            input: AnalyzerError::named_source(source, token),
+            error_location: token.into(),
+        }
+    }
+
     pub fn unresolvable_generic_argument(
         identifier: &str,
         source: &str,

crates/analyzer/src/handlers/create_reference.rs

@@ -10,7 +10,7 @@ use crate::type_dag::{self, Context, DagError};
 use std::collections::HashMap;
 use veryl_parser::resource_table;
 use veryl_parser::veryl_grammar_trait::*;
-use veryl_parser::veryl_token::{is_anonymous_text, Token, TokenRange};
+use veryl_parser::veryl_token::{is_anonymous_text, Token, TokenRange, TokenSource};
 use veryl_parser::veryl_walker::{Handler, HandlerPoint};
 use veryl_parser::ParolError;
 
@@ -20,6 +20,7 @@ pub struct CreateReference<'a> {
     text: &'a str,
     point: HandlerPoint,
     inst_ports: Vec<Port>,
+    definition_token: Option<Token>,
     inst_sv_module: bool,
     is_anonymous_identifier: bool,
     port_direction: Option<Direction>,
@@ -107,6 +108,10 @@ impl<'a> CreateReference<'a> {
 
             match symbol_table::resolve((&base_path, namespace)) {
                 Ok(symbol) => {
+                    if (i + 1) == path.len() {
+                        self.check_pacakge_reference(self.definition_token, &symbol.found);
+                    }
+
                     symbol_table::add_reference(symbol.found.id, &path.paths[0].base);
 
                     // Check number of arguments
@@ -181,6 +186,39 @@ impl<'a> CreateReference<'a> {
         }
     }
 
+    fn check_pacakge_reference(&mut self, base_token: Option<Token>, symbol: &Symbol) {
+        if base_token.is_none() {
+            return;
+        }
+
+        let package_symbol = symbol
+            .get_ancestors()
+            .into_iter()
+            .find(|x| matches!(x.kind, SymbolKind::Package(_)));
+        if package_symbol.is_none() {
+            return;
+        }
+
+        let base_token = base_token.unwrap();
+        let package_token = package_symbol.unwrap().token;
+        if let (TokenSource::File(package_file), TokenSource::File(base_file)) =
+            (package_token.source, base_token.source)
+        {
+            let referecne_before_definition = package_file == base_file
+                && (package_token.line > base_token.line
+                    || package_token.line == base_token.line
+                        && package_token.column > base_token.column);
+            if referecne_before_definition {
+                self.errors
+                    .push(AnalyzerError::referring_package_before_definition(
+                        &package_token.to_string(),
+                        self.text,
+                        &package_token.into(),
+                    ));
+            }
+        }
+    }
+
     fn insert_declaration_dag_node(&mut self, symbol: &Symbol) -> Option<u32> {
         if let Some(child) = self.insert_dag_node(symbol) {
             if let Some(parent) = self.dag_scope_parent.last().cloned() {
@@ -599,9 +637,13 @@ impl VerylGrammarTrait for CreateReference<'_> {
         match self.point {
             HandlerPoint::Before => {
                 let symbol = symbol_table::resolve(arg.identifier.as_ref()).unwrap();
+                self.definition_token = Some(symbol.found.token);
                 self.insert_scope_declaration_dag_node(&symbol.found, Context::Module);
             }
-            HandlerPoint::After => self.pop_scope_dag(),
+            HandlerPoint::After => {
+                self.definition_token = None;
+                self.pop_scope_dag();
+            }
         }
         Ok(())
     }
@@ -610,9 +652,13 @@ impl VerylGrammarTrait for CreateReference<'_> {
         match self.point {
             HandlerPoint::Before => {
                 let symbol = symbol_table::resolve(arg.identifier.as_ref()).unwrap();
+                self.definition_token = Some(symbol.found.token);
                 self.insert_scope_declaration_dag_node(&symbol.found, Context::Interface);
             }
-            HandlerPoint::After => self.pop_scope_dag(),
+            HandlerPoint::After => {
+                self.definition_token = None;
+                self.pop_scope_dag();
+            }
         }
         Ok(())
     }
@@ -621,9 +667,13 @@ impl VerylGrammarTrait for CreateReference<'_> {
         match self.point {
             HandlerPoint::Before => {
                 let symbol = symbol_table::resolve(arg.identifier.as_ref()).unwrap();
+                self.definition_token = Some(symbol.found.token);
                 self.insert_scope_declaration_dag_node(&symbol.found, Context::Package);
             }
-            HandlerPoint::After => self.pop_scope_dag(),
+            HandlerPoint::After => {
+                self.definition_token = None;
+                self.pop_scope_dag();
+            }
         }
         Ok(())
     }
@@ -638,6 +688,10 @@ impl VerylGrammarTrait for CreateReference<'_> {
                             if let Ok(symbol) = symbol_table::resolve(
                                 x.import_declaration.scoped_identifier.as_ref(),
                             ) {
+                                self.check_pacakge_reference(
+                                    Some(x.import_declaration.import.import_token.token),
+                                    &symbol.found,
+                                );
                                 if let Some(child) = self.insert_dag_node(&symbol.found) {
                                     self.dag_file_imports.push(child);
                                 }

crates/analyzer/src/symbol.rs

@@ -113,6 +113,17 @@ impl Symbol {
         None
     }
 
+    pub fn get_ancestors(&self) -> Vec<Symbol> {
+        let mut ancestors = Vec::new();
+
+        ancestors.push(self.clone());
+        if let Some(parent) = self.get_parent() {
+            ancestors.append(&mut parent.get_ancestors());
+        }
+
+        ancestors
+    }
+
     pub fn evaluate(&self) -> Evaluated {
         if let Some(evaluated) = self.evaluated.get() {
             evaluated

crates/analyzer/src/tests.rs

@@ -1758,6 +1758,67 @@ fn undefined_identifier() {
     ));
 }
 
+#[test]
+fn referring_package_before_definition() {
+    let code = r#"
+    module ModuleA {
+        const A: u32 = PakcageB::B;
+    }
+    package PakcageB {
+        const B: u32 = 0;
+    }
+    "#;
+
+    let errors = analyze(code);
+    assert!(matches!(
+        errors[0],
+        AnalyzerError::ReferringPackageBeforeDefinition { .. }
+    ));
+
+    let code = r#"
+    interface InterfaceA {
+        const A: u32 = PakcageB::B;
+    }
+    package PakcageB {
+        const B: u32 = 0;
+    }
+    "#;
+
+    let errors = analyze(code);
+    assert!(matches!(
+        errors[0],
+        AnalyzerError::ReferringPackageBeforeDefinition { .. }
+    ));
+
+    let code = r#"
+    package PackageA {
+        const A: u32 = PakcageB::B;
+    }
+    package PakcageB {
+        const B: u32 = 0;
+    }
+    "#;
+
+    let errors = analyze(code);
+    assert!(matches!(
+        errors[0],
+        AnalyzerError::ReferringPackageBeforeDefinition { .. }
+    ));
+
+    let code = r#"
+    import PakcageB::B;
+    package PakcageB {
+        const B: u32 = 0;
+    }
+    "#;
+
+    let errors = analyze(code);
+    assert!(matches!(
+        errors[0],
+        AnalyzerError::ReferringPackageBeforeDefinition { .. }
+    ));
+}
+
 #[test]
 fn unknown_attribute() {
     let code = r#"