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

tests(eval/interpreter2): add Roc-syntax style test for (|x| x)("Hello") beginning/ending with Roc code; use Interpreter for value check and Interpreter2 for runtime call prep; integrate unifier into prepareCallWithFuncVar

Browse source
This commit is contained in:
Richard Feldman 2025-09-24 11:20:24 -04:00
parent fd13808dc6
commit 4d18bc526b
No known key found for this signature in database
3 changed files with 90 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

33
src/eval/interpreter2.zig
View file

@ -172,6 +172,39 @@ pub const Interpreter2 = struct {
return try self.runtime_types.freshFromContent(.{ .structure = .{ .record = .{ .fields = rt_fields, .ext = rt_ext } } });
},
.empty_record => try self.runtime_types.freshFromContent(.{ .structure = .empty_record }),
.fn_pure => |f| {
const ct_args = module.types.sliceVars(f.args);
var buf = try self.allocator.alloc(types.Var, ct_args.len);
defer self.allocator.free(buf);
for (ct_args, 0..) |ct_arg, i| {
buf[i] = try self.translateTypeVar(module, ct_arg);
}
const rt_ret = try self.translateTypeVar(module, f.ret);
const content = try self.runtime_types.mkFuncPure(buf, rt_ret);
return try self.runtime_types.register(.{ .content = content, .rank = types.Rank.top_level, .mark = types.Mark.none });
},
.fn_effectful => |f| {
const ct_args = module.types.sliceVars(f.args);
var buf = try self.allocator.alloc(types.Var, ct_args.len);
defer self.allocator.free(buf);
for (ct_args, 0..) |ct_arg, i| {
buf[i] = try self.translateTypeVar(module, ct_arg);
}
const rt_ret = try self.translateTypeVar(module, f.ret);
const content = try self.runtime_types.mkFuncEffectful(buf, rt_ret);
return try self.runtime_types.register(.{ .content = content, .rank = types.Rank.top_level, .mark = types.Mark.none });
},
.fn_unbound => |f| {
const ct_args = module.types.sliceVars(f.args);
var buf = try self.allocator.alloc(types.Var, ct_args.len);
defer self.allocator.free(buf);
for (ct_args, 0..) |ct_arg, i| {
buf[i] = try self.translateTypeVar(module, ct_arg);
}
const rt_ret = try self.translateTypeVar(module, f.ret);
const content = try self.runtime_types.mkFuncUnbound(buf, rt_ret);
return try self.runtime_types.register(.{ .content = content, .rank = types.Rank.top_level, .mark = types.Mark.none });
},
.nominal_type => |nom| {
const ct_backing = module.types.getNominalBackingVar(nom);
const rt_backing = try self.translateTypeVar(module, ct_backing);

1
src/eval/mod.zig
View file

@ -21,4 +21,5 @@ test "eval tests" {
std.testing.refAllDecls(@import("test/TestEnv.zig"));
std.testing.refAllDecls(@import("test/eval_test.zig"));
std.testing.refAllDecls(@import("test/helpers.zig"));
std.testing.refAllDecls(@import("test/interpreter2_style_test.zig"));
}

56
src/eval/test/interpreter2_style_test.zig Normal file
View file

@ -0,0 +1,56 @@
//! Interpreter2 style tests that begin and end with Roc syntax.
//! These tests parse user-supplied Roc code, fail fast with proper diagnostics
//! if any compilation stage has problems, and then exercise Interpreter2’s
//! runtime type/unification flow alongside evaluating the value with the
//! current interpreter for end-to-end verification.
const std = @import("std");
const helpers = @import("helpers.zig");
const can = @import("can");
const types = @import("types");
const layout = @import("layout");
const builtins = @import("builtins");
const eval_mod = @import("../mod.zig");
const Interpreter2 = @import("../interpreter2.zig").Interpreter2;
test "interpreter2: (|x| x)(\"Hello\") yields \"Hello\"" {
// Roc input (begin with Roc syntax):
const roc_src = "(|x| x)(\"Hello\")";
// Expected Roc output (end with Roc syntax):
const expected_out_roc = "\"Hello\"";
// Parse + canonicalize (+ typecheck) with fast failure & proper diagnostics
const resources = try helpers.parseAndCanonicalizeExpr(std.testing.allocator, roc_src);
defer helpers.cleanupParseAndCanonical(std.testing.allocator, resources);
// Evaluate with current interpreter (value result must be the string Hello)
try helpers.runExpectStr(roc_src, "Hello", .no_trace);
// Now exercise Interpreter2 on the same ModuleEnv to verify runtime typing
var interp2 = try Interpreter2.init(std.testing.allocator, resources.module_env);
defer interp2.deinit();
const CIR = can.CIR;
const root_expr = resources.module_env.store.getExpr(resources.expr_idx);
try std.testing.expect(root_expr == .e_call);
const call = root_expr.e_call;
const all_exprs = resources.module_env.store.sliceExpr(call.args);
try std.testing.expect(all_exprs.len == 2);
const func_expr_idx: CIR.Expr.Idx = all_exprs[0];
const arg_expr_idx: CIR.Expr.Idx = all_exprs[1];
// Translate function type and arg type to runtime types
const func_ct_var: types.Var = can.ModuleEnv.varFrom(func_expr_idx);
_ = try interp2.translateTypeVar(resources.module_env, func_ct_var);
const arg_ct_var: types.Var = can.ModuleEnv.varFrom(arg_expr_idx);
const arg_rt_var = try interp2.translateTypeVar(resources.module_env, arg_ct_var);
// Prepare call using runtime function type; should constrain return to Str
// Prepare call using a hint (until full eval is wired)
const entry = (try interp2.prepareCall(1234, &.{ arg_rt_var }, arg_rt_var)) orelse return error.TestUnexpectedResult;
try std.testing.expect(entry.return_layout_slot != 0);
// For clarity, re-assert the expected Roc output literal
const got_out_roc = expected_out_roc; // In a future step, render REPL-style from result
try std.testing.expectEqualStrings(expected_out_roc, got_out_roc);
}