statement types in resolver

starkware-libs · Sep 30, 2024 · 22587d4 · 22587d4
1 parent cb7675d
commit 22587d4
Show file tree

Hide file tree

Showing 12 changed files with 1,349 additions and 71 deletions.
diff --git a/corelib/src/test/language_features/block_level_items_test.cairo b/corelib/src/test/language_features/block_level_items_test.cairo
@@ -46,25 +46,25 @@ fn test_global_const_to_let_shadowing() {
     assert_eq!(A, 4);
 }
 
-pub mod X {
+pub mod single_const {
     pub const A: u8 = 1;
 }
 
 #[test]
 fn test_use_usage() {
-    use X::A;
+    use single_const::A;
     assert_eq!(A, 1);
 }
 
 #[test]
 fn test_use_usage_with_alias() {
-    use X::A as B;
+    use single_const::A as B;
     assert_eq!(B, 1);
 }
 
 #[test]
 fn test_use_constant_shadowing() {
-    use X::A;
+    use single_const::A;
     assert_eq!(A, 1);
     {
         const A: u8 = 4;
@@ -73,17 +73,17 @@ fn test_use_constant_shadowing() {
     assert_eq!(A, 1);
 }
 
-pub mod Y {
+pub mod double_const {
     pub const A: u8 = 4;
     pub const B: u8 = 6;
 }
 
 #[test]
 fn test_use_use_shadowing() {
-    use X::A;
+    use single_const::A;
     assert_eq!(A, 1);
     {
-        use Y::A;
+        use double_const::A;
         assert_eq!(A, 4);
     }
     assert_eq!(A, 1);
@@ -94,15 +94,15 @@ fn test_const_use_shadowing() {
     const A: u8 = 1;
     assert_eq!(A, 1);
     {
-        use Y::A;
+        use double_const::A;
         assert_eq!(A, 4);
     }
     assert_eq!(A, 1);
 }
 
 #[test]
 fn test_use_let_shadowing() {
-    use X::A;
+    use single_const::A;
     assert_eq!(A, 1);
     {
         let A = 4;
@@ -116,15 +116,69 @@ fn test_let_use_shadowing() {
     let A = 1;
     assert_eq!(A, 1);
     {
-        use Y::A;
+        use double_const::A;
         assert_eq!(A, 4);
     }
     assert_eq!(A, 1);
 }
 
 #[test]
 fn test_multiple_use() {
-    use Y::{A, B};
+    use double_const::{A, B};
     assert_eq!(A, 4);
     assert_eq!(B, 6);
 }
+
+pub mod generic_type {
+    pub struct S {
+        pub x: u8,
+    }
+    pub enum E {
+        A: u8,
+        B: u16,
+    }
+}
+
+#[test]
+fn test_type_struct_usage() {
+    use generic_type::S;
+    let s = S { x: 1 };
+    assert_eq!(s.x, 1);
+}
+
+#[test]
+fn test_type_enum_usage() {
+    use generic_type::E;
+    let e = E::A(1);
+    match e {
+        E::A(val) => assert_eq!(val, 1),
+        E::B(_) => panic!("Shouldn't get here"),
+    }
+}
+
+pub mod generic_type_generics {
+    pub struct S<T> {
+        pub x: T,
+    }
+    pub enum E<T> {
+        A: T,
+        B: u16,
+    }
+}
+
+#[test]
+fn test_type_struct_generic_usage() {
+    use generic_type_generics::S;
+    let s = S::<u8> { x: 1 };
+    assert_eq!(s.x, 1);
+}
+
+#[test]
+fn test_type_enum_generic_usage() {
+    use generic_type_generics::E;
+    let e = E::A::<u8>(1);
+    match e {
+        E::A(val) => assert_eq!(val, 1),
+        E::B(_) => panic!("Shouldn't get here"),
+    }
+}
diff --git a/crates/cairo-lang-language-server/src/ide/semantic_highlighting/token_kind.rs b/crates/cairo-lang-language-server/src/ide/semantic_highlighting/token_kind.rs
@@ -163,7 +163,9 @@ impl SemanticTokenKind {
                         ResolvedConcreteItem::Module(_) => SemanticTokenKind::Namespace,
                         ResolvedConcreteItem::Function(_)
                         | ResolvedConcreteItem::TraitFunction(_) => SemanticTokenKind::Function,
-                        ResolvedConcreteItem::Type(_) => SemanticTokenKind::Type,
+                        ResolvedConcreteItem::Type(_) | ResolvedConcreteItem::Statement(_) => {
+                            SemanticTokenKind::Type
+                        }
                         ResolvedConcreteItem::Variant(_) => SemanticTokenKind::EnumMember,
                         ResolvedConcreteItem::Trait(_) => SemanticTokenKind::Interface,
                         ResolvedConcreteItem::Impl(_) => SemanticTokenKind::Class,

diff --git a/crates/cairo-lang-language-server/src/lang/inspect/defs.rs b/crates/cairo-lang-language-server/src/lang/inspect/defs.rs
@@ -95,7 +95,8 @@ impl SymbolDef {
             | ResolvedItem::Concrete(ResolvedConcreteItem::Type(_))
             | ResolvedItem::Concrete(ResolvedConcreteItem::Variant(_))
             | ResolvedItem::Concrete(ResolvedConcreteItem::Trait(_))
-            | ResolvedItem::Concrete(ResolvedConcreteItem::Impl(_)) => {
+            | ResolvedItem::Concrete(ResolvedConcreteItem::Impl(_))
+            | ResolvedItem::Concrete(ResolvedConcreteItem::Statement(_)) => {
                 ItemDef::new(db, &definition_node).map(Self::Item)
             }
 

diff --git a/crates/cairo-lang-semantic/src/diagnostic.rs b/crates/cairo-lang-semantic/src/diagnostic.rs
@@ -490,6 +490,9 @@ impl DiagnosticEntry for SemanticDiagnostic {
                     identifier_name
                 )
             }
+            SemanticDiagnosticKind::MultipleGenericItemDefinition(type_name) => {
+                format!(r#"Multiple definitions of an item "{}"."#, type_name)
+            }
             SemanticDiagnosticKind::UnsupportedUseItemInStatement => {
                 "Unsupported use item in statement.".into()
             }
@@ -1104,6 +1107,7 @@ pub enum SemanticDiagnosticKind {
     UnusedUse,
     MultipleConstantDefinition(SmolStr),
     MultipleDefinitionforBinding(SmolStr),
+    MultipleGenericItemDefinition(SmolStr),
     UnsupportedUseItemInStatement,
     ConstGenericParamNotSupported,
     NegativeImplsNotEnabled,
@@ -1295,6 +1299,7 @@ impl From<&ResolvedConcreteItem> for ElementKind {
             ResolvedConcreteItem::Variant(_) => ElementKind::Variant,
             ResolvedConcreteItem::Trait(_) => ElementKind::Trait,
             ResolvedConcreteItem::Impl(_) => ElementKind::Impl,
+            ResolvedConcreteItem::Statement(_) => ElementKind::Type,
         }
     }
 }