3 files changed, 122 insertions, 109 deletions

diff --git a/src/main.c b/src/main.c
index 40d9ad0..b0207f7 100644
--- a/src/main.c
+++ b/src/main.c
@@ -856,7 +856,6 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
             node->type = type->val.name;
             return node->type;
         } break;
-        case NODE_SYMBOL_IDX:
         case NODE_SYMBOL: {
             Str symbol = node->value.str;
             SymbolMap *type = find_type(scope, symbol);
diff --git a/tests/semantics.bad b/tests/semantics.bad
index e5178f2..b0cc26e 100644
--- a/tests/semantics.bad
+++ b/tests/semantics.bad
@@ -1,30 +1,24 @@
-; fun foo(a: int): int {
-;     1
-; }
-; fun bar(): int {
-;     fun foo(): int 1 + 2
-;     1 
-; }
-struct vec {
-    x: f64
-    y: f64
-    huh: {
-        z: int
-        id: str
-    }
-}
-let a = 1
-
-match a {
-    case 1 = "ha"
-    case 2 = "ho"
-}
-
-cond {
-    1 == 1 = "ha"
-    2 != 2 = "ho"
-}
-
+; We can have static arrays and have indexed access.
+; let numbers: int[0xff]
+let numbers: int[0xff]
+set numbers[0] = 32
+set numbers[1] = numbers[0]
+
+; ; Arrays are syntactic sugar for pointers (@).
+; let ptr:@u32 = numbers
+; set ptr[10] = 33
+
+; ; Strings hold a .mem and .size fields with the number of bytes it holds.
+; let hello: str = "hello world"
+; set c[1] = 'a' ; "hallo world"
+
+; ; fun foo(a: int): int {
+; ;     1
+; ; }
+; ; fun bar(): int {
+; ;     fun foo(): int 1 + 2
+; ;     1 
+; ; }
 ; struct vec {
 ;     x: f64
 ;     y: f64
@@ -33,88 +27,108 @@ cond {
 ;         id: str
 ;     }
 ; }
+; let a = 1
 
-; let v: vec = vec : {
-;     x = 10.0
-;     huh = {
-;         z = 10
-;         id = "blah"
-;     }
+; match a {
+;     case 1 = "ha"
+;     case 2 = "ho"
 ; }
 
-; fun foo(): nil {
-;     struct vec {
-;         z: f64
-;     }
-;     let a: vec
-;     set a.z = 1.0
+; cond {
+;     1 == 1 = "ha"
+;     2 != 2 = "ho"
 ; }
 
-; struct vec {
-;     x: f64 = 2.0
-;     y: f64 = 1.0
-;     bruh: {
-;         id:  int = 10
-;         msg: str = "hello"
-;         inner: {
-;             x: int = 32
-;             y: str
-;         }
-;     }
-; }
+; ; struct vec {
+; ;     x: f64
+; ;     y: f64
+; ;     huh: {
+; ;         z: int
+; ;         id: str
+; ;     }
+; ; }
 
-; let v: vec
-; set v.x = 1.0
-; set v.bruh.id = 1
-; set v.bruh.inner.y = "yo"
-
-; set v = vec : { 
-;     x = 1.0 
-;     y = 32.0
-;     ; bruh = dud : {
-;     ;     id = 1
-;     ; }
-; }
+; ; let v: vec = vec : {
+; ;     x = 10.0
+; ;     huh = {
+; ;         z = 10
+; ;         id = "blah"
+; ;     }
+; ; }
 
-; struct person {
-;     name: str = "joe"
-;     age: int = 18 * 2
-; }
+; ; fun foo(): nil {
+; ;     struct vec {
+; ;         z: f64
+; ;     }
+; ;     let a: vec
+; ;     set a.z = 1.0
+; ; }
 
-; ; We can use the dot operator to access fields.
-; let player_a: person
-; set player_a.name = "alex"
+; ; struct vec {
+; ;     x: f64 = 2.0
+; ;     y: f64 = 1.0
+; ;     bruh: {
+; ;         id:  int = 10
+; ;         msg: str = "hello"
+; ;         inner: {
+; ;             x: int = 32
+; ;             y: str
+; ;         }
+; ;     }
+; ; }
 
-; struct vec {
-;     x: f64
-;     y: f64
-;     z: f64
+; ; let v: vec
+; ; set v.x = 1.0
+; ; set v.bruh.id = 1
+; ; set v.bruh.inner.y = "yo"
+
+; ; set v = vec : { 
+; ;     x = 1.0 
+; ;     y = 32.0
+; ;     ; bruh = dud : {
+; ;     ;     id = 1
+; ;     ; }
+; ; }
+
+; ; struct person {
+; ;     name: str = "joe"
+; ;     age: int = 18 * 2
+; ; }
+
+; ; ; We can use the dot operator to access fields.
+; ; let player_a: person
+; ; set player_a.name = "alex"
+
+; ; struct vec {
+; ;     x: f64
+; ;     y: f64
+; ;     z: f64
+; ; }
+; ; let v = vec : { x = 1.0 }
+
+; enum weekdays {
+;     mon = 1
+;     tue
+;     wed
+;     thu
+;     fri
+;     sat
+;     sun
+; }
+; let d = weekdays.tue
+; ; let b = a
+
+; match 1 {
+;     case 2 = "monday"
+;     case 3 = "tuesday"
+;     else = "whateverday"
 ; }
-; let v = vec : { x = 1.0 }
-
-enum weekdays {
-    mon = 1
-    tue
-    wed
-    thu
-    fri
-    sat
-    sun
-}
-let d = weekdays.tue
-; let b = a
 
-match 1 {
-    case 2 = "monday"
-    case 3 = "tuesday"
-    else = "whateverday"
-}
-
-match d {
-    case mon = "monday"
-    case tue = "tuesday"
-    else = "whateverday"
-}
+; match d {
+;     case mon = "monday"
+;     case tue = "tuesday"
+;     else = "whateverday"
+; }
 
 ; struct item {
 ;     id: int
diff --git a/tests/variables.bad b/tests/variables.bad
index ce765bc..8043c14 100644
--- a/tests/variables.bad
+++ b/tests/variables.bad
@@ -53,15 +53,15 @@ let particle = entity : {
 }
 set particle = entity : {}
 
-; ; We can have static arrays and have indexed access.
-; let numbers: u32[0xff]
-; set numbers[0] = 32
-; set numbers[1] = 42
+; We can have static arrays and have indexed access.
+let numbers: u32[0xff]
+set numbers[0] = 32
+set numbers[1] = numbers[0]
 
-; ; Arrays are syntactic sugar for pointers (@).
-; let ptr:@u32 = numbers
-; set ptr[10] = 33
+; Arrays are syntactic sugar for pointers (@).
+let ptr:@u32 = numbers
+set ptr[10] = 33
 
-; ; Strings hold a .mem and .size fields with the number of bytes it holds.
-; let hello: str = "hello world"
-; set c[1] = 'a' ; "hallo world"
+; Strings hold a .mem and .size fields with the number of bytes it holds.
+let hello: str = "hello world"
+set c[1] = 'a' ; "hallo world"