Types from beginning to end

TODO.md

@@ -65,7 +65,7 @@
   - [ ] Length operator: `#`
   - [ ] Subscripting
 - [ ] Strings
-  - [ ] Parsing string literals.
+  - [x] Parsing string literals.
   - [ ] Codegen.
   - [ ] Backend.
 - [ ] Structs

src/ast.c

@@ -62,7 +62,7 @@ static Type t_byte_def = {
 };
 
 Type * const t_void = &t_void_def;
-Type * const t_pointer = &t_void_pointer_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;
@@ -511,6 +511,16 @@ 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.
 /// ===========================================================================
@@ -607,7 +617,7 @@ static void ast_print_children(
 );
 
 /// Print a node.
-void ast_print_node(
+void ast_print_node_internal(
   FILE *file,
   const Node *logical_parent,
   const Node *node,
@@ -755,6 +765,12 @@ 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;
@@ -836,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.
@@ -861,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;

src/ast.h

@@ -572,6 +572,13 @@ usz type_alignof(Type *type);
 /// Check if a type is void.
 bool type_is_void(Type *type);
 
+/// Check if a type is of pointer type.
+bool type_is_pointer(Type *type);
+
+/// Check if a type is of array type.
+bool type_is_array(Type *type);
+
+
 /// ===========================================================================
 ///  Miscellaneous AST functions.
 /// ===========================================================================
@@ -588,10 +595,7 @@ void ast_print(FILE *file, const AST *ast);
 void ast_print_scope_tree(FILE *file, const AST *ast);
 
 /// Print a node and all of it's children.
-/// Use like so:
-///   string_buffer buf = {0};
-///   ast_print_node(file, NULL, node, &buf);
-void ast_print_node(FILE *file, const Node *logical_parent, const Node *node, string_buffer *leading_text);
+void ast_print_node(const Node *node);
 
 /// Intern a string.
 size_t ast_intern_string(AST *ast, span string);
@@ -603,7 +607,7 @@ void ast_replace_node(AST *ast, Node *old, Node *new);
 ///  Builtin types.
 /// ===========================================================================
 extern Type *const t_void;
-extern Type *const t_pointer;
+extern Type *const t_void_ptr;
 extern Type *const t_integer_literal;
 extern Type *const t_integer;
 extern Type *const t_byte;

src/codegen.c

@@ -361,31 +361,36 @@ static void codegen_expr(CodegenContext *ctx, Node *expr) {
     }
 
     if (expr->binary.op == TK_LBRACK) {
-      codegen_expr(ctx, rhs);
+      // TODO: Just use lhs operand of subscript operator when right hand
+      // side is a compile-time-known zero value.
 
       IRInstruction *subs_lhs = NULL;
-      if (lhs->type->kind != TYPE_ARRAY && lhs->type->kind == TYPE_POINTER) {
+      if (!type_is_array(lhs->type) && !type_is_pointer(lhs->type))
         ERR("Subscript operator may only operate on arrays and pointers, which type %T is not", lhs->type);
-      }
+
       if (lhs->kind == NODE_VARIABLE_REFERENCE) {
-        // TODO: Handle local variable references, somehow. How can we tell if it's local/static?
-        subs_lhs = ir_static_reference(ctx, as_span(lhs->var->name));
+        IRInstruction *var = lhs->var->val.node->ir;
+        // ASSERT(var);
+        if (var->kind == IR_STATIC_REF)
+          subs_lhs = var;
+        else if (var->kind == IR_ALLOCA)
+          subs_lhs = var;
       } else if (lhs->kind == NODE_LITERAL && lhs->literal.type == TK_STRING) {
+        // ctx->ast->strings.data[lhs->literal.string_index];
         TODO("IR generation for subscript of string literal");
       }
       else ERR("LHS of subscript operator has invalid kind %d", lhs->kind);
 
-      // TODO: Just use lhs operand of subscript operator when right hand
-      // side is a compile-time-known zero value.
+      codegen_expr(ctx, rhs);
 
       IRInstruction *scaled_rhs = NULL;
       // An array subscript needs multiplied by the sizeof the array's base type.
-      if (lhs->type->kind == TYPE_ARRAY) {
+      if (type_is_array(lhs->type)) {
         IRInstruction *immediate = ir_immediate(ctx, t_integer, type_sizeof(lhs->type->array.of));
         scaled_rhs = ir_mul(ctx, rhs->ir, immediate);
       }
-        // A pointer subscript needs multiplied by the sizeof the pointer's base type.
-      else if (lhs->type->kind == TYPE_POINTER) {
+      // A pointer subscript needs multiplied by the sizeof the pointer's base type.
+      else if (type_is_pointer(lhs->type)) {
         IRInstruction *immediate = ir_immediate(ctx, t_integer, type_sizeof(lhs->type->pointer.to));
         scaled_rhs = ir_mul(ctx, rhs->ir, immediate);
       }
@@ -473,7 +478,7 @@ static void codegen_expr(CodegenContext *ctx, Node *expr) {
     if (expr->literal.type == TK_NUMBER) expr->ir = ir_immediate(ctx, expr->type, expr->literal.integer);
     else if (expr->literal.type == TK_STRING) {
       // TODO: We should probably set this name earlier, or have some
-      // way of getting this name from jujst a string index. Static
+      // way of getting this name from just a string index. Static
       // variable is big bad. Valve, pls fix. Literally unplayable.
       char buf[48] = {0};
       static size_t string_literal_count = 0;
@@ -492,12 +497,6 @@ static void codegen_expr(CodegenContext *ctx, Node *expr) {
   /// Variable reference.
   case NODE_VARIABLE_REFERENCE:
     expr->ir = ir_load(ctx, expr->var->val.node->ir);
-    // TODO: Be smarter about when an array should decay to a pointer or not.
-    //       Maybe it never should, and this should be implemented per backend?
-    // "I’d just emit a load of the array and have the backend
-    // deal w/ copying 1000 ints." ~ Sirraide
-    if (expr->ir->type->kind == TYPE_ARRAY)
-      expr->ir->type = ast_make_type_pointer(ctx->ast, expr->type->source_location, expr->type->array.of);
     return;
 
   /// Function reference. These should have all been removed by the semantic analyser.

src/codegen/intermediate_representation.c

@@ -645,14 +645,15 @@ IRInstruction *ir_create_static(CodegenContext *context, Type *type, span name)
   return ref;
 }
 
+/// NOTE: Currently unused, but can be used to load a static reference
+/// more than once without generating duplicate static variables.
 IRInstruction *ir_static_reference(CodegenContext *context, span name) {
   foreach_ptr(IRStaticVariable *, v, context->static_vars) {
     if (string_eq(v->name, name)) {
       INSTRUCTION(ref, IR_STATIC_REF);
       ref->static_ref = v;
       ref->type = ast_make_type_pointer(context->ast, v->type->source_location, v->type);
-      // TODO: `v->reference` may need to become list of references? I think this is why
-      // optimisation is broken.
+      // TODO: `v->reference` may need to become list of references?
       INSERT(ref);
       return ref;
     }

src/codegen/x86_64/arch_x86_64.c

@@ -928,8 +928,8 @@ static void emit_instruction(CodegenContext *context, IRInstruction *inst) {
   case IR_EQ: codegen_comparison(context, COMPARE_EQ, inst->lhs->result, inst->rhs->result, inst->result); break;
   case IR_NE: codegen_comparison(context, COMPARE_NE, inst->lhs->result, inst->rhs->result, inst->result); break;
   case IR_ADD:
-    femit_reg_to_reg(context, I_ADD, inst->rhs->result, inst->lhs->result);
-    femit_reg_to_reg(context, I_MOV, inst->lhs->result, inst->result);
+    femit_reg_to_reg(context, I_ADD, inst->lhs->result, inst->rhs->result);
+    femit_reg_to_reg(context, I_MOV, inst->rhs->result, inst->result);
     break;
   case IR_SUB:
     femit_reg_to_reg(context, I_SUB, inst->rhs->result, inst->lhs->result);
@@ -988,7 +988,7 @@ static void emit_instruction(CodegenContext *context, IRInstruction *inst) {
       enum RegSize size = -1;
       // TODO: Should this array to pointer decay happen here? Or higher up in codegen?
       if (inst->operand->type->kind == TYPE_ARRAY || inst->operand->type->pointer.to->kind == TYPE_ARRAY)
-        size = regsize_from_bytes(type_sizeof(t_pointer));
+        size = regsize_from_bytes(type_sizeof(t_void_ptr));
       else size = regsize_from_bytes(type_sizeof(inst->operand->type));
       // TODO: Use `movzx`/`movzbl`
       if (size == r8 || size == r16) femit_reg_to_reg(context, I_XOR, inst->result, inst->result);
@@ -1004,7 +1004,7 @@ static void emit_instruction(CodegenContext *context, IRInstruction *inst) {
       enum RegSize size = -1;
       // TODO: Should this array to pointer decay happen here? Or higher up in codegen?
       if (inst->operand->type->kind == TYPE_ARRAY || inst->operand->type->pointer.to->kind == TYPE_ARRAY)
-        size = regsize_from_bytes(type_sizeof(t_pointer));
+        size = regsize_from_bytes(type_sizeof(t_void_ptr));
       else size = regsize_from_bytes(inst->operand->alloca.size);
       // TODO: Use `movzx`/`movzbl`
       if (size == r8 || size == r16) femit_reg_to_reg(context, I_XOR, inst->result, inst->result);
@@ -1018,7 +1018,7 @@ static void emit_instruction(CodegenContext *context, IRInstruction *inst) {
     else {
       enum RegSize size = -1;
       // TODO: Should this array to pointer decay happen here? Or higher up in codegen?
-      if (inst->operand->type->kind == TYPE_ARRAY) size = regsize_from_bytes(type_sizeof(t_pointer));
+      if (inst->operand->type->kind == TYPE_ARRAY) size = regsize_from_bytes(type_sizeof(t_void_ptr));
       // TODO: We are "supposed" to be loading sizeof pointed to type
       // here, but that causes segfaults when handling arrays.
       else size = regsize_from_bytes(type_sizeof(inst->operand->type));
@@ -1165,14 +1165,14 @@ Clobbers does_clobber(IRInstruction *instruction) {
   case IR_DIV:
   case IR_MUL:
   case IR_MOD:
-  case IR_SHL:
-  case IR_SHR:
-  case IR_SAR:
   case IR_AND:
   case IR_OR:
     return CLOBBERS_RIGHT;
 
   case IR_SUB:
+  case IR_SHL:
+  case IR_SHR:
+  case IR_SAR:
     return CLOBBERS_LEFT;
 
   case IR_NOT:

src/main.c

@@ -153,7 +153,7 @@ int handle_command_line_arguments(int argc, char **argv) {
         print_acceptable_formats();
         return 1;
       }
-    } else if (strcmp(argument, "--colours") == 0) {
+    } else if (strcmp(argument, "--colours") == 0 || strcmp(argument, "--colors") == 0) {
       i++;
       if (i >= argc) {
         fprint(stderr, "Error: Expected option value after `--colours`\n");
@@ -269,6 +269,8 @@ int main(int argc, char **argv) {
   if (len >= 3 && memcmp(infile + len - 3, ".ir", 3) == 0) {
     ASSERT(s.data);
 
+    TODO("Development of IR parser and codegen is severely behind right now.");
+
     if (!codegen(
       LANG_IR,
       output_format,

src/parser.c

@@ -392,7 +392,6 @@ static void next_token(Parser *p) {
       if (isstart(p->lastc)) {
         next_identifier(p);
 
-        /// Check if the identifier is a keyword.
         for (size_t i = 0; i < sizeof keywords / sizeof *keywords; i++) {
           if (string_eq(keywords[i].kw, p->tok.text)) {
             p->tok.type = keywords[i].type;
@@ -1074,14 +1073,13 @@ static Node *parse_expr_with_precedence(Parser *p, isz current_precedence) {
     if (prec == current_precedence && !is_right_associative(p, p->tok)) return lhs;
 
     /// Otherwise, we need to parse the RHS.
-    u32 start = p->tok.source_location.start;
     enum TokenType tt = p->tok.type;
     next_token(p);
 
     /// The `as` operator is special because its RHS is a type.
     if (tt == TK_AS) {
       Type *type = parse_type(p);
-      lhs = ast_make_cast(p->ast, (loc){.start = start, .end = type->source_location.end}, type, lhs);
+      lhs = ast_make_cast(p->ast, (loc){.start = lhs->source_location.start, .end = type->source_location.end}, type, lhs);
       continue;
     }
 
@@ -1090,7 +1088,7 @@ static Node *parse_expr_with_precedence(Parser *p, isz current_precedence) {
       Node *rhs = parse_expr_with_precedence(p, prec);
 
       /// Combine the LHS and RHS into a binary expression.
-      lhs = ast_make_binary(p->ast, (loc){.start = start, .end = rhs->source_location.end}, tt, lhs, rhs);
+      lhs = ast_make_binary(p->ast, (loc){.start = lhs->source_location.start, .end = rhs->source_location.end}, tt, lhs, rhs);
     }
   }
 }

src/typechecker.c

@@ -200,10 +200,10 @@ NODISCARD static Type *common_type(Type *a, Type *b) {
 }
 
 /// Check if a type is a pointer type.
-NODISCARD static bool is_pointer(Type *type) { return type->kind == TYPE_POINTER; }
+NODISCARD static bool is_pointer(Type *type) { return type_is_pointer(type); }
 
 /// Check if a type is an array type.
-NODISCARD static bool is_array(Type *type) { return type->kind == TYPE_ARRAY; }
+NODISCARD static bool is_array(Type *type) { return type_is_array(type); }
 
 /// Check if an expression is an lvalue.
 NODISCARD static bool is_lvalue(Node *expr) {
@@ -789,10 +789,15 @@ NODISCARD bool typecheck_expression(AST *ast, Node *expr) {
       /// Make sure the return type of the body is convertible to that of the function.
       Type *ret = expr->type->function.return_type;
       Type *body = expr->function.body->type;
-      if (!convertible(ret, body))
-        ERR(expr->source_location,
-          "Type '%T' of function body is not convertible to return type '%T'.",
-            ret, body);
+      if (!convertible(ret, body)) {
+        loc l = {0};
+        if (expr->function.body->kind == NODE_BLOCK)
+          l = vector_back_or(expr->function.body->block.children, expr)->source_location;
+        else l = expr->function.body->source_location;
+        ERR(l,
+            "Type '%T' of function body is not convertible to return type '%T'.",
+            body, ret);
+      }
     } break;
 
     /// Typecheck declarations.
@@ -906,10 +911,10 @@ NODISCARD bool typecheck_expression(AST *ast, Node *expr) {
       if (types_equal(t_to, t_from)) break;
 
       // FROM any incomplete type is DISALLOWED
-      if (type_is_incomplete(t_from) || type_is_incomplete(t_to))
+      if (type_is_incomplete(t_from))
         ERR(expr->cast.value->source_location, "Can not cast from an incomplete type %T", t_from);
       // TO any complete type is DISALLOWED
-      if (type_is_incomplete(t_from) || type_is_incomplete(t_to))
+      if (type_is_incomplete(t_to))
         ERR(expr->cast.value->source_location, "Can not cast to an incomplete type %T", t_to);
 
       // FROM any pointer type TO any pointer type is ALLOWED

tst/tests/shiftleft.un

@@ -0,0 +1,3 @@
+; 8
+
+2 << 2

tst/tests/shiftright.un

@@ -0,0 +1,3 @@
+; 2
+
+8 >> 2