functional parameter type conversion

src/Convert/Traverse.hs

@@ -849,6 +849,13 @@ traverseTypesM mapper item =
             fullMapper t >>= \t' -> return $ MIPackageItem $ Function l t' x d s
         miMapper (MIPackageItem (other @ (Task _ _ _ _))) =
             return $ MIPackageItem other
+        miMapper (Instance m params x r p) = do
+            params' <- mapM mapParam params
+            return $ Instance m params' x r p
+            where
+                mapParam (i, Left t) =
+                    fullMapper t >>= \t' -> return (i, Left t')
+                mapParam (i, Right e) = return $ (i, Right e)
         miMapper other = return other
 
 traverseTypes :: Mapper Type -> Mapper ModuleItem

src/Convert/Typedef.hs

@@ -36,6 +36,7 @@ convert =
 convertDescription :: Types -> Description -> Description
 convertDescription globalTypes description =
     traverseModuleItems removeTypedef $
+    traverseModuleItems convertModuleItem $
     traverseModuleItems (traverseExprs $ traverseNestedExprs $ convertExpr) $
     traverseModuleItems (traverseTypes $ resolveType types) $
     description
@@ -49,12 +50,20 @@ convertDescription globalTypes description =
         removeTypedef (MIPackageItem (Typedef _ x)) =
             MIPackageItem $ Comment $ "removed typedef: " ++ x
         removeTypedef other = other
-        convertExpr :: Expr -> Expr
-        convertExpr (Bits (Right (Ident x))) =
+        convertTypeOrExpr :: TypeOrExpr -> TypeOrExpr
+        convertTypeOrExpr (Right (Ident x)) =
             if Map.member x types
-                then Bits $ Left $ resolveType types (Alias Nothing x [])
-                else Bits $ Right $ Ident x
+                then Left $ resolveType types (Alias Nothing x [])
+                else Right $ Ident x
+        convertTypeOrExpr other = other
+        convertExpr :: Expr -> Expr
+        convertExpr (Bits v) = Bits $ convertTypeOrExpr v
         convertExpr other = other
+        convertModuleItem :: ModuleItem -> ModuleItem
+        convertModuleItem (Instance m params x r p) =
+            Instance m (map mapParam params) x r p
+            where mapParam (i, v) = (i, convertTypeOrExpr v)
+        convertModuleItem other = other
 
 resolveItem :: Types -> (Type, Identifier) -> (Type, Identifier)
 resolveItem types (t, x) = (resolveType types t, x)

test/basic/paramtype.sv

@@ -88,6 +88,7 @@ module d_1; n_def #(logic [1:0], logic [2:0]) x(); endmodule
 module d_2; n_def #(.T(logic [1:0])) x(); endmodule
 module d_3; n_def #(.U(logic [1:0])) x(); endmodule
 module d_4; n_def #(.U(logic), .T(logic [1:0])) x(); endmodule
+module d_5; n_def x(); endmodule
 
 module e_1; n_tdef #(logic [1:0], logic [2:0]) x(); endmodule
 module e_2; n_tdef #(.T(logic [1:0]), .U(logic)) x(); endmodule

test/basic/paramtype.v

@@ -20,6 +20,8 @@ module top;
 		$display("n_def 01 00000000000000000000000000000010           2");
 		$display("n_def 00 00000000000000000000000000000001           2");
 		$display("n_def 1 00000000000000000000000000000010           1");
+		$display("n_def 0 00000000000000000000000000000001           1");
+		$display("n_def 1 00000000000000000000000000000010           1");
 		$display("n_tdef 00 00000000000000000000000000000001           2");
 		$display("n_tdef 001 00000000000000000000000000000010           3");
 		$display("n_tdef 00 00000000000000000000000000000001           2");

test/basic/paramtype_recurse.sv

+module foo #(
+    parameter type T = logic,
+    parameter size = 0
+);
+    generate
+        if (size != 0) begin : foo
+            bar #(T, size - 1) x();
+        end
+    endgenerate
+    initial $display("foo %d %d", $bits(T), size);
+endmodule
+
+module bar #(
+    parameter type U = logic,
+    parameter size = 0
+);
+    generate
+        if (size != 0) begin : bar
+            foo #(U, size - 1) x();
+        end
+    endgenerate
+    initial $display("bar %d %d", $bits(U), size);
+endmodule
+
+module top_1; foo #(byte, 2) x(); endmodule
+module top_2; bar #(byte, 3) x(); endmodule
+
+module top_3; foo #(bit, 4) x(); endmodule
+module top_4; bar #(bit, 5) x(); endmodule
+
+module top; endmodule

test/basic/paramtype_recurse.v

+module foo_default #(
+    parameter size = 0
+);
+    initial $display("foo %d %d", 1, size);
+endmodule
+
+module bar_default #(
+    parameter size = 0
+);
+    initial $display("bar %d %d", 1, size);
+endmodule
+
+module foo_byte #(
+    parameter size = 0
+);
+    generate
+        if (size != 0) begin : foo
+            bar_byte #(size - 1) x();
+        end
+    endgenerate
+    initial $display("foo %d %d", 8, size);
+endmodule
+
+module bar_byte #(
+    parameter size = 0
+);
+    generate
+        if (size != 0) begin : bar
+            foo_byte #(size - 1) x();
+        end
+    endgenerate
+    initial $display("bar %d %d", 8, size);
+endmodule
+
+module foo_bit #(
+    parameter size = 0
+);
+    generate
+        if (size != 0) begin : foo
+            bar_bit #(size - 1) x();
+        end
+    endgenerate
+    initial $display("foo %d %d", 1, size);
+endmodule
+
+module bar_bit #(
+    parameter size = 0
+);
+    generate
+        if (size != 0) begin : bar
+            foo_bit #(size - 1) x();
+        end
+    endgenerate
+    initial $display("bar %d %d", 1, size);
+endmodule
+
+module top_1; foo_byte #(2) x(); endmodule
+module top_2; bar_byte #(3) x(); endmodule
+
+module top_3; foo_bit #(4) x(); endmodule
+module top_4; bar_bit #(5) x(); endmodule
+
+module top; endmodule