add #typeof() compiler function

doc/langref.md

@@ -60,7 +60,9 @@ ParamDeclList : token(LParen) list(ParamDecl, token(Comma)) token(RParen)
 
 ParamDecl : token(Symbol) token(Colon) Type | token(Ellipsis)
 
-Type : token(Symbol) | token(Unreachable) | token(Void) | PointerType | ArrayType | MaybeType
+Type : token(Symbol) | token(Unreachable) | token(Void) | PointerType | ArrayType | MaybeType | CompileTimeFnCall
+
+CompileTimeFnCall : token(NumberSign) token(Symbol) token(LParen) Expression token(RParen)
 
 PointerType : token(Ampersand) option(token(Const)) Type
 

example/rand/main.zig

@@ -2,7 +2,7 @@
 const ARRAY_SIZE : u16 = 624;
 
 /// Use `rand_init` to initialize this state.
-pub struct Rand {
+struct Rand {
     array: [u32; ARRAY_SIZE],
     index: #typeof(ARRAY_SIZE),
 

src/analyze.cpp

@@ -59,6 +59,7 @@ static AstNode *first_executing_node(AstNode *node) {
         case NodeTypeStructValueExpr:
         case NodeTypeStructValueField:
         case NodeTypeWhileExpr:
+        case NodeTypeCompilerFnCall:
             return node;
     }
     zig_panic("unreachable");
@@ -208,7 +209,7 @@ static TypeTableEntry *get_array_type(CodeGen *g, TypeTableEntry *child_type, ui
     }
 }
 
-static TypeTableEntry *resolve_type(CodeGen *g, AstNode *node) {
+static TypeTableEntry *resolve_type(CodeGen *g, AstNode *node, ImportTableEntry *import, BlockContext *context) {
     assert(node->type == NodeTypeType);
     alloc_codegen_node(node);
     TypeNode *type_node = &node->codegen_node->data.type_node;
@@ -228,7 +229,7 @@ static TypeTableEntry *resolve_type(CodeGen *g, AstNode *node) {
             }
         case AstNodeTypeTypePointer:
             {
-                resolve_type(g, node->data.type.child_type);
+                resolve_type(g, node->data.type.child_type, import, context);
                 TypeTableEntry *child_type = node->data.type.child_type->codegen_node->data.type_node.entry;
                 assert(child_type);
                 if (child_type->id == TypeTableEntryIdUnreachable) {
@@ -242,7 +243,7 @@ static TypeTableEntry *resolve_type(CodeGen *g, AstNode *node) {
             }
         case AstNodeTypeTypeArray:
             {
-                resolve_type(g, node->data.type.child_type);
+                resolve_type(g, node->data.type.child_type, import, context);
                 TypeTableEntry *child_type = node->data.type.child_type->codegen_node->data.type_node.entry;
                 if (child_type->id == TypeTableEntryIdUnreachable) {
                     add_node_error(g, node,
@@ -263,7 +264,7 @@ static TypeTableEntry *resolve_type(CodeGen *g, AstNode *node) {
             }
         case AstNodeTypeTypeMaybe:
             {
-                resolve_type(g, node->data.type.child_type);
+                resolve_type(g, node->data.type.child_type, import, context);
                 TypeTableEntry *child_type = node->data.type.child_type->codegen_node->data.type_node.entry;
                 assert(child_type);
                 if (child_type->id == TypeTableEntryIdUnreachable) {
@@ -275,11 +276,26 @@ static TypeTableEntry *resolve_type(CodeGen *g, AstNode *node) {
                 type_node->entry = get_maybe_type(g, child_type);
                 return type_node->entry;
             }
+        case AstNodeTypeTypeCompilerExpr:
+            {
+                AstNode *compiler_expr_node = node->data.type.compiler_expr;
+                Buf *fn_name = &compiler_expr_node->data.compiler_fn_call.name;
+                if (buf_eql_str(fn_name, "typeof")) {
+                    return analyze_expression(g, import, context, nullptr,
+                            compiler_expr_node->data.compiler_fn_call.expr);
+                } else {
+                    add_node_error(g, node,
+                            buf_sprintf("invalid compiler function: '%s'", buf_ptr(fn_name)));
+                    return g->builtin_types.entry_invalid;
+                }
+            }
     }
     zig_unreachable();
 }
 
-static void resolve_function_proto(CodeGen *g, AstNode *node, FnTableEntry *fn_table_entry) {
+static void resolve_function_proto(CodeGen *g, AstNode *node, FnTableEntry *fn_table_entry,
+        ImportTableEntry *import)
+{
     assert(node->type == NodeTypeFnProto);
 
     for (int i = 0; i < node->data.fn_proto.directives->length; i += 1) {
@@ -310,7 +326,7 @@ static void resolve_function_proto(CodeGen *g, AstNode *node, FnTableEntry *fn_t
     for (int i = 0; i < node->data.fn_proto.params.length; i += 1) {
         AstNode *child = node->data.fn_proto.params.at(i);
         assert(child->type == NodeTypeParamDecl);
-        TypeTableEntry *type_entry = resolve_type(g, child->data.param_decl.type);
+        TypeTableEntry *type_entry = resolve_type(g, child->data.param_decl.type, import, import->block_context);
         if (type_entry->id == TypeTableEntryIdUnreachable) {
             add_node_error(g, child->data.param_decl.type,
                 buf_sprintf("parameter of type 'unreachable' not allowed"));
@@ -322,7 +338,7 @@ static void resolve_function_proto(CodeGen *g, AstNode *node, FnTableEntry *fn_t
         }
     }
 
-    resolve_type(g, node->data.fn_proto.return_type);
+    resolve_type(g, node->data.fn_proto.return_type, import, import->block_context);
 }
 
 static void preview_function_labels(CodeGen *g, AstNode *node, FnTableEntry *fn_table_entry) {
@@ -383,7 +399,7 @@ static void resolve_struct_type(CodeGen *g, ImportTableEntry *import, TypeTableE
         AstNode *field_node = decl_node->data.struct_decl.fields.at(i);
         TypeStructField *type_struct_field = &struct_type->data.structure.fields[i];
         type_struct_field->name = &field_node->data.struct_field.name;
-        type_struct_field->type_entry = resolve_type(g, field_node->data.struct_field.type);
+        type_struct_field->type_entry = resolve_type(g, field_node->data.struct_field.type, import, import->block_context);
 
         if (type_struct_field->type_entry->id == TypeTableEntryIdStruct) {
             resolve_struct_type(g, import, type_struct_field->type_entry);
@@ -453,7 +469,7 @@ static void preview_function_declarations(CodeGen *g, ImportTableEntry *import,
                 fn_table_entry->import_entry = import;
                 fn_table_entry->label_table.init(8);
 
-                resolve_function_proto(g, fn_proto, fn_table_entry);
+                resolve_function_proto(g, fn_proto, fn_table_entry, import);
 
                 Buf *name = &fn_proto->data.fn_proto.name;
                 g->fn_protos.append(fn_table_entry);
@@ -512,7 +528,7 @@ static void preview_function_declarations(CodeGen *g, ImportTableEntry *import,
                         g->fn_table.put(proto_name, fn_table_entry);
                     }
 
-                    resolve_function_proto(g, proto_node, fn_table_entry);
+                    resolve_function_proto(g, proto_node, fn_table_entry, import);
 
 
                     alloc_codegen_node(proto_node);
@@ -609,6 +625,7 @@ static void preview_function_declarations(CodeGen *g, ImportTableEntry *import,
         case NodeTypeStructField:
         case NodeTypeStructValueExpr:
         case NodeTypeStructValueField:
+        case NodeTypeCompilerFnCall:
             zig_unreachable();
     }
 }
@@ -681,6 +698,7 @@ static void preview_types(CodeGen *g, ImportTableEntry *import, AstNode *node) {
         case NodeTypeStructField:
         case NodeTypeStructValueExpr:
         case NodeTypeStructValueField:
+        case NodeTypeCompilerFnCall:
             zig_unreachable();
     }
 }
@@ -1132,7 +1150,7 @@ static bool is_op_allowed(TypeTableEntry *type, BinOpType op) {
 static TypeTableEntry *analyze_cast_expr(CodeGen *g, ImportTableEntry *import, BlockContext *context,
         TypeTableEntry *expected_type, AstNode *node)
 {
-    TypeTableEntry *wanted_type = resolve_type(g, node->data.cast_expr.type);
+    TypeTableEntry *wanted_type = resolve_type(g, node->data.cast_expr.type, import, context);
     TypeTableEntry *actual_type = analyze_expression(g, import, context, nullptr, node->data.cast_expr.expr);
 
     if (wanted_type->id == TypeTableEntryIdInvalid ||
@@ -1328,7 +1346,7 @@ static VariableTableEntry *analyze_variable_declaration_raw(CodeGen *g, ImportTa
 {
     TypeTableEntry *explicit_type = nullptr;
     if (variable_declaration->type != nullptr) {
-        explicit_type = resolve_type(g, variable_declaration->type);
+        explicit_type = resolve_type(g, variable_declaration->type, import, context);
         if (explicit_type->id == TypeTableEntryIdUnreachable) {
             add_node_error(g, variable_declaration->type,
                 buf_sprintf("variable of type 'unreachable' not allowed"));
@@ -1428,7 +1446,7 @@ static TypeTableEntry *analyze_struct_val_expr(CodeGen *g, ImportTableEntry *imp
 
     AstNodeStructValueExpr *struct_val_expr = &node->data.struct_val_expr;
 
-    TypeTableEntry *type_entry = resolve_type(g, struct_val_expr->type);
+    TypeTableEntry *type_entry = resolve_type(g, struct_val_expr->type, import, context);
 
     if (type_entry->id == TypeTableEntryIdInvalid) {
         return g->builtin_types.entry_invalid;
@@ -1655,7 +1673,7 @@ static TypeTableEntry * analyze_expression(CodeGen *g, ImportTableEntry *import,
                     AsmOutput *asm_output = node->data.asm_expr.output_list.at(i);
                     if (asm_output->return_type) {
                         node->data.asm_expr.return_count += 1;
-                        return_type = resolve_type(g, asm_output->return_type);
+                        return_type = resolve_type(g, asm_output->return_type, import, context);
                         if (node->data.asm_expr.return_count > 1) {
                             add_node_error(g, node,
                                 buf_sprintf("inline assembly allows up to one output value"));
@@ -1848,6 +1866,7 @@ static TypeTableEntry * analyze_expression(CodeGen *g, ImportTableEntry *import,
         case NodeTypeStructDecl:
         case NodeTypeStructField:
         case NodeTypeStructValueField:
+        case NodeTypeCompilerFnCall:
             zig_unreachable();
     }
     assert(return_type);
@@ -1996,6 +2015,7 @@ static void analyze_top_level_declaration(CodeGen *g, ImportTableEntry *import,
         case NodeTypeStructField:
         case NodeTypeStructValueExpr:
         case NodeTypeStructValueField:
+        case NodeTypeCompilerFnCall:
             zig_unreachable();
     }
 }

src/analyze.hpp

@@ -159,9 +159,11 @@ struct CodeGen {
     struct {
         TypeTableEntry *entry_bool;
         TypeTableEntry *entry_u8;
+        TypeTableEntry *entry_u16;
         TypeTableEntry *entry_u32;
         TypeTableEntry *entry_u64;
         TypeTableEntry *entry_i8;
+        TypeTableEntry *entry_i16;
         TypeTableEntry *entry_i32;
         TypeTableEntry *entry_i64;
         TypeTableEntry *entry_isize;

src/codegen.cpp

@@ -1326,6 +1326,7 @@ static LLVMValueRef gen_expr_no_cast(CodeGen *g, AstNode *node) {
         case NodeTypeStructDecl:
         case NodeTypeStructField:
         case NodeTypeStructValueField:
+        case NodeTypeCompilerFnCall:
             zig_unreachable();
     }
     zig_unreachable();
@@ -1685,6 +1686,19 @@ static void define_builtin_types(CodeGen *g) {
         g->type_table.put(&entry->name, entry);
         g->builtin_types.entry_u8 = entry;
     }
+    {
+        TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdInt);
+        entry->type_ref = LLVMInt16Type();
+        buf_init_from_str(&entry->name, "u16");
+        entry->size_in_bits = 16;
+        entry->align_in_bits = 16;
+        entry->data.integral.is_signed = false;
+        entry->di_type = LLVMZigCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name),
+                entry->size_in_bits, entry->align_in_bits,
+                LLVMZigEncoding_DW_ATE_unsigned());
+        g->type_table.put(&entry->name, entry);
+        g->builtin_types.entry_u16 = entry;
+    }
     {
         TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdInt);
         entry->type_ref = LLVMInt32Type();
@@ -1725,6 +1739,19 @@ static void define_builtin_types(CodeGen *g) {
         g->type_table.put(&entry->name, entry);
         g->builtin_types.entry_i8 = entry;
     }
+    {
+        TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdInt);
+        entry->type_ref = LLVMInt16Type();
+        buf_init_from_str(&entry->name, "i16");
+        entry->size_in_bits = 16;
+        entry->align_in_bits = 16;
+        entry->data.integral.is_signed = true;
+        entry->di_type = LLVMZigCreateDebugBasicType(g->dbuilder, buf_ptr(&entry->name),
+                entry->size_in_bits, entry->align_in_bits,
+                LLVMZigEncoding_DW_ATE_signed());
+        g->type_table.put(&entry->name, entry);
+        g->builtin_types.entry_i16 = entry;
+    }
     {
         TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdInt);
         entry->type_ref = LLVMInt32Type();

src/parser.cpp

@@ -142,6 +142,8 @@ const char *node_type_str(NodeType node_type) {
             return "StructValueExpr";
         case NodeTypeStructValueField:
             return "StructValueField";
+        case NodeTypeCompilerFnCall:
+            return "CompilerFnCall";
     }
     zig_unreachable();
 }
@@ -233,6 +235,12 @@ void ast_print(AstNode *node, int indent) {
                         ast_print(node->data.type.child_type, indent + 2);
                         break;
                     }
+                case AstNodeTypeTypeCompilerExpr:
+                    {
+                        fprintf(stderr, "CompilerExprType\n");
+                        ast_print(node->data.type.compiler_expr, indent + 2);
+                        break;
+                    }
             }
             break;
         case NodeTypeReturnExpr:
@@ -402,6 +410,9 @@ void ast_print(AstNode *node, int indent) {
             fprintf(stderr, "%s '%s'\n", node_type_str(node->type), buf_ptr(&node->data.struct_val_field.name));
             ast_print(node->data.struct_val_field.expr, indent + 2);
             break;
+        case NodeTypeCompilerFnCall:
+            fprintf(stderr, "%s\n", node_type_str(node->type));
+            break;
     }
 }
 
@@ -985,16 +996,48 @@ static void ast_parse_type_assume_amp(ParseContext *pc, int *token_index, AstNod
 }
 
 /*
-Type : token(Symbol) | token(Unreachable) | token(Void) | PointerType | ArrayType | MaybeType
+CompileTimeFnCall : token(NumberSign) token(Symbol) token(LParen) Expression token(RParen)
+*/
+static AstNode *ast_parse_compiler_fn_call(ParseContext *pc, int *token_index, bool mandatory) {
+    Token *token = &pc->tokens->at(*token_index);
+
+    if (token->id == TokenIdNumberSign) {
+        *token_index += 1;
+    } else if (mandatory) {
+        ast_invalid_token_error(pc, token);
+    } else {
+        return nullptr;
+    }
+
+    Token *name_symbol = ast_eat_token(pc, token_index, TokenIdSymbol);
+    ast_eat_token(pc, token_index, TokenIdLParen);
+
+    AstNode *node = ast_create_node(pc, NodeTypeCompilerFnCall, token);
+    ast_buf_from_token(pc, name_symbol, &node->data.compiler_fn_call.name);
+    node->data.compiler_fn_call.expr = ast_parse_expression(pc, token_index, true);
+
+    ast_eat_token(pc, token_index, TokenIdRParen);
+    return node;
+}
+
+/*
+Type : token(Symbol) | token(Unreachable) | token(Void) | PointerType | ArrayType | MaybeType | CompileTimeFnCall
 PointerType : token(Ampersand) option(token(Const)) Type
 ArrayType : token(LBracket) Type token(Semicolon) token(Number) token(RBracket)
 */
 static AstNode *ast_parse_type(ParseContext *pc, int *token_index) {
     Token *token = &pc->tokens->at(*token_index);
-    *token_index += 1;
-
     AstNode *node = ast_create_node(pc, NodeTypeType, token);
 
+    AstNode *compiler_fn_call = ast_parse_compiler_fn_call(pc, token_index, false);
+    if (compiler_fn_call) {
+        node->data.type.type = AstNodeTypeTypeCompilerExpr;
+        node->data.type.compiler_expr = compiler_fn_call;
+        return node;
+    }
+
+    *token_index += 1;
+
     if (token->id == TokenIdKeywordUnreachable) {
         node->data.type.type = AstNodeTypeTypePrimitive;
         buf_init_from_str(&node->data.type.primitive_name, "unreachable");

src/parser.hpp

@@ -57,6 +57,7 @@ enum NodeType {
     NodeTypeStructField,
     NodeTypeStructValueExpr,
     NodeTypeStructValueField,
+    NodeTypeCompilerFnCall,
 };
 
 struct AstNodeRoot {
@@ -97,6 +98,7 @@ enum AstNodeTypeType {
     AstNodeTypeTypePointer,
     AstNodeTypeTypeArray,
     AstNodeTypeTypeMaybe,
+    AstNodeTypeTypeCompilerExpr,
 };
 
 struct AstNodeType {
@@ -105,6 +107,7 @@ struct AstNodeType {
     AstNode *child_type;
     AstNode *array_size;
     bool is_const;
+    AstNode *compiler_expr;
 };
 
 struct AstNodeBlock {
@@ -329,6 +332,11 @@ struct AstNodeStructValueExpr {
     ZigList<AstNode *> fields;
 };
 
+struct AstNodeCompilerFnCall {
+    Buf name;
+    AstNode *expr;
+};
+
 struct AstNode {
     enum NodeType type;
     int line;
@@ -368,6 +376,7 @@ struct AstNode {
         AstNodeNumberLiteral number_literal;
         AstNodeStructValueExpr struct_val_expr;
         AstNodeStructValueField struct_val_field;
+        AstNodeCompilerFnCall compiler_fn_call;
         Buf symbol;
         bool bool_literal;
     } data;

test/run_tests.cpp

@@ -347,7 +347,7 @@ pub fn main(argc: isize, argv: &&u8, env: &&u8) -> i32 {
     add_simple_case("hello world without libc", R"SOURCE(
 use "std.zig";
 
-export fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
+pub fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
     print_str("Hello, world!\n");
     return 0;
 }
@@ -357,7 +357,7 @@ export fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
     add_simple_case("a + b + c", R"SOURCE(
 use "std.zig";
 
-export fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
+pub fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
     if (false || false || false) { print_str("BAD 1\n"); }
     if (true && true && false)   { print_str("BAD 2\n"); }
     if (1 | 2 | 4 != 7)          { print_str("BAD 3\n"); }
@@ -379,7 +379,7 @@ export fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
     add_simple_case("short circuit", R"SOURCE(
 use "std.zig";
 
-export fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
+pub fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
     if (true || { print_str("BAD 1\n"); false }) {
       print_str("OK 1\n");
     }
@@ -402,7 +402,7 @@ export fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
     add_simple_case("modify operators", R"SOURCE(
 use "std.zig";
 
-export fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
+pub fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
     var i : i32 = 0;
     i += 5;  if (i != 5)  { print_str("BAD +=\n"); }
     i -= 2;  if (i != 3)  { print_str("BAD -=\n"); }
@@ -554,7 +554,7 @@ export fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
     add_simple_case("structs", R"SOURCE(
 use "std.zig";
 
-export fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
+pub fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
     var foo : Foo;
     foo.a += 1;
     foo.b = foo.a == 1;
@@ -628,7 +628,7 @@ use "std.zig";
 const g1 : i32 = 1233 + 1;
 var g2 : i32;
 
-export fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
+pub fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
     if (g2 != 0) { print_str("BAD\n"); }
     g2 = g1;
     if (g2 != 1234) { print_str("BAD\n"); }
@@ -639,7 +639,7 @@ export fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
 
     add_simple_case("while loop", R"SOURCE(
 use "std.zig";
-export fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
+pub fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
     var i : i32 = 0;
     while (i < 4) {
         print_str("loop\n");
@@ -651,7 +651,7 @@ export fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
 
     add_simple_case("continue and break", R"SOURCE(
 use "std.zig";
-export fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
+pub fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
     var i : i32 = 0;
     while (true) {
         print_str("loop\n");
@@ -667,7 +667,7 @@ export fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
 
     add_simple_case("maybe type", R"SOURCE(
 use "std.zig";
-export fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
+pub fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
     const x : ?bool = true;
 
     if (const y ?= x) {
@@ -685,7 +685,7 @@ export fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
 
     add_simple_case("implicit cast after unreachable", R"SOURCE(
 use "std.zig";
-export fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
+pub fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
     const x = outer();
     if (x == 1234) {
         print_str("OK\n");
@@ -695,6 +695,17 @@ export fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
 fn inner() -> i32 { 1234 }
 fn outer() -> isize {
     return inner();
+}
+    )SOURCE", "OK\n");
+
+    add_simple_case("#typeof()", R"SOURCE(
+use "std.zig";
+const x: u16 = 13;
+const z: #typeof(x) = 19;
+pub fn main(argc : isize, argv : &&u8, env : &&u8) -> i32 {
+    const y: #typeof(x) = 120;
+    print_str("OK\n");
+    return 0;
 }
     )SOURCE", "OK\n");
 }
@@ -999,6 +1010,11 @@ fn f() -> i32 {
     (return 1) as i32
 }
     )SOURCE", 1, ".tmp_source.zig:3:16: error: invalid cast from type 'unreachable' to 'i32'");
+
+    add_compile_fail_case("invalid compiler fn", R"SOURCE(
+fn f() -> #bogus(foo) {
+}
+    )SOURCE", 1, ".tmp_source.zig:2:11: error: invalid compiler function: 'bogus'");
 }
 
 static void print_compiler_invocation(TestCase *test_case) {