language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-08-04 12:18:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 7

Merge remote-tracking branch 'origin/main' into enforce-literal-sizes

Browse source
This commit is contained in:
Richard Feldman 2025-06-26 18:14:15 -04:00
commit b656a75d71
No known key found for this signature in database
23 changed files with 231 additions and 239 deletions
Download patch file Download diff file Expand all files Collapse all files

43
src/check/canonicalize.zig
View file

@ -3,7 +3,7 @@ const base = @import("../base.zig");
const parse = @import("parse.zig");
const tokenize = @import("parse/tokenize.zig");
const collections = @import("../collections.zig");
const types = @import("../types/types.zig");
const types = @import("../types.zig");
const RocDec = @import("../builtins/dec.zig").RocDec;
const NodeStore = @import("./canonicalize/NodeStore.zig");
@ -1212,38 +1212,35 @@ pub fn canonicalize_expr(
// Iterate over the tuple items, canonicalizing each one
// Then append the result to the scratch list
const items_slice = self.parse_ir.store.exprSlice(e.items);
const elems_var_top = self.can_ir.env.types.tuple_elems.len();
for (items_slice) |item| {
if (self.canonicalize_expr(item)) |canonicalized| {
self.can_ir.store.addScratchExpr(canonicalized);
_ = self.can_ir.env.types.appendTupleElem(@enumFromInt(@intFromEnum(canonicalized)));
}
}
const elems_var_range = types.Var.SafeList.Range{
.start = @enumFromInt(elems_var_top),
.end = @enumFromInt(self.can_ir.env.types.tuple_elems.len()),
};
// Create span of the new scratch expressions
const elems_span = self.can_ir.store.exprSpanFrom(scratch_top);
// create type vars, first "reserve" node slots
const tuple_expr_idx = self.can_ir.store.predictNodeIndex(2);
// then insert the type vars, setting the parent to be the final slot
const tuple_type_var = self.can_ir.pushFreshTypeVar(
tuple_expr_idx,
region,
);
// then in the final slot the actual expr is inserted
const expr_idx = self.can_ir.store.addExpr(CIR.Expr{
.tuple = .{
.elems = elems_span,
.tuple_var = tuple_type_var,
.region = region,
},
});
// Insert concrete type variable for tuple
// TODO: Implement proper tuple type structure when tuple types are available
_ = self.can_ir.setTypeVarAtExpr(
expr_idx,
Content{ .flex_var = null },
Content{ .structure = FlatType{
.tuple = types.Tuple{ .elems = elems_var_range },
} },
);
return expr_idx;
@ -1878,34 +1875,34 @@ fn canonicalize_pattern(
// Iterate over the tuple patterns, canonicalizing each one
// Then append the result to the scratch list
const patterns_slice = self.parse_ir.store.patternSlice(e.patterns);
const elems_var_top = self.can_ir.env.types.tuple_elems.len();
for (patterns_slice) |pattern| {
if (self.canonicalize_pattern(pattern)) |canonicalized| {
self.can_ir.store.addScratchPattern(canonicalized);
_ = self.can_ir.env.types.appendTupleElem(@enumFromInt(@intFromEnum(canonicalized)));
}
}
const elems_var_range = types.Var.SafeList.Range{
.start = @enumFromInt(elems_var_top),
.end = @enumFromInt(self.can_ir.env.types.tuple_elems.len()),
};
// Create span of the new scratch patterns
const patterns_span = self.can_ir.store.patternSpanFrom(scratch_top);
// Reserve node slots for type vars, then insert into them.
const tuple_pattern_idx = self.can_ir.store.predictNodeIndex(2);
const tuple_type_var = self.can_ir.pushFreshTypeVar(
tuple_pattern_idx,
region,
);
const pattern_idx = self.can_ir.store.addPattern(CIR.Pattern{
.tuple = .{
.patterns = patterns_span,
.tuple_var = tuple_type_var,
.region = region,
},
});
// Insert concrete type variable for tuple pattern
// TODO: Implement proper tuple type structure when tuple types are available
_ = self.can_ir.setTypeVarAtPat(
pattern_idx,
Content{ .flex_var = null },
Content{ .structure = FlatType{
.tuple = types.Tuple{ .elems = elems_var_range },
} },
);
return pattern_idx;
@ -2855,7 +2852,6 @@ fn canonicalize_statement(self: *Self, stmt_idx: AST.Statement.Idx) ?CIR.Expr.Id
// Create an empty tuple as a unit value
const empty_span = CIR.Expr.Span{ .span = base.DataSpan{ .start = 0, .len = 0 } };
const unit_expr = self.can_ir.store.addExpr(CIR.Expr{ .tuple = .{
.tuple_var = self.can_ir.pushFreshTypeVar(@enumFromInt(0), region),
.elems = empty_span,
.region = region,
} });
@ -2869,7 +2865,6 @@ fn canonicalize_statement(self: *Self, stmt_idx: AST.Statement.Idx) ?CIR.Expr.Id
const region = self.parse_ir.tokenizedRegionToRegion(import_stmt.region);
const empty_span = CIR.Expr.Span{ .span = base.DataSpan{ .start = 0, .len = 0 } };
const unit_expr = self.can_ir.store.addExpr(CIR.Expr{ .tuple = .{
.tuple_var = self.can_ir.pushFreshTypeVar(@enumFromInt(0), region),
.elems = empty_span,
.region = region,
} });

8
src/check/canonicalize/CIR.zig
View file

@ -1112,7 +1112,6 @@ pub const Expr = union(enum) {
region: Region,
},
tuple: struct {
tuple_var: TypeVar,
elems: Expr.Span,
region: Region,
},
@ -1447,9 +1446,6 @@ pub const Expr = union(enum) {
var node = SExpr.init(gpa, "e-tuple");
node.appendRegion(gpa, ir.calcRegionInfo(t.region));
// Add tuple_var
node.appendTypeVar(gpa, "tuple-var", t.tuple_var);
// Add tuple elements
var elems_node = SExpr.init(gpa, "elems");
for (ir.store.sliceExpr(t.elems)) |elem_idx| {
@ -2199,7 +2195,6 @@ pub const Pattern = union(enum) {
region: Region,
},
tuple: struct {
tuple_var: TypeVar,
patterns: Pattern.Span,
region: Region,
},
@ -2330,9 +2325,6 @@ pub const Pattern = union(enum) {
// var pattern_idx_node = formatPatternIdxNode(gpa, pattern_idx);
// node.appendNode(gpa, &pattern_idx_node);
// Add tuple_var
node.appendTypeVar(gpa, "tuple-var", p.tuple_var);
var patterns_node = SExpr.init(gpa, "patterns");
for (ir.store.slicePatterns(p.patterns)) |patt_idx| {

4
src/check/canonicalize/NodeStore.zig
View file

@ -215,7 +215,6 @@ pub fn getExpr(store: *const NodeStore, expr: CIR.Expr.Idx) CIR.Expr {
return .{
.tuple = .{
.elems = .{ .span = .{ .start = node.data_1, .len = node.data_2 } },
.tuple_var = @enumFromInt(node.data_3),
.region = node.region,
},
};
@ -467,7 +466,6 @@ pub fn getPattern(store: *const NodeStore, pattern_idx: CIR.Pattern.Idx) CIR.Pat
.tuple = .{
.region = node.region,
.patterns = DataSpan.init(node.data_1, node.data_2).as(CIR.Pattern.Span),
.tuple_var = @enumFromInt(node.data_3),
},
},
.pattern_num_literal => {
@ -811,7 +809,6 @@ pub fn addExpr(store: *NodeStore, expr: CIR.Expr) CIR.Expr.Idx {
node.tag = .expr_tuple;
node.data_1 = e.elems.span.start;
node.data_2 = e.elems.span.len;
node.data_3 = @intFromEnum(e.tuple_var);
},
.frac_f64 => |e| {
node.region = e.region;
@ -1046,7 +1043,6 @@ pub fn addPattern(store: *NodeStore, pattern: CIR.Pattern) CIR.Pattern.Idx {
node.region = p.region;
node.data_1 = p.patterns.span.start;
node.data_2 = p.patterns.span.len;
node.data_3 = @intFromEnum(p.tuple_var);
},
.int_literal => |p| {
node.tag = .pattern_int_literal;

6
src/check/check_types.zig
View file

@ -283,7 +283,11 @@ pub fn checkExpr(self: *Self, expr_idx: CIR.Expr.Idx) void {
.binop => |_| {},
.block => |_| {},
.lambda => |_| {},
.tuple => |_| {},
.tuple => |tuple| {
for (self.can_ir.store.exprSlice(tuple.elems)) |single_elem_expr_idx| {
self.checkExpr(single_elem_expr_idx);
}
},
.dot_access => |_| {
// TODO: Implement type checking for dot access
// This will need to:

4
src/snapshots/binops.md generated
View file

@ -116,7 +116,7 @@ CloseRound(17:1-17:2),EndOfFile(17:2-17:2),
~~~
# CANONICALIZE
~~~clojure
(e-tuple @1-1-17-2 (tuple-var 147) (id 148)
(e-tuple @1-1-17-2 (id 147)
(elems
(e-binop @2-5-2-11 (op "add")
(e-int @2-5-2-6 (num-var 73) (value "4"))
@ -166,5 +166,5 @@ CloseRound(17:1-17:2),EndOfFile(17:2-17:2),
~~~
# TYPES
~~~clojure
(expr (id 148) (type "*"))
(expr (id 147) (type "(*, *, *, *, *, *, *, *, *, *, *, *, *, *, *)"))
~~~

6
src/snapshots/can_import_comprehensive.md generated
View file

@ -172,9 +172,9 @@ main = {
# CANONICALIZE
~~~clojure
(can-ir
(d-let (id 121)
(d-let (id 120)
(p-assign @7-1-7-5 (ident "main") (id 77))
(e-block @7-8-35-2 (id 120)
(e-block @7-8-35-2 (id 119)
(s-let @8-5-8-22
(p-assign @8-5-8-11 (ident "client") (id 78))
(e-lookup-external (id 80)
@ -207,7 +207,7 @@ main = {
(p-assign @23-5-23-13 (ident "combined") (id 106))
(e-lookup-external (id 108)
(ext-decl @23-16-23-26 (qualified "utils.String.concat") (module "utils.String") (local "concat") (kind "value") (type-var 107))))
(e-tuple @25-5-34-6 (tuple-var 118)
(e-tuple @25-5-34-6
(elems
(e-lookup-local @26-9-26-15
(pattern (id 78)))

6
src/snapshots/expr/record_field_update.md
View file

@ -60,13 +60,13 @@ OpenCurly(1:1-1:2),LowerIdent(1:3-1:9),OpAmpersand(1:10-1:11),LowerIdent(1:12-1:
~~~
# CANONICALIZE
~~~clojure
(e-block @1-1-1-21 (id 79)
(e-block @1-1-1-21 (id 78)
(s-expr @1-3-1-11
(e-runtime-error (tag "ident_not_in_scope")))
(e-tuple @1-12-1-21 (tuple-var 77)
(e-tuple @1-12-1-21
(elems)))
~~~
# TYPES
~~~clojure
(expr (id 79) (type "*"))
(expr (id 78) (type "*"))
~~~

4
src/snapshots/expr/tuple.md
View file

@ -27,7 +27,7 @@ NO CHANGE
~~~
# CANONICALIZE
~~~clojure
(e-tuple @1-1-1-19 (tuple-var 78) (id 79)
(e-tuple @1-1-1-19 (id 78)
(elems
(e-int @1-2-1-3 (num-var 73) (value "1"))
(e-string @1-5-1-12
@ -36,5 +36,5 @@ NO CHANGE
~~~
# TYPES
~~~clojure
(expr (id 79) (type "*"))
(expr (id 78) (type "(Num(*), Str, [True, * *])"))
~~~

72
src/snapshots/expr/tuple_comprehensive.md
View file

@ -229,7 +229,7 @@ CloseCurly(19:1-19:2),EndOfFile(19:2-19:2),
~~~
# CANONICALIZE
~~~clojure
(e-block @1-1-19-2 (id 172)
(e-block @1-1-19-2 (id 162)
(s-let @3-5-3-21
(p-assign @3-5-3-12 (ident "add_one") (id 72))
(e-lambda @3-15-3-21 (id 76)
@ -247,57 +247,57 @@ CloseCurly(19:1-19:2),EndOfFile(19:2-19:2),
(e-int @6-9-6-11 (num-var 88) (value "30") (id 88)))
(s-let @9-2-9-12
(p-assign @9-2-9-7 (ident "empty") (id 90))
(e-tuple @9-10-9-12 (tuple-var 91) (id 92)
(e-tuple @9-10-9-12 (id 91)
(elems)))
(s-let @10-2-10-15
(p-assign @10-2-10-8 (ident "single") (id 94))
(e-tuple @10-11-10-15 (tuple-var 97) (id 98)
(p-assign @10-2-10-8 (ident "single") (id 93))
(e-tuple @10-11-10-15 (id 96)
(elems
(e-int @10-12-10-14 (num-var 96) (value "42")))))
(e-int @10-12-10-14 (num-var 95) (value "42")))))
(s-let @11-2-11-15
(p-assign @11-2-11-6 (ident "pair") (id 100))
(e-tuple @11-9-11-15 (tuple-var 105) (id 106)
(p-assign @11-2-11-6 (ident "pair") (id 98))
(e-tuple @11-9-11-15 (id 103)
(elems
(e-int @11-10-11-11 (num-var 102) (value "1"))
(e-int @11-13-11-14 (num-var 104) (value "2")))))
(e-int @11-10-11-11 (num-var 100) (value "1"))
(e-int @11-13-11-14 (num-var 102) (value "2")))))
(s-let @12-2-12-29
(p-assign @12-2-12-8 (ident "triple") (id 108))
(e-tuple @12-11-12-29 (tuple-var 115) (id 116)
(p-assign @12-2-12-8 (ident "triple") (id 105))
(e-tuple @12-11-12-29 (id 112)
(elems
(e-int @12-12-12-13 (num-var 110) (value "1"))
(e-int @12-12-12-13 (num-var 107) (value "1"))
(e-string @12-15-12-22
(e-literal @12-16-12-21 (string "hello")))
(e-tag @12-24-12-28 (ext-var 0) (name "True") (args "TODO")))))
(s-let @13-2-13-27
(p-assign @13-2-13-8 (ident "nested") (id 118))
(e-tuple @13-11-13-27 (tuple-var 131) (id 132)
(p-assign @13-2-13-8 (ident "nested") (id 114))
(e-tuple @13-11-13-27 (id 125)
(elems
(e-tuple @13-12-13-18 (tuple-var 123)
(e-tuple @13-12-13-18
(elems
(e-int @13-13-13-14 (num-var 120) (value "1"))
(e-int @13-16-13-17 (num-var 122) (value "2"))))
(e-tuple @13-20-13-26 (tuple-var 129)
(e-int @13-13-13-14 (num-var 116) (value "1"))
(e-int @13-16-13-17 (num-var 118) (value "2"))))
(e-tuple @13-20-13-26
(elems
(e-int @13-21-13-22 (num-var 126) (value "3"))
(e-int @13-24-13-25 (num-var 128) (value "4")))))))
(e-int @13-21-13-22 (num-var 121) (value "3"))
(e-int @13-24-13-25 (num-var 123) (value "4")))))))
(s-let @14-2-14-42
(p-assign @14-2-14-7 (ident "mixed") (id 134))
(e-tuple @14-10-14-42 (tuple-var 149) (id 150)
(p-assign @14-2-14-7 (ident "mixed") (id 127))
(e-tuple @14-10-14-42 (id 142)
(elems
(e-call @14-11-14-21
(e-lookup-local @14-11-14-18
(pattern (id 72)))
(e-int @14-19-14-20 (num-var 137) (value "5")))
(e-int @14-19-14-20 (num-var 130) (value "5")))
(e-string @14-23-14-30
(e-literal @14-24-14-29 (string "world")))
(e-list @14-32-14-41 (elem-var 147)
(e-list @14-32-14-41 (elem-var 140)
(elems
(e-int @14-33-14-34 (num-var 142) (value "1"))
(e-int @14-36-14-37 (num-var 144) (value "2"))
(e-int @14-39-14-40 (num-var 146) (value "3")))))))
(e-int @14-33-14-34 (num-var 135) (value "1"))
(e-int @14-36-14-37 (num-var 137) (value "2"))
(e-int @14-39-14-40 (num-var 139) (value "3")))))))
(s-let @15-2-15-23
(p-assign @15-2-15-11 (ident "with_vars") (id 152))
(e-tuple @15-14-15-23 (tuple-var 156) (id 157)
(p-assign @15-2-15-11 (ident "with_vars") (id 144))
(e-tuple @15-14-15-23 (id 148)
(elems
(e-lookup-local @15-15-15-16
(pattern (id 78)))
@ -306,21 +306,21 @@ CloseCurly(19:1-19:2),EndOfFile(19:2-19:2),
(e-lookup-local @15-21-15-22
(pattern (id 86))))))
(s-let @16-2-16-31
(p-assign @16-2-16-13 (ident "with_lambda") (id 159))
(e-tuple @16-16-16-31 (tuple-var 168) (id 169)
(p-assign @16-2-16-13 (ident "with_lambda") (id 150))
(e-tuple @16-16-16-31 (id 159)
(elems
(e-lambda @16-17-16-27
(args
(p-assign @16-18-16-19 (ident "n") (id 160)))
(p-assign @16-18-16-19 (ident "n") (id 151)))
(e-binop @16-21-16-27 (op "add")
(e-lookup-local @16-21-16-22
(pattern (id 160)))
(e-int @16-25-16-26 (num-var 163) (value "1"))))
(e-int @16-28-16-30 (num-var 167) (value "42")))))
(pattern (id 151)))
(e-int @16-25-16-26 (num-var 154) (value "1"))))
(e-int @16-28-16-30 (num-var 158) (value "42")))))
(e-lookup-local @18-2-18-7
(pattern (id 90))))
~~~
# TYPES
~~~clojure
(expr (id 172) (type "*"))
(expr (id 162) (type "*"))
~~~

58
src/snapshots/expr/tuple_patterns.md
View file

@ -255,59 +255,59 @@ CloseCurly(19:1-19:2),EndOfFile(19:2-19:2),
~~~
# CANONICALIZE
~~~clojure
(e-block @1-1-19-2 (id 174)
(e-block @1-1-19-2 (id 160)
(s-expr @4-5-4-13
(e-tuple @4-5-4-11 (tuple-var 76)
(e-tuple @4-5-4-11
(elems
(e-runtime-error (tag "ident_not_in_scope"))
(e-runtime-error (tag "ident_not_in_scope")))))
(s-expr @4-14-7-6
(e-tuple @4-14-4-20 (tuple-var 83)
(e-tuple @4-14-4-20
(elems
(e-int @4-15-4-16 (num-var 80) (value "1"))
(e-int @4-18-4-19 (num-var 82) (value "2")))))
(e-int @4-15-4-16 (num-var 79) (value "1"))
(e-int @4-18-4-19 (num-var 81) (value "2")))))
(s-expr @7-5-7-23
(e-tuple @7-5-7-21 (tuple-var 98)
(e-tuple @7-5-7-21
(elems
(e-tuple @7-6-7-12 (tuple-var 90)
(e-tuple @7-6-7-12
(elems
(e-runtime-error (tag "ident_not_in_scope"))
(e-runtime-error (tag "ident_not_in_scope"))))
(e-tuple @7-14-7-20 (tuple-var 96)
(e-tuple @7-14-7-20
(elems
(e-runtime-error (tag "ident_not_in_scope"))
(e-runtime-error (tag "ident_not_in_scope")))))))
(s-expr @7-24-10-6
(e-tuple @7-24-7-44 (tuple-var 113)
(e-tuple @7-24-7-44
(elems
(e-tuple @7-25-7-33 (tuple-var 105)
(e-tuple @7-25-7-33
(elems
(e-int @7-26-7-28 (num-var 102) (value "10"))
(e-int @7-30-7-32 (num-var 104) (value "20"))))
(e-tuple @7-35-7-43 (tuple-var 111)
(e-int @7-26-7-28 (num-var 97) (value "10"))
(e-int @7-30-7-32 (num-var 99) (value "20"))))
(e-tuple @7-35-7-43
(elems
(e-int @7-36-7-38 (num-var 108) (value "30"))
(e-int @7-40-7-42 (num-var 110) (value "40")))))))
(e-int @7-36-7-38 (num-var 102) (value "30"))
(e-int @7-40-7-42 (num-var 104) (value "40")))))))
(s-expr @10-5-10-29
(e-tuple @10-5-10-27 (tuple-var 122)
(e-tuple @10-5-10-27
(elems
(e-runtime-error (tag "ident_not_in_scope"))
(e-runtime-error (tag "ident_not_in_scope"))
(e-runtime-error (tag "ident_not_in_scope")))))
(s-expr @10-30-13-6
(e-tuple @10-30-10-44 (tuple-var 131)
(e-tuple @10-30-10-44
(elems
(e-int @10-31-10-34 (num-var 126) (value "100"))
(e-int @10-36-10-38 (num-var 128) (value "42"))
(e-int @10-40-10-43 (num-var 130) (value "200")))))
(e-int @10-31-10-34 (num-var 117) (value "100"))
(e-int @10-36-10-38 (num-var 119) (value "42"))
(e-int @10-40-10-43 (num-var 121) (value "200")))))
(s-expr @13-5-13-30
(e-tuple @13-5-13-28 (tuple-var 140)
(e-tuple @13-5-13-28
(elems
(e-runtime-error (tag "ident_not_in_scope"))
(e-runtime-error (tag "ident_not_in_scope"))
(e-runtime-error (tag "ident_not_in_scope")))))
(s-expr @13-31-16-6
(e-tuple @13-31-13-55 (tuple-var 149)
(e-tuple @13-31-13-55
(elems
(e-string @13-32-13-39
(e-literal @13-33-13-38 (string "Alice")))
@ -315,23 +315,23 @@ CloseCurly(19:1-19:2),EndOfFile(19:2-19:2),
(e-literal @13-42-13-47 (string "fixed")))
(e-tag @13-50-13-54 (ext-var 0) (name "True") (args "TODO")))))
(s-expr @16-5-16-20
(e-tuple @16-5-16-18 (tuple-var 156)
(e-tuple @16-5-16-18
(elems
(e-runtime-error (tag "ident_not_in_scope"))
(e-runtime-error (tag "ident_not_in_scope")))))
(s-expr @16-21-18-6
(e-tuple @16-21-16-41 (tuple-var 169)
(e-tuple @16-21-16-41
(elems
(e-list @16-22-16-31 (elem-var 165)
(e-list @16-22-16-31 (elem-var 152)
(elems
(e-int @16-23-16-24 (num-var 160) (value "1"))
(e-int @16-26-16-27 (num-var 162) (value "2"))
(e-int @16-29-16-30 (num-var 164) (value "3"))))
(e-int @16-23-16-24 (num-var 147) (value "1"))
(e-int @16-26-16-27 (num-var 149) (value "2"))
(e-int @16-29-16-30 (num-var 151) (value "3"))))
(e-string @16-33-16-40
(e-literal @16-34-16-39 (string "hello"))))))
(e-runtime-error (tag "not_implemented")))
~~~
# TYPES
~~~clojure
(expr (id 174) (type "*"))
(expr (id 160) (type "*"))
~~~

2
src/snapshots/records/record_access_function_call.md
View file

@ -32,5 +32,5 @@ NO CHANGE
~~~
# TYPES
~~~clojure
(expr (id 79) (type "*"))
(expr (id 78) (type "*"))
~~~

2
src/snapshots/records/record_different_fields_error.md
View file

@ -345,5 +345,5 @@ CloseCurly(8:1-8:2),EndOfFile(8:2-8:2),
~~~
# TYPES
~~~clojure
(expr (id 109) (type "*"))
(expr (id 106) (type "*"))
~~~

2
src/snapshots/records/record_different_fields_reserved_error.md
View file

@ -286,5 +286,5 @@ CloseCurly(8:1-8:2),EndOfFile(8:2-8:2),
~~~
# TYPES
~~~clojure
(expr (id 93) (type "*"))
(expr (id 92) (type "*"))
~~~

2
src/snapshots/records/record_extension_update.md
View file

@ -108,5 +108,5 @@ CloseCurly(4:1-4:2),EndOfFile(4:2-4:2),
~~~
# TYPES
~~~clojure
(expr (id 83) (type "*"))
(expr (id 81) (type "*"))
~~~

76
src/snapshots/syntax_grab_bag.md generated
View file

@ -1288,9 +1288,9 @@ NO CHANGE
(p-assign @81-2-81-3 (ident "a") (id 226))
(p-assign @82-2-82-3 (ident "b") (id 227)))
(e-runtime-error (tag "not_implemented"))))
(d-let (id 436)
(d-let (id 432)
(p-assign @144-1-144-6 (ident "main!") (id 242))
(e-lambda @144-9-196-2 (id 430)
(e-lambda @144-9-196-2 (id 426)
(args
(p-underscore @144-10-144-11 (id 243)))
(e-block @144-13-196-2
@ -1343,7 +1343,7 @@ NO CHANGE
(e-runtime-error (tag "not_implemented") (id 304)))
(s-let @179-2-179-68
(p-assign @179-2-179-7 (ident "tuple") (id 306))
(e-tuple @179-10-179-68 (tuple-var 329) (id 330)
(e-tuple @179-10-179-68 (id 328)
(elems
(e-int @179-11-179-14 (num-var 308) (value "123"))
(e-string @179-16-179-23
@ -1354,21 +1354,21 @@ NO CHANGE
(e-tag @179-30-179-32 (ext-var 0) (name "Ok") (args "TODO"))
(e-lookup-local @179-33-179-38
(pattern (id 244))))
(e-tuple @179-41-179-56 (tuple-var 319)
(e-tuple @179-41-179-56
(elems
(e-runtime-error (tag "ident_not_in_scope"))
(e-lookup-local @179-50-179-55
(pattern (id 306)))))
(e-list @179-58-179-67 (elem-var 327)
(e-list @179-58-179-67 (elem-var 326)
(elems
(e-int @179-59-179-60 (num-var 322) (value "1"))
(e-int @179-62-179-63 (num-var 324) (value "2"))
(e-int @179-65-179-66 (num-var 326) (value "3")))))))
(e-int @179-59-179-60 (num-var 321) (value "1"))
(e-int @179-62-179-63 (num-var 323) (value "2"))
(e-int @179-65-179-66 (num-var 325) (value "3")))))))
(s-let @180-2-187-3
(p-assign @180-2-180-17 (ident "multiline_tuple") (id 332))
(e-tuple @180-20-187-3 (tuple-var 356) (id 357)
(p-assign @180-2-180-17 (ident "multiline_tuple") (id 330))
(e-tuple @180-20-187-3 (id 353)
(elems
(e-int @181-3-181-6 (num-var 334) (value "123"))
(e-int @181-3-181-6 (num-var 332) (value "123"))
(e-string @182-3-182-10
(e-literal @182-4-182-9 (string "World")))
(e-runtime-error (tag "ident_not_in_scope"))
@ -1376,48 +1376,48 @@ NO CHANGE
(e-tag @184-3-184-5 (ext-var 0) (name "Ok") (args "TODO"))
(e-lookup-local @184-6-184-11
(pattern (id 244))))
(e-tuple @185-3-185-18 (tuple-var 346)
(e-tuple @185-3-185-18
(elems
(e-runtime-error (tag "ident_not_in_scope"))
(e-lookup-local @185-12-185-17
(pattern (id 306)))))
(e-list @186-3-186-12 (elem-var 354)
(e-list @186-3-186-12 (elem-var 351)
(elems
(e-int @186-4-186-5 (num-var 349) (value "1"))
(e-int @186-7-186-8 (num-var 351) (value "2"))
(e-int @186-10-186-11 (num-var 353) (value "3")))))))
(e-int @186-4-186-5 (num-var 346) (value "1"))
(e-int @186-7-186-8 (num-var 348) (value "2"))
(e-int @186-10-186-11 (num-var 350) (value "3")))))))
(s-let @188-2-189-23
(p-assign @188-2-188-15 (ident "bin_op_result") (id 359))
(e-binop @188-18-189-23 (op "or") (id 400)
(p-assign @188-2-188-15 (ident "bin_op_result") (id 355))
(e-binop @188-18-189-23 (op "or") (id 396)
(e-binop @188-18-188-74 (op "or")
(e-binop @188-18-188-43 (op "gt")
(e-binop @188-18-188-34 (op "null_coalesce")
(e-call @188-18-188-26
(e-tag @188-18-188-21 (ext-var 0) (name "Err") (args "TODO"))
(e-runtime-error (tag "ident_not_in_scope")))
(e-int @188-30-188-32 (num-var 366) (value "12")))
(e-int @188-30-188-32 (num-var 362) (value "12")))
(e-binop @188-35-188-43 (op "mul")
(e-int @188-35-188-36 (num-var 369) (value "5"))
(e-int @188-39-188-40 (num-var 371) (value "5"))))
(e-int @188-35-188-36 (num-var 365) (value "5"))
(e-int @188-39-188-40 (num-var 367) (value "5"))))
(e-binop @188-44-188-74 (op "and")
(e-binop @188-44-188-58 (op "lt")
(e-binop @188-44-188-52 (op "add")
(e-int @188-44-188-46 (num-var 375) (value "13"))
(e-int @188-49-188-50 (num-var 377) (value "2")))
(e-int @188-53-188-54 (num-var 380) (value "5")))
(e-int @188-44-188-46 (num-var 371) (value "13"))
(e-int @188-49-188-50 (num-var 373) (value "2")))
(e-int @188-53-188-54 (num-var 376) (value "5")))
(e-binop @188-59-188-74 (op "ge")
(e-binop @188-59-188-68 (op "sub")
(e-int @188-59-188-61 (num-var 383) (value "10"))
(e-int @188-64-188-65 (num-var 385) (value "1")))
(e-int @188-69-188-71 (num-var 388) (value "16")))))
(e-int @188-59-188-61 (num-var 379) (value "10"))
(e-int @188-64-188-65 (num-var 381) (value "1")))
(e-int @188-69-188-71 (num-var 384) (value "16")))))
(e-binop @188-75-189-23 (op "le")
(e-int @188-75-188-77 (num-var 393) (value "12"))
(e-int @188-75-188-77 (num-var 389) (value "12"))
(e-binop @188-81-189-23 (op "div")
(e-int @188-81-188-82 (num-var 395) (value "3"))
(e-int @188-85-188-86 (num-var 397) (value "5"))))))
(e-int @188-81-188-82 (num-var 391) (value "3"))
(e-int @188-85-188-86 (num-var 393) (value "5"))))))
(s-let @189-2-190-8
(p-assign @189-2-189-23 (ident "static_dispatch_style") (id 402))
(e-dot-access @189-26-190-8 (field "unknown") (id 407)
(p-assign @189-2-189-23 (ident "static_dispatch_style") (id 398))
(e-dot-access @189-26-190-8 (field "unknown") (id 403)
(receiver
(e-dot-access @189-26-189-110 (field "unknown")
(receiver
@ -1428,7 +1428,7 @@ NO CHANGE
(e-runtime-error (tag "not_implemented")))
(e-call @191-2-195-3
(e-lookup-external
(ext-decl @191-2-191-14 (qualified "pf.Stdout.line!") (module "pf.Stdout") (local "line!") (kind "value") (type-var 412)))
(ext-decl @191-2-191-14 (qualified "pf.Stdout.line!") (module "pf.Stdout") (local "line!") (kind "value") (type-var 408)))
(e-string @192-3-194-18
(e-literal @192-4-192-14 (string "How about "))
(e-call @193-4-193-21
@ -1436,7 +1436,7 @@ NO CHANGE
(e-lookup-local @193-14-193-20
(pattern (id 250))))
(e-literal @194-4-194-17 (string " as a string?"))))))
(annotation @144-1-144-6 (signature 434) (id 435)
(annotation @144-1-144-6 (signature 430) (id 431)
(declared-type
(ty-fn @143-9-143-38 (effectful false)
(ty-apply @143-9-143-21 (symbol "List")
@ -1444,10 +1444,10 @@ NO CHANGE
(ty-apply @143-25-143-38 (symbol "Result")
(ty-record @143-32-143-34)
(ty-underscore @143-36-143-37))))))
(d-let (id 444)
(p-assign @199-1-199-6 (ident "empty") (id 438))
(e-runtime-error (tag "not_implemented") (id 440))
(annotation @199-1-199-6 (signature 442) (id 443)
(d-let (id 440)
(p-assign @199-1-199-6 (ident "empty") (id 434))
(e-runtime-error (tag "not_implemented") (id 436))
(annotation @199-1-199-6 (signature 438) (id 439)
(declared-type
(ty-record @198-9-198-11))))
(s-type-decl @22-1-23-6 (id 84)

22
src/snapshots/type_alias_parameterized.md generated
View file

@ -86,21 +86,21 @@ NO CHANGE
# CANONICALIZE
~~~clojure
(can-ir
(d-let (id 105)
(d-let (id 103)
(p-assign @6-1-6-9 (ident "swapPair") (id 90))
(e-lambda @6-12-6-27 (id 99)
(e-lambda @6-12-6-27 (id 97)
(args
(p-tuple @6-13-6-19 (tuple-var 93) (id 94)
(p-tuple @6-13-6-19 (id 93)
(patterns
(p-assign @6-14-6-15 (ident "x") (id 91))
(p-assign @6-17-6-18 (ident "y") (id 92)))))
(e-tuple @6-21-6-27 (tuple-var 97)
(e-tuple @6-21-6-27
(elems
(e-lookup-local @6-22-6-23
(pattern (id 92)))
(e-lookup-local @6-25-6-26
(pattern (id 91))))))
(annotation @6-1-6-9 (signature 103) (id 104)
(annotation @6-1-6-9 (signature 101) (id 102)
(declared-type
(ty-fn @5-12-5-36 (effectful false)
(ty-apply @5-12-5-22 (symbol "Pair")
@ -109,16 +109,16 @@ NO CHANGE
(ty-apply @5-26-5-36 (symbol "Pair")
(ty-var @5-31-5-32 (name "b"))
(ty-var @5-34-5-35 (name "a")))))))
(d-let (id 115)
(p-assign @8-1-8-6 (ident "main!") (id 106))
(e-lambda @8-9-8-27 (id 114)
(d-let (id 113)
(p-assign @8-1-8-6 (ident "main!") (id 104))
(e-lambda @8-9-8-27 (id 112)
(args
(p-underscore @8-10-8-11 (id 107)))
(p-underscore @8-10-8-11 (id 105)))
(e-call @8-13-8-27
(e-lookup-local @8-13-8-21
(pattern (id 90)))
(e-int @8-22-8-23 (num-var 110) (value "1"))
(e-int @8-25-8-26 (num-var 112) (value "2")))))
(e-int @8-22-8-23 (num-var 108) (value "1"))
(e-int @8-25-8-26 (num-var 110) (value "2")))))
(s-type-decl @3-1-5-9 (id 78)
(ty-header @3-1-3-11 (name "Pair")
(ty-args

18
src/snapshots/type_alias_simple.md generated
View file

@ -79,15 +79,15 @@ NO CHANGE
# CANONICALIZE
~~~clojure
(can-ir
(d-let (id 100)
(d-let (id 99)
(p-assign @6-1-6-8 (ident "getUser") (id 78))
(e-lambda @1-1-1-1 (id 94)
(e-lambda @1-1-1-1 (id 93)
(args
(p-assign @6-12-6-14 (ident "id") (id 79)))
(e-if @1-1-1-1 (cond-var 0) (branch-var 0)
(if-branches
(if-branch
(e-tuple @6-19-6-28 (tuple-var 84)
(e-tuple @6-19-6-28
(elems
(e-binop @6-20-6-28 (op "gt")
(e-lookup-local @6-20-6-22
@ -98,20 +98,20 @@ NO CHANGE
(if-else
(e-string @6-40-6-47
(e-literal @6-41-6-46 (string "small"))))))
(annotation @6-1-6-8 (signature 98) (id 99)
(annotation @6-1-6-8 (signature 97) (id 98)
(declared-type
(ty-fn @5-11-5-24 (effectful false)
(ty @5-11-5-17 (name "UserId"))
(ty @5-21-5-24 (name "Str"))))))
(d-let (id 108)
(p-assign @8-1-8-6 (ident "main!") (id 101))
(e-lambda @8-9-8-25 (id 107)
(d-let (id 107)
(p-assign @8-1-8-6 (ident "main!") (id 100))
(e-lambda @8-9-8-25 (id 106)
(args
(p-underscore @8-10-8-11 (id 102)))
(p-underscore @8-10-8-11 (id 101)))
(e-call @8-13-8-25
(e-lookup-local @8-13-8-20
(pattern (id 78)))
(e-int @8-21-8-24 (num-var 105) (value "100")))))
(e-int @8-21-8-24 (num-var 104) (value "100")))))
(s-type-decl @3-1-5-8 (id 74)
(ty-header @3-1-3-7 (name "UserId"))
(ty @3-10-3-13 (name "U64"))))

58
src/snapshots/type_annotation_basic.md generated
View file

@ -203,19 +203,19 @@ main! = |_| {
(ty-fn @4-12-4-18 (effectful false)
(ty-var @4-12-4-13 (name "a"))
(ty-var @4-17-4-18 (name "a"))))))
(d-let (id 113)
(d-let (id 112)
(p-assign @9-1-9-8 (ident "combine") (id 98))
(e-lambda @9-11-9-42 (id 105)
(e-lambda @9-11-9-42 (id 104)
(args
(p-assign @9-12-9-17 (ident "first") (id 99))
(p-assign @9-19-9-25 (ident "second") (id 100)))
(e-tuple @9-27-9-42 (tuple-var 103)
(e-tuple @9-27-9-42
(elems
(e-lookup-local @9-28-9-33
(pattern (id 99)))
(e-lookup-local @9-35-9-41
(pattern (id 100))))))
(annotation @9-1-9-8 (signature 111) (id 112)
(annotation @9-1-9-8 (signature 110) (id 111)
(declared-type
(ty-fn @8-11-8-25 (effectful false)
(ty-var @8-11-8-12 (name "a"))
@ -223,56 +223,56 @@ main! = |_| {
(ty-tuple @8-19-8-25
(ty-var @8-20-8-21 (name "a"))
(ty-var @8-23-8-24 (name "b")))))))
(d-let (id 129)
(p-assign @13-1-13-7 (ident "addOne") (id 117))
(e-lambda @13-10-15-6 (id 123)
(d-let (id 128)
(p-assign @13-1-13-7 (ident "addOne") (id 116))
(e-lambda @13-10-15-6 (id 122)
(args
(p-assign @13-11-13-12 (ident "n") (id 118)))
(p-assign @13-11-13-12 (ident "n") (id 117)))
(e-binop @13-14-15-6 (op "add")
(e-lookup-local @13-14-13-15
(pattern (id 118)))
(e-int @13-18-13-19 (num-var 121) (value "1"))))
(annotation @13-1-13-7 (signature 127) (id 128)
(pattern (id 117)))
(e-int @13-18-13-19 (num-var 120) (value "1"))))
(annotation @13-1-13-7 (signature 126) (id 127)
(declared-type
(ty-fn @12-10-12-20 (effectful false)
(ty @12-10-12-13 (name "U64"))
(ty @12-17-12-20 (name "U64"))))))
(d-let (id 160)
(p-assign @15-1-15-6 (ident "main!") (id 130))
(e-lambda @15-9-27-2 (id 159)
(d-let (id 159)
(p-assign @15-1-15-6 (ident "main!") (id 129))
(e-lambda @15-9-27-2 (id 158)
(args
(p-underscore @15-10-15-11 (id 131)))
(p-underscore @15-10-15-11 (id 130)))
(e-block @15-13-27-2
(s-let @17-5-17-23
(p-assign @17-5-17-8 (ident "num") (id 132))
(e-call @17-11-17-23 (id 136)
(p-assign @17-5-17-8 (ident "num") (id 131))
(e-call @17-11-17-23 (id 135)
(e-lookup-local @17-11-17-19
(pattern (id 77)))
(e-int @17-20-17-22 (num-var 135) (value "42"))))
(e-int @17-20-17-22 (num-var 134) (value "42"))))
(s-let @18-5-18-29
(p-assign @18-5-18-9 (ident "text") (id 138))
(e-call @18-12-18-29 (id 142)
(p-assign @18-5-18-9 (ident "text") (id 137))
(e-call @18-12-18-29 (id 141)
(e-lookup-local @18-12-18-20
(pattern (id 77)))
(e-string @18-21-18-28
(e-literal @18-22-18-27 (string "hello")))))
(s-let @21-5-21-30
(p-assign @21-5-21-9 (ident "pair") (id 144))
(e-call @21-12-21-30 (id 148)
(p-assign @21-5-21-9 (ident "pair") (id 143))
(e-call @21-12-21-30 (id 147)
(e-lookup-local @21-12-21-19
(pattern (id 98)))
(e-lookup-local @21-20-21-23
(pattern (id 132)))
(pattern (id 131)))
(e-lookup-local @21-25-21-29
(pattern (id 138)))))
(pattern (id 137)))))
(s-let @24-5-24-23
(p-assign @24-5-24-11 (ident "result") (id 150))
(e-call @24-14-24-23 (id 154)
(p-assign @24-5-24-11 (ident "result") (id 149))
(e-call @24-14-24-23 (id 153)
(e-lookup-local @24-14-24-20
(pattern (id 117)))
(e-int @24-21-24-22 (num-var 153) (value "5"))))
(pattern (id 116)))
(e-int @24-21-24-22 (num-var 152) (value "5"))))
(e-lookup-local @26-5-26-11
(pattern (id 150)))))))
(pattern (id 149)))))))
~~~
# TYPES
~~~clojure

16
src/snapshots/type_same_var_multiple_uses.md generated
View file

@ -67,29 +67,29 @@ NO CHANGE
# CANONICALIZE
~~~clojure
(can-ir
(d-let (id 93)
(d-let (id 92)
(p-assign @4-1-4-5 (ident "pair") (id 80))
(e-lambda @4-8-4-18 (id 86)
(e-lambda @4-8-4-18 (id 85)
(args
(p-assign @4-9-4-10 (ident "x") (id 81)))
(e-tuple @4-12-4-18 (tuple-var 84)
(e-tuple @4-12-4-18
(elems
(e-lookup-local @4-13-4-14
(pattern (id 81)))
(e-lookup-local @4-16-4-17
(pattern (id 81))))))
(annotation @4-1-4-5 (signature 91) (id 92)
(annotation @4-1-4-5 (signature 90) (id 91)
(declared-type
(ty-fn @3-8-3-19 (effectful false)
(ty-var @3-8-3-9 (name "a"))
(ty-tuple @3-13-3-19
(ty-var @3-14-3-15 (name "a"))
(ty-var @3-17-3-18 (name "a")))))))
(d-let (id 99)
(p-assign @6-1-6-6 (ident "main!") (id 94))
(e-lambda @6-9-6-15 (id 98)
(d-let (id 98)
(p-assign @6-1-6-6 (ident "main!") (id 93))
(e-lambda @6-9-6-15 (id 97)
(args
(p-underscore @6-10-6-11 (id 95)))
(p-underscore @6-10-6-11 (id 94)))
(e-runtime-error (tag "not_implemented")))))
~~~
# TYPES

18
src/snapshots/type_two_variables.md generated
View file

@ -71,21 +71,21 @@ NO CHANGE
# CANONICALIZE
~~~clojure
(can-ir
(d-let (id 98)
(d-let (id 96)
(p-assign @4-1-4-5 (ident "swap") (id 83))
(e-lambda @4-8-4-23 (id 92)
(e-lambda @4-8-4-23 (id 90)
(args
(p-tuple @4-9-4-15 (tuple-var 86) (id 87)
(p-tuple @4-9-4-15 (id 86)
(patterns
(p-assign @4-10-4-11 (ident "x") (id 84))
(p-assign @4-13-4-14 (ident "y") (id 85)))))
(e-tuple @4-17-4-23 (tuple-var 90)
(e-tuple @4-17-4-23
(elems
(e-lookup-local @4-18-4-19
(pattern (id 85)))
(e-lookup-local @4-21-4-22
(pattern (id 84))))))
(annotation @4-1-4-5 (signature 96) (id 97)
(annotation @4-1-4-5 (signature 94) (id 95)
(declared-type
(ty-fn @3-8-3-24 (effectful false)
(ty-tuple @3-8-3-14
@ -94,11 +94,11 @@ NO CHANGE
(ty-tuple @3-18-3-24
(ty-var @3-19-3-20 (name "b"))
(ty-var @3-22-3-23 (name "a")))))))
(d-let (id 104)
(p-assign @6-1-6-6 (ident "main!") (id 99))
(e-lambda @6-9-6-15 (id 103)
(d-let (id 102)
(p-assign @6-1-6-6 (ident "main!") (id 97))
(e-lambda @6-9-6-15 (id 101)
(args
(p-underscore @6-10-6-11 (id 100)))
(p-underscore @6-10-6-11 (id 98)))
(e-runtime-error (tag "not_implemented")))))
~~~
# TYPES

18
src/snapshots/type_var_multiple.md generated
View file

@ -122,25 +122,25 @@ main! = |_| {}
# CANONICALIZE
~~~clojure
(can-ir
(d-let (id 107)
(d-let (id 105)
(p-assign @5-1-5-5 (ident "swap") (id 83))
(e-lambda @5-8-8-2 (id 101)
(e-lambda @5-8-8-2 (id 99)
(args
(p-assign @5-9-5-13 (ident "pair") (id 84)))
(e-block @5-15-8-2
(s-expr @6-5-6-22
(e-tuple @6-5-6-20 (tuple-var 89)
(e-tuple @6-5-6-20
(elems
(e-runtime-error (tag "ident_not_in_scope"))
(e-runtime-error (tag "ident_not_in_scope")))))
(s-expr @6-23-7-6
(e-lookup-local @6-23-6-27
(pattern (id 84))))
(e-tuple @7-5-7-20 (tuple-var 98)
(e-tuple @7-5-7-20
(elems
(e-runtime-error (tag "ident_not_in_scope"))
(e-runtime-error (tag "ident_not_in_scope"))))))
(annotation @5-1-5-5 (signature 105) (id 106)
(annotation @5-1-5-5 (signature 103) (id 104)
(declared-type
(ty-fn @4-8-4-24 (effectful false)
(ty-tuple @4-8-4-14
@ -149,11 +149,11 @@ main! = |_| {}
(ty-tuple @4-18-4-24
(ty-var @4-19-4-20 (name "b"))
(ty-var @4-22-4-23 (name "a")))))))
(d-let (id 113)
(p-assign @10-1-10-6 (ident "main!") (id 108))
(e-lambda @10-9-10-15 (id 112)
(d-let (id 111)
(p-assign @10-1-10-6 (ident "main!") (id 106))
(e-lambda @10-9-10-15 (id 110)
(args
(p-underscore @10-10-10-11 (id 109)))
(p-underscore @10-10-10-11 (id 107)))
(e-runtime-error (tag "not_implemented")))))
~~~
# TYPES

20
src/snapshots/type_var_namespace.md generated
View file

@ -149,9 +149,9 @@ main! = |_| {}
# CANONICALIZE
~~~clojure
(can-ir
(d-let (id 108)
(d-let (id 107)
(p-assign @5-1-5-8 (ident "process") (id 78))
(e-lambda @5-11-14-2 (id 101)
(e-lambda @5-11-14-2 (id 100)
(args
(p-assign @5-12-5-16 (ident "list") (id 79)))
(e-block @5-18-14-2
@ -159,8 +159,8 @@ main! = |_| {}
(p-assign @7-5-7-9 (ident "elem") (id 80))
(e-int @7-12-7-14 (num-var 82) (value "42") (id 82)))
(s-let @11-5-11-30
(p-assign @11-5-11-11 (ident "result") (id 88))
(e-call @11-14-11-30 (id 92)
(p-assign @11-5-11-11 (ident "result") (id 87))
(e-call @11-14-11-30 (id 91)
(e-runtime-error (tag "ident_not_in_scope"))
(e-lookup-local @11-25-11-29
(pattern (id 79)))))
@ -170,18 +170,18 @@ main! = |_| {}
(e-lookup-local @11-53-11-57
(pattern (id 80)))))
(e-lookup-local @13-5-13-11
(pattern (id 88)))))
(annotation @5-1-5-8 (signature 106) (id 107)
(pattern (id 87)))))
(annotation @5-1-5-8 (signature 105) (id 106)
(declared-type
(ty-fn @4-11-4-29 (effectful false)
(ty-apply @4-11-4-21 (symbol "List")
(ty-var @4-16-4-20 (name "elem")))
(ty-var @4-25-4-29 (name "elem"))))))
(d-let (id 114)
(p-assign @16-1-16-6 (ident "main!") (id 109))
(e-lambda @16-9-16-15 (id 113)
(d-let (id 113)
(p-assign @16-1-16-6 (ident "main!") (id 108))
(e-lambda @16-9-16-15 (id 112)
(args
(p-underscore @16-10-16-11 (id 110)))
(p-underscore @16-10-16-11 (id 109)))
(e-runtime-error (tag "not_implemented")))))
~~~
# TYPES

5
src/types/store.zig
View file

@ -241,6 +241,11 @@ pub const Store = struct {
return self.alias_args.appendSlice(self.gpa, slice);
}
/// Append a tuple elem to the backing list, returning the idx
pub fn appendTupleElem(self: *Self, v: Var) VarSafeList.Idx {
return self.tuple_elems.append(self.gpa, v);
}
/// Append a slice of tuple elems to the backing list, returning the range
pub fn appendTupleElems(self: *Self, slice: []const Var) VarSafeList.Range {
return self.tuple_elems.appendSlice(self.gpa, slice);