Types from beginning to end

TODO.md

@@ -10,6 +10,12 @@
   - [ ] Function bodies must be blocks or preceded by `=`.
   - [ ] `ext` functions may have a body.
   - [ ] Implicit cast sema pass: `a + b` where `a` is a `byte` and `b` an `integer` -> `(a as integer) + b`
+  - [ ] Testing Framework: Add ability to only show failing tests
+  - [ ] `x as void` used to discard `x`
+  - [ ] Resolve the two different kinds of array-type loading: entire copy vs pointer decay. Basically, `foo[2]` needs `foo` to be loaded as a pointer. `a : foo[2] = b` requires loading entire copy of `b` into `a`.
+- [ ] Optimisation
+  - [ ] Zero subscript still does add/multiply when it doesn't need to
+  - [ ] Eliminate unused parameters (they are currently allocated registers)
 - [ ] Attributes
   - [ ] Parsing
   - [ ] `[[noreturn]]`
@@ -36,12 +42,14 @@
     - [ ] Disallow overloading on the return value.
   - [ ] Proper checking for incomplete types in the parser.
 - [ ] Types in the IR
-  - [ ] Byte type
-  - [ ] Type info in codegen/IR.
+  - [x] Byte type
+  - [x] Type info in codegen/IR.
   - [ ] Backend: Handle size/alignment requirements
-  - [ ] Use eax, ax, al, etc.
+  - [x] Use eax, ax, al, etc.
   - [ ] Actually implementing casts.
+    - [ ] During codegen, we should actually output `zext`/`sext` if needed. Otherwise truncation is automatic.
   - [ ] Update IR parser
+  - [ ] Operators (unary and binary) need to pick return type instead of strictly returning `integer`
 - [ ] Arrays
   - [ ] Semantic analysis for static arrays.
   - [ ] Codegen
@@ -57,7 +65,7 @@
   - [ ] Length operator: `#`
   - [ ] Subscripting
 - [ ] Strings
-  - [ ] Parsing string literals.
+  - [x] Parsing string literals.
   - [ ] Codegen.
   - [ ] Backend.
 - [ ] Structs
@@ -69,6 +77,7 @@
   - [ ] `type` keyword in the parser/grammar.
   - [ ] Make sure nested structs work.
   - [ ] Arbitrary compile-time struct literals.
+    - [ ] Syntax?
   - [ ] Structs as parameters.
   - [ ] Structs as return values.
 - [ ] Modules.

examples/byte.un

@@ -0,0 +1,4 @@
+a : byte = 34
+b : byte = 35
+c : byte = a + b
+c

examples/bytearray.un

@@ -0,0 +1,15 @@
+; 0
+; Eyyy
+
+puts : ext integer(str : @byte)
+
+foo : byte[69]
+@foo[0] := 69
+@foo[1] := 121
+@foo[2] := 121
+@foo[3] := 121
+@foo[4] := 0
+
+puts(foo[0])
+
+0

examples/string_literals.un

@@ -0,0 +1,6 @@
+puts : ext void(s : @byte)
+
+str : @byte = "Hello, LISP programmer!"[0]
+
+puts(str)
+0

src/ast.c

@@ -9,17 +9,23 @@
   usz alignment;
   span name;
   bool is_signed;
+  /// A unique ID that is used to compare primitives.
   uint8_t id;
 } TypePrimitive;*/
 static Type t_void_def = {
-    .kind = TYPE_PRIMITIVE,
-    .source_location = {0},
-    .primitive = {
-        .size = 0,
-        .alignment = 0,
-        .name = literal_span_raw("void"),
-        .id = 0,
-    },
+  .kind = TYPE_PRIMITIVE,
+  .source_location = {0},
+  .primitive = {
+    .size = 0,
+    .alignment = 0,
+    .name = literal_span_raw("void"),
+  },
+};
+
+static Type t_void_pointer_def = {
+  .kind = TYPE_POINTER,
+  .source_location = {0},
+  .pointer = { .to = &t_void_def },
 };
 
 static Type t_integer_literal_def = {
@@ -30,34 +36,33 @@ static Type t_integer_literal_def = {
     .alignment = 8,
     .name = literal_span_raw("<integer_literal>"),
     .is_signed = true,
-    .id = 1,
   },
 };
 
 static Type t_integer_def = {
-    .kind = TYPE_PRIMITIVE,
-    .source_location = {0},
-    .primitive = {
-        .size = 8,
-        .alignment = 8,
-        .name = literal_span_raw("integer"),
-        .is_signed = true,
-        .id = 1,
-    },
+  .kind = TYPE_PRIMITIVE,
+  .source_location = {0},
+  .primitive = {
+    .size = 8,
+    .alignment = 8,
+    .name = literal_span_raw("integer"),
+    .is_signed = true,
+  },
 };
 
 static Type t_byte_def = {
-    .kind = TYPE_PRIMITIVE,
-    .source_location = {0},
-    .primitive = {
-        .size = 1,
-        .alignment = 1,
-        .name = literal_span_raw("byte"),
-        .id = 3,
-    },
+  .kind = TYPE_PRIMITIVE,
+  .source_location = {0},
+  .primitive = {
+    .size = 1,
+    .alignment = 1,
+    .name = literal_span_raw("byte"),
+    .is_signed = false,
+  },
 };
 
 Type * const t_void = &t_void_def;
+Type * const t_void_ptr = &t_void_pointer_def;
 Type * const t_integer_literal = &t_integer_literal_def;
 Type * const t_integer = &t_integer_def;
 Type * const t_byte = &t_byte_def;
@@ -497,10 +502,25 @@ usz type_sizeof(Type *type) {
   }
 }
 
+usz type_alignof(Type *type) {
+  TODO("Unimplemented, sorry");
+  return 69;
+}
+
 bool type_is_void(Type *type) {
   return type_canonical(type) == t_void;
 }
 
+bool type_is_pointer(Type *type) {
+  Type * t = type_canonical(type);
+  return t && t->kind == TYPE_POINTER;
+}
+
+bool type_is_array(Type *type) {
+  Type * t = type_canonical(type);
+  return t && t->kind == TYPE_ARRAY;
+}
+
 /// ===========================================================================
 ///  Miscellaneous AST functions.
 /// ===========================================================================
@@ -597,7 +617,7 @@ static void ast_print_children(
 );
 
 /// Print a node.
-static void ast_print_node(
+void ast_print_node_internal(
   FILE *file,
   const Node *logical_parent,
   const Node *node,
@@ -745,6 +765,12 @@ static void ast_print_node(
   }
 }
 
+void ast_print_node(const Node *node) {
+  string_buffer buf = {0};
+  ast_print_node_internal(stdout, NULL, node, &buf);
+  vector_delete(buf);
+}
+
 /// Scope tree for printing scopes.
 typedef struct scope_tree_node {
   const Scope *scope;
@@ -826,7 +852,7 @@ void ast_print(FILE *file, const AST *ast) {
   string_buffer buf = {0};
 
   /// Print the root node.
-  ast_print_node(file, NULL, ast->root, &buf);
+  ast_print_node_internal(file, NULL, ast->root, &buf);
 }
 
 /// Print the children of a node.
@@ -851,7 +877,7 @@ static void ast_print_children(
     format_to(buf, "%s", node == vector_back(*nodes) ? "  " : "│ ");
 
     /// Print the node.
-    ast_print_node(file, logical_parent, node, buf);
+    ast_print_node_internal(file, logical_parent, node, buf);
 
     /// Restore the leading text.
     buf->size = sz;