diff --git a/crates/analyzer/src/handlers/check_type.rs b/crates/analyzer/src/handlers/check_type.rs index e44b06ab2..795d79151 100644 --- a/crates/analyzer/src/handlers/check_type.rs +++ b/crates/analyzer/src/handlers/check_type.rs @@ -93,7 +93,7 @@ fn check_generic_type_arg( namespace: &Namespace, base: &Symbol, ) -> Option { - if matches!(arg.kind, GenericSymbolPathKind::FixedType) { + if matches!(arg.kind, GenericSymbolPathKind::FixedType(_)) { None } else if arg.is_resolvable() { let Ok(symbol) = symbol_table::resolve((&arg.generic_path(), namespace)) else { diff --git a/crates/analyzer/src/symbol_path.rs b/crates/analyzer/src/symbol_path.rs index aa3e609f5..a1c043c00 100644 --- a/crates/analyzer/src/symbol_path.rs +++ b/crates/analyzer/src/symbol_path.rs @@ -256,10 +256,157 @@ impl From<(&GenericSymbolPath, &Namespace)> for GenericSymbolPathNamesapce { } } +#[derive(Copy, Debug, Clone, PartialEq, Eq)] +pub enum FixedTypeKind { + U8, + U16, + U32, + U64, + I8, + I16, + I32, + I64, + F32, + F64, + Bool, + String, +} + +impl fmt::Display for FixedTypeKind { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let text = match self { + Self::U8 => "u8", + Self::U16 => "u16", + Self::U32 => "u32", + Self::U64 => "u64", + Self::I8 => "i8", + Self::I16 => "i16", + Self::I32 => "i32", + Self::I64 => "i64", + Self::F32 => "f32", + Self::F64 => "f64", + Self::Bool => "bool", + Self::String => "string", + }; + text.fmt(f) + } +} + +impl FixedTypeKind { + pub fn to_sv_string(&self) -> String { + let text = match self { + Self::U8 => "byte unsigned", + Self::U16 => "shortint unsigned", + Self::U32 => "int unsigned", + Self::U64 => "longint unsigned", + Self::I8 => "byte signed", + Self::I16 => "shortint signed", + Self::I32 => "int signed", + Self::I64 => "longint signed", + Self::F32 => "shortreal", + Self::F64 => "real", + Self::Bool => "logic", + Self::String => "string", + }; + text.to_string() + } +} + +impl From<&syntax_tree::U8> for FixedTypeKind { + fn from(_value: &syntax_tree::U8) -> Self { + Self::U8 + } +} + +impl From<&syntax_tree::U16> for FixedTypeKind { + fn from(_value: &syntax_tree::U16) -> Self { + Self::U16 + } +} + +impl From<&syntax_tree::U32> for FixedTypeKind { + fn from(_value: &syntax_tree::U32) -> Self { + Self::U32 + } +} + +impl From<&syntax_tree::U64> for FixedTypeKind { + fn from(_value: &syntax_tree::U64) -> Self { + Self::U64 + } +} + +impl From<&syntax_tree::I8> for FixedTypeKind { + fn from(_value: &syntax_tree::I8) -> Self { + Self::I8 + } +} + +impl From<&syntax_tree::I16> for FixedTypeKind { + fn from(_value: &syntax_tree::I16) -> Self { + Self::I16 + } +} + +impl From<&syntax_tree::I32> for FixedTypeKind { + fn from(_value: &syntax_tree::I32) -> Self { + Self::I32 + } +} + +impl From<&syntax_tree::I64> for FixedTypeKind { + fn from(_value: &syntax_tree::I64) -> Self { + Self::I64 + } +} + +impl From<&syntax_tree::F32> for FixedTypeKind { + fn from(_value: &syntax_tree::F32) -> Self { + Self::F32 + } +} + +impl From<&syntax_tree::F64> for FixedTypeKind { + fn from(_value: &syntax_tree::F64) -> Self { + Self::F64 + } +} + +impl From<&syntax_tree::Bool> for FixedTypeKind { + fn from(_value: &syntax_tree::Bool) -> Self { + Self::Bool + } +} + +impl From<&syntax_tree::Strin> for FixedTypeKind { + fn from(_value: &syntax_tree::Strin) -> Self { + Self::String + } +} + +impl From<&syntax_tree::FixedType> for FixedTypeKind { + fn from(value: &syntax_tree::FixedType) -> Self { + match value { + syntax_tree::FixedType::U8(x) => x.u8.as_ref().into(), + syntax_tree::FixedType::U16(x) => x.u16.as_ref().into(), + syntax_tree::FixedType::U32(x) => x.u32.as_ref().into(), + syntax_tree::FixedType::U64(x) => x.u64.as_ref().into(), + syntax_tree::FixedType::I8(x) => x.i8.as_ref().into(), + syntax_tree::FixedType::I16(x) => x.i16.as_ref().into(), + syntax_tree::FixedType::I32(x) => x.i32.as_ref().into(), + syntax_tree::FixedType::I64(x) => x.i64.as_ref().into(), + syntax_tree::FixedType::F32(x) => x.f32.as_ref().into(), + syntax_tree::FixedType::F64(x) => x.f64.as_ref().into(), + syntax_tree::FixedType::Bool(x) => x.bool.as_ref().into(), + syntax_tree::FixedType::Strin(x) => x.strin.as_ref().into(), + } + } +} + #[derive(Copy, Debug, Clone, PartialEq, Eq)] pub enum GenericSymbolPathKind { Identifier, - FixedType, + FixedType(FixedTypeKind), IntegerBased, IntegerBaseLess, IntegerAllBit, @@ -272,7 +419,7 @@ impl fmt::Display for GenericSymbolPathKind { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let text = match self { GenericSymbolPathKind::Identifier => "identifier".to_string(), - GenericSymbolPathKind::FixedType => "fixed type".to_string(), + GenericSymbolPathKind::FixedType(x) => x.to_string(), GenericSymbolPathKind::IntegerBased => "integer based".to_string(), GenericSymbolPathKind::IntegerBaseLess => "integer base less".to_string(), GenericSymbolPathKind::IntegerAllBit => "integer all bit".to_string(), @@ -658,28 +805,15 @@ impl From<&Token> for GenericSymbolPath { impl From<&syntax_tree::FixedType> for GenericSymbolPath { fn from(value: &syntax_tree::FixedType) -> Self { - let token = match value { - syntax_tree::FixedType::U8(x) => x.u8.u8_token.token, - syntax_tree::FixedType::U16(x) => x.u16.u16_token.token, - syntax_tree::FixedType::U32(x) => x.u32.u32_token.token, - syntax_tree::FixedType::U64(x) => x.u64.u64_token.token, - syntax_tree::FixedType::I8(x) => x.i8.i8_token.token, - syntax_tree::FixedType::I16(x) => x.i16.i16_token.token, - syntax_tree::FixedType::I32(x) => x.i32.i32_token.token, - syntax_tree::FixedType::I64(x) => x.i64.i64_token.token, - syntax_tree::FixedType::F32(x) => x.f32.f32_token.token, - syntax_tree::FixedType::F64(x) => x.f64.f64_token.token, - syntax_tree::FixedType::Bool(x) => x.bool.bool_token.token, - syntax_tree::FixedType::Strin(x) => x.strin.string_token.token, - }; - + let token: TokenRange = value.into(); + let kind: FixedTypeKind = value.into(); GenericSymbolPath { paths: vec![GenericSymbol { - base: token, + base: token.beg, arguments: Vec::new(), }], - kind: GenericSymbolPathKind::FixedType, - range: token.into(), + kind: GenericSymbolPathKind::FixedType(kind), + range: token, } } } diff --git a/crates/emitter/src/emitter.rs b/crates/emitter/src/emitter.rs index a8014890e..c7c4124b4 100644 --- a/crates/emitter/src/emitter.rs +++ b/crates/emitter/src/emitter.rs @@ -13,7 +13,9 @@ use veryl_analyzer::symbol::TypeModifierKind as SymTypeModifierKind; use veryl_analyzer::symbol::{ GenericMap, GenericTables, Port, Symbol, SymbolId, SymbolKind, TypeKind, VariableAffiliation, }; -use veryl_analyzer::symbol_path::{GenericSymbolPath, GenericSymbolPathKind, SymbolPath}; +use veryl_analyzer::symbol_path::{ + FixedTypeKind, GenericSymbolPath, GenericSymbolPathKind, SymbolPath, +}; use veryl_analyzer::symbol_table::{self, ResolveError, ResolveResult}; use veryl_analyzer::{msb_table, namespace_table}; use veryl_metadata::{Build, BuiltinType, ClockType, Format, Metadata, ResetType, SourceMapTarget}; @@ -2176,7 +2178,8 @@ impl VerylWalker for Emitter { /// Semantic action for non-terminal 'Bool' fn bool(&mut self, arg: &Bool) { - self.veryl_token(&arg.bool_token.replace("logic")); + let kind: FixedTypeKind = arg.into(); + self.veryl_token(&arg.bool_token.replace(&kind.to_sv_string())); } /// Semantic action for non-terminal 'Clock' @@ -2226,12 +2229,14 @@ impl VerylWalker for Emitter { /// Semantic action for non-terminal 'F32' fn f32(&mut self, arg: &F32) { - self.veryl_token(&arg.f32_token.replace("shortreal")); + let kind: FixedTypeKind = arg.into(); + self.veryl_token(&arg.f32_token.replace(&kind.to_sv_string())); } /// Semantic action for non-terminal 'F64' fn f64(&mut self, arg: &F64) { - self.veryl_token(&arg.f64_token.replace("real")); + let kind: FixedTypeKind = arg.into(); + self.veryl_token(&arg.f64_token.replace(&kind.to_sv_string())); } /// Semantic action for non-terminal 'False' @@ -2241,22 +2246,26 @@ impl VerylWalker for Emitter { /// Semantic action for non-terminal 'I8' fn i8(&mut self, arg: &I8) { - self.veryl_token(&arg.i8_token.replace("byte signed")); + let kind: FixedTypeKind = arg.into(); + self.veryl_token(&arg.i8_token.replace(&kind.to_sv_string())); } /// Semantic action for non-terminal 'I16' fn i16(&mut self, arg: &I16) { - self.veryl_token(&arg.i16_token.replace("shortint signed")); + let kind: FixedTypeKind = arg.into(); + self.veryl_token(&arg.i16_token.replace(&kind.to_sv_string())); } /// Semantic action for non-terminal 'I32' fn i32(&mut self, arg: &I32) { - self.veryl_token(&arg.i32_token.replace("int signed")); + let kind: FixedTypeKind = arg.into(); + self.veryl_token(&arg.i32_token.replace(&kind.to_sv_string())); } /// Semantic action for non-terminal 'I64' fn i64(&mut self, arg: &I64) { - self.veryl_token(&arg.i64_token.replace("longint signed")); + let kind: FixedTypeKind = arg.into(); + self.veryl_token(&arg.i64_token.replace(&kind.to_sv_string())); } /// Semantic action for non-terminal 'Lsb' @@ -2294,22 +2303,26 @@ impl VerylWalker for Emitter { /// Semantic action for non-terminal 'U8' fn u8(&mut self, arg: &U8) { - self.veryl_token(&arg.u8_token.replace("byte unsigned")); + let kind: FixedTypeKind = arg.into(); + self.veryl_token(&arg.u8_token.replace(&kind.to_sv_string())); } /// Semantic action for non-terminal 'U16' fn u16(&mut self, arg: &U16) { - self.veryl_token(&arg.u16_token.replace("shortint unsigned")); + let kind: FixedTypeKind = arg.into(); + self.veryl_token(&arg.u16_token.replace(&kind.to_sv_string())); } /// Semantic action for non-terminal 'U32' fn u32(&mut self, arg: &U32) { - self.veryl_token(&arg.u32_token.replace("int unsigned")); + let kind: FixedTypeKind = arg.into(); + self.veryl_token(&arg.u32_token.replace(&kind.to_sv_string())); } /// Semantic action for non-terminal 'U64' fn u64(&mut self, arg: &U64) { - self.veryl_token(&arg.u64_token.replace("longint unsigned")); + let kind: FixedTypeKind = arg.into(); + self.veryl_token(&arg.u64_token.replace(&kind.to_sv_string())); } /// Semantic action for non-terminal 'Identifier' @@ -2410,10 +2423,16 @@ impl VerylWalker for Emitter { } (Err(_), path) if !path.is_resolvable() => { // emit literal by generics - let text = if let GenericSymbolPathKind::Boolean(x) = path.kind { - if x { "1'b1" } else { "1'b0" } - } else { - &path.base_path(0).0[0].to_string() + let text = match path.kind { + GenericSymbolPathKind::Boolean(x) => { + if x { + "1'b1" + } else { + "1'b0" + } + } + GenericSymbolPathKind::FixedType(x) => &x.to_sv_string(), + _ => &path.base_path(0).0[0].to_string(), }; self.identifier(&Identifier { identifier_token: arg.identifier().replace(text), diff --git a/testcases/map/57_generic_package.sv.map b/testcases/map/57_generic_package.sv.map index 1fee63283..50af86f73 100644 --- a/testcases/map/57_generic_package.sv.map +++ b/testcases/map/57_generic_package.sv.map @@ -1 +1 @@ -{"version":3,"file":"57_generic_package.sv.map","sources":["../veryl/57_generic_package.veryl"],"names":["","/// Generic package test for doc comment","package","veryl_testcase___Package57A__1",";","localparam","int unsigned","X","=","1","endpackage","veryl_testcase___Package57A__2","2","veryl_testcase___Package57B__5","5","veryl_testcase___Package57B__3","3","veryl_testcase___Package57B__4","4","veryl_testcase___Package57B__Package57E_Y","veryl_testcase_Package57E::Y","veryl_testcase___Package57C__2","typedef struct packed","{","logic","[","]","c","StructC","veryl_testcase___Package57D__1","d0","d1","__StructD__2","veryl_testcase_Package57E","Y","module","veryl_testcase_Module57F","endmodule","veryl_testcase___Package57F__Module57F","veryl_testcase_Module57","import","::","*","A","veryl_testcase___Package57A__1::X","longint unsigned","B","veryl_testcase___Package57A__2::X","C","veryl_testcase___Package57B__3::X","D","E","veryl_testcase___Package57B__4::X","F","veryl_testcase___Package57B__Package57E_Y::X","G","veryl_testcase___Package57C__2::StructC","_c","veryl_testcase___Package57D__1::__StructD__2","_d","always_comb",".","0","u"],"mappings":"AAAAA,AAAAC;AACIC,QAAQC,8BAAqBC;IAC7BC,WAASC,aAAHC,EAAOC,EAAEC,CAACL;AACpBM;;AAEAT;AAJIC,QAAQS,8BAAqBP;IAC7BC,WAASC,aAAHC,EAAOC,EAAEI,CAACR;AACpBM;;AAEAT;AACIC,QAAQW,8BAAyBT;IACjCC,WAASC,aAAHC,EAAOC,EAAEM,CAACV;AACpBM;AAFIR,QAAQa,8BAAyBX;IACjCC,WAASC,aAAHC,EAAOC,EAAEQ,CAACZ;AACpBM;AAFIR,QAAQe,8BAAyBb;IACjCC,WAASC,aAAHC,EAAOC,EAAEU,CAACd;AACpBM;AAFIR,QAAQiB,yCAAyBf;IACjCC,WAASC,aAAHC,EAAOC,EAAEY,4BAAChB;AACpBM;;AAEAR,QAAQmB,8BAAqBjB;IACzBkB,sBAAeC;QACRC,MAAKC,CAACb,KAACc,EAAVC,CAAWvB;MADRwB,QAEP5B;AACJU;;AAEAR,QAAQ2B,8BAAqBzB;IACzBkB,sBAAyBC;QACjBC,MAAKC,CAAChB,KAACiB,EAAXI,EAAY1B;QACRoB,MAAKC,CAACb,KAACc,EAAXK,EAAY3B;MAFT4B,aAGPhC;AACJU;;AAEAR,QAAQ+B,yBAAW7B;IACfC,WAASC,aAAH4B,EAAO1B,EAAEC,CAACL;AACpBM;;;AAGAyB,OAAOC,wBAA6BhC;AAACiC;;;AAKrCnC,QAAQoC,sCAAoDlC;;;AAE5DM;;AAEAyB,OAAOI,uBAASnC;IACZoC,OAAOpB,4BAAahB;IACpBoC,OAAO3B,8BAAe4B,EAAEC,CAACtC;;;IACzBC,WAASC,iBAAHqC,EAAOnC,EAAEoC,iCAAkBxC;IACjCC,WAASwC,iBAAHC,EAAOtC,EAAEuC,iCAAkB3C;IACjCC,WAASC,iBAAH0C,EAAOxC,EAAEyC,iCAAkB7C;IACjCC,WAASC,iBAAH4C,EAAO1C,EAAEyC,iCAAkB7C;IACjCC,WAASwC,iBAAHM,EAAO3C,EAAE4C,iCAAiBhD;IAChCC,WAASwC,iBAAHQ,EAAO7C,EAAE8C,4CAAkBlD;IACjCC,WAASwC,iBAAHU,EAAO/C,EAAED,CAACH;;IAELoD,6CAAPC,KAAoCrD;IAC7BsD,6CAAPC,KAAoCvD;IACxCwD,YAAOH,EAAEI,CAAClC,GAAGnB,EAAEC,CAACL;IAChBwD,YAAOD,EAAEE,CAAC/B,GAAGtB,EAAEsD,CAAC1D;IAChBwD,YAAOD,EAAEE,CAAC9B,GAAGvB,EAAEC,CAACL;;IAEhBJ,AAAQoC,yBAAH2B,IAAsC3D;AAC/CiC"} \ No newline at end of file +{"version":3,"file":"57_generic_package.sv.map","sources":["../veryl/57_generic_package.veryl"],"names":["","/// Generic package test for doc comment","package","veryl_testcase___Package57A__1",";","localparam","int unsigned","X","=","1","endpackage","veryl_testcase___Package57A__2","2","veryl_testcase___Package57B__5","5","veryl_testcase___Package57B__3","3","veryl_testcase___Package57B__4","4","veryl_testcase___Package57B__Package57E_Y","veryl_testcase_Package57E::Y","veryl_testcase___Package57C__2","typedef struct packed","{","logic","[","]","c","StructC","veryl_testcase___Package57D__1","d0","d1","__StructD__2","veryl_testcase_Package57E","Y","module","veryl_testcase_Module57F","endmodule","veryl_testcase___Package57F__Module57F","veryl_testcase___Package57G__i32","typedef","int signed","TYPE","veryl_testcase___Package57G__u32","veryl_testcase___Package57G__bool","veryl_testcase_Module57","import","::","*","A","veryl_testcase___Package57A__1::X","longint unsigned","B","veryl_testcase___Package57A__2::X","C","veryl_testcase___Package57B__3::X","D","E","veryl_testcase___Package57B__4::X","F","veryl_testcase___Package57B__Package57E_Y::X","G","veryl_testcase___Package57C__2::StructC","_c","veryl_testcase___Package57D__1::__StructD__2","_d","always_comb",".","0","u","veryl_testcase___Package57G__i32::TYPE","_e","veryl_testcase___Package57G__u32::TYPE","_f","veryl_testcase___Package57G__bool::TYPE","_g","1'b0"],"mappings":"AAAAA,AAAAC;AACIC,QAAQC,8BAAqBC;IAC7BC,WAASC,aAAHC,EAAOC,EAAEC,CAACL;AACpBM;;AAEAT;AAJIC,QAAQS,8BAAqBP;IAC7BC,WAASC,aAAHC,EAAOC,EAAEI,CAACR;AACpBM;;AAEAT;AACIC,QAAQW,8BAAyBT;IACjCC,WAASC,aAAHC,EAAOC,EAAEM,CAACV;AACpBM;AAFIR,QAAQa,8BAAyBX;IACjCC,WAASC,aAAHC,EAAOC,EAAEQ,CAACZ;AACpBM;AAFIR,QAAQe,8BAAyBb;IACjCC,WAASC,aAAHC,EAAOC,EAAEU,CAACd;AACpBM;AAFIR,QAAQiB,yCAAyBf;IACjCC,WAASC,aAAHC,EAAOC,EAAEY,4BAAChB;AACpBM;;AAEAR,QAAQmB,8BAAqBjB;IACzBkB,sBAAeC;QACRC,MAAKC,CAACb,KAACc,EAAVC,CAAWvB;MADRwB,QAEP5B;AACJU;;AAEAR,QAAQ2B,8BAAqBzB;IACzBkB,sBAAyBC;QACjBC,MAAKC,CAAChB,KAACiB,EAAXI,EAAY1B;QACRoB,MAAKC,CAACb,KAACc,EAAXK,EAAY3B;MAFT4B,aAGPhC;AACJU;;AAEAR,QAAQ+B,yBAAW7B;IACfC,WAASC,aAAH4B,EAAO1B,EAAEC,CAACL;AACpBM;;;AAGAyB,OAAOC,wBAA6BhC;AAACiC;;;AAKrCnC,QAAQoC,sCAAoDlC;;;AAE5DM;;AAEAR,QAAQqC,gCAAsBnC;IAC1BoC,QAAYC,WAAPC,IAAQtC;AACjBM;AAFAR,QAAQyC,gCAAsBvC;IAC1BoC,QAAYlC,aAAPoC,IAAQtC;AACjBM;AAFAR,QAAQ0C,iCAAsBxC;IAC1BoC,QAAYhB,MAAPkB,IAAQtC;AACjBM;;AAEAyB,OAAOU,uBAASzC;IACZ0C,OAAO1B,4BAAahB;IACpB0C,OAAOjC,8BAAekC,EAAEC,CAAC5C;;;IACzBC,WAASC,iBAAH2C,EAAOzC,EAAE0C,iCAAkB9C;IACjCC,WAAS8C,iBAAHC,EAAO5C,EAAE6C,iCAAkBjD;IACjCC,WAASC,iBAAHgD,EAAO9C,EAAE+C,iCAAkBnD;IACjCC,WAASC,iBAAHkD,EAAOhD,EAAE+C,iCAAkBnD;IACjCC,WAAS8C,iBAAHM,EAAOjD,EAAEkD,iCAAiBtD;IAChCC,WAAS8C,iBAAHQ,EAAOnD,EAAEoD,4CAAkBxD;IACjCC,WAAS8C,iBAAHU,EAAOrD,EAAED,CAACH;;IAEL0D,6CAAPC,KAAoC3D;IAC7B4D,6CAAPC,KAAoC7D;IACxC8D,YAAOH,EAAEI,CAACxC,GAAGnB,EAAEC,CAACL;IAChB8D,YAAOD,EAAEE,CAACrC,GAAGtB,EAAE4D,CAAChE;IAChB8D,YAAOD,EAAEE,CAACpC,GAAGvB,EAAEC,CAACL;;IAEhBJ,AAAQoC,yBAAHiC,IAAsCjE;;IAEnCkE,wCAAJC,gBAAAA,GAA6B/D,EAAE4D,CAAChE;IAC5BoE,wCAAJC,gBAAAA,GAA6BjE,EAAE4D,CAAChE;IAC5BsE,wCAAJC,gBAAAA,GAA6BnE,EAAEoE,IAAKxE;AAC5CiC"} \ No newline at end of file diff --git a/testcases/sv/57_generic_package.sv b/testcases/sv/57_generic_package.sv index f1a0e5662..e2a23e832 100644 --- a/testcases/sv/57_generic_package.sv +++ b/testcases/sv/57_generic_package.sv @@ -49,6 +49,16 @@ package veryl_testcase___Package57F__Module57F; endpackage +package veryl_testcase___Package57G__i32; + typedef int signed TYPE; +endpackage +package veryl_testcase___Package57G__u32; + typedef int unsigned TYPE; +endpackage +package veryl_testcase___Package57G__bool; + typedef logic TYPE; +endpackage + module veryl_testcase_Module57; import veryl_testcase_Package57E::Y; import veryl_testcase___Package57B__5::*; @@ -69,5 +79,9 @@ module veryl_testcase_Module57; always_comb _d.d1 = 1; veryl_testcase_Module57F u (); + + veryl_testcase___Package57G__i32::TYPE _e; always_comb _e = 0; + veryl_testcase___Package57G__u32::TYPE _f; always_comb _f = 0; + veryl_testcase___Package57G__bool::TYPE _g; always_comb _g = 1'b0; endmodule //# sourceMappingURL=../map/57_generic_package.sv.map diff --git a/testcases/veryl/57_generic_package.veryl b/testcases/veryl/57_generic_package.veryl index fe4dc8955..24d250301 100644 --- a/testcases/veryl/57_generic_package.veryl +++ b/testcases/veryl/57_generic_package.veryl @@ -35,6 +35,10 @@ package Package57F:: for ProtoPackage57F { alias module InstModule = M; } +package Package57G:: { + type TYPE = T; +} + module Module57 { import Package57E::Y; import Package57B::<5>::*; @@ -53,4 +57,8 @@ module Module57 { assign _d.d1 = 1; inst u: Package57F::::InstModule; + + let _e: Package57G::::TYPE = 0; + let _f: Package57G::::TYPE = 0; + let _g: Package57G::::TYPE = false; }