@ascent-lang/dev 0.1.0 → 0.2.0

package/src/parser/typechecker.ts

@@ -1,9 +1,9 @@
-import type { Expr, Statement, Program, Block, If, TypeExpr } from './ast.js';
+import type { Expr, Statement, Program, Block, If, TypeExpr, TypeName, ArgType } from './ast.js';
 import type { Marker, Span } from '../lexer/token.js';
 import type { TypedExpr, TypedBlock, TypedIf, TypedStatement, TypedProgram } from './typed-ast.js';
 import {
   AscentType, INT_TYPE, FLOAT_TYPE, BOOL_TYPE, STRING_TYPE, NONE_TYPE, DONE_TYPE, listOfType,
-  leastCommonType, isAssignableTo,
+  leastCommonType, isAssignableTo, typeToString,
 } from '../types/types.js';
 
 export interface TypeCheckResult {
@@ -11,17 +11,27 @@ export interface TypeCheckResult {
   errorMarkers: Marker[];
 }
 
+// origin records how the name was created — 'fix'/'mut' declarations, or a
+// program 'arg' input — so the three reassignment mistakes get distinct errors.
+// declSpan is where a fix/mut name was created (so errors can point back at it);
+// it is null for names with no source location (program args).
+interface Binding {
+  ty: AscentType;
+  origin: 'fix' | 'mut' | 'arg';
+  declSpan: Span | null;
+}
+
 // A chain of scopes mirroring Environment in the interpreter.
 class TypeEnv {
-  private vars = new Map<string, { ty: AscentType; mutable: boolean }>();
+  private vars = new Map<string, Binding>();
   public constructor(private readonly parent: TypeEnv | null = null) { }
 
-  public get(name: string): { ty: AscentType; mutable: boolean } | null {
+  public get(name: string): Binding | null {
     return this.vars.get(name) ?? this.parent?.get(name) ?? null;
   }
 
-  public set(name: string, ty: AscentType, mutable: boolean): void {
-    this.vars.set(name, { ty, mutable });
+  public set(name: string, ty: AscentType, origin: Binding['origin'], declSpan: Span | null = null): void {
+    this.vars.set(name, { ty, origin, declSpan });
   }
 
   public child(): TypeEnv {
@@ -29,34 +39,59 @@ class TypeEnv {
   }
 }
 
-const resolveTypeExpr = (te: TypeExpr): AscentType => {
-  switch (te.kind) {
-    case 'TypeName': {
-      switch (te.name) {
-        case 'Int': return INT_TYPE;
-        case 'Float': return FLOAT_TYPE;
-        case 'Bool': return BOOL_TYPE;
-        case 'String': return STRING_TYPE;
-      }
-    }
-    case 'ListType':
-      return listOfType(resolveTypeExpr(te.elem));
+// ---- Type formation:  ⊢ T type --------------------------------------
+//
+// The one place a syntactic type name becomes a semantic AscentType.
+// Total over the name union, so an unexpected name is a compile error
+// here rather than a silent fall-through elsewhere.
+
+const typeFromName = (name: TypeName['name'] | ArgType): AscentType => {
+  switch (name) {
+    case 'Int': return INT_TYPE;
+    case 'Float': return FLOAT_TYPE;
+    case 'Bool': return BOOL_TYPE;
+    case 'String': return STRING_TYPE;
   }
 };
 
+const typeFromExpr = (te: TypeExpr): AscentType =>
+  te.kind === 'TypeName' ? typeFromName(te.name) : listOfType(typeFromExpr(te.elem));
+
 // ---- Method type signatures ------------------------------------------
 
 const requireArity = (expected: number, got: number, markers: Marker[], span: Span): boolean => {
-  if (got !== expected) { markers.push({ code: 'T0007', span }); return false; }
+  if (got !== expected) {
+    markers.push({ code: 'T0007', span, data: { expected: String(expected), got: String(got) } });
+    return false;
+  }
   return true;
 };
 
+// A value-type mismatch that carries the expected and actual type names.
+const typeMismatch = (
+  code: string, markers: Marker[], span: Span, expected: AscentType, actual: AscentType,
+  related: { key: string; span: Span }[] = [],
+): null => {
+  markers.push({
+    code, span, related,
+    data: { expected: typeToString(expected), actual: typeToString(actual) },
+  });
+  return null;
+};
+
+// An operator applied to operands it doesn't accept (T0009). `operands` is the
+// joined list of type names — one for a unary '-', two for a binary operator.
+const operandError = (markers: Marker[], op: string, span: Span, ...operands: AscentType[]): null => {
+  markers.push({ code: 'T0009', span, data: { op, operands: operands.map(typeToString).join(' and ') } });
+  return null;
+};
+
 const intMethodType = (method: string, argTypes: AscentType[], markers: Marker[], span: Span): AscentType | null => {
   switch (method) {
     case 'toStr': return requireArity(0, argTypes.length, markers, span) ? STRING_TYPE : null;
     case 'toFloat': return requireArity(0, argTypes.length, markers, span) ? FLOAT_TYPE : null;
     case 'abs': return requireArity(0, argTypes.length, markers, span) ? INT_TYPE : null;
-    default: markers.push({ code: 'T0006', span }); return null;
+    default: markers.push({ code: 'T0006', span, data: { method, type: 'Int' } }); return null;
   }
 };
 
@@ -65,7 +100,7 @@ const floatMethodType = (method: string, argTypes: AscentType[], markers: Marker
     case 'toStr': return requireArity(0, argTypes.length, markers, span) ? STRING_TYPE : null;
     case 'toInt': return requireArity(0, argTypes.length, markers, span) ? INT_TYPE : null;
     case 'abs': return requireArity(0, argTypes.length, markers, span) ? FLOAT_TYPE : null;
-    default: markers.push({ code: 'T0006', span }); return null;
+    default: markers.push({ code: 'T0006', span, data: { method, type: 'Float' } }); return null;
   }
 };
 
@@ -80,18 +115,18 @@ const listMethodType = (
     case 'prepend': {
       if (!requireArity(1, argTypes.length, markers, span)) return null;
       const ct = leastCommonType(elemType, argTypes[0]!);
-      if (ct === null) { markers.push({ code: 'T0008', span }); return null; }
+      if (ct === null) return typeMismatch('T0008', markers, span, elemType, argTypes[0]!);
       return listOfType(ct);
     }
     case 'concat': {
       if (!requireArity(1, argTypes.length, markers, span)) return null;
       const arg = argTypes[0]!;
-      if (arg.kind !== 'List') { markers.push({ code: 'T0008', span }); return null; }
+      if (arg.kind !== 'List') return typeMismatch('T0008', markers, span, listOfType(elemType), arg);
       const ct = leastCommonType(elemType, arg.elem);
-      if (ct === null) { markers.push({ code: 'T0008', span }); return null; }
+      if (ct === null) return typeMismatch('T0008', markers, span, listOfType(elemType), arg);
       return listOfType(ct);
     }
-    default: markers.push({ code: 'T0006', span }); return null;
+    default: markers.push({ code: 'T0006', span, data: { method, type: typeToString(listOfType(elemType)) } }); return null;
   }
 };
 
@@ -124,19 +159,25 @@ const inferExpr = (
 
     case 'call': {
       // floor is the only built-in for now.
-      if (expr.callee !== 'floor') { markers.push({ code: 'T0006', span: expr.span }); return null; }
+      if (expr.callee !== 'floor') { markers.push({ code: 'T0013', span: expr.span, data: { name: expr.callee } }); return null; }
       if (!requireArity(1, expr.args.length, markers, expr.span)) return null;
       const typedArg = inferExpr(expr.args[0]!, env, markers);
       if (typedArg === null) return null;
-      if (typedArg.type.kind !== 'Float') { markers.push({ code: 'T0008', span: expr.span }); return null; }
+      if (typedArg.type.kind !== 'Float') return typeMismatch('T0008', markers, expr.span, FLOAT_TYPE, typedArg.type);
       return { kind: 'call', callee: expr.callee, args: [typedArg], type: FLOAT_TYPE, span: expr.span };
     }
 
     case 'unary': {
       const typedOperand = inferExpr(expr.operand, env, markers);
       if (typedOperand === null) return null;
+      if (expr.op === 'not') {
+        if (typedOperand.type.kind !== 'Bool') {
+          return operandError(markers, expr.op, expr.span, typedOperand.type);
+        }
+        return { kind: 'unary', op: expr.op, operand: typedOperand, type: BOOL_TYPE, span: expr.span };
+      }
       if (typedOperand.type.kind !== 'Int' && typedOperand.type.kind !== 'Float') {
-        markers.push({ code: 'T0009', span: expr.span }); return null;
+        return operandError(markers, expr.op, expr.span, typedOperand.type);
       }
       return { kind: 'unary', op: expr.op, operand: typedOperand, type: typedOperand.type, span: expr.span };
     }
@@ -152,35 +193,43 @@ const inferExpr = (
       switch (expr.op) {
         case '+': case '-': case '*': {
           if ((lt.kind !== 'Int' && lt.kind !== 'Float') || (rt.kind !== 'Int' && rt.kind !== 'Float')) {
-            markers.push({ code: 'T0009', span: expr.span }); return null;
+            return operandError(markers, expr.op, expr.span, lt, rt);
           }
           type = (lt.kind === 'Float' || rt.kind === 'Float') ? FLOAT_TYPE : INT_TYPE;
           break;
         }
         case '/': {
           if ((lt.kind !== 'Int' && lt.kind !== 'Float') || (rt.kind !== 'Int' && rt.kind !== 'Float')) {
-            markers.push({ code: 'T0009', span: expr.span }); return null;
+            return operandError(markers, expr.op, expr.span, lt, rt);
           }
           type = FLOAT_TYPE;
           break;
         }
         case 'div': case 'mod': {
           if (lt.kind !== 'Int' || rt.kind !== 'Int') {
-            markers.push({ code: 'T0009', span: expr.span }); return null;
+            return operandError(markers, expr.op, expr.span, lt, rt);
           }
           type = INT_TYPE;
           break;
         }
         case '==': case '!=': {
           if (leastCommonType(lt, rt) === null) {
-            markers.push({ code: 'T0009', span: expr.span }); return null;
+            return operandError(markers, expr.op, expr.span, lt, rt);
           }
           type = BOOL_TYPE;
           break;
         }
         case '<': case '<=': case '>': case '>=': {
           if ((lt.kind !== 'Int' && lt.kind !== 'Float') || (rt.kind !== 'Int' && rt.kind !== 'Float')) {
-            markers.push({ code: 'T0009', span: expr.span }); return null;
+            return operandError(markers, expr.op, expr.span, lt, rt);
+          }
+          type = BOOL_TYPE;
+          break;
+        }
+        case 'and':
+        case 'or': {
+          if (lt.kind !== 'Bool' || rt.kind !== 'Bool') {
+            return operandError(markers, expr.op, expr.span, lt, rt);
           }
           type = BOOL_TYPE;
           break;
@@ -209,7 +258,14 @@ const inferExpr = (
       let elemType: AscentType = typedElements[0]!.type;
       for (const te of typedElements.slice(1)) {
         const ct = leastCommonType(elemType, te.type);
-        if (ct === null) { markers.push({ code: 'T0002', span: expr.span }); return null; }
+        if (ct === null) {
+          markers.push({
+            code: 'T0002', span: expr.span,
+            data: { first: typeToString(elemType), other: typeToString(te.type) },
+            related: [{ key: 'element', span: te.span }],
+          });
+          return null;
+        }
         elemType = ct;
       }
       // If the surrounding context expects a List with a wider element type
@@ -226,8 +282,14 @@ const inferExpr = (
       const typedList = inferExpr(expr.list, env, markers);
       const typedIndex = inferExpr(expr.index, env, markers);
       if (typedList === null || typedIndex === null) return null;
-      if (typedList.type.kind !== 'List') { markers.push({ code: 'T0010', span: expr.span }); return null; }
-      if (typedIndex.type.kind !== 'Int') { markers.push({ code: 'T0011', span: expr.span }); return null; }
+      if (typedList.type.kind !== 'List') {
+        markers.push({ code: 'T0010', span: expr.list.span, data: { actual: typeToString(typedList.type) } });
+        return null;
+      }
+      if (typedIndex.type.kind !== 'Int') {
+        markers.push({ code: 'T0011', span: expr.index.span, data: { actual: typeToString(typedIndex.type) } });
+        return null;
+      }
       return { kind: 'index', list: typedList, index: typedIndex, type: typedList.type.elem, span: expr.span };
     }
 
@@ -249,7 +311,7 @@ const inferExpr = (
         case 'Int': resultType = intMethodType(expr.method, argTypes, markers, expr.span); break;
         case 'Float': resultType = floatMethodType(expr.method, argTypes, markers, expr.span); break;
         case 'List': resultType = listMethodType(typedReceiver.type.elem, expr.method, argTypes, markers, expr.span); break;
-        default: markers.push({ code: 'T0012', span: expr.span }); return null;
+        default: markers.push({ code: 'T0012', span: expr.span, data: { type: typeToString(typedReceiver.type) } }); return null;
       }
       if (resultType === null) return null;
       return {
@@ -289,7 +351,7 @@ const inferBlock = (block: Block, env: TypeEnv, markers: Marker[]): TypedBlock |
 const inferIf = (expr: If, env: TypeEnv, markers: Marker[]): TypedIf | null => {
   const typedCond = inferExpr(expr.cond, env, markers);
   if (typedCond !== null && typedCond.type.kind !== 'Bool') {
-    markers.push({ code: 'T0004', span: expr.cond.span });
+    markers.push({ code: 'T0004', span: expr.cond.span, data: { actual: typeToString(typedCond.type) } });
   }
 
   const typedThen = inferBlock(expr.then, env, markers);
@@ -306,7 +368,17 @@ const inferIf = (expr: If, env: TypeEnv, markers: Marker[]): TypedIf | null => {
   if (typedCond === null || typedThen === null || typedElse === null) return null;
 
   const ct = leastCommonType(typedThen.type, typedElse.type);
-  if (ct === null) { markers.push({ code: 'T0005', span: expr.span }); return null; }
+  if (ct === null) {
+    markers.push({
+      code: 'T0005', span: expr.span,
+      data: { then: typeToString(typedThen.type), else: typeToString(typedElse.type) },
+      related: [
+        { key: 'then', span: typedThen.span },
+        { key: 'else', span: typedElse.span },
+      ],
+    });
+    return null;
+  }
 
   return { kind: 'if', cond: typedCond, then: typedThen, else: typedElse, type: ct, span: expr.span };
 };
@@ -315,20 +387,24 @@ const inferStmt = (stmt: Statement, env: TypeEnv, markers: Marker[]): TypedState
   switch (stmt.kind) {
     case 'fix':
     case 'mut': {
-      const annotation = stmt.typeAnnotation !== null ? resolveTypeExpr(stmt.typeAnnotation) : null;
+      const annotation = stmt.typeAnnotation !== null ? typeFromExpr(stmt.typeAnnotation) : null;
       const typedInit = inferExpr(stmt.init, env, markers, annotation);
 
       let slotType: AscentType | null;
       if (annotation !== null) {
         if (typedInit !== null && !isAssignableTo(typedInit.type, annotation)) {
-          markers.push({ code: 'T0001', span: stmt.span });
+          markers.push({
+            code: 'T0001', span: stmt.init.span,
+            data: { expected: typeToString(annotation), actual: typeToString(typedInit.type) },
+            related: [{ key: 'annotation', span: stmt.typeAnnotation!.span }],
+          });
         }
         slotType = annotation;
       } else {
         slotType = typedInit?.type ?? null;
       }
 
-      if (slotType !== null) env.set(stmt.name, slotType, stmt.kind === 'mut');
+      if (slotType !== null) env.set(stmt.name, slotType, stmt.kind, stmt.span);
       if (typedInit === null) return null;
 
       return {
@@ -344,13 +420,29 @@ const inferStmt = (stmt: Statement, env: TypeEnv, markers: Marker[]): TypedState
     case 'assign': {
       const binding = env.get(stmt.name);
       if (binding === null) {
-        markers.push({ code: 'N0001', span: stmt.span });
-      } else if (!binding.mutable) {
-        markers.push({ code: 'N0002', span: stmt.span });
+        // Assigning to a name that was never created — a different mistake
+        // (and lesson) than using an undefined name in an expression (N0001).
+        markers.push({ code: 'N0003', span: stmt.nameSpan });
+      } else if (binding.origin === 'arg') {
+        // A program input is read-only for the whole run — its own lesson,
+        // distinct from a 'fix' slot (there is no 'mut' arg to switch to).
+        markers.push({ code: 'N0004', span: stmt.nameSpan });
+      } else if (binding.origin === 'fix') {
+        // Point back at the 'fix' declaration ("created with 'fix' here"),
+        // which always has a source location.
+        const related = binding.declSpan !== null
+          ? [{ key: 'declaration', span: binding.declSpan }]
+          : [];
+        markers.push({ code: 'N0002', span: stmt.nameSpan, related });
       }
       const typedValue = inferExpr(stmt.value, env, markers);
       if (binding !== null && typedValue !== null && !isAssignableTo(typedValue.type, binding.ty)) {
-        markers.push({ code: 'T0001', span: stmt.span });
+        const related = binding.declSpan !== null ? [{ key: 'declaration', span: binding.declSpan }] : [];
+        markers.push({
+          code: 'T0001', span: stmt.value.span,
+          data: { expected: typeToString(binding.ty), actual: typeToString(typedValue.type) },
+          related,
+        });
       }
       if (typedValue === null) return null;
       return {
@@ -365,7 +457,7 @@ const inferStmt = (stmt: Statement, env: TypeEnv, markers: Marker[]): TypedState
     case 'while': {
       const typedCond = inferExpr(stmt.cond, env, markers);
       if (typedCond !== null && typedCond.type.kind !== 'Bool') {
-        markers.push({ code: 'T0004', span: stmt.cond.span });
+        markers.push({ code: 'T0004', span: stmt.cond.span, data: { actual: typeToString(typedCond.type) } });
       }
       const typedBody = inferBlock(stmt.body, env, markers);
       if (typedCond === null || typedBody === null) return null;
@@ -385,11 +477,7 @@ export const typecheck = (program: Program): TypeCheckResult => {
   const env = new TypeEnv();
 
   for (const arg of program.args) {
-    const ty: AscentType = arg.type === 'Int' ? INT_TYPE
-      : arg.type === 'Float' ? FLOAT_TYPE
-        : arg.type === 'Bool' ? BOOL_TYPE
-          : STRING_TYPE;
-    env.set(arg.name, ty, false);
+    env.set(arg.name, typeFromName(arg.type), 'arg');
   }
 
   const typedStmts: TypedStatement[] = [];

package/src/types/types.ts

@@ -34,20 +34,44 @@ export const typesEqual = (a: AscentType, b: AscentType): boolean => {
   return true;
 };
 
-// Int widens to Float everywhere — the only implicit numeric promotion.
-// List<Int> widens to List<Float> via the same rule applied recursively.
-// Returns null when the two types have no common supertype.
-export const leastCommonType = (a: AscentType, b: AscentType): AscentType | null => {
-  if (typesEqual(a, b)) {
-    return a;
+// A coercion is the runtime witness of a subtyping edge: how to turn a value
+// of the sub-type into one of the super-type. `null` means the two types are
+// equal — no runtime conversion needed.
+export type Coercion = 'intToFloat' | { elem: Coercion } | null;
+
+// S <: T — the one place widening is defined. Int widens to Float, and lists
+// widen covariantly (sound only because Ascent lists are immutable: append /
+// prepend / concat return new lists rather than mutating in place). Returns
+// the coercion that witnesses the edge, or `false` when S is not a subtype of T.
+export const subtype = (sub: AscentType, sup: AscentType): Coercion | false => {
+  if (typesEqual(sub, sup)) {
+    return null;
+  }
+
+  if (sub.kind === 'Int' && sup.kind === 'Float') {
+    return 'intToFloat';
+  }
+
+  if (sub.kind === 'List' && sup.kind === 'List') {
+    const c = subtype(sub.elem, sup.elem);
+    return c === false ? false : { elem: c };
   }
 
-  if (a.kind === 'Int' && b.kind === 'Float') {
-    return FLOAT_TYPE;
+  return false;
+};
+
+// The least common supertype — derived from subtyping. When one side
+// subtypes the other, that supertype is the join. Otherwise, for two lists
+// whose elements aren't directly related by subtyping, recurse on the
+// elements (structural join; doesn't add any widening knowledge of its own).
+// Returns null when the two types have no common supertype.
+export const leastCommonType = (a: AscentType, b: AscentType): AscentType | null => {
+  if (subtype(a, b) !== false) {
+    return b;
   }
 
-  if (a.kind === 'Float' && b.kind === 'Int') {
-    return FLOAT_TYPE;
+  if (subtype(b, a) !== false) {
+    return a;
   }
 
   if (a.kind === 'List' && b.kind === 'List') {
@@ -57,9 +81,5 @@ export const leastCommonType = (a: AscentType, b: AscentType): AscentType | null
   return null;
 };
 
-// `from` is assignable to `to` when their LCT is exactly `to`
-// (i.e., `from` fits inside `to`, possibly by widening).
-export const isAssignableTo = (from: AscentType, to: AscentType): boolean => {
-  const lct = leastCommonType(from, to);
-  return lct !== null && typesEqual(lct, to);
-};
+// `from` is assignable to `to` exactly when it's a subtype of `to`.
+export const isAssignableTo = (from: AscentType, to: AscentType): boolean => subtype(from, to) !== false;