blu/lux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 13 Wiki Activity

fix: record type aliases now work for unification and field access

Browse Source 
Expand type aliases via unify_with_env() everywhere in the type checker,
not just in a few places. This fixes named record types like
`type Vec2 = { x: Float, y: Float }` — they now properly unify with
anonymous records and support field access (v.x, v.y).

Also adds scripts/validate.sh for automated full-suite regression
testing (Rust tests + all 5 package test suites + type checking).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
Brandon Lucas
2026-02-18 20:09:46 -05:00
parent d76aa17b38
commit bd843d2219
4 changed files with 127 additions and 30 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
src/typechecker.rs
View File

@@ -1536,7 +1536,7 @@ impl TypeChecker {
// Use the declared type if present, otherwise use inferred
let final_type = if let Some(ref type_expr) = let_decl.typ {
let declared = self.resolve_type(type_expr);
if let Err(e) = unify(&inferred, &declared) {
if let Err(e) = unify_with_env(&inferred, &declared, &self.env) {
self.errors.push(TypeError {
message: format!(
"Variable '{}' has type {}, but declared type is {}: {}",
@@ -1783,7 +1783,7 @@ impl TypeChecker {
match op {
BinaryOp::Add => {
// Add supports both numeric types and string concatenation
if let Err(e) = unify(&left_type, &right_type) {
if let Err(e) = unify_with_env(&left_type, &right_type, &self.env) {
self.errors.push(TypeError {
message: format!("Operands of '{}' must have same type: {}", op, e),
span,
@@ -1806,7 +1806,7 @@ impl TypeChecker {
BinaryOp::Sub | BinaryOp::Mul | BinaryOp::Div | BinaryOp::Mod => {
// Arithmetic: both operands must be same numeric type
if let Err(e) = unify(&left_type, &right_type) {
if let Err(e) = unify_with_env(&left_type, &right_type, &self.env) {
self.errors.push(TypeError {
message: format!("Operands of '{}' must have same type: {}", op, e),
span,
@@ -1830,7 +1830,7 @@ impl TypeChecker {
BinaryOp::Eq | BinaryOp::Ne => {
// Equality: operands must have same type
if let Err(e) = unify(&left_type, &right_type) {
if let Err(e) = unify_with_env(&left_type, &right_type, &self.env) {
self.errors.push(TypeError {
message: format!("Operands of '{}' must have same type: {}", op, e),
span,
@@ -1841,7 +1841,7 @@ impl TypeChecker {
BinaryOp::Lt | BinaryOp::Le | BinaryOp::Gt | BinaryOp::Ge => {
// Comparison: operands must be same orderable type
if let Err(e) = unify(&left_type, &right_type) {
if let Err(e) = unify_with_env(&left_type, &right_type, &self.env) {
self.errors.push(TypeError {
message: format!("Operands of '{}' must have same type: {}", op, e),
span,
@@ -1852,13 +1852,13 @@ impl TypeChecker {
BinaryOp::And | BinaryOp::Or => {
// Logical: both must be Bool
if let Err(e) = unify(&left_type, &Type::Bool) {
if let Err(e) = unify_with_env(&left_type, &Type::Bool, &self.env) {
self.errors.push(TypeError {
message: format!("Left operand of '{}' must be Bool: {}", op, e),
span: left.span(),
});
}
if let Err(e) = unify(&right_type, &Type::Bool) {
if let Err(e) = unify_with_env(&right_type, &Type::Bool, &self.env) {
self.errors.push(TypeError {
message: format!("Right operand of '{}' must be Bool: {}", op, e),
span: right.span(),
@@ -1872,7 +1872,7 @@ impl TypeChecker {
// right must be a function that accepts left's type
let result_type = Type::var();
let expected_fn = Type::function(vec![left_type.clone()], result_type.clone());
if let Err(e) = unify(&right_type, &expected_fn) {
if let Err(e) = unify_with_env(&right_type, &expected_fn, &self.env) {
self.errors.push(TypeError {
message: format!(
"Pipe target must be a function accepting {}: {}",
@@ -1904,7 +1904,7 @@ impl TypeChecker {
}
},
UnaryOp::Not => {
if let Err(e) = unify(&operand_type, &Type::Bool) {
if let Err(e) = unify_with_env(&operand_type, &Type::Bool, &self.env) {
self.errors.push(TypeError {
message: format!("Operator '!' requires Bool operand: {}", e),
span,
@@ -1955,7 +1955,7 @@ impl TypeChecker {
self.current_effects.clone(),
);
match unify(&func_type, &expected_fn) {
match unify_with_env(&func_type, &expected_fn, &self.env) {
Ok(subst) => result_type.apply(&subst),
Err(e) => {
// Provide more detailed error message based on the type of mismatch
@@ -2032,7 +2032,7 @@ impl TypeChecker {
let result_type = Type::var();
let expected_fn = Type::function(arg_types, result_type.clone());
if let Err(e) = unify(field_type, &expected_fn) {
if let Err(e) = unify_with_env(field_type, &expected_fn, &self.env) {
self.errors.push(TypeError {
message: format!(
"Type mismatch in {}.{} call: {}",
@@ -2104,7 +2104,7 @@ impl TypeChecker {
for (i, (arg_type, (_, param_type))) in
arg_types.iter().zip(op.params.iter()).enumerate()
{
if let Err(e) = unify(arg_type, param_type) {
if let Err(e) = unify_with_env(arg_type, param_type, &self.env) {
self.errors.push(TypeError {
message: format!(
"Argument {} of '{}.{}' has type {}, expected {}: {}",
@@ -2137,6 +2137,7 @@ impl TypeChecker {
fn infer_field(&mut self, object: &Expr, field: &Ident, span: Span) -> Type {
let object_type = self.infer_expr(object);
let object_type = self.env.expand_type_alias(&object_type);
match &object_type {
Type::Record(fields) => match fields.iter().find(|(n, _)| n == &field.name) {
@@ -2217,7 +2218,7 @@ impl TypeChecker {
// Check return type if specified
let ret_type = if let Some(rt) = return_type {
let declared = self.resolve_type(rt);
if let Err(e) = unify(&body_type, &declared) {
if let Err(e) = unify_with_env(&body_type, &declared, &self.env) {
self.errors.push(TypeError {
message: format!(
"Lambda body type {} doesn't match declared {}: {}",
@@ -2283,7 +2284,7 @@ impl TypeChecker {
span: Span,
) -> Type {
let cond_type = self.infer_expr(condition);
if let Err(e) = unify(&cond_type, &Type::Bool) {
if let Err(e) = unify_with_env(&cond_type, &Type::Bool, &self.env) {
self.errors.push(TypeError {
message: format!("If condition must be Bool, got {}: {}", cond_type, e),
span: condition.span(),
@@ -2293,7 +2294,7 @@ impl TypeChecker {
let then_type = self.infer_expr(then_branch);
let else_type = self.infer_expr(else_branch);
match unify(&then_type, &else_type) {
match unify_with_env(&then_type, &else_type, &self.env) {
Ok(subst) => then_type.apply(&subst),
Err(e) => {
self.errors.push(TypeError {
@@ -2334,7 +2335,7 @@ impl TypeChecker {
// Check guard if present
if let Some(ref guard) = arm.guard {
let guard_type = self.infer_expr(guard);
if let Err(e) = unify(&guard_type, &Type::Bool) {
if let Err(e) = unify_with_env(&guard_type, &Type::Bool, &self.env) {
self.errors.push(TypeError {
message: format!("Match guard must be Bool: {}", e),
span: guard.span(),
@@ -2350,7 +2351,7 @@ impl TypeChecker {
match &result_type {
None => result_type = Some(body_type),
Some(prev) => {
if let Err(e) = unify(prev, &body_type) {
if let Err(e) = unify_with_env(prev, &body_type, &self.env) {
self.errors.push(TypeError {
message: format!(
"Match arm has incompatible type: expected {}, got {}: {}",
@@ -2400,7 +2401,7 @@ impl TypeChecker {
Pattern::Literal(lit) => {
let lit_type = self.infer_literal(lit);
if let Err(e) = unify(&lit_type, expected) {
if let Err(e) = unify_with_env(&lit_type, expected, &self.env) {
self.errors.push(TypeError {
message: format!("Pattern literal type mismatch: {}", e),
span: lit.span,
@@ -2414,7 +2415,7 @@ impl TypeChecker {
// For now, handle Option specially
match name.name.as_str() {
"None" => {
if let Err(e) = unify(expected, &Type::Option(Box::new(Type::var()))) {
if let Err(e) = unify_with_env(expected, &Type::Option(Box::new(Type::var())), &self.env) {
self.errors.push(TypeError {
message: format!(
"None pattern doesn't match type {}: {}",
@@ -2427,7 +2428,7 @@ impl TypeChecker {
}
"Some" => {
let inner_type = Type::var();
if let Err(e) = unify(expected, &Type::Option(Box::new(inner_type.clone())))
if let Err(e) = unify_with_env(expected, &Type::Option(Box::new(inner_type.clone())), &self.env)
{
self.errors.push(TypeError {
message: format!(
@@ -2456,7 +2457,7 @@ impl TypeChecker {
Pattern::Tuple { elements, span } => {
let element_types: Vec<Type> = elements.iter().map(|_| Type::var()).collect();
if let Err(e) = unify(expected, &Type::Tuple(element_types.clone())) {
if let Err(e) = unify_with_env(expected, &Type::Tuple(element_types.clone()), &self.env) {
self.errors.push(TypeError {
message: format!("Tuple pattern doesn't match type {}: {}", expected, e),
span: *span,
@@ -2506,7 +2507,7 @@ impl TypeChecker {
if let Some(type_expr) = typ {
let declared = self.resolve_type(type_expr);
if let Err(e) = unify(&value_type, &declared) {
if let Err(e) = unify_with_env(&value_type, &declared, &self.env) {
self.errors.push(TypeError {
message: format!(
"Variable '{}' has type {}, but declared type is {}: {}",
@@ -2549,7 +2550,7 @@ impl TypeChecker {
let first_type = self.infer_expr(&elements[0]);
for elem in &elements[1..] {
let elem_type = self.infer_expr(elem);
if let Err(e) = unify(&first_type, &elem_type) {
if let Err(e) = unify_with_env(&first_type, &elem_type, &self.env) {
self.errors.push(TypeError {
message: format!("List elements must have same type: {}", e),
span,
@@ -2855,7 +2856,7 @@ impl TypeChecker {
// Check return type matches if specified
if let Some(ref return_type_expr) = impl_method.return_type {
let return_type = self.resolve_type(return_type_expr);
if let Err(e) = unify(&body_type, &return_type) {
if let Err(e) = unify_with_env(&body_type, &return_type, &self.env) {
self.errors.push(TypeError {
message: format!(
"Method '{}' body has type {}, but declared return type is {}: {}",