refact(rivet): remove .prefs field from some structs, use Env.prefs instead

Author: StunxFS

cmd/src/tools/cmd_fmt.ri

@@ -39,11 +39,11 @@ pub func cmd_fmt(args: []string) -> ! {
         );
         prefs_.check_input(input);
         prefs_.load_module_info()!;
-        table_ := ast.Table.new(prefs_);
-        mut builder := rivet.Builder(table: table_, prefs: prefs_);
+        env := ast.Env.new(prefs_);
+        mut builder := rivet.Builder(env: env);
         builder.load_root_module()!;
-        mut formatter := fmt.Formatter(prefs_, table_, write_to_file: write_to_file);
-        for source_file in table_.source_files {
+        mut formatter := fmt.Formatter(env, write_to_file: write_to_file);
+        for source_file in env.source_files {
             output := formatter.format(source_file);
             console.writeln(output);
         }

lib/rivet/src/ast/Builtin.ri

@@ -0,0 +1,144 @@
+// Copyright (C) 2023 The Rivet Developers. All rights reserved.
+// Use of this source code is governed by an MIT license that can
+// be found in the LICENSE file.
+
+import ../token;
+
+pub enum Builtin {
+    Invalid,
+    Const {
+        name: string;
+        type: Type;
+    },
+    Func {
+        name: string;
+        args: []BuiltinArg;
+        type: Type;
+        is_unsafe: bool;
+        checks: []BuiltinFuncCheck;
+
+        func args_len(self) -> uint {
+            mut l: uint := 0;
+            for arg in self.args {
+                if arg.is_optional {
+                    break;
+                }
+                l += 1;
+            }
+            return l;
+        }
+    };
+
+    pub func type(self) -> Type {
+        return match self {
+            .Const(b_const) -> b_const.type,
+            .Func(b_func) -> b_func.type,
+            else -> .Void
+        };
+    }
+}
+
+struct BuiltinArg {
+    pub name: string;
+    pub is_mut: bool;
+    pub is_any: bool; // any type
+    pub type: Type;
+    pub is_optional: bool;
+}
+
+enum BuiltinFuncType {
+    Pointer,
+    Enum,
+    Integer
+}
+
+enum BuiltinFuncCheck {
+    ReturnTypeEqualToArgumentType(uint),
+    ArgumentTypeEqualToArgumentType {
+        arg1_idx: uint;
+        arg2_idx: uint;
+    },
+    ArgumentTypeShouldBe {
+        arg_idx: uint;
+        type: BuiltinFuncType;
+    }
+}
+
+extend Env {
+    func setup_builtins(mut self) {
+        self.builtins = +[
+            // variables
+            .Const("_FILE_", self.string_t),
+            .Const("_LINE_", self.uint_t),
+            .Const("_COLUMN_", self.uint_t),
+            .Const("_FUNCTION_", self.string_t),
+            .Const("_RIVET_VERSION_", self.string_t),
+            .Const("_RIVET_COMMIT_", self.string_t),
+
+            // functions
+            .Func("size_of", +[BuiltinArg("value", is_any: true)], self.uint_t),
+            .Func("align_of", +[BuiltinArg("value", is_any: true)], self.uint_t),
+
+            .Func("ptr_add", +[
+                BuiltinArg("pointer", is_any: true),
+                BuiltinArg("value", is_any: true)
+            ], is_unsafe: true, checks: +[
+                .ArgumentTypeShouldBe(0, .Pointer),
+                .ArgumentTypeShouldBe(1, .Integer),
+                .ReturnTypeEqualToArgumentType(0)
+            ]),
+            .Func("ptr_diff", +[
+                BuiltinArg("pointer", is_any: true),
+                BuiltinArg("pointer2", is_any: true)
+            ], self.uint_t, is_unsafe: true, checks: +[
+                .ArgumentTypeShouldBe(0, .Pointer),
+                .ArgumentTypeEqualToArgumentType(1, 0)
+            ]),
+
+            .Func("as", +[
+                BuiltinArg("type", is_any: true),
+                BuiltinArg("value", is_any: true)
+            ], checks: +[
+                .ReturnTypeEqualToArgumentType(0)
+            ]),
+
+            .Func("unreachable", +[], .Never(token.noPos)),
+            .Func("breakpoint", +[]),
+            .Func("assert", +[
+                BuiltinArg("cond", type: self.bool_t),
+                BuiltinArg("msg", type: self.string_t, is_optional: true)
+            ]),
+
+            .Func("set_enum_ref_value", +[
+                BuiltinArg("enum_value", is_any: true, is_mut: true),
+                BuiltinArg("new_value", is_any: true)
+            ], is_unsafe: true, checks: +[
+                .ArgumentTypeShouldBe(0, .Enum),
+                .ArgumentTypeEqualToArgumentType(1, 0)
+            ]),
+
+            // TODO: rename to `ignore_warn`: `@ignore_warn("not_mutated", expr)`.
+            .Func("ignore_not_mutated_warn", +[
+                BuiltinArg("expr", is_any: true, is_mut: true)
+            ])
+        ];
+    }
+
+    pub func find_builtin(self, name: string) -> ?Builtin {
+        for builtin in self.builtins {
+            is_equal := match builtin {
+                .Const(b_var) -> b_var.name == name,
+                .Func(b_func) -> b_func.name == name,
+                else -> false
+            };
+            if is_equal {
+                return builtin;
+            }
+        }
+        return none;
+    }
+
+    pub func exist_builtin(self, name: string) -> bool {
+        return self.find_builtin(name) != none;
+    }
+}

lib/rivet/src/ast/CHeader.ri

@@ -108,7 +108,7 @@ enum CImportValue {
     }
 }
 
-extend Table {
+extend Env {
     func setup_c_utils(mut self) {
         self.c_include_paths = self.get_include_paths();
         self.c_defines = self.get_global_defines();