From 41dbdc91f91750b8038719304a9b674f8bab4281 Mon Sep 17 00:00:00 2001 From: StunxFS Date: Wed, 3 Jan 2024 17:39:23 -0400 Subject: [PATCH] fix resolver module --- lib/rivet/src/ast/Decl.ri | 10 ++-- lib/rivet/src/ast/Expr.ri | 6 +-- lib/rivet/src/ast/SourceFile.ri | 8 +-- lib/rivet/src/ast/Stmt.ri | 18 +++---- lib/rivet/src/ast/Sym.ri | 4 +- lib/rivet/src/ast/Type.ri | 4 +- lib/rivet/src/ast/TypeInfo.ri | 2 +- lib/rivet/src/ast/comptime.ri | 2 +- lib/rivet/src/ast/imports.ri | 8 +-- lib/rivet/src/checker/builtin_call.ri | 2 +- lib/rivet/src/checker/decls.ri | 2 +- lib/rivet/src/checker/exprs.ri | 6 +-- lib/rivet/src/checker/match_expr.ri | 2 +- lib/rivet/src/checker/types.ri | 2 +- lib/rivet/src/codegen/mod.ri | 4 +- lib/rivet/src/codegen/types.ri | 2 +- lib/rivet/src/resolver/Register.ri | 72 +++++++++++++-------------- lib/rivet/src/resolver/decls.ri | 22 ++++---- lib/rivet/src/resolver/exprs.ri | 54 ++++++++++---------- lib/rivet/src/resolver/mod.ri | 17 ++++--- lib/rivet/src/resolver/stmts.ri | 14 +++--- lib/rivet/src/resolver/types.ri | 28 +++++------ tests/valid/src/guard_expr.ri | 2 +- 23 files changed, 146 insertions(+), 145 deletions(-) diff --git a/lib/rivet/src/ast/Decl.ri b/lib/rivet/src/ast/Decl.ri index 19c0ba1fd..1c2483a05 100644 --- a/lib/rivet/src/ast/Decl.ri +++ b/lib/rivet/src/ast/Decl.ri @@ -97,7 +97,7 @@ pub enum Decl { is_public: bool; is_extern: bool; abi: ABI; - mut lefts: []+ObjectData; + mut lefts: []+mut ObjectData; mut right: +mut Expr; pos: token.Pos; mut sym: Sym; @@ -116,11 +116,11 @@ pub enum Decl { is_operator: bool; abi: ABI; name: string; - mut args: []+Arg; + args: []+mut Arg; has_named_args: bool; - mut ret_type: +mut Type; - mut stmts: []+mut Stmt; - mut scope: +Scope; + ret_type: +mut Type; + stmts: []+mut Stmt; + scope: +mut Scope; has_body: bool; self_is_ptr: bool; self_is_boxed: bool; diff --git a/lib/rivet/src/ast/Expr.ri b/lib/rivet/src/ast/Expr.ri index 70d593938..8799f5624 100644 --- a/lib/rivet/src/ast/Expr.ri +++ b/lib/rivet/src/ast/Expr.ri @@ -622,7 +622,7 @@ pub enum Expr < traits.Stringable { pub struct CallArg { pub name: string; - pub mut expr: +mut Expr; + pub expr: +mut Expr; pub is_named: bool; pub pos: token.Pos; pub mut type: +mut Type; @@ -633,9 +633,9 @@ pub struct CallErrorHandler { pub varname_pos: token.Pos; pub has_varname: bool; pub is_propagate: bool; - pub mut expr: +mut Expr; + pub expr: +mut Expr; pub has_expr: bool; - pub mut scope: +Scope; + pub scope: +mut Scope; pub pos: token.Pos; } diff --git a/lib/rivet/src/ast/SourceFile.ri b/lib/rivet/src/ast/SourceFile.ri index d69d2e7de..745af0f9b 100644 --- a/lib/rivet/src/ast/SourceFile.ri +++ b/lib/rivet/src/ast/SourceFile.ri @@ -7,8 +7,8 @@ import ../token; #[boxed] pub struct SourceFile { pub path: string; - pub mut decls: []+mut Decl; - pub mut mod: +Module; - pub mut imported_symbols: +ImportedSymbols; - pub mut pos: token.Pos; + pub decls: []+mut Decl; + pub mut mod: +mut Module; + pub imported_symbols: +mut ImportedSymbols; + pub pos: token.Pos; } diff --git a/lib/rivet/src/ast/Stmt.ri b/lib/rivet/src/ast/Stmt.ri index 94a01ce9f..f2dca1b21 100644 --- a/lib/rivet/src/ast/Stmt.ri +++ b/lib/rivet/src/ast/Stmt.ri @@ -11,9 +11,9 @@ pub enum Stmt { ComptimeIf(ComptimeIf), Expr(+mut Expr), VarDecl { - mut lefts: []+ObjectData; - mut right: +mut Expr; - mut scope: +Scope; + lefts: []+mut ObjectData; + right: +mut Expr; + scope: +mut Scope; pos: token.Pos; }, While { @@ -27,12 +27,12 @@ pub enum Stmt { pos: token.Pos; }, For { - mut index: +ObjectData; + index: +mut ObjectData; has_index: bool; - mut values: []+ObjectData; - mut iterable: +mut Expr; - mut stmt: +mut Stmt; - mut scope: +Scope; + values: []+mut ObjectData; + iterable: +mut Expr; + stmt: +mut Stmt; + scope: +mut Scope; pos: token.Pos; }, Defer { @@ -42,7 +42,7 @@ pub enum Stmt { Success } - mut expr: +mut Expr; + expr: +mut Expr; mode: Mode; pos: token.Pos; }; diff --git a/lib/rivet/src/ast/Sym.ri b/lib/rivet/src/ast/Sym.ri index 47853df23..110aaa776 100644 --- a/lib/rivet/src/ast/Sym.ri +++ b/lib/rivet/src/ast/Sym.ri @@ -288,7 +288,7 @@ pub struct Module < Sym { return type_sym; } - pub func add_or_get_func(+mut self, func_sym: +Func) -> +mut TypeSym { + pub func add_or_get_func(+mut self, func_sym: +mut Func) -> +mut TypeSym { unique_name := { mut sb := strings.Builder.from_string("func("); if func_sym.is_method { @@ -418,7 +418,7 @@ pub struct Func < Sym { } #[inline] - pub func type(+self, universe: +mut Module) -> +mut Type { + pub func type(+mut self, universe: +mut Module) -> +mut Type { return +mut .Func( is_method: self.is_method, self_is_ptr: self.self_is_ptr, diff --git a/lib/rivet/src/ast/Type.ri b/lib/rivet/src/ast/Type.ri index 01f6a811b..94fa9c6be 100644 --- a/lib/rivet/src/ast/Type.ri +++ b/lib/rivet/src/ast/Type.ri @@ -94,11 +94,11 @@ pub enum Type < traits.Stringable { mut has_sym: bool; #[inline] - func symbol(&self) -> +Func { + func symbol(&self) -> +mut Func { return if self.has_sym && self.sym.info is .Func(func_sym) { func_sym } else { - +Func( + +mut Func( is_method: self.is_method, self_type: +mut .Void, self_is_mut: self.self_is_mut, diff --git a/lib/rivet/src/ast/TypeInfo.ri b/lib/rivet/src/ast/TypeInfo.ri index dd68ac169..8c40981f9 100644 --- a/lib/rivet/src/ast/TypeInfo.ri +++ b/lib/rivet/src/ast/TypeInfo.ri @@ -32,7 +32,7 @@ pub enum TypeInfo < traits.Stringable { size: uint; }, String, - Func(+Func), + Func(+mut Func), Alias { parent: +mut Type; }, diff --git a/lib/rivet/src/ast/comptime.ri b/lib/rivet/src/ast/comptime.ri index 33a5ccbb6..ea0666783 100644 --- a/lib/rivet/src/ast/comptime.ri +++ b/lib/rivet/src/ast/comptime.ri @@ -31,7 +31,7 @@ pub struct ComptimeIfBranch { } extend Env { - pub func evalue_comptime_if(+self, mut comptime_if: ComptimeIf) -> []+mut Node { + pub func evalue_comptime_if(+self, comptime_if: &mut ComptimeIf) -> []+mut Node { if branch_idx := comptime_if.branch_idx { return comptime_if.branches[branch_idx].nodes; } diff --git a/lib/rivet/src/ast/imports.ri b/lib/rivet/src/ast/imports.ri index b88afc01d..fa3624cf2 100644 --- a/lib/rivet/src/ast/imports.ri +++ b/lib/rivet/src/ast/imports.ri @@ -43,14 +43,14 @@ pub struct ImportedSymbol { } pub struct ImportedSymbols { - pub mut syms: []+ImportedSymbol; + pub mut syms: []+mut ImportedSymbol; #[inline] - pub func add(mut self, name: string, sym: Sym, pos: token.Pos, is_used: bool := false) { - self.syms.push(+ImportedSymbol(name, sym, pos, is_used)); + pub func add(&mut self, name: string, sym: Sym, pos: token.Pos, is_used: bool := false) { + self.syms.push(+mut ImportedSymbol(name, sym, pos, is_used)); } - pub func find(&self, name: string) -> ?+ImportedSymbol { + pub func find(&self, name: string) -> ?+mut ImportedSymbol { for imported_sym in self.syms { if name == imported_sym.name { return imported_sym; diff --git a/lib/rivet/src/checker/builtin_call.ri b/lib/rivet/src/checker/builtin_call.ri index 46883eb64..88d5aa262 100644 --- a/lib/rivet/src/checker/builtin_call.ri +++ b/lib/rivet/src/checker/builtin_call.ri @@ -124,7 +124,7 @@ extend Checker { ), builtin_call.pos ); } - } else if mut from_ts := from_type.symbol() { + } else if from_ts := from_type.symbol() { match from_ts.info { .Trait(trait_info) -> if to_ts := to_type.symbol() { if to_ts in trait_info.implements { diff --git a/lib/rivet/src/checker/decls.ri b/lib/rivet/src/checker/decls.ri index a50ac8938..be8c9ec7e 100644 --- a/lib/rivet/src/checker/decls.ri +++ b/lib/rivet/src/checker/decls.ri @@ -10,7 +10,7 @@ extend Checker { old_sym := self.sym; if decl is .Const || decl is .Var { self.check_decl(decl); - } else if mut decl_decls := decl.decls() { + } else if decl_decls := decl.decls() { self.check_global_vars(decl_decls); } self.sym = old_sym; diff --git a/lib/rivet/src/checker/exprs.ri b/lib/rivet/src/checker/exprs.ri index 1caeb83d5..e3578353f 100644 --- a/lib/rivet/src/checker/exprs.ri +++ b/lib/rivet/src/checker/exprs.ri @@ -115,7 +115,7 @@ extend Checker { }, .TupleLiteral(tuple_lit) -> self.check_tuple_literal(tuple_lit), .ArrayCtor(array_ctor) -> { - if mut init_value := array_ctor.init_value { + if init_value := array_ctor.init_value { init_t := self.check_expr(init_value); if !self.check_compatible_types(init_t, array_ctor.elem_type) { report.error( @@ -131,7 +131,7 @@ extend Checker { ); } } - if mut len_value := array_ctor.len_value { + if len_value := array_ctor.len_value { len_t := self.check_expr(len_value); if !(len_t == self.env.uint_t || len_t == self.env.comptime_int_t) { report.error( @@ -140,7 +140,7 @@ extend Checker { ); } } - if mut cap_value := array_ctor.cap_value { + if cap_value := array_ctor.cap_value { cap_t := self.check_expr(cap_value); if !(cap_t == self.env.uint_t || cap_t == self.env.comptime_int_t) { report.error( diff --git a/lib/rivet/src/checker/match_expr.ri b/lib/rivet/src/checker/match_expr.ri index e34937feb..2a940ab53 100644 --- a/lib/rivet/src/checker/match_expr.ri +++ b/lib/rivet/src/checker/match_expr.ri @@ -88,7 +88,7 @@ extend Checker { } } } - if mut branch_var := branch.branch_var { + if branch_var := branch.branch_var { self.check_name_case( .Snake, "branch variable", branch_var.name, branch_var.pos ); diff --git a/lib/rivet/src/checker/types.ri b/lib/rivet/src/checker/types.ri index 35c761ebd..2d744d181 100644 --- a/lib/rivet/src/checker/types.ri +++ b/lib/rivet/src/checker/types.ri @@ -18,7 +18,7 @@ extend Checker { +self, got: +mut ast.Type, expected: +mut ast.Type, pos: token.Pos, arg_name: string, func_kind: string, func_name: string ) { - if mut expected_sym := expected.symbol(); expected_sym.info is .Trait(trait_info) + if expected_sym := expected.symbol(); expected_sym.info is .Trait(trait_info) && expected != got { got_t := self.env.comptime_number_to_type(got); if got_t.symbol()? in trait_info.implements { diff --git a/lib/rivet/src/codegen/mod.ri b/lib/rivet/src/codegen/mod.ri index 6ae3767b0..efc5d20b8 100644 --- a/lib/rivet/src/codegen/mod.ri +++ b/lib/rivet/src/codegen/mod.ri @@ -134,7 +134,7 @@ pub struct Codegen { }, else -> { prefix_type := self.prefix_type(type); - if mut type_sym := type.symbol() { + if type_sym := type.symbol() { if type_sym.is_primitive() { "{}{}".fmt(type_sym.name.len, type_sym.name) } else { @@ -157,7 +157,7 @@ pub struct Codegen { return sym.mangled_name; } mut sb := strings.Builder.new(); - if mut parent := sym.parent; !parent.is_universe { + if parent := sym.parent; !parent.is_universe { sb.write(self.mangle_symbol(parent)); } else if insert_r { sb.write("_R"); diff --git a/lib/rivet/src/codegen/types.ri b/lib/rivet/src/codegen/types.ri index 855e8c48a..c93319c39 100644 --- a/lib/rivet/src/codegen/types.ri +++ b/lib/rivet/src/codegen/types.ri @@ -158,7 +158,7 @@ extend Codegen { } else { .SizedUint(bits, size) } - } else if mut type_sym := type.symbol() { + } else if type_sym := type.symbol() { if type_sym.is_primitive() { return .Basic(type_sym.name, size, true); } diff --git a/lib/rivet/src/resolver/Register.ri b/lib/rivet/src/resolver/Register.ri index d7fef8c23..03a8b3b06 100644 --- a/lib/rivet/src/resolver/Register.ri +++ b/lib/rivet/src/resolver/Register.ri @@ -26,10 +26,10 @@ pub struct Register { self.source_file = sf; self.walk_decls(self.source_file.decls); } - self.env.throwable_t = .Basic(self.env.throwable_sym); + self.env.throwable_t = +mut .Basic(self.env.throwable_sym); } - func walk_decls(+mut self, mut decls: []+mut ast.Decl) { + func walk_decls(+mut self, decls: []+mut ast.Decl) { for decl in decls { old_abi := self.abi; old_sym := self.sym; @@ -42,23 +42,23 @@ pub struct Register { func walk_decl(+mut self, decl: +mut ast.Decl) { match decl.+ { - .ComptimeIf(comptime_if_decl) -> self.comptime_if(comptime_if_decl), - .Import(import_decl) -> self.import_decl(&import_decl), - .Extern(extern_decl) -> { + .ComptimeIf(&mut comptime_if_decl) -> self.comptime_if(comptime_if_decl), + .Import(&mut import_decl) -> self.import_decl(import_decl), + .Extern(&mut extern_decl) -> { self.abi = extern_decl.abi; self.walk_decls(extern_decl.decls); }, - .Alias(alias_decl) -> alias_decl.sym = self.add_sym( + .Alias(&mut alias_decl) -> alias_decl.sym = self.add_sym( if alias_decl.is_typealias { - ast.TypeSym( + +mut ast.TypeSym( parent: self.sym, is_public: alias_decl.is_public, name: alias_decl.name, - info: .Alias(alias_decl.parent_type) + info: +mut .Alias(alias_decl.parent_type) ) } else { // updated later - ast.SymRef( + +mut ast.SymRef( parent: self.sym, is_public: alias_decl.is_public, name: alias_decl.name, @@ -66,13 +66,13 @@ pub struct Register { ) }, alias_decl.pos ), - .Trait(trait_decl) -> { + .Trait(&mut trait_decl) -> { trait_decl.sym = self.add_sym( - ast.TypeSym( + +mut ast.TypeSym( parent: self.sym, is_public: trait_decl.is_public, name: trait_decl.name, - info: .Trait() + info: +mut .Trait() ), trait_decl.pos ); if self.is_core_mod && trait_decl.name == "Throwable" && !self.env.throwable_sym_is_set { @@ -82,15 +82,15 @@ pub struct Register { self.sym = trait_decl.sym; self.walk_decls(trait_decl.decls); }, - .Struct(struct_decl) -> { + .Struct(&mut struct_decl) -> { struct_decl.sym = if self.is_core_mod && struct_decl.name == "string" { - @as(ast.Type.Basic, self.env.string_t).sym + @as(+ast.Type.Basic, self.env.string_t).sym } else { self.add_sym(+mut ast.TypeSym( parent: self.sym, is_public: struct_decl.is_public, name: struct_decl.name, - info: .Struct( + info: +mut .Struct( is_opaque: struct_decl.is_opaque, is_boxed: struct_decl.attributes.has("boxed") ) @@ -102,14 +102,14 @@ pub struct Register { self.sym = struct_decl.sym; self.walk_decls(struct_decl.decls); }, - .Enum(enum_decl) -> { - info := ast.TypeInfo.Enum( + .Enum(&mut enum_decl) -> { + info := +mut ast.TypeInfo.Enum( underlying_type: enum_decl.underlying_type, is_tagged: enum_decl.is_tagged, is_boxed: enum_decl.attributes.has("boxed") ); enum_decl.sym = self.add_sym( - ast.TypeSym( + +mut ast.TypeSym( parent: self.sym, is_public: enum_decl.is_public, name: enum_decl.name, @@ -117,7 +117,7 @@ pub struct Register { ), enum_decl.pos ); mut enum_info := @as(ast.TypeInfo.Enum, info); - for variant in enum_decl.variants { + for &mut variant in enum_decl.variants { if enum_info.has_variant(variant.name) { report.error("enum `{}` has duplicate variant `{}`".fmt( enum_decl.name, variant.name @@ -126,11 +126,11 @@ pub struct Register { } fields := ast.filter_field_decl(variant.decls); if !variant.decls.is_empty() { - variant_sym := ast.TypeSym( + variant_sym := +mut ast.TypeSym( parent: enum_decl.sym, is_public: enum_decl.is_public, name: variant.name, - info: .Struct( + info: +mut .Struct( false, true, true, parent: @as(+mut ast.TypeSym, enum_decl.sym) ) @@ -142,10 +142,10 @@ pub struct Register { self.sym = variant_sym; self.walk_decls(variant.decls); self.sym = old_v_sym; - variant.type = .Basic(variant_sym); + variant.type = +mut .Basic(variant_sym); } enum_info.add_variant( - ast.EnumVariant( + +mut ast.EnumVariant( name: variant.name, has_type: variant.has_type, type: variant.type, @@ -157,8 +157,8 @@ pub struct Register { self.sym = enum_decl.sym; self.walk_decls(enum_decl.decls); }, - .Field(field_decl) -> { - mut type_sym := @as(+mut ast.TypeSym, self.sym); + .Field(&mut field_decl) -> { + type_sym := @as(+mut ast.TypeSym, self.sym); if type_sym.has_field(field_decl.name) { report.error( "{} `{}` has duplicate field `{}`".fmt( @@ -167,7 +167,7 @@ pub struct Register { ); return; } - type_sym.fields.push(ast.Field( + type_sym.fields.push(+mut ast.Field( name: field_decl.name, is_mut: field_decl.is_mut, is_public: field_decl.is_public, @@ -177,7 +177,7 @@ pub struct Register { is_required: field_decl.attributes.has("required") )); }, - .Const(const_decl) -> const_decl.sym = self.add_sym(+mut ast.Const( + .Const(&mut const_decl) -> const_decl.sym = self.add_sym(+mut ast.Const( parent: self.sym, is_public: const_decl.is_public, abi: self.abi, @@ -185,9 +185,9 @@ pub struct Register { expr: const_decl.expr, type: const_decl.type ), const_decl.pos), - .Var(var_decl) -> { + .Var(&mut var_decl) -> { for left in var_decl.lefts { - left.sym = ast.Var( + left.sym = +mut ast.Var( parent: self.sym, is_public: var_decl.is_public, is_extern: var_decl.is_extern, @@ -202,7 +202,7 @@ pub struct Register { }; } }, - .Extend(extend_decl) -> if extend_decl.type is .Basic(basic_type) { + .Extend(&mut extend_decl) -> if extend_decl.type is .Basic(&mut basic_type) { if type_sym := basic_type.sym { self.sym = type_sym; if type_sym.is_primitive() @@ -210,14 +210,14 @@ pub struct Register { report.error("cannot extend primitive types", extend_decl.pos); } } else { - if basic_type.expr is .Ident(ident) { + if basic_type.expr is .Ident(&mut ident) { self.sym = if type_sym := self.sym.scope.find(ident.name) { type_sym } else { self.add_sym(+mut ast.TypeSym( parent: self.sym, name: ident.name, - info: .Placeholder + info: +mut .Placeholder ), ident.pos) }; ident.found = true; @@ -239,7 +239,7 @@ pub struct Register { extend_decl.pos ); }, - .Func(func_decl) -> func_decl.sym = self.add_sym(+mut ast.Func( + .Func(&mut func_decl) -> func_decl.sym = self.add_sym(+mut ast.Func( parent: self.sym, abi: func_decl.abi, is_public: func_decl.is_public, @@ -264,7 +264,7 @@ pub struct Register { } } - func comptime_if(+mut self, mut comptime_if_decl: ast.ComptimeIf) { + func comptime_if(+mut self, comptime_if_decl: &mut ast.ComptimeIf) { nodes := self.env.evalue_comptime_if(comptime_if_decl); self.walk_decls(ast.nodes_to_decls(nodes)); } @@ -331,7 +331,7 @@ pub struct Register { import_decl.pos ); } - } else if sym := import_decl.info.mod.scope.find(import_info.name) { + } else if mut sym := import_decl.info.mod.scope.find(import_info.name) { self.check_vis(sym, import_info.pos); if self.check_imported_symbol(sym.name, import_info.pos, true) { if import_decl.is_public { @@ -397,7 +397,7 @@ pub struct Register { return true; } - func check_vis(+self, sym: ast.Sym, pos: token.Pos) { + func check_vis(+self, mut sym: ast.Sym, pos: token.Pos) { if !sym.is_public && !self.sym.has_access_to(sym) { report.error("{} `{}` is private".fmt(sym.type_of(), sym.name), pos); } diff --git a/lib/rivet/src/resolver/decls.ri b/lib/rivet/src/resolver/decls.ri index b55aebed1..fea1b17aa 100644 --- a/lib/rivet/src/resolver/decls.ri +++ b/lib/rivet/src/resolver/decls.ri @@ -12,7 +12,7 @@ extend Resolver { old_self_sym_is_set := self.self_sym_is_set; match decl.+ { // .Empty(empty_pos) -> report.error("BUG: empty declaration found", empty_pos), - .ComptimeIf(comptime_if) -> { + .ComptimeIf(&mut comptime_if) -> { ct_decls := ast.nodes_to_decls( self.env.evalue_comptime_if(comptime_if) ); @@ -51,10 +51,10 @@ extend Resolver { for base in trait_decl.bases { if self.resolve_type(base) { base_sym := base.symbol()?; - if base_sym.info is .Trait(base_trait_info) { + if base_sym.info is .Trait(&mut base_trait_info) { trait_info.bases.push(base_sym); for impl in base_trait_info.implements { - if impl.info is .Struct(struct_info) { + if impl.info is .Struct(&mut struct_info) { if !struct_info.contains_trait(base_sym) { base_trait_info.implement(impl); struct_info.traits.push(base_sym); @@ -88,7 +88,7 @@ extend Resolver { for base in enum_decl.bases { if self.resolve_type(base) { base_sym := base.symbol()?; - if base_sym.info is .Trait(trait_info) { + if base_sym.info is .Trait(&mut trait_info) { enum_info.traits.push(base_sym); trait_info.implement(self.self_sym); } else { @@ -122,10 +122,10 @@ extend Resolver { if self.resolve_type(base) { mut struct_info := @as(ast.TypeInfo.Struct, self.self_sym.info); base_sym := base.symbol()?; - if base_sym.info is .Trait(trait_info) { + if base_sym.info is .Trait(&mut trait_info) { struct_info.traits.push(base_sym); trait_info.implement(self.self_sym); - } else if base_sym.info is .Struct(struct_info2) { + } else if base_sym.info is .Struct(&mut struct_info2) { struct_info.bases.push(base_sym); for b_trait in struct_info2.traits { @as(ast.TypeInfo.Trait, b_trait.info).implement( @@ -149,9 +149,9 @@ extend Resolver { for base in extend_decl.bases { if self.resolve_type(base) { base_sym := base.symbol()?; - if base_sym.info is .Trait(trait_info) { + if base_sym.info is .Trait(&mut trait_info) { trait_info.implement(self.self_sym); - } else if self.self_sym.info is .Struct(struct_info) + } else if self.self_sym.info is .Struct(&mut struct_info) && base_sym.info is .Struct { struct_info.bases.push(base_sym); } else { @@ -178,13 +178,13 @@ extend Resolver { ); } }, - .Func(func_decl) -> { + .Func(&mut func_decl) -> { if func_decl.is_method { - mut self_type := ast.Type.Basic( + mut self_type := +mut ast.Type.Basic( self.self_sym, is_boxed: func_decl.self_is_boxed, is_mut: func_decl.self_is_boxed ); if func_decl.self_is_ptr { - self_type = .Pointer(self_type, func_decl.self_is_ptr); + self_type = +mut .Pointer(self_type, func_decl.self_is_ptr); } is_used := self.self_sym.info is .Trait && !func_decl.has_body; func_decl.scope.add_local(+mut ast.Var( diff --git a/lib/rivet/src/resolver/exprs.ri b/lib/rivet/src/resolver/exprs.ri index 6715d12e1..08019c1d7 100644 --- a/lib/rivet/src/resolver/exprs.ri +++ b/lib/rivet/src/resolver/exprs.ri @@ -8,7 +8,7 @@ extend Resolver { func resolve_expr(+mut self, expr: +mut ast.Expr) { match expr.+ { .Empty(empty_pos) -> report.error("bug: unexpected empty expression found", empty_pos), - .ComptimeIf(comptime_if) -> { + .ComptimeIf(&mut comptime_if) -> { exprs := ast.nodes_to_exprs( self.env.evalue_comptime_if(comptime_if) ); @@ -16,17 +16,17 @@ extend Resolver { }, .Paren(paren) -> self.resolve_expr(paren.expr), .Type(type) -> _ = self.resolve_type(type), - .Ident(mut ident) -> self.resolve_ident(ident), - .Selector(selector) -> self.resolve_selector(selector), - .Indirect(indirect) -> self.resolve_expr(indirect.left), - .OptionCheck(option_check) -> self.resolve_expr(option_check.left), - .SelfTy(self_ty) -> if self.self_sym_is_set { + .Ident(&mut ident) -> self.resolve_ident(ident), + .Selector(&mut selector) -> self.resolve_selector(selector), + .Indirect(&mut indirect) -> self.resolve_expr(indirect.left), + .OptionCheck(&mut option_check) -> self.resolve_expr(option_check.left), + .SelfTy(&mut self_ty) -> if self.self_sym_is_set { self_ty.sym = self.self_sym; self_ty.found = true; } else { report.error("cannot resolve `Self` expression", self_ty.pos); }, - .SelfLiteral(self_lit) -> if self.self_sym_is_set { + .SelfLiteral(&mut self_lit) -> if self.self_sym_is_set { self_lit.sym = self.self_sym; self_lit.found = true; self_lit.obj = @as(+mut ast.Var, self_lit.scope.lookup("self")?); @@ -39,12 +39,12 @@ extend Resolver { self.resolve_expr(value); } }, - .ArrayCtor(array_ctor) -> { + .ArrayCtor(&mut array_ctor) -> { _ = self.resolve_type(array_ctor.elem_type); - if mut init_value := array_ctor.init_value { + if init_value := array_ctor.init_value { self.resolve_expr(init_value); } - if mut len_value := array_ctor.len_value { + if len_value := array_ctor.len_value { self.resolve_expr(len_value); if !array_ctor.is_dyn { if len_res := self.eval_size(len_value) { @@ -61,7 +61,7 @@ extend Resolver { } } } - if mut cap_value := array_ctor.cap_value { + if cap_value := array_ctor.cap_value { self.resolve_expr(cap_value); } }, @@ -70,7 +70,7 @@ extend Resolver { self.resolve_expr(value); } }, - .BuiltinCall(builtin_call) -> { + .BuiltinCall(&mut builtin_call) -> { if builtin := self.env.find_builtin(builtin_call.name) { if builtin is .Func { builtin_call.builtin = builtin; @@ -90,7 +90,7 @@ extend Resolver { ); } }, - .Call(call) -> { + .Call(&mut call) -> { self.resolve_expr(call.left); for arg in call.args { self.resolve_expr(arg.expr); @@ -122,10 +122,10 @@ extend Resolver { self.resolve_expr(binary.right); if binary.has_var_obj { self.check_variable_shadowing(binary.var_obj.name, binary.var_obj.pos); - binary.var_obj.sym = ast.Var( + binary.var_obj.sym = +mut ast.Var( is_mut: binary.var_obj.is_mut && !binary.var_obj.is_ref, name: binary.var_obj.name, - type: .Void, + type: +mut .Void, level: .Local, pos: binary.var_obj.pos ); @@ -159,11 +159,11 @@ extend Resolver { .Guard(guard) -> { for var_ in guard.vars { self.check_variable_shadowing(var_.name, var_.pos); - var_.sym = ast.Var( + var_.sym = +mut ast.Var( is_mut: var_.is_mut, name: var_.name, level: .Local, - type: .Void, + type: +mut .Void, pos: var_.pos ); guard.scope.add_local(var_.sym) catch |err| report.error( @@ -196,7 +196,7 @@ extend Resolver { is_mut: branch_var.is_mut && !branch_var.is_ref, name: branch_var.name, level: .Local, - type: .Void, + type: +mut .Void, pos: branch_var.pos )) catch |err| report.error( err.to_string(), branch_var.pos @@ -217,7 +217,7 @@ extend Resolver { } } - func resolve_ident(+mut self, ident: +mut ast.Expr.Ident) { + func resolve_ident(+mut self, ident: &mut ast.Expr.Ident) { if ident.name == "_" { ident.found = true; ident.is_obj = true; @@ -235,12 +235,12 @@ extend Resolver { report.error("unknown builtin constant `{}`".fmt(ident.name), ident.pos); } return; - } else if mut obj := ident.scope.lookup(ident.name) { + } else if obj := ident.scope.lookup(ident.name) { ident.found = true; ident.is_obj = true; ident.sym = obj; @as(+mut ast.Var, obj).is_used = true; - } else if mut imported := self.source_file.imported_symbols.find(ident.name) { + } else if imported := self.source_file.imported_symbols.find(ident.name) { if !(imported.sym is ast.TypeSym(type_sym) && type_sym.info is .Placeholder) { imported.is_used = true; ident.found = true; @@ -280,7 +280,7 @@ extend Resolver { } if ident.found { - if ident.is_sym && ident.sym is ast.SymRef(sym_ref) { + if ident.is_sym && ident.sym is ast.SymRef(mut sym_ref) { ident.sym = self.clean_symbol_reference(sym_ref); } self.check_symbol_abi(ident.sym, ident.pos); @@ -289,9 +289,9 @@ extend Resolver { } } - func resolve_selector(+mut self, selector: +mut ast.Expr.Selector) { + func resolve_selector(+mut self, selector: &mut ast.Expr.Selector) { self.resolve_expr(selector.left); - match selector.left { + match selector.left.+ { .SelfTy(self_ty) if self_ty.found -> { selector.is_path = true; selector.left_sym = self_ty.sym; @@ -325,12 +325,12 @@ extend Resolver { func find_symbol(+mut self, mut sym: ast.Sym, name: string, pos: token.Pos) -> ?ast.Sym { mut sym_ := sym; - if sym is ast.SymRef(sym_ref) { + if sym is ast.SymRef(mut sym_ref) { sym_ = self.clean_symbol_reference(sym_ref); } if mut s := sym_.scope.find(name) { self.check_vis(s, pos); - return if s is ast.SymRef(sym_ref2) { + return if s is ast.SymRef(mut sym_ref2) { self.clean_symbol_reference(sym_ref2) } else { s @@ -369,7 +369,7 @@ extend Resolver { sym_ref.ref = selector.sym; sym_ref.ref_resolved = true; } - if sym_ref.ref is ast.SymRef(sym_ref2) { + if sym_ref.ref is ast.SymRef(mut sym_ref2) { sym_ref.ref = self.clean_symbol_reference(sym_ref2); } } diff --git a/lib/rivet/src/resolver/mod.ri b/lib/rivet/src/resolver/mod.ri index 6e244c947..1b8166fda 100644 --- a/lib/rivet/src/resolver/mod.ri +++ b/lib/rivet/src/resolver/mod.ri @@ -26,7 +26,8 @@ pub struct Resolver { mut different_abi_usage_count: uint; pub func resolve_files(+mut self, source_files: []+mut ast.SourceFile) { - Register(self.env).walk_files(source_files); + register := +mut Register(self.env); + register.walk_files(source_files); if report.total_errors() > 0 { return; } @@ -54,22 +55,22 @@ pub struct Resolver { } } - func check_vis(+self, sym: ast.Sym, pos: token.Pos) { + func check_vis(+self, mut sym: ast.Sym, pos: token.Pos) { if !sym.is_public && !self.source_file.mod.has_access_to(sym) { report.error("{} `{}` is private".fmt(sym.type_of(), sym.name), pos); } } - func eval_size(+mut self, mut expr: +mut ast.Expr) -> ?int { + func eval_size(+mut self, expr: +mut ast.Expr) -> ?int { return match expr.+ { - .ComptimeIf(comptime_if) -> { - mut ct_expr := ast.nodes_to_exprs(self.env.evalue_comptime_if(comptime_if))[0]; + .ComptimeIf(&mut comptime_if) -> { + ct_expr := ast.nodes_to_exprs(self.env.evalue_comptime_if(comptime_if))[0]; self.eval_size(ct_expr) }, .Block(block) if block.is_expr -> self.eval_size(block.expr), .Paren(paren) -> self.eval_size(paren.expr), .IntegerLiteral(int_lit) -> int_lit.value.to_int() catch return none, - .Ident(ident) -> { + .Ident(&mut ident) -> { self.resolve_ident(ident); if ident.found { self.eval_sym(ident.sym, ident.pos) @@ -77,7 +78,7 @@ pub struct Resolver { none } }, - .Selector(selector) -> { + .Selector(&mut selector) -> { self.resolve_selector(selector); if selector.found { self.eval_sym(selector.sym, selector.pos) @@ -123,7 +124,7 @@ pub struct Resolver { } func eval_sym(+mut self, mut sym: ast.Sym, pos: token.Pos) -> ?int { - if sym is ast.Const(const_) { + if sym is ast.Const(mut const_) { if !const_.has_evaled_size { const_.evaled_size = self.eval_size(const_.expr)?; } diff --git a/lib/rivet/src/resolver/stmts.ri b/lib/rivet/src/resolver/stmts.ri index 7379652d3..edc91c725 100644 --- a/lib/rivet/src/resolver/stmts.ri +++ b/lib/rivet/src/resolver/stmts.ri @@ -15,8 +15,8 @@ extend Resolver { match stmt.+ { .Comment -> {}, .Empty(empty_pos) -> report.error("bug: unexpected empty statement found", empty_pos), - .ComptimeIf(comptime_if) -> { - mut stmts := ast.nodes_to_stmts( + .ComptimeIf(&mut comptime_if) -> { + stmts := ast.nodes_to_stmts( self.env.evalue_comptime_if(comptime_if) ); self.resolve_stmts(stmts); @@ -26,7 +26,7 @@ extend Resolver { for left in var_stmt.lefts { self.check_variable_shadowing(left.name, left.pos); _ = self.resolve_type(left.type); - left.sym = ast.Var( + left.sym = +mut ast.Var( is_mut: left.is_mut, name: left.name, level: .Local, @@ -54,12 +54,12 @@ extend Resolver { .For(for_stmt) -> { if for_stmt.has_index { self.check_variable_shadowing(for_stmt.index.name, for_stmt.index.pos); - for_stmt.index.sym = ast.Var( + for_stmt.index.sym = +mut ast.Var( is_mut: for_stmt.index.is_mut, name: for_stmt.index.name, level: .Local, pos: for_stmt.index.pos, - type: .Void // updated later + type: +mut .Void // updated later ); for_stmt.scope.add_local(for_stmt.index.sym) catch |err| report.error( err.to_string(), for_stmt.index.pos @@ -67,12 +67,12 @@ extend Resolver { } for value in for_stmt.values { self.check_variable_shadowing(value.name, value.pos); - value.sym = ast.Var( + value.sym = +mut ast.Var( is_mut: value.is_mut, name: value.name, level: .Local, pos: value.pos, - type: .Void // updated later + type: +mut .Void // updated later ); for_stmt.scope.add_local(value.sym) catch |err| report.error( err.to_string(), value.pos diff --git a/lib/rivet/src/resolver/types.ri b/lib/rivet/src/resolver/types.ri index 7f44ddf07..7a964b238 100644 --- a/lib/rivet/src/resolver/types.ri +++ b/lib/rivet/src/resolver/types.ri @@ -10,9 +10,9 @@ extend Resolver { .Void, .Never, .Rawptr, .Boxedptr -> true, .Option(opt) -> self.resolve_type(opt.inner), .Result(res) -> self.resolve_type(res.inner), - .Variadic(variadic) -> if self.resolve_type(variadic.inner) { - mut elem_sym := variadic.inner.symbol()?; - if elem_sym.info is .Trait(trait_info) { + .Variadic(&mut variadic) -> if self.resolve_type(variadic.inner) { + elem_sym := variadic.inner.symbol()?; + if elem_sym.info is .Trait(&mut trait_info) { trait_info.has_objects = true; } variadic.sym = self.env.universe.add_or_get_slice(variadic.inner, false); @@ -20,19 +20,19 @@ extend Resolver { } else { false }, - .Slice(slice) -> if self.resolve_type(slice.inner) { + .Slice(&mut slice) -> if self.resolve_type(slice.inner) { slice.sym = self.env.universe.add_or_get_slice(slice.inner, slice.is_mut); true } else { false }, - .DynArray(dyn_arr) -> if self.resolve_type(dyn_arr.inner) { + .DynArray(&mut dyn_arr) -> if self.resolve_type(dyn_arr.inner) { dyn_arr.sym = self.env.universe.add_or_get_dyn_array(dyn_arr.inner, dyn_arr.is_mut); true } else { false }, - .Array(arr) -> if self.resolve_type(arr.inner) { + .Array(&mut arr) -> if self.resolve_type(arr.inner) { if arr_size := self.eval_size(arr.size) { if arr_size <= 0 { err := report.error_builder( @@ -58,7 +58,7 @@ extend Resolver { false }, .Pointer(ptr) -> self.resolve_type(ptr.inner), - .Tuple(tuple) -> { + .Tuple(&mut tuple) -> { mut resolved := false; for inner in tuple.inners { resolved = self.resolve_type(inner); @@ -68,7 +68,7 @@ extend Resolver { } resolved }, - .Func(func_t) -> { + .Func(&mut func_t) -> { mut res1 := false; for arg in func_t.args { res1 = self.resolve_type(arg.type); @@ -78,8 +78,8 @@ extend Resolver { func_t.has_sym = true; res1 }, - .Basic(basic) -> if basic.is_unresolved { - match basic.expr { + .Basic(&mut basic) -> if basic.is_unresolved { + match basic.expr.+ { .SelfTy -> if self.self_sym_is_set { basic.is_unresolved = false; basic.sym = self.self_sym; @@ -87,10 +87,10 @@ extend Resolver { } else { false }, - .Ident(ident) -> { + .Ident(&mut ident) -> { self.resolve_ident(ident); if ident.found { - if ident.sym is ast.TypeSym(type_sym) { + if ident.sym is ast.TypeSym(mut type_sym) { basic.is_unresolved = false; basic.sym = type_sym; if type_sym.info is .Alias(alias_info) { @@ -107,10 +107,10 @@ extend Resolver { } ident.found }, - .Selector(selector) -> { + .Selector(&mut selector) -> { self.resolve_selector(selector); if selector.found { - if selector.sym is ast.TypeSym(type_sym) { + if selector.sym is ast.TypeSym(mut type_sym) { if type_sym.info is .Placeholder { report.error( "cannot find type `{}` in {} `{}`".fmt( diff --git a/tests/valid/src/guard_expr.ri b/tests/valid/src/guard_expr.ri index 1e4d3d6aa..947d98eb7 100644 --- a/tests/valid/src/guard_expr.ri +++ b/tests/valid/src/guard_expr.ri @@ -7,7 +7,7 @@ func ret_err() -> !int32 { } test "guard expression with mutable variable" { - if mut val := ret_none() { + if val := ret_none() { @assert(val == 3); val += 2; @assert(val == 5);