Merge pull request #2286 from taichi-ishitani/restore

Restore

Author: dalance

crates/analyzer/src/conv/statement.rs

@@ -277,8 +277,9 @@ impl Conv<&IdentifierStatement> for ir::StatementBlock {
                     ir::Arguments::Null
                 };
 
-                let symbol = symbol_table::resolve(value.expression_identifier.as_ref())
-                    .map_err(|_| ir_error!(token))?;
+                let resolved_path =
+                    context.resolve_path(value.expression_identifier.as_ref().into());
+                let symbol = symbol_table::resolve(&resolved_path).map_err(|_| ir_error!(token))?;
 
                 match &symbol.found.kind {
                     SymbolKind::SystemFunction(_) => {

crates/analyzer/src/conv/utils.rs

@@ -1106,8 +1106,8 @@ pub fn eval_function_call(
             ir::Arguments::Null
         };
 
-        let symbol = symbol_table::resolve(value.expression_identifier.as_ref())
-            .map_err(|_| ir_error!(token))?;
+        let resolved_path = context.resolve_path(value.expression_identifier.as_ref().into());
+        let symbol = symbol_table::resolve(&resolved_path).map_err(|_| ir_error!(token))?;
 
         match &symbol.found.kind {
             SymbolKind::SystemFunction(_) => {

crates/analyzer/src/ir/signature.rs

@@ -66,6 +66,14 @@ impl Signature {
                 }
                 symbol.found
             }
+            SymbolKind::ProtoFunction(_) => {
+                let resolved = context.resolve_path(path.clone());
+                let symbol = symbol_table::resolve(&resolved).ok()?;
+                match &symbol.found.kind {
+                    SymbolKind::Function(_) => symbol.found,
+                    _ => return None,
+                }
+            }
             SymbolKind::ProtoAliasModule(x) => {
                 let symbol = symbol_table::resolve(&x.target).ok()?;
                 return Some(Signature::new(symbol.found.id));

crates/analyzer/src/ir/tests.rs

@@ -1839,7 +1839,7 @@ fn concat() {
     o: output logic<16>,
     o2: output logic<16>,
 ) {
-    assign o = {8'hff + 8'h1}; 
+    assign o = {8'hff + 8'h1};
     assign o2 = {8'hf0, 8'hff + 8'h1};
 }
     "#;
@@ -1857,3 +1857,99 @@ fn concat() {
 "#;
     check_ir(code, exp);
 }
+
+#[test]
+fn proto_function() {
+    let code = r#"
+    proto package Element {
+        type data;
+        function gt(a: input data, b: input data) -> logic;
+    }
+    package IntElement for Element {
+        type data = logic<8>;
+        function gt(a: input data, b: input data) -> logic {
+            return a >: b;
+        }
+    }
+    module ModuleA::<E: Element> (
+        a: input  E::data,
+        b: input  E::data,
+        r: output logic,
+    ) {
+        always_comb {
+            r = E::gt(a, b);
+        }
+    }
+    module Top (
+        a: input  logic<8>,
+        b: input  logic<8>,
+        r: output logic,
+    ) {
+        inst inner: ModuleA::<IntElement> (a, b, r);
+    }
+    "#;
+    let exp = r#"module ModuleA {
+  input var0(a): unknown = 1'hx;
+  input var1(b): unknown = 1'hx;
+  output var2(r): logic = 1'hx;
+
+  comb {
+    var2 = unknown;
+  }
+}
+module Top {
+  input var0(a): logic<8> = 8'hxx;
+  input var1(b): logic<8> = 8'hxx;
+  output var2(r): logic = 1'hx;
+
+  inst inner (
+    var0 <- var0;
+    var1 <- var1;
+    var2 -> var2;
+  ) {
+    module ModuleA {
+      input var0(a): logic<8> = 8'hxx;
+      input var1(b): logic<8> = 8'hxx;
+      output var2(r): logic = 1'hx;
+      var var4(E.gt.return): logic = 1'hx;
+      input var5(E.gt.a): logic<8> = 8'hxx;
+      input var6(E.gt.b): logic<8> = 8'hxx;
+      func var3(E.gt) -> var4 {
+        var4 = (var5 >: var6);
+      }
+
+      comb {
+        var2 = var3(a: var0, b: var1);
+      }
+    }
+  }
+}
+"#;
+    check_ir(code, exp);
+}
+
+#[test]
+fn binary_operation_with_large_width_variable() {
+    let code = r#"
+module Top (
+  a: input  logic<65>,
+  b: output logic    ,
+) {
+  always_comb {
+    b = a == '0;
+  }
+}
+"#;
+
+    let exp = r#"module Top {
+  input var0(a): logic<65> = 65'hxxxxxxxxxxxxxxxxx;
+  output var1(b): logic = 1'hx;
+
+  comb {
+    var1 = (var0 == '0);
+  }
+}
+"#;
+
+    check_ir(code, exp);
+}

crates/analyzer/src/value.rs

@@ -752,7 +752,7 @@ impl Value {
     }
 
     pub fn expand(&self, width: usize, use_sign: bool) -> Cow<'_, Self> {
-        if self.width() == 0 || self.width() >= width {
+        if (self.width() == 0 && width <= 64) || self.width() >= width {
             Cow::Borrowed(self)
         } else if width > 64 {
             let ret = match self {