diff options
author | Bad Diode <bd@badd10de.dev> | 2024-06-26 17:56:42 +0200 |
---|---|---|
committer | Bad Diode <bd@badd10de.dev> | 2024-06-26 17:56:42 +0200 |
commit | f3e0021067c03f5434e306eeea375f0f7aa62287 (patch) | |
tree | 1fafcfdb2c6cd8be654ff02987eb0bf307bf1081 /tests/semantics.bad | |
parent | de360fb4023c4a18961817bcdb248e0720de7ec7 (diff) | |
download | bdl-f3e0021067c03f5434e306eeea375f0f7aa62287.tar.gz bdl-f3e0021067c03f5434e306eeea375f0f7aa62287.zip |
Prepare for array/pointer typechecking
Diffstat (limited to 'tests/semantics.bad')
-rw-r--r-- | tests/semantics.bad | 210 |
1 files changed, 112 insertions, 98 deletions
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 @@ | |||
1 | ; fun foo(a: int): int { | 1 | ; We can have static arrays and have indexed access. |
2 | ; 1 | 2 | ; let numbers: int[0xff] |
3 | ; } | 3 | let numbers: int[0xff] |
4 | ; fun bar(): int { | 4 | set numbers[0] = 32 |
5 | ; fun foo(): int 1 + 2 | 5 | set numbers[1] = numbers[0] |
6 | ; 1 | 6 | |
7 | ; } | 7 | ; ; Arrays are syntactic sugar for pointers (@). |
8 | struct vec { | 8 | ; let ptr:@u32 = numbers |
9 | x: f64 | 9 | ; set ptr[10] = 33 |
10 | y: f64 | 10 | |
11 | huh: { | 11 | ; ; Strings hold a .mem and .size fields with the number of bytes it holds. |
12 | z: int | 12 | ; let hello: str = "hello world" |
13 | id: str | 13 | ; set c[1] = 'a' ; "hallo world" |
14 | } | 14 | |
15 | } | 15 | ; ; fun foo(a: int): int { |
16 | let a = 1 | 16 | ; ; 1 |
17 | 17 | ; ; } | |
18 | match a { | 18 | ; ; fun bar(): int { |
19 | case 1 = "ha" | 19 | ; ; fun foo(): int 1 + 2 |
20 | case 2 = "ho" | 20 | ; ; 1 |
21 | } | 21 | ; ; } |
22 | |||
23 | cond { | ||
24 | 1 == 1 = "ha" | ||
25 | 2 != 2 = "ho" | ||
26 | } | ||
27 | |||
28 | ; struct vec { | 22 | ; struct vec { |
29 | ; x: f64 | 23 | ; x: f64 |
30 | ; y: f64 | 24 | ; y: f64 |
@@ -33,88 +27,108 @@ cond { | |||
33 | ; id: str | 27 | ; id: str |
34 | ; } | 28 | ; } |
35 | ; } | 29 | ; } |
30 | ; let a = 1 | ||
36 | 31 | ||
37 | ; let v: vec = vec : { | 32 | ; match a { |
38 | ; x = 10.0 | 33 | ; case 1 = "ha" |
39 | ; huh = { | 34 | ; case 2 = "ho" |
40 | ; z = 10 | ||
41 | ; id = "blah" | ||
42 | ; } | ||
43 | ; } | 35 | ; } |
44 | 36 | ||
45 | ; fun foo(): nil { | 37 | ; cond { |
46 | ; struct vec { | 38 | ; 1 == 1 = "ha" |
47 | ; z: f64 | 39 | ; 2 != 2 = "ho" |
48 | ; } | ||
49 | ; let a: vec | ||
50 | ; set a.z = 1.0 | ||
51 | ; } | 40 | ; } |
52 | 41 | ||
53 | ; struct vec { | 42 | ; ; struct vec { |
54 | ; x: f64 = 2.0 | 43 | ; ; x: f64 |
55 | ; y: f64 = 1.0 | 44 | ; ; y: f64 |
56 | ; bruh: { | 45 | ; ; huh: { |
57 | ; id: int = 10 | 46 | ; ; z: int |
58 | ; msg: str = "hello" | 47 | ; ; id: str |
59 | ; inner: { | 48 | ; ; } |
60 | ; x: int = 32 | 49 | ; ; } |
61 | ; y: str | ||
62 | ; } | ||
63 | ; } | ||
64 | ; } | ||
65 | 50 | ||
66 | ; let v: vec | 51 | ; ; let v: vec = vec : { |
67 | ; set v.x = 1.0 | 52 | ; ; x = 10.0 |
68 | ; set v.bruh.id = 1 | 53 | ; ; huh = { |
69 | ; set v.bruh.inner.y = "yo" | 54 | ; ; z = 10 |
70 | 55 | ; ; id = "blah" | |
71 | ; set v = vec : { | 56 | ; ; } |
72 | ; x = 1.0 | 57 | ; ; } |
73 | ; y = 32.0 | ||
74 | ; ; bruh = dud : { | ||
75 | ; ; id = 1 | ||
76 | ; ; } | ||
77 | ; } | ||
78 | 58 | ||
79 | ; struct person { | 59 | ; ; fun foo(): nil { |
80 | ; name: str = "joe" | 60 | ; ; struct vec { |
81 | ; age: int = 18 * 2 | 61 | ; ; z: f64 |
82 | ; } | 62 | ; ; } |
63 | ; ; let a: vec | ||
64 | ; ; set a.z = 1.0 | ||
65 | ; ; } | ||
83 | 66 | ||
84 | ; ; We can use the dot operator to access fields. | 67 | ; ; struct vec { |
85 | ; let player_a: person | 68 | ; ; x: f64 = 2.0 |
86 | ; set player_a.name = "alex" | 69 | ; ; y: f64 = 1.0 |
70 | ; ; bruh: { | ||
71 | ; ; id: int = 10 | ||
72 | ; ; msg: str = "hello" | ||
73 | ; ; inner: { | ||
74 | ; ; x: int = 32 | ||
75 | ; ; y: str | ||
76 | ; ; } | ||
77 | ; ; } | ||
78 | ; ; } | ||
87 | 79 | ||
88 | ; struct vec { | 80 | ; ; let v: vec |
89 | ; x: f64 | 81 | ; ; set v.x = 1.0 |
90 | ; y: f64 | 82 | ; ; set v.bruh.id = 1 |
91 | ; z: f64 | 83 | ; ; set v.bruh.inner.y = "yo" |
84 | |||
85 | ; ; set v = vec : { | ||
86 | ; ; x = 1.0 | ||
87 | ; ; y = 32.0 | ||
88 | ; ; ; bruh = dud : { | ||
89 | ; ; ; id = 1 | ||
90 | ; ; ; } | ||
91 | ; ; } | ||
92 | |||
93 | ; ; struct person { | ||
94 | ; ; name: str = "joe" | ||
95 | ; ; age: int = 18 * 2 | ||
96 | ; ; } | ||
97 | |||
98 | ; ; ; We can use the dot operator to access fields. | ||
99 | ; ; let player_a: person | ||
100 | ; ; set player_a.name = "alex" | ||
101 | |||
102 | ; ; struct vec { | ||
103 | ; ; x: f64 | ||
104 | ; ; y: f64 | ||
105 | ; ; z: f64 | ||
106 | ; ; } | ||
107 | ; ; let v = vec : { x = 1.0 } | ||
108 | |||
109 | ; enum weekdays { | ||
110 | ; mon = 1 | ||
111 | ; tue | ||
112 | ; wed | ||
113 | ; thu | ||
114 | ; fri | ||
115 | ; sat | ||
116 | ; sun | ||
117 | ; } | ||
118 | ; let d = weekdays.tue | ||
119 | ; ; let b = a | ||
120 | |||
121 | ; match 1 { | ||
122 | ; case 2 = "monday" | ||
123 | ; case 3 = "tuesday" | ||
124 | ; else = "whateverday" | ||
92 | ; } | 125 | ; } |
93 | ; let v = vec : { x = 1.0 } | ||
94 | |||
95 | enum weekdays { | ||
96 | mon = 1 | ||
97 | tue | ||
98 | wed | ||
99 | thu | ||
100 | fri | ||
101 | sat | ||
102 | sun | ||
103 | } | ||
104 | let d = weekdays.tue | ||
105 | ; let b = a | ||
106 | 126 | ||
107 | match 1 { | 127 | ; match d { |
108 | case 2 = "monday" | 128 | ; case mon = "monday" |
109 | case 3 = "tuesday" | 129 | ; case tue = "tuesday" |
110 | else = "whateverday" | 130 | ; else = "whateverday" |
111 | } | 131 | ; } |
112 | |||
113 | match d { | ||
114 | case mon = "monday" | ||
115 | case tue = "tuesday" | ||
116 | else = "whateverday" | ||
117 | } | ||
118 | 132 | ||
119 | ; struct item { | 133 | ; struct item { |
120 | ; id: int | 134 | ; id: int |