Skip passing SequentialRoot, build from parent

Author: kraigher

vhdl_lang/src/analysis/concurrent.rs

@@ -8,7 +8,6 @@
 #![allow(clippy::unneeded_field_pattern)]
 
 use super::named_entity::*;
-use super::sequential::SequentialRoot;
 use super::*;
 use crate::ast::*;
 use crate::data::*;
@@ -121,13 +120,7 @@ impl<'a> AnalyzeContext<'a> {
                 let nested = scope.nested();
                 self.define_labels_for_sequential_part(scope, parent, statements, diagnostics)?;
                 self.analyze_declarative_part(&nested, parent, decl, diagnostics)?;
-                self.analyze_sequential_part(
-                    &nested,
-                    parent,
-                    &SequentialRoot::Process,
-                    statements,
-                    diagnostics,
-                )?;
+                self.analyze_sequential_part(&nested, parent, statements, diagnostics)?;
             }
             ConcurrentStatement::ForGenerate(ref mut gen) => {
                 let ForGenerateStatement {

vhdl_lang/src/analysis/declarative.rs

@@ -8,7 +8,6 @@ use super::formal_region::FormalRegion;
 use super::formal_region::RecordRegion;
 use super::named_entity::*;
 use super::names::*;
-use super::sequential::SequentialRoot;
 use super::*;
 use crate::ast;
 use crate::ast::*;
@@ -494,12 +493,6 @@ impl<'a> AnalyzeContext<'a> {
                     }
                 };
 
-                let sroot = if let Some(return_type) = subpgm_ent.signature().return_type() {
-                    SequentialRoot::Function(return_type)
-                } else {
-                    SequentialRoot::Procedure
-                };
-
                 scope.add(subpgm_ent.into(), diagnostics);
 
                 self.define_labels_for_sequential_part(
@@ -518,7 +511,6 @@ impl<'a> AnalyzeContext<'a> {
                 self.analyze_sequential_part(
                     &subpgm_region,
                     subpgm_ent.into(),
-                    &sroot,
                     &mut body.statements,
                     diagnostics,
                 )?;

vhdl_lang/src/analysis/sequential.rs

@@ -87,18 +87,17 @@ impl<'a> AnalyzeContext<'a> {
         &self,
         scope: &Scope<'a>,
         parent: EntRef<'a>,
-        sroot: &SequentialRoot<'a>,
         statement: &mut LabeledSequentialStatement,
         diagnostics: &mut dyn DiagnosticHandler,
     ) -> FatalResult {
         match statement.statement {
             SequentialStatement::Return(ref mut ret) => {
                 let ReturnStatement { ref mut expression } = ret.item;
 
-                match sroot {
+                match SequentialRoot::from(parent) {
                     SequentialRoot::Function(ttyp) => {
                         if let Some(ref mut expression) = expression {
-                            self.expr_with_ttyp(scope, *ttyp, expression, diagnostics)?;
+                            self.expr_with_ttyp(scope, ttyp, expression, diagnostics)?;
                         } else {
                             diagnostics.error(&ret.pos, "Functions cannot return without a value");
                         }
@@ -186,10 +185,10 @@ impl<'a> AnalyzeContext<'a> {
                 for conditional in conditionals {
                     let Conditional { condition, item } = conditional;
                     self.boolean_expr(scope, condition, diagnostics)?;
-                    self.analyze_sequential_part(scope, parent, sroot, item, diagnostics)?;
+                    self.analyze_sequential_part(scope, parent, item, diagnostics)?;
                 }
                 if let Some(else_item) = else_item {
-                    self.analyze_sequential_part(scope, parent, sroot, else_item, diagnostics)?;
+                    self.analyze_sequential_part(scope, parent, else_item, diagnostics)?;
                 }
             }
             SequentialStatement::Case(ref mut case_stmt) => {
@@ -203,7 +202,7 @@ impl<'a> AnalyzeContext<'a> {
                 for alternative in alternatives.iter_mut() {
                     let Alternative { choices, item } = alternative;
                     self.choice_with_ttyp(scope, ctyp, choices, diagnostics)?;
-                    self.analyze_sequential_part(scope, parent, sroot, item, diagnostics)?;
+                    self.analyze_sequential_part(scope, parent, item, diagnostics)?;
                 }
             }
             SequentialStatement::Loop(ref mut loop_stmt) => {
@@ -221,32 +220,14 @@ impl<'a> AnalyzeContext<'a> {
                                 .define(index, parent, AnyEntKind::LoopParameter(typ)),
                             diagnostics,
                         );
-                        self.analyze_sequential_part(
-                            &region,
-                            parent,
-                            sroot,
-                            statements,
-                            diagnostics,
-                        )?;
+                        self.analyze_sequential_part(&region, parent, statements, diagnostics)?;
                     }
                     Some(IterationScheme::While(ref mut expr)) => {
                         self.boolean_expr(scope, expr, diagnostics)?;
-                        self.analyze_sequential_part(
-                            scope,
-                            parent,
-                            sroot,
-                            statements,
-                            diagnostics,
-                        )?;
+                        self.analyze_sequential_part(scope, parent, statements, diagnostics)?;
                     }
                     None => {
-                        self.analyze_sequential_part(
-                            scope,
-                            parent,
-                            sroot,
-                            statements,
-                            diagnostics,
-                        )?;
+                        self.analyze_sequential_part(scope, parent, statements, diagnostics)?;
                     }
                 }
             }
@@ -337,7 +318,6 @@ impl<'a> AnalyzeContext<'a> {
         &self,
         scope: &Scope<'a>,
         parent: EntRef<'a>,
-        sroot: &SequentialRoot<'a>,
         statements: &mut [LabeledSequentialStatement],
         diagnostics: &mut dyn DiagnosticHandler,
     ) -> FatalResult {
@@ -359,15 +339,37 @@ impl<'a> AnalyzeContext<'a> {
                 parent
             };
 
-            self.analyze_sequential_statement(scope, parent, sroot, statement, diagnostics)?;
+            self.analyze_sequential_statement(scope, parent, statement, diagnostics)?;
         }
 
         Ok(())
     }
 }
 
-pub enum SequentialRoot<'a> {
+enum SequentialRoot<'a> {
     Process,
     Procedure,
     Function(TypeEnt<'a>),
 }
+
+impl<'a> From<EntRef<'a>> for SequentialRoot<'a> {
+    fn from(value: EntRef<'a>) -> Self {
+        match value.kind() {
+            AnyEntKind::Overloaded(overloaded) => {
+                if let Some(return_type) = overloaded.signature().return_type() {
+                    SequentialRoot::Function(return_type)
+                } else {
+                    SequentialRoot::Procedure
+                }
+            }
+            AnyEntKind::Label => {
+                if let Some(parent) = value.parent {
+                    SequentialRoot::from(parent)
+                } else {
+                    SequentialRoot::Process
+                }
+            }
+            _ => SequentialRoot::Process,
+        }
+    }
+}