address import resolution issues

- fix wildcard imports shadowing other items
- fix explicit imports depending on other items
- fix example export in package.sv

src/Convert/Package.hs

@@ -25,6 +25,7 @@
 
 module Convert.Package (convert) where
 
+import Control.Monad.State
 import Control.Monad.Writer
 import qualified Data.Map.Strict as Map
 import qualified Data.Set as Set
@@ -86,6 +87,21 @@ prefixPackageItem packageName idents item =
             if Set.member x idents
                 then packageName ++ '_' : x
                 else x
+        prefixM :: Identifier -> State Idents Identifier
+        prefixM x = do
+            locals <- get
+            if Set.notMember x locals
+                then return $ prefix x
+                else return x
+        traverseDeclM :: Decl -> State Idents Decl
+        traverseDeclM decl = do
+            case decl of
+                Variable _ _ x _ _ -> modify $ Set.insert x
+                Param _ _ x _      -> modify $ Set.insert x
+                ParamType _ x _    -> modify $ Set.insert x
+                _ -> return ()
+            traverseDeclTypesM (traverseNestedTypesM convertTypeM) decl
+
         item' = case item of
             Function       a b x c d  -> Function       a b (prefix x) c d
             Task           a   x c d  -> Task           a   (prefix x) c d
@@ -94,21 +110,34 @@ prefixPackageItem packageName idents item =
             Decl (Param    a b x c  ) -> Decl (Param    a b (prefix x) c  )
             Decl (ParamType  a x b  ) -> Decl (ParamType  a (prefix x) b  )
             other -> other
-        convertType (Alias Nothing x rs) = Alias Nothing (prefix x) rs
-        convertType (Enum t items rs) = Enum t items' rs
-            where
-                items' = map prefixItem items
-                prefixItem (x, e) = (prefix x, e)
-        convertType other = other
-        convertExpr (Ident x) = Ident $ prefix x
-        convertExpr other = other
-        convertLHS (LHSIdent x) = LHSIdent $ prefix x
-        convertLHS other = other
-        converter =
-            (traverseTypes $ traverseNestedTypes convertType) .
-            (traverseExprs $ traverseNestedExprs convertExpr) .
-            (traverseLHSs  $ traverseNestedLHSs  convertLHS )
-        MIPackageItem item'' = converter $ MIPackageItem item'
+
+        convertTypeM (Alias Nothing x rs) =
+            prefixM x >>= \x' -> return $ Alias Nothing x' rs
+        convertTypeM (Enum t items rs) =
+            mapM prefixItem items >>= \items' -> return $ Enum t items' rs
+            where prefixItem (x, e) = prefixM x >>= \x' -> return (x', e)
+        convertTypeM other = return other
+        convertExprM (Ident x) = prefixM x >>= return . Ident
+        convertExprM other =
+            traverseExprTypesM (traverseNestedTypesM convertTypeM) other
+        convertLHSM (LHSIdent x) = prefixM x >>= return . LHSIdent
+        convertLHSM other = return other
+
+        convertModuleItemM x = return x >>=
+            (traverseTypesM                        convertTypeM) >>=
+            (traverseExprsM $ traverseNestedExprsM convertExprM) >>=
+            (traverseLHSsM  $ traverseNestedLHSsM  convertLHSM )
+        convertStmtM stmt = return stmt >>=
+            (traverseStmtExprsM $ traverseNestedExprsM convertExprM) >>=
+            (traverseStmtLHSsM  $ traverseNestedLHSsM  convertLHSM )
+
+        MIPackageItem item'' =
+            evalState
+            (traverseScopesM
+            traverseDeclM
+            convertModuleItemM
+            convertStmtM
+            (MIPackageItem item')) Set.empty
 
 collectDescriptionM :: Description -> Writer Packages ()
 collectDescriptionM (Package _ name items) =
@@ -144,6 +173,8 @@ traverseDescription packages description =
         existingItemNames = execWriter $
             collectModuleItemsM writePIName description
         writePIName :: ModuleItem -> Writer Idents ()
+        writePIName (MIPackageItem (Import _ (Just x))) =
+            tell $ Set.singleton x
         writePIName (MIPackageItem item) =
             case piName item of
                 "" -> return ()
@@ -153,14 +184,16 @@ traverseDescription packages description =
 traverseModuleItem :: Idents -> Packages -> ModuleItem -> ModuleItem
 traverseModuleItem existingItemNames packages (MIPackageItem (Import x y)) =
     if Map.member x packages
-        then Generate $ map (GenModuleItem . MIPackageItem) items
+        then Generate $ map (GenModuleItem . MIPackageItem) itemsRenamed
         else MIPackageItem $ Import x y
     where
         packageItems = packages Map.! x
-        filterer itemName = case y of
-                Nothing -> Set.notMember itemName existingItemNames
-                Just ident -> ident == itemName
-        items = map snd $ filter (filterer . fst) $ packageItems
+        namesToAvoid = case y of
+            Nothing -> existingItemNames
+            Just ident -> Set.delete ident existingItemNames
+        itemsRenamed = map
+            (prefixPackageItem x namesToAvoid)
+            (map snd packageItems)
 traverseModuleItem _ _ item =
     (traverseExprs $ traverseNestedExprs traverseExpr) $
     (traverseTypes $ traverseNestedTypes traverseType) $

src/Convert/Traverse.hs

@@ -57,6 +57,9 @@ module Convert.Traverse
 , traverseTypeExprsM
 , traverseTypeExprs
 , collectTypeExprsM
+, traverseDeclTypesM
+, traverseDeclTypes
+, collectDeclTypesM
 , traverseTypesM'
 , traverseTypes'
 , collectTypesM'
@@ -892,6 +895,20 @@ traverseTypeExprs = unmonad traverseTypeExprsM
 collectTypeExprsM :: Monad m => CollectorM m Expr -> CollectorM m Type
 collectTypeExprsM = collectify traverseTypeExprsM
 
+traverseDeclTypesM :: Monad m => MapperM m Type -> MapperM m Decl
+traverseDeclTypesM mapper (Param s t x e) =
+    mapper t >>= \t' -> return $ Param s t' x e
+traverseDeclTypesM mapper (ParamType s x mt) =
+    mapM mapper mt >>= \mt' -> return $ ParamType s x mt'
+traverseDeclTypesM mapper (Variable d t x a e) =
+    mapper t >>= \t' -> return $ Variable d t' x a e
+traverseDeclTypesM _ (CommentDecl c) = return $ CommentDecl c
+
+traverseDeclTypes :: Mapper Type -> Mapper Decl
+traverseDeclTypes = unmonad traverseDeclTypesM
+collectDeclTypesM :: Monad m => CollectorM m Type -> CollectorM m Decl
+collectDeclTypesM = collectify traverseDeclTypesM
+
 traverseTypesM' :: Monad m => TypeStrategy -> MapperM m Type -> MapperM m ModuleItem
 traverseTypesM' strategy mapper item =
     miMapper item >>=
@@ -899,16 +916,8 @@ traverseTypesM' strategy mapper item =
     traverseExprsM (traverseNestedExprsM exprMapper)
     where
         fullMapper = traverseNestedTypesM mapper
-        maybeMapper Nothing = return Nothing
-        maybeMapper (Just t) = fullMapper t >>= return . Just
         exprMapper = traverseExprTypesM fullMapper
-        declMapper (Param s t x e) =
-            fullMapper t >>= \t' -> return $ Param s t' x e
-        declMapper (ParamType s x mt) =
-            maybeMapper mt >>= \mt' -> return $ ParamType s x mt'
-        declMapper (Variable d t x a e) =
-            fullMapper t >>= \t' -> return $ Variable d t' x a e
-        declMapper (CommentDecl c) = return $ CommentDecl c
+        declMapper = traverseDeclTypesM fullMapper
         miMapper (MIPackageItem (Typedef t x)) =
             fullMapper t >>= \t' -> return $ MIPackageItem $ Typedef t' x
         miMapper (MIPackageItem (Function l t x d s)) =

test/basic/package.sv

@@ -17,7 +17,7 @@ package D;
 endpackage
 package E;
     import D::*;
-    export D::*;
+    export D::pack;
 endpackage
 package F;
     localparam MAGIC = -42;

test/basic/package_implied.sv

+package P;
+    localparam X = 10;
+    localparam Y = X;
+endpackage
+
+module top;
+    import P::Y;
+    initial $display(Y);
+endmodule

test/basic/package_implied.v

+module top;
+    localparam P_X = 10;
+    localparam Y = P_X;
+    initial $display(Y);
+endmodule

test/basic/package_shadow.sv

+package P;
+    localparam X = 10;
+    localparam Y = X + 1;
+    function integer flip;
+        input integer X;
+        return ~X;
+    endfunction
+endpackage
+
+package Q;
+    import P::*;
+    localparam Y = X + 1000;
+endpackage
+
+package R;
+    import Q::*;
+    export Q::Y;
+endpackage
+
+package S;
+    typedef enum logic { A, B } enum_t;
+    function enum_t flop;
+        input enum_t X;
+        if (X == A) return B;
+        else return A;
+    endfunction
+endpackage
+
+module top;
+    import P::*;
+    localparam X = 20;
+    localparam Z = Y + 1;
+    import S::flop;
+    typedef enum logic [3:0] { T = 3, U } enum_t;
+    initial begin
+        $display("X %0d", X);
+        $display("P::Y %0d", P::Y);
+        $display("Z %0d", Z);
+        $display("R::Y %0d", R::Y);
+        $display("flip(0) %0d", flip(0));
+        $display("T %b", T);
+        $display("U %b", U);
+        $display("flop(0) %b", flop(0));
+        $display("flop(1) %b", flop(1));
+    end
+endmodule

test/basic/package_shadow.v

+module top;
+    localparam P_X = 10;
+    localparam P_Y = P_X + 1;
+    localparam X = 20;
+    localparam Z = P_Y + 1;
+    localparam R_Y = P_X + 1000;
+    localparam Q_Y = R_Y;
+    localparam [3:0] T = 3;
+    localparam [3:0] U = 4;
+    function integer flip;
+        input integer inp;
+        flip = ~inp;
+    endfunction
+    function flop;
+        input inp;
+        flop = ~inp;
+    endfunction
+    initial begin
+        $display("X %0d", X);
+        $display("P::Y %0d", P_Y);
+        $display("Z %0d", Z);
+        $display("R::Y %0d", Q_Y);
+        $display("flip(0) %0d", flip(0));
+        $display("T %b", T);
+        $display("U %b", U);
+        $display("flop(0) %b", flop(0));
+        $display("flop(1) %b", flop(1));
+    end
+endmodule