@rcrsr/rill 0.16.0 → 0.17.0

package/dist/runtime/core/eval/index.js

@@ -70,6 +70,17 @@ export function assertType(value, expected, location) {
         resolverConfigs: new Map(),
         resolvingSchemes: new Set(),
         typeMethodDicts: new Map(),
+        leafTypes: new Set([
+            'string',
+            'number',
+            'bool',
+            'vector',
+            'type',
+            'any',
+            'closure',
+            'field_descriptor',
+        ]),
+        unvalidatedMethodReceivers: new Set(),
     };
     const evaluator = getEvaluator(minimalContext);
     return evaluator.assertType(value, expected, location);

package/dist/runtime/core/eval/mixins/closures.js

@@ -43,8 +43,8 @@
  */
 import { RillError, RuntimeError } from '../../../../types.js';
 import { isCallable, isScriptCallable, isApplicationCallable, isDict, marshalArgs, } from '../../callable.js';
-import { getVariable, pushCallFrame, popCallFrame, UNVALIDATED_METHOD_PARAMS, UNVALIDATED_METHOD_RECEIVERS, } from '../../context.js';
-import { inferType, isTypeValue, isTuple, isOrdered, paramToFieldDef, inferStructuralType, structuralTypeMatches, formatStructuralType, anyTypeValue, rillTypeToTypeValue, } from '../../values.js';
+import { getVariable, pushCallFrame, popCallFrame, UNVALIDATED_METHOD_PARAMS, } from '../../context.js';
+import { inferType, isTypeValue, isTuple, isOrdered, paramToFieldDef, inferStructure, structureMatches, formatStructure, anyTypeValue, structureToTypeValue, } from '../../values.js';
 /**
  * ClosuresMixin implementation.
  *
@@ -215,8 +215,8 @@ function createClosuresMixin(Base) {
         validateParamType(param, value, callLocation) {
             if (param.type === undefined)
                 return;
-            if (!structuralTypeMatches(value, param.type)) {
-                const expectedType = formatStructuralType(param.type);
+            if (!structureMatches(value, param.type)) {
+                const expectedType = formatStructure(param.type);
                 const actualType = inferType(value);
                 throw new RuntimeError('RILL-R001', `Parameter type mismatch: ${param.name} expects ${expectedType}, got ${actualType}`, callLocation, { paramName: param.name, expectedType, actualType });
             }
@@ -541,13 +541,13 @@ function createClosuresMixin(Base) {
                 throw new RuntimeError('RILL-R003', `Method .${node.name} not available on callable (invoke with -> $() first)`, this.getNodeLocation(node), { methodName: node.name, receiverType: 'callable' });
             }
             // IR-3: .name on type values returns the typeName string (method path)
-            // IR-4: .signature on type values returns formatStructuralType(structure)
+            // IR-4: .signature on type values returns formatStructure(structure)
             if (isTypeValue(receiver)) {
                 if (node.name === 'name') {
                     return receiver.typeName;
                 }
                 if (node.name === 'signature') {
-                    return formatStructuralType(receiver.structure);
+                    return formatStructure(receiver.structure);
                 }
             }
             const args = await this.evaluateArgs(node.args);
@@ -617,10 +617,10 @@ function createClosuresMixin(Base) {
                 throw new RuntimeError('RILL-R009', `Property '${node.name}' not found on type value (available: name, signature)`, this.getNodeLocation(node), { property: node.name, type: 'type value' });
             }
             // RILL-R003: method exists on other types but not this receiver's type.
-            // Methods in UNVALIDATED_METHOD_RECEIVERS handle their own receiver validation
+            // Methods in unvalidatedMethodReceivers handle their own receiver validation
             // with specific error messages; skip generic RILL-R003 for them and let the
             // method body run its own check (they exist in at least one type dict).
-            if (!UNVALIDATED_METHOD_RECEIVERS.has(node.name)) {
+            if (!this.ctx.unvalidatedMethodReceivers.has(node.name)) {
                 const supportedTypes = [];
                 for (const [dictType, dict] of this.ctx.typeMethodDicts) {
                     if (dict[node.name] !== undefined) {
@@ -632,14 +632,14 @@ function createClosuresMixin(Base) {
                 }
             }
             else {
-                // UNVALIDATED_METHOD_RECEIVERS: dispatch to the method in ANY type dict so the
+                // unvalidatedMethodReceivers: dispatch to the method in ANY type dict so the
                 // method body can run its own custom receiver validation and error message.
                 for (const [, dict] of this.ctx.typeMethodDicts) {
                     const fallbackMethod = dict[node.name];
                     if (fallbackMethod !== undefined &&
                         isApplicationCallable(fallbackMethod)) {
                         try {
-                            // UNVALIDATED_METHOD_RECEIVERS handle their own receiver validation.
+                            // Unvalidated methods handle their own receiver validation.
                             // Build named record with receiver so buildMethodEntry extracts it correctly;
                             // the method body performs its own receiver type check with a custom error.
                             const fbMethodArgs = { receiver };
@@ -706,7 +706,7 @@ function createClosuresMixin(Base) {
                 const typeValue = Object.freeze({
                     __rill_type: true,
                     typeName: inferType(value),
-                    structure: inferStructuralType(value),
+                    structure: inferStructure(value),
                 });
                 return typeValue;
             }
@@ -728,10 +728,10 @@ function createClosuresMixin(Base) {
             if (key === 'input') {
                 // Untyped host callables have params set to undefined at runtime (see callable() factory)
                 if (value.params === undefined) {
-                    return rillTypeToTypeValue({ type: 'ordered', fields: [] });
+                    return structureToTypeValue({ kind: 'ordered', fields: [] });
                 }
-                const fields = value.params.map((param) => paramToFieldDef(param.name, param.type ?? { type: 'any' }, param.defaultValue));
-                return rillTypeToTypeValue({ type: 'ordered', fields });
+                const fields = value.params.map((param) => paramToFieldDef(param.name, param.type ?? { kind: 'any' }, param.defaultValue));
+                return structureToTypeValue({ kind: 'ordered', fields });
             }
             // IR-3: ^output reads callable.returnType directly for all kinds
             if (key === 'output') {
@@ -894,7 +894,7 @@ function createClosuresMixin(Base) {
                 const paramEntry = {};
                 // Add type field if param has type annotation
                 if (param.type !== undefined) {
-                    paramEntry['type'] = formatStructuralType(param.type);
+                    paramEntry['type'] = formatStructure(param.type);
                 }
                 // Add __annotations field if param has parameter-level annotations
                 if (Object.keys(param.annotations).length > 0) {

package/dist/runtime/core/eval/mixins/conversion.js

@@ -27,8 +27,9 @@
  * @internal
  */
 import { RuntimeError } from '../../../../types.js';
-import { inferType, isTuple, isOrdered, isTypeValue, createOrdered, createTuple, formatValue, deepCopyRillValue, hasCollectionFields, emptyForType, } from '../../values.js';
+import { inferType, isTuple, isOrdered, isTypeValue, createOrdered, createTuple, deepCopyRillValue, hasCollectionFields, emptyForType, } from '../../values.js';
 import { isDict } from '../../callable.js';
+import { BUILT_IN_TYPES } from '../../type-registrations.js';
 import { getVariable } from '../../context.js';
 /**
  * ConversionMixin implementation.
@@ -106,7 +107,15 @@ function createConversionMixin(Base) {
         }
         /**
          * Apply conversion from source value to target type name.
-         * Implements the compatibility matrix from IR-9.
+         * Dispatches to protocol.convertTo on the source type's registration.
+         *
+         * IR-6: Replaces the hardcoded conversion matrix with protocol dispatch.
+         *
+         * Special cases preserved:
+         * - Same type = no-op (short-circuit)
+         * - dict -> :>ordered without structural sig raises RILL-R037 (EC-11)
+         * - String-to-number parse failure raises RILL-R038 (EC-12)
+         * - Missing convertTo target raises RILL-R036 (EC-10)
          */
         applyConversion(input, targetType, node) {
             const sourceType = inferType(input);
@@ -114,105 +123,34 @@ function createConversionMixin(Base) {
             if (sourceType === targetType) {
                 return input;
             }
-            // Apply compatibility matrix
-            switch (targetType) {
-                case 'list':
-                    return this.convertToList(input, sourceType, node);
-                case 'dict':
-                    return this.convertToDict(input, sourceType, node);
-                case 'tuple':
-                    return this.convertToTuple(input, sourceType, node);
-                case 'ordered':
-                    // dict -> :>ordered without structural sig is always a runtime error (EC-11)
-                    if (sourceType === 'dict') {
-                        throw new RuntimeError('RILL-R037', 'dict to ordered conversion requires structural type signature', this.getNodeLocation(node));
-                    }
-                    return this.convertToOrdered(input, sourceType, node);
-                case 'number':
-                    return this.convertToNumber(input, sourceType, node);
-                case 'string':
-                    return this.convertToString(input, sourceType, node);
-                case 'bool':
-                    return this.convertToBoolean(input, sourceType, node);
-                default:
-                    this.throwIncompatible(sourceType, targetType, node);
+            // dict -> :>ordered without structural sig is always RILL-R037 (EC-11)
+            if (sourceType === 'dict' && targetType === 'ordered') {
+                throw new RuntimeError('RILL-R037', 'dict to ordered conversion requires structural type signature', this.getNodeLocation(node));
             }
-            // TypeScript exhaustiveness
-            return input;
-        }
-        /** Convert to list type. Valid source: tuple. */
-        convertToList(input, sourceType, node) {
-            if (isTuple(input)) {
-                return input.entries;
+            // Find source type registration and dispatch via protocol.convertTo
+            const reg = BUILT_IN_TYPES.find((r) => r.name === sourceType);
+            const converter = reg?.protocol.convertTo?.[targetType];
+            if (!converter) {
+                throw new RuntimeError('RILL-R036', `cannot convert ${sourceType} to ${targetType}`, this.getNodeLocation(node), { source: sourceType, target: targetType });
             }
-            this.throwIncompatible(sourceType, 'list', node);
-            return input;
-        }
-        /** Convert to dict type. Valid source: ordered. */
-        convertToDict(input, sourceType, node) {
-            if (isOrdered(input)) {
-                const result = {};
-                for (const [key, value] of input.entries) {
-                    result[key] = value;
-                }
-                return result;
+            try {
+                return converter(input);
             }
-            this.throwIncompatible(sourceType, 'dict', node);
-            return input;
-        }
-        /** Convert to tuple type. Valid source: list. */
-        convertToTuple(input, sourceType, node) {
-            if (Array.isArray(input) && !isTuple(input) && !isOrdered(input)) {
-                return createTuple(input);
-            }
-            this.throwIncompatible(sourceType, 'tuple', node);
-            return input;
-        }
-        /** Convert to ordered type. Valid source: dict (with sig, handled separately). */
-        convertToOrdered(input, sourceType, node) {
-            // Only dict -> ordered is valid, but it requires a sig (checked by caller)
-            this.throwIncompatible(sourceType, 'ordered', node);
-            return input;
-        }
-        /** Convert to number type. Valid source: string (parseable) or bool. */
-        convertToNumber(input, sourceType, node) {
-            if (sourceType === 'string') {
-                const str = input;
-                const parsed = Number(str);
-                if (isNaN(parsed) || str.trim() === '') {
-                    throw new RuntimeError('RILL-R038', `cannot convert string "${str}" to number`, this.getNodeLocation(node), { value: str });
+            catch (err) {
+                // Protocol converters throw plain Errors; wrap as RuntimeError
+                // with the appropriate error code.
+                if (err instanceof RuntimeError)
+                    throw err;
+                // String-to-number parse failures use RILL-R038 (EC-12)
+                // Preserve the protocol's detailed message (includes unparseable value).
+                if (sourceType === 'string' && targetType === 'number') {
+                    const message = err instanceof Error ? err.message : String(err);
+                    throw new RuntimeError('RILL-R038', message, this.getNodeLocation(node), { value: input });
                 }
-                return parsed;
+                // All other conversion failures use RILL-R036 (EC-10)
+                // Use consistent "cannot convert X to Y" format.
+                throw new RuntimeError('RILL-R036', `cannot convert ${sourceType} to ${targetType}`, this.getNodeLocation(node), { source: sourceType, target: targetType });
             }
-            if (sourceType === 'bool') {
-                return input ? 1 : 0;
-            }
-            this.throwIncompatible(sourceType, 'number', node);
-            return input;
-        }
-        /** Convert to bool type. Valid source: number (0 or 1) or string ("true" or "false"). */
-        convertToBoolean(input, sourceType, node) {
-            if (sourceType === 'number') {
-                const n = input;
-                if (n === 0)
-                    return false;
-                if (n === 1)
-                    return true;
-                this.throwIncompatible(sourceType, 'bool', node);
-            }
-            if (sourceType === 'string') {
-                const s = input;
-                if (s === 'true')
-                    return true;
-                if (s === 'false')
-                    return false;
-                this.throwIncompatible(sourceType, 'bool', node);
-            }
-            this.throwIncompatible(sourceType, 'bool', node);
-        }
-        /** Convert to string type. Valid source: any type via formatValue semantics. */
-        convertToString(input, _sourceType, _node) {
-            return formatValue(input);
         }
         /**
          * Convert dict -> :>ordered(field: type = default, ...) using structural signature.
@@ -238,7 +176,7 @@ function createConversionMixin(Base) {
             // Evaluate the full type constructor to get resolved fields with defaults.
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             const typeValue = await this.evaluateTypeConstructor(sigNode);
-            const resolvedFields = typeValue.structure.type === 'ordered' && typeValue.structure.fields
+            const resolvedFields = typeValue.structure.kind === 'ordered' && typeValue.structure.fields
                 ? typeValue.structure.fields
                 : [];
             const entries = [];
@@ -292,7 +230,7 @@ function createConversionMixin(Base) {
             // Evaluate the full type constructor to get resolved fields with defaults.
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             const typeValue = await this.evaluateTypeConstructor(sigNode);
-            const resolvedFields = typeValue.structure.type === 'dict' && typeValue.structure.fields
+            const resolvedFields = typeValue.structure.kind === 'dict' && typeValue.structure.fields
                 ? typeValue.structure.fields
                 : {};
             const result = {};
@@ -345,7 +283,7 @@ function createConversionMixin(Base) {
             // Evaluate the full type constructor to get resolved elements with defaults.
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             const typeValue = await this.evaluateTypeConstructor(sigNode);
-            const resolvedElements = typeValue.structure.type === 'tuple' && typeValue.structure.elements
+            const resolvedElements = typeValue.structure.kind === 'tuple' && typeValue.structure.elements
                 ? typeValue.structure.elements
                 : [];
             const inputEntries = isTupleInput
@@ -379,10 +317,13 @@ function createConversionMixin(Base) {
          * Returns the value unchanged if the type has no fields or the value type does not match.
          */
         hydrateNested(value, fieldType, node) {
-            if (fieldType.type === 'dict' && fieldType.fields && isDict(value)) {
+            if (fieldType.kind === 'dict' &&
+                fieldType.fields &&
+                isDict(value)) {
+                const ft = fieldType;
                 const dictValue = value;
                 const result = {};
-                for (const [fieldName, resolvedField] of Object.entries(fieldType.fields)) {
+                for (const [fieldName, resolvedField] of Object.entries(ft.fields)) {
                     if (fieldName in dictValue) {
                         const fieldValue = this.hydrateNested(dictValue[fieldName], resolvedField.type, node);
                         result[fieldName] = fieldValue;
@@ -401,7 +342,9 @@ function createConversionMixin(Base) {
                 }
                 return result;
             }
-            else if (fieldType.type === 'ordered' && fieldType.fields) {
+            else if (fieldType.kind === 'ordered' &&
+                fieldType.fields) {
+                const ft = fieldType;
                 // Only hydrate if the runtime value is an ordered or dict; return unchanged otherwise.
                 if (!isOrdered(value) && !isDict(value)) {
                     return value;
@@ -412,7 +355,7 @@ function createConversionMixin(Base) {
                     ? value.entries.map(([k, v]) => [k, v])
                     : Object.entries(value));
                 const resultEntries = [];
-                for (const field of fieldType.fields) {
+                for (const field of ft.fields) {
                     const name = field.name;
                     if (lookup.has(name)) {
                         const fieldValue = this.hydrateNested(lookup.get(name), field.type, node);
@@ -436,15 +379,17 @@ function createConversionMixin(Base) {
                 }
                 return createOrdered(resultEntries);
             }
-            else if (fieldType.type === 'tuple' && fieldType.elements) {
+            else if (fieldType.kind === 'tuple' &&
+                fieldType.elements) {
+                const ft = fieldType;
                 // Only hydrate if the runtime value is a tuple; return unchanged otherwise.
                 if (!isTuple(value)) {
                     return value;
                 }
                 const inputEntries = value.entries;
                 const resultEntries = [];
-                for (let i = 0; i < fieldType.elements.length; i++) {
-                    const element = fieldType.elements[i];
+                for (let i = 0; i < ft.elements.length; i++) {
+                    const element = ft.elements[i];
                     if (i < inputEntries.length) {
                         const elementValue = this.hydrateNested(inputEntries[i], element.type, node);
                         resultEntries.push(elementValue);
@@ -463,10 +408,6 @@ function createConversionMixin(Base) {
             }
             return value;
         }
-        /** Throw EC-10 incompatible conversion error. */
-        throwIncompatible(source, target, node) {
-            throw new RuntimeError('RILL-R036', `cannot convert ${source} to ${target}`, this.getNodeLocation(node), { source, target });
-        }
     };
 }
 /**

package/dist/runtime/core/eval/mixins/core.js

@@ -282,8 +282,8 @@ function createCoreMixin(Base) {
                             primary.typeName === 'ordered' ||
                             primary.typeName === 'vector' ||
                             primary.typeName === 'type'
-                            ? { type: primary.typeName }
-                            : { type: 'any' },
+                            ? { kind: primary.typeName }
+                            : { kind: 'any' },
                     });
                 case 'TypeConstructor':
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/dist/runtime/core/eval/mixins/expressions.js

@@ -18,9 +18,17 @@
  * @internal
  */
 import { RuntimeError } from '../../../../types.js';
-import { inferType, isTruthy, deepEquals } from '../../values.js';
+import { inferType, isTruthy } from '../../values.js';
+import { BUILT_IN_TYPES } from '../../type-registrations.js';
 import { createChildContext } from '../../context.js';
 import { isCallable } from '../../callable.js';
+/**
+ * Find the type registration for a value by type name.
+ * Returns undefined when no registration matches.
+ */
+function findRegistration(typeName) {
+    return BUILT_IN_TYPES.find((r) => r.name === typeName);
+}
 /**
  * ExpressionsMixin implementation.
  *
@@ -150,39 +158,39 @@ function createExpressionsMixin(Base) {
             }
         }
         /**
-         * Evaluate comparison between two values.
-         * Equality works on all types, ordering requires compatible types.
+         * Evaluate comparison between two values via protocol dispatch.
+         *
+         * - == / != dispatch to protocol.eq; absent eq raises RILL-R002.
+         * - Ordering ops dispatch to protocol.compare; absent compare raises RILL-R002.
+         *
+         * IR-5: Breaking change: bool ordering (e.g. true > false) raises RILL-R002
+         * because the bool registration has no protocol.compare.
          */
         evaluateBinaryComparison(left, right, op, node) {
+            const typeName = inferType(left);
+            const reg = findRegistration(typeName);
+            if (op === '==' || op === '!=') {
+                if (!reg || !reg.protocol.eq) {
+                    throw new RuntimeError('RILL-R002', `Cannot compare ${typeName} using ${op}`, node.span.start);
+                }
+                const eqResult = reg.protocol.eq(left, right);
+                return op === '==' ? eqResult : !eqResult;
+            }
+            // Ordering ops: <, >, <=, >=
+            const rightTypeName = inferType(right);
+            if (!reg || !reg.protocol.compare || typeName !== rightTypeName) {
+                throw new RuntimeError('RILL-R002', `Cannot compare ${typeName} with ${rightTypeName} using ${op}`, node.span.start);
+            }
+            const cmp = reg.protocol.compare(left, right);
             switch (op) {
-                case '==':
-                    return deepEquals(left, right);
-                case '!=':
-                    return !deepEquals(left, right);
                 case '<':
+                    return cmp < 0;
                 case '>':
+                    return cmp > 0;
                 case '<=':
+                    return cmp <= 0;
                 case '>=':
-                    // Ordering comparisons require compatible types
-                    if (typeof left === 'number' && typeof right === 'number') {
-                        return op === '<'
-                            ? left < right
-                            : op === '>'
-                                ? left > right
-                                : op === '<='
-                                    ? left <= right
-                                    : left >= right;
-                    }
-                    if (typeof left === 'string' && typeof right === 'string') {
-                        return op === '<'
-                            ? left < right
-                            : op === '>'
-                                ? left > right
-                                : op === '<='
-                                    ? left <= right
-                                    : left >= right;
-                    }
-                    throw new RuntimeError('RILL-R002', `Cannot compare ${inferType(left)} with ${inferType(right)} using ${op}`, node.span.start);
+                    return cmp >= 0;
             }
         }
         /**

package/dist/runtime/core/eval/mixins/literals.js

@@ -642,13 +642,13 @@ function createLiteralsMixin(Base) {
                 if (resolvedType === undefined && defaultValue !== undefined) {
                     const defaultKind = typeof defaultValue;
                     if (defaultKind === 'string') {
-                        resolvedType = { type: 'string' };
+                        resolvedType = { kind: 'string' };
                     }
                     else if (defaultKind === 'number') {
-                        resolvedType = { type: 'number' };
+                        resolvedType = { kind: 'number' };
                     }
                     else if (defaultKind === 'boolean') {
-                        resolvedType = { type: 'bool' };
+                        resolvedType = { kind: 'bool' };
                     }
                 }
                 // Evaluate per-param annotations inline