temp

Author: dalance

Cargo.lock

@@ -39,9 +39,12 @@ console         = "0.16.1"
 futures         = "0.3.31"
 fxhash          = "0.2.1"
 handlebars      = "6.3"
+itertools       = "0.14.0"
 log             = "0.4.28"
 mdbook          = "0.4.51"
 miette          = {version = "7.6"}
+num-bigint      = "0.4.6"
+num-traits      = "0.2.19"
 once_cell       = "1.21"
 parol_runtime   = "4.0"
 pulldown-cmark  = "0.13.0"

Cargo.toml

@@ -77,6 +77,9 @@ install:
 gen_sv:
 	cargo run --bin veryl -- build
 
+gen_ir:
+	cargo run --bin veryl -- dump --ir
+
 fmt_veryl:
 	cargo run --bin veryl -- fmt
 

Makefile

@@ -16,10 +16,11 @@ edition.workspace     = true
 bimap           = "0.6.3"
 daggy           = "0.9.0"
 fxhash          = {workspace = true}
-itertools       = "0.14.0"
+indent          = "0.1.1"
+itertools       = {workspace = true}
 log             = {workspace = true}
-num-bigint      = "0.4.6"
-num-traits      = "0.2.19"
+num-bigint      = {workspace = true}
+num-traits      = {workspace = true}
 smallvec        = {workspace = true}
 strnum_bitwidth = {workspace = true}
 thiserror       = {workspace = true}

crates/analyzer/Cargo.toml

@@ -5,6 +5,7 @@ use crate::attribute_table;
 use crate::handlers::check_expression::CheckExpression;
 use crate::handlers::*;
 use crate::instance_history;
+use crate::ir::{Ir, ir_table};
 use crate::msb_table;
 use crate::namespace::Namespace;
 use crate::namespace_table;
@@ -377,11 +378,18 @@ impl Analyzer {
         ret
     }
 
+    fn create_ir(input: &Veryl) -> (Ir, Vec<AnalyzerError>) {
+        let ir = input.into();
+        let errors = ir_table::drain_errors();
+        (ir, errors)
+    }
+
     pub fn analyze_pass2<T: AsRef<Path>>(
         &self,
         project_name: &str,
         _path: T,
         input: &Veryl,
+        ir: Option<&mut Ir>,
     ) -> Vec<AnalyzerError> {
         let mut ret = Vec::new();
 
@@ -393,6 +401,14 @@ impl Analyzer {
         pass2.veryl(input);
         ret.append(&mut pass2.handlers.get_errors());
 
+        // some pass2 errors are generated in create_ir
+        // The actual implementation is under crate/analyzer/src/ir/conv
+        let mut ir_result = Self::create_ir(input);
+        ret.append(&mut ir_result.1);
+        if let Some(x) = ir {
+            x.append(&mut ir_result.0);
+        }
+
         ret
     }
 

crates/analyzer/src/analyzer.rs

@@ -169,6 +169,40 @@ pub enum AnalyzerError {
         error_location: SourceSpan,
     },
 
+    #[diagnostic(
+        severity(Error),
+        code(invalid_operand),
+        help(""),
+        url("https://doc.veryl-lang.org/book/07_appendix/02_semantic_error.html#invalid_operand")
+    )]
+    #[error("{kind} cannot be used as a operand of {op} operator")]
+    InvalidOperand {
+        kind: String,
+        op: String,
+        #[source_code]
+        input: MultiSources,
+        #[label("Error location")]
+        error_location: SourceSpan,
+        // TODO
+        //#[label(collection, "instantiated at")]
+        //inst_context: Vec<SourceSpan>,
+    },
+
+    #[diagnostic(
+        severity(Warning),
+        code(invalid_logical_operand),
+        help(""),
+        url("https://doc.veryl-lang.org/book/07_appendix/02_semantic_error.html#invalid_operand")
+    )]
+    #[error("{kind} should be 1-bit value")]
+    InvalidLogicalOperand {
+        kind: String,
+        #[source_code]
+        input: MultiSources,
+        #[label("Error location")]
+        error_location: SourceSpan,
+    },
+
     #[diagnostic(
         severity(Error),
         code(invalid_factor),
@@ -1487,6 +1521,28 @@ impl AnalyzerError {
         }
     }
 
+    pub fn invalid_operand(kind: &str, op: &str, token: &TokenRange) -> Self {
+        AnalyzerError::InvalidOperand {
+            kind: kind.to_string(),
+            op: op.to_string(),
+            input: source(token),
+            error_location: token.into(),
+        }
+    }
+
+    pub fn invalid_logical_operand(op: bool, token: &TokenRange) -> Self {
+        let kind = if op {
+            "Operand of logical operator"
+        } else {
+            "Conditional expression"
+        };
+        AnalyzerError::InvalidLogicalOperand {
+            kind: kind.to_string(),
+            input: source(token),
+            error_location: token.into(),
+        }
+    }
+
     pub fn invalid_factor(
         identifier: Option<&str>,
         kind: &str,

crates/analyzer/src/analyzer_error.rs

@@ -12,8 +12,6 @@ pub mod check_modport;
 pub mod check_msb_lsb;
 pub mod check_number;
 pub mod check_port;
-pub mod check_proto;
-pub mod check_separator;
 pub mod check_statement;
 pub mod check_type;
 pub mod check_unsafe;
@@ -33,8 +31,6 @@ use check_modport::*;
 use check_msb_lsb::*;
 use check_number::*;
 use check_port::*;
-use check_proto::*;
-use check_separator::*;
 use check_statement::*;
 use check_type::*;
 use check_unsafe::*;
@@ -101,7 +97,6 @@ impl Pass1Handlers {
 }
 
 pub struct Pass2Handlers {
-    check_separator: CheckSeparator,
     check_enum: CheckEnum,
     check_modport: CheckModport,
     check_function: CheckFunction,
@@ -112,15 +107,13 @@ pub struct Pass2Handlers {
     check_anonymous: CheckAnonymous,
     check_expression: CheckExpression,
     check_clock_domain: CheckClockDomain,
-    check_proto: CheckProto,
     check_type: CheckType,
-    enables: [bool; 13],
+    enables: [bool; 11],
 }
 
 impl Pass2Handlers {
     pub fn new(_build_opt: &Build, _lint_opt: &Lint, env_var: &EnvVar) -> Self {
         Self {
-            check_separator: CheckSeparator::new(),
             check_enum: CheckEnum::new(),
             check_modport: CheckModport::new(),
             check_function: CheckFunction::new(),
@@ -131,7 +124,6 @@ impl Pass2Handlers {
             check_anonymous: CheckAnonymous::new(),
             check_expression: CheckExpression::new(vec![]),
             check_clock_domain: CheckClockDomain::new(),
-            check_proto: CheckProto::new(),
             check_type: CheckType::new(),
             enables: env_var.analyzer_pass2_enables,
         }
@@ -140,25 +132,22 @@ impl Pass2Handlers {
     pub fn get_handlers(&mut self) -> Vec<(bool, &mut dyn Handler)> {
         let en = &self.enables;
         vec![
-            (en[0], &mut self.check_separator as &mut dyn Handler),
-            (en[1], &mut self.check_enum as &mut dyn Handler),
-            (en[2], &mut self.check_modport as &mut dyn Handler),
-            (en[3], &mut self.check_function as &mut dyn Handler),
-            (en[4], &mut self.check_msb_lsb as &mut dyn Handler),
-            (en[5], &mut self.check_connect_operation as &mut dyn Handler),
-            (en[6], &mut self.check_var_ref as &mut dyn Handler),
-            (en[7], &mut self.check_clock_reset as &mut dyn Handler),
-            (en[8], &mut self.check_anonymous as &mut dyn Handler),
-            (en[9], &mut self.check_expression as &mut dyn Handler),
-            (en[10], &mut self.check_clock_domain as &mut dyn Handler),
-            (en[11], &mut self.check_proto as &mut dyn Handler),
-            (en[12], &mut self.check_type as &mut dyn Handler),
+            (en[0], &mut self.check_enum as &mut dyn Handler),
+            (en[1], &mut self.check_modport as &mut dyn Handler),
+            (en[2], &mut self.check_function as &mut dyn Handler),
+            (en[3], &mut self.check_msb_lsb as &mut dyn Handler),
+            (en[4], &mut self.check_connect_operation as &mut dyn Handler),
+            (en[5], &mut self.check_var_ref as &mut dyn Handler),
+            (en[6], &mut self.check_clock_reset as &mut dyn Handler),
+            (en[7], &mut self.check_anonymous as &mut dyn Handler),
+            (en[8], &mut self.check_expression as &mut dyn Handler),
+            (en[9], &mut self.check_clock_domain as &mut dyn Handler),
+            (en[10], &mut self.check_type as &mut dyn Handler),
         ]
     }
 
     pub fn get_errors(&mut self) -> Vec<AnalyzerError> {
         let mut ret = Vec::new();
-        ret.append(&mut self.check_separator.errors);
         ret.append(&mut self.check_enum.errors);
         ret.append(&mut self.check_modport.errors);
         ret.append(&mut self.check_function.errors);
@@ -169,7 +158,6 @@ impl Pass2Handlers {
         ret.append(&mut self.check_anonymous.errors);
         ret.append(&mut self.check_expression.errors);
         ret.append(&mut self.check_clock_domain.errors);
-        ret.append(&mut self.check_proto.errors);
         ret.append(&mut self.check_type.errors);
         ret
     }

crates/analyzer/src/handlers.rs

@@ -117,7 +117,7 @@ impl VerylGrammarTrait for CheckAnonymous {
                     if let Some(port) = self
                         .inst_ports
                         .iter()
-                        .find(|x| x.name() == arg.identifier.identifier_token.token.text)
+                        .find(|x| x.name() == arg.identifier.text())
                     {
                         if let SymbolKind::Port(port) = symbol_table::get(port.symbol).unwrap().kind
                         {

crates/analyzer/src/handlers/check_anonymous.rs

@@ -253,7 +253,7 @@ impl VerylGrammarTrait for CheckClockDomain {
                 let domain = self.check_expr_clock_domains(&arg.identifier.identifier_token.token);
                 let range: TokenRange = arg.identifier.as_ref().into();
                 self.inst_clock_domains
-                    .insert(arg.identifier.identifier_token.token.text, (domain, range));
+                    .insert(arg.identifier.text(), (domain, range));
             }
         }
         Ok(())