update cat example, refactor std

partial implementation of @err_name

3 files changed, 44 insertions, 7 deletions

diff --git a/src/all_types.hpp b/src/all_types.hpp
index 7677232d8f..f51d242d3b 100644
--- a/src/all_types.hpp
+++ b/src/all_types.hpp
@@ -1044,6 +1044,7 @@ enum BuiltinFnId {
     BuiltinFnIdClz,
     BuiltinFnIdImport,
     BuiltinFnIdCImport,
+    BuiltinFnIdErrName,
 };
 
 struct BuiltinFnEntry {
@@ -1177,7 +1178,7 @@ struct CodeGen {
     LLVMValueRef trap_fn_val;
     bool error_during_imports;
     uint32_t next_node_index;
-    uint32_t error_value_count;
+    ZigList<AstNode *> error_decls;
     TypeTableEntry *err_tag_type;
     LLVMValueRef int_overflow_fns[2][3][4]; // [0-signed,1-unsigned][0-add,1-sub,2-mul][0-8,1-16,2-32,3-64]
     LLVMValueRef int_builtin_fns[2][4]; // [0-ctz,1-clz][0-8,1-16,2-32,3-64]
@@ -1189,6 +1190,8 @@ struct CodeGen {
     uint32_t test_fn_count;
 
     bool check_unused;
+
+    bool generate_error_name_table;
 };
 
 struct VariableTableEntry {
diff --git a/src/analyze.cpp b/src/analyze.cpp
index 96eca1de91..fc647c82d7 100644
--- a/src/analyze.cpp
+++ b/src/analyze.cpp
@@ -1415,9 +1415,10 @@ static void preview_error_value_decl(CodeGen *g, AstNode *node) {
         // duplicate error definitions allowed and they get the same value
         err->value = existing_entry->value->value;
     } else {
-        assert(g->error_value_count < (((uint32_t)1) << (uint32_t)g->err_tag_type->data.integral.bit_count));
-        err->value = g->error_value_count;
-        g->error_value_count += 1;
+        int error_value_count = g->error_decls.length;
+        assert(error_value_count < (((uint32_t)1) << (uint32_t)g->err_tag_type->data.integral.bit_count));
+        err->value = error_value_count;
+        g->error_decls.append(node);
         g->error_table.put(&err->name, err);
     }
 
@@ -4084,7 +4085,7 @@ static TypeTableEntry *analyze_cast_expr(CodeGen *g, ImportTableEntry *import, B
         wanted_type->id == TypeTableEntryIdInt)
     {
         BigNum bn;
-        bignum_init_unsigned(&bn, g->error_value_count);
+        bignum_init_unsigned(&bn, g->error_decls.length);
         if (bignum_fits_in_bits(&bn, wanted_type->data.integral.bit_count,
                     wanted_type->data.integral.is_signed))
         {
@@ -4242,6 +4243,25 @@ static TypeTableEntry *analyze_c_import(CodeGen *g, ImportTableEntry *parent_imp
     return resolve_expr_const_val_as_import(g, node, child_import);
 }
 
+static TypeTableEntry *analyze_err_name(CodeGen *g, ImportTableEntry *import,
+        BlockContext *context, AstNode *node)
+{
+    assert(node->type == NodeTypeFnCallExpr);
+
+    AstNode *err_value = node->data.fn_call_expr.params.at(0);
+    TypeTableEntry *resolved_type = analyze_expression(g, import, context,
+            g->builtin_types.entry_pure_error, err_value);
+
+    if (resolved_type->id == TypeTableEntryIdInvalid) {
+        return resolved_type;
+    }
+
+    g->generate_error_name_table = true;
+
+    TypeTableEntry *str_type = get_slice_type(g, g->builtin_types.entry_u8, true);
+    return str_type;
+}
+
 static TypeTableEntry *analyze_builtin_fn_call_expr(CodeGen *g, ImportTableEntry *import, BlockContext *context,
         TypeTableEntry *expected_type, AstNode *node)
 {
@@ -4570,7 +4590,8 @@ static TypeTableEntry *analyze_builtin_fn_call_expr(CodeGen *g, ImportTableEntry
             return analyze_import(g, import, context, node);
         case BuiltinFnIdCImport:
             return analyze_c_import(g, import, context, node);
-
+        case BuiltinFnIdErrName:
+            return analyze_err_name(g, import, context, node);
     }
     zig_unreachable();
 }
diff --git a/src/codegen.cpp b/src/codegen.cpp
index fc7c036061..ec4ec8f0d2 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -65,7 +65,9 @@ CodeGen *codegen_create(Buf *root_source_dir, const ZigTarget *target) {
     g->generic_table.init(16);
     g->is_release_build = false;
     g->is_test_build = false;
-    g->error_value_count = 1;
+
+    // the error.Ok value
+    g->error_decls.append(nullptr);
 
     g->root_package = new_package(buf_ptr(root_source_dir), "");
     g->std_package = new_package(ZIG_STD_DIR, "index.zig");
@@ -328,6 +330,14 @@ static LLVMValueRef get_handle_value(CodeGen *g, AstNode *source_node, LLVMValue
     }
 }
 
+static LLVMValueRef gen_err_name(CodeGen *g, AstNode *node) {
+    zig_panic("TODO");
+    //assert(node->type == NodeTypeFnCallExpr);
+    //AstNode *err_val_node = node->data.fn_call_expr.params.at(0);
+    //LLVMValueRef err_val = gen_expr(g, err_val_node);
+    //arg
+}
+
 static LLVMValueRef gen_builtin_fn_call_expr(CodeGen *g, AstNode *node) {
     assert(node->type == NodeTypeFnCallExpr);
     AstNode *fn_ref_expr = node->data.fn_call_expr.fn_ref_expr;
@@ -467,6 +477,8 @@ static LLVMValueRef gen_builtin_fn_call_expr(CodeGen *g, AstNode *node) {
             zig_unreachable();
         case BuiltinFnIdCompileVar:
             return nullptr;
+        case BuiltinFnIdErrName:
+            return gen_err_name(g, node);
     }
     zig_unreachable();
 }
@@ -3739,6 +3751,7 @@ static void define_builtin_fns(CodeGen *g) {
     create_builtin_fn_with_arg_count(g, BuiltinFnIdClz, "clz", 2);
     create_builtin_fn_with_arg_count(g, BuiltinFnIdImport, "import", 1);
     create_builtin_fn_with_arg_count(g, BuiltinFnIdCImport, "c_import", 1);
+    create_builtin_fn_with_arg_count(g, BuiltinFnIdErrName, "err_name", 1);
 }
 
 static void init(CodeGen *g, Buf *source_path) {