Check implicit boolean conditions

Author: kraigher

vhdl_lang/src/analysis/assignment.rs

@@ -36,7 +36,7 @@ impl<'a> AnalyzeContext<'a> {
                 for conditional in conditionals {
                     let Conditional { condition, item } = conditional;
                     self.analyze_expression_for_target(scope, ttyp, item, diagnostics)?;
-                    self.analyze_expression(scope, condition, diagnostics)?;
+                    self.boolean_expr(scope, condition, diagnostics)?;
                 }
                 if let Some(expr) = else_item {
                     self.analyze_expression_for_target(scope, ttyp, expr, diagnostics)?;
@@ -78,7 +78,7 @@ impl<'a> AnalyzeContext<'a> {
                 for conditional in conditionals {
                     let Conditional { condition, item } = conditional;
                     self.analyze_waveform(scope, ttyp, item, diagnostics)?;
-                    self.analyze_expression(scope, condition, diagnostics)?;
+                    self.boolean_expr(scope, condition, diagnostics)?;
                 }
                 if let Some(wavf) = else_item {
                     self.analyze_waveform(scope, ttyp, wavf, diagnostics)?;
@@ -112,13 +112,7 @@ impl<'a> AnalyzeContext<'a> {
                     let WaveformElement { value, after } = elem;
                     self.analyze_expression_for_target(scope, ttyp, value, diagnostics)?;
                     if let Some(expr) = after {
-                        self.expr_pos_with_ttyp(
-                            scope,
-                            self.time(),
-                            &expr.pos,
-                            &mut expr.item,
-                            diagnostics,
-                        )?;
+                        self.expr_with_ttyp(scope, self.time(), expr, diagnostics)?;
                     }
                 }
             }
@@ -135,7 +129,7 @@ impl<'a> AnalyzeContext<'a> {
         diagnostics: &mut dyn DiagnosticHandler,
     ) -> FatalResult {
         if let Some(ttyp) = ttyp {
-            self.expr_pos_with_ttyp(scope, ttyp, &expr.pos, &mut expr.item, diagnostics)?;
+            self.expr_with_ttyp(scope, ttyp, expr, diagnostics)?;
         } else {
             self.analyze_expression_pos(scope, &expr.pos, &mut expr.item, diagnostics)?;
         }

vhdl_lang/src/analysis/concurrent.rs

@@ -43,7 +43,7 @@ impl<'a> AnalyzeContext<'a> {
         match statement.statement {
             ConcurrentStatement::Block(ref mut block) => {
                 if let Some(ref mut guard_condition) = block.guard_condition {
-                    self.analyze_expression(scope, guard_condition, diagnostics)?;
+                    self.boolean_expr(scope, guard_condition, diagnostics)?;
                 }
                 let nested = scope.nested();
                 if let Some(ref mut list) = block.header.generic_clause {
@@ -106,7 +106,7 @@ impl<'a> AnalyzeContext<'a> {
                 } = gen;
                 for conditional in conditionals.iter_mut() {
                     let Conditional { condition, item } = conditional;
-                    self.analyze_expression(scope, condition, diagnostics)?;
+                    self.boolean_expr(scope, condition, diagnostics)?;
                     let nested = scope.nested();
                     self.analyze_generate_body(&nested, item, diagnostics)?;
                 }
@@ -149,12 +149,12 @@ impl<'a> AnalyzeContext<'a> {
                             severity,
                         },
                 } = assert;
-                self.analyze_expression(scope, condition, diagnostics)?;
+                self.boolean_expr(scope, condition, diagnostics)?;
                 if let Some(expr) = report {
-                    self.analyze_expression(scope, expr, diagnostics)?;
+                    self.expr_with_ttyp(scope, self.string(), expr, diagnostics)?;
                 }
                 if let Some(expr) = severity {
-                    self.analyze_expression(scope, expr, diagnostics)?;
+                    self.expr_with_ttyp(scope, self.severity_level(), expr, diagnostics)?;
                 }
             }
         };

vhdl_lang/src/analysis/sequential.rs

@@ -62,10 +62,10 @@ impl<'a> AnalyzeContext<'a> {
                 } = wait_stmt;
                 self.sensitivity_list_check(scope, sensitivity_clause, diagnostics)?;
                 if let Some(expr) = condition_clause {
-                    self.analyze_expression(scope, expr, diagnostics)?;
+                    self.boolean_expr(scope, expr, diagnostics)?;
                 }
                 if let Some(expr) = timeout_clause {
-                    self.analyze_expression(scope, expr, diagnostics)?;
+                    self.expr_with_ttyp(scope, self.time(), expr, diagnostics)?;
                 }
             }
             SequentialStatement::Assert(ref mut assert_stmt) => {
@@ -97,7 +97,7 @@ impl<'a> AnalyzeContext<'a> {
                 } = exit_stmt;
 
                 if let Some(expr) = condition {
-                    self.analyze_expression(scope, expr, diagnostics)?;
+                    self.boolean_expr(scope, expr, diagnostics)?;
                 }
             }
             SequentialStatement::Next(ref mut next_stmt) => {
@@ -108,7 +108,7 @@ impl<'a> AnalyzeContext<'a> {
                 } = next_stmt;
 
                 if let Some(expr) = condition {
-                    self.analyze_expression(scope, expr, diagnostics)?;
+                    self.boolean_expr(scope, expr, diagnostics)?;
                 }
             }
             SequentialStatement::If(ref mut ifstmt) => {
@@ -120,8 +120,8 @@ impl<'a> AnalyzeContext<'a> {
                 // @TODO write generic function for this
                 for conditional in conditionals {
                     let Conditional { condition, item } = conditional;
+                    self.boolean_expr(scope, condition, diagnostics)?;
                     self.analyze_sequential_part(scope, sroot, item, diagnostics)?;
-                    self.analyze_expression(scope, condition, diagnostics)?;
                 }
                 if let Some(else_item) = else_item {
                     self.analyze_sequential_part(scope, sroot, else_item, diagnostics)?;
@@ -156,7 +156,7 @@ impl<'a> AnalyzeContext<'a> {
                         self.analyze_sequential_part(&region, sroot, statements, diagnostics)?;
                     }
                     Some(IterationScheme::While(ref mut expr)) => {
-                        self.analyze_expression(scope, expr, diagnostics)?;
+                        self.boolean_expr(scope, expr, diagnostics)?;
                         self.analyze_sequential_part(scope, sroot, statements, diagnostics)?;
                     }
                     None => {