@velarscript/compiler 0.11.1 → 0.12.1

package/dist/analyzer.js

@@ -145,16 +145,15 @@ const builtinTypeNames = new Set(["string", "number", "bool", "null", "unknown",
 const asyncResultAnnotationMessage = "An async result annotation in a declaration names the resolved value; write '-> T', not '-> Promise<T>'";
 const memberNarrowingPrefix = "\u0000member:";
 /**
- * D43 item 69: the emitted member behind a class's `@dispose:` block. The key
- * is not a source-shaped identifier, so no author member can collide with it —
- * `@dispose` is the language's name, not a name in the author's namespace.
+ * The emitted member behind a class's `@dispose:` block. The key is not a
+ * source-shaped identifier, so no author member can collide with it:
+ * `@dispose` is compiler-owned, not part of the author's namespace.
  */
 export const disposeMemberKey = "__velar:dispose";
 /**
- * D68 rule 177: the emitted member behind a class's `@iterate:` block, under
- * the same kind of key and for the same reason — `@iterate` is the language's
- * name for the question, so no author member can answer it by accident and no
- * author call can reach it.
+ * The emitted member behind a class's `@iterate:` block, under the same kind of
+ * key and for the same reason: `@iterate` is compiler-owned, so no author
+ * member can answer it by accident and no author call can reach it.
  */
 export const iterateMemberKey = "__velar:iterate";
 /** What each bound admits, written the way a rejected call needs to hear it. */
@@ -593,8 +592,6 @@ export class Analyzer {
     inferredFunctionResultTypes = new Map();
     finalizeFunctionResultInference;
     logicalConditionNarrowings = new Map();
-    collectionInferenceGroups = new WeakMap();
-    collectionInferenceTypes = new WeakMap();
     privateFields = new Map();
     privateGetters = new Map();
     privateMethods = new Map();
@@ -1418,6 +1415,10 @@ export class Analyzer {
             return instantiated;
         return this.extensionFieldsOf(identity);
     }
+    enumValuesOf(identity) {
+        const values = this.enums.get(identity)?.members;
+        return values ? [...values] : null;
+    }
     /**
      * D55 rule 121: an instantiation's field table is the declaration's fields
      * with the arguments substituted, registered under the instantiation's own
@@ -1534,11 +1535,10 @@ export class Analyzer {
         if (!info)
             return null;
         const built = genericApplicationType(info.identity, info.name, application.arguments.map(resolveArgument), type.readonlyView === true);
-        // One object per instantiation, not one per resolution. Several traversals
-        // cut their cycles by object identity (`freezeEscapedCollectionInference`
-        // keys a WeakMap by the expanded type), and a recursive generic re-enters
-        // them; handing back a fresh equal object each time would defeat the guard
-        // and recur without end.
+        // One object per instantiation, not one per resolution. A recursive
+        // generic re-enters resolution, so handing back a fresh equal object each
+        // time would defeat any traversal that memoizes by type identity and recur
+        // without end.
         const key = `${built.identity}${built.readonlyView ? "\u0000readonly" : ""}`;
         const cached = this.canonicalGenericApplications.get(key);
         if (cached)
@@ -2583,9 +2583,6 @@ export class Analyzer {
                 }
                 const annotated = statement.type ? this.resolveAnnotation(statement.type) : null;
                 const annotationValid = statement.type ? this.validateTypeReference(statement.type) : true;
-                const aliasedBinding = !annotated && statement.initializer.kind === "IdentifierExpression"
-                    ? this.lookup(statement.initializer.name)
-                    : null;
                 const actual = this.inferExpression(statement.initializer, annotationValid ? annotated ?? unknownType : invalidType);
                 // D44 rule 71: an unannotated alias of an assignment-established fact
                 // declares the source's domain and re-establishes the fact below, so
@@ -2599,6 +2596,7 @@ export class Analyzer {
                 const contract = annotationValid ? annotated ?? inferredStorage : invalidType;
                 if (annotationValid)
                     this.requireAssignable(actual, declared, statement.initializer.span);
+                this.requireSettledCollectionElement(statement.initializer, declared, annotated !== null);
                 this.declarePattern(statement.pattern, statement.binding === "let", declared, contract);
                 // D51 rule 101: an alias of an owned handle — or a closure over one —
                 // is the same resource under a second name, so it inherits the
@@ -2620,14 +2618,6 @@ export class Analyzer {
                     if (binding?.span.start === statement.pattern.span.start && binding.span.end === statement.pattern.span.end) {
                         if (this.expandAliases(actual).kind === "promise")
                             this.promiseInitializerBindings.add(binding);
-                        if (!annotated) {
-                            const aliasedGroup = aliasedBinding ? this.collectionInferenceGroups.get(aliasedBinding) : null;
-                            if (aliasedGroup)
-                                this.joinCollectionInference(statement.pattern.name, binding, aliasedGroup);
-                            else if (this.isFreshUnresolvedCollection(statement.initializer, declared)) {
-                                this.joinCollectionInference(statement.pattern.name, binding, this.createCollectionInference(declared));
-                            }
-                        }
                     }
                 }
                 break;
@@ -4069,12 +4059,11 @@ export class Analyzer {
         return this.inferredFunctionResultSeeds.get(this.iterationResultKey(block)) ?? inferredResultPlaceholderType;
     }
     /**
-     * D68 rule 177: `@iterate:` answers the language's question "what does
+     * `@iterate:` answers the compiler's question "what does
      * iterating you mean?" with a collection the language already iterates. It
-     * shares `@dispose:`'s path because it is the same kind of member — a
-     * contract, not a method — and it differs in exactly two ways, both forced:
-     * it produces a value, and it may not `await`, because every one of the eight
-     * consumers reads it synchronously.
+     * shares `@dispose:`'s compiler-name path, then supplies its own role: it is
+     * a contract, not a method, it produces a value, and it may not `await`,
+     * because every one of the eight consumers reads it synchronously.
      */
     analyzeClassIterate(statement, block, baseName) {
         this.enterScope();
@@ -4545,9 +4534,12 @@ export class Analyzer {
             this.declareBinding("self", false, selfType, statement.span, true);
         }
         for (const parameter of statement.parameters) {
-            const type = this.resolveAnnotation(parameter.type);
-            const valid = parameter.type ? this.validateTypeReference(parameter.type) : true;
-            if (parameter.defaultValue && valid) {
+            const contextualType = !parameter.type && parameter.defaultValue
+                ? this.contextualFunctionParameterDefault(statement, parameter)
+                : null;
+            const type = contextualType ?? this.resolveAnnotation(parameter.type);
+            const valid = contextualType !== null || (parameter.type ? this.validateTypeReference(parameter.type) : true);
+            if (parameter.defaultValue && valid && contextualType === null) {
                 this.requireAssignable(this.inferParameterDefault(parameter.defaultValue, type), type, parameter.defaultValue.span);
             }
             const declared = valid ? type : invalidType;
@@ -4590,6 +4582,15 @@ export class Analyzer {
         this.typeParameterFrames.pop();
         this.constructorDepth = outerConstructorDepth;
     }
+    /**
+     * A target-owned declaration may use an ordinary default expression as a
+     * typed input descriptor. The target analyzes that expression and returns
+     * the value type visible inside the body; Core owns only the function-scope
+     * plumbing and never learns the descriptor vocabulary.
+     */
+    contextualFunctionParameterDefault(_statement, _parameter) {
+        return null;
+    }
     analyzeBlock(statements, narrowed = new Map()) {
         const visible = this.visibleBindings();
         this.enterScope();
@@ -4833,7 +4834,6 @@ export class Analyzer {
                         storageBinding.type = rebound;
                     targetBinding.storageType = rebound;
                     targetBinding.type = rebound;
-                    this.rebindCollectionInference(statement.target.kind === "IdentifierExpression" ? statement.target.name : "", targetBinding, statement.value, valueType);
                 }
                 // D44 rule 71: the assignment establishes the right-hand side's type
                 // as the location's fact (`x = maybeNull()` establishes nothing —
@@ -5273,6 +5273,31 @@ export class Analyzer {
                 this.requireAssignable(operand, numberType, expression.operand.span);
                 return numberType;
             }
+            case "RequiredExpression": {
+                // D86 rule 212: `value!` answers "absent here is a bug", so it takes
+                // `T?` to `T` and has nothing to say about a value that already holds
+                // one. The contextual type is the optional of what the consumer wants,
+                // since the unwrap is what removes the question.
+                const value = this.inferExpression(expression.value, optionalOf(this.expandAliases(contextualType)));
+                if (isInvalidType(value))
+                    return invalidType;
+                const resolved = this.expandAliases(value);
+                if (resolved.kind === "any")
+                    return value;
+                if (resolved.kind === "optional")
+                    return resolved.inner;
+                const message = resolved.kind === "unknown"
+                    ? `'!' unwraps an optional, and ${describeType(value)} is not one; validate it with 'is' or 'parse' before reading it`
+                    : resolved.kind === "promise"
+                        // The same mistake `try` guards against: the unwrap reached the
+                        // Promise rather than the value it resolves to.
+                        ? `'!' unwraps an optional, and this expression is ${describeType(value)}; write '(await ...)!' so the unwrap reaches the resolved value`
+                        : `'!' unwraps an optional, and this value is already ${describeType(value)}; remove the '!'`;
+                this.diagnostics.push(diagnostic("VEL4040", message, expression.span, ...(resolved.kind === "unknown" || resolved.kind === "promise"
+                    ? []
+                    : [mechanicalFix({ start: expression.span.end - 1, end: expression.span.end }, "", "Remove the redundant '!'")])));
+                return value;
+            }
             case "TryExpression": {
                 // D39 item 51: an expected failure is an optional. The inner
                 // expression is checked against the non-optional shape of whatever the
@@ -7507,11 +7532,7 @@ export class Analyzer {
                 this.collectionCalls.set(member.span.end, "listAppend");
                 const argument = argumentAt(0);
                 const value = inferArgument(0, object.element);
-                if (argument && object.element.kind === "unknown") {
-                    if (!this.refineCollectionInference(object, { kind: "list", element: value }))
-                        this.requireAssignable(value, object.element, argument.span);
-                }
-                else if (argument)
+                if (argument)
                     this.requireAssignable(value, object.element, argument.span);
                 requireCount(1);
                 return nullType;
@@ -7520,11 +7541,7 @@ export class Analyzer {
                 this.collectionCalls.set(member.span.end, "listExtend");
                 const argument = argumentAt(0);
                 const source = argument ? this.expandAliases(inferArgument(0)) : unknownType;
-                let inferred = false;
-                if (argument && source.kind === "list" && object.element.kind === "unknown") {
-                    inferred = this.refineCollectionInference(object, source);
-                }
-                if (argument && !inferred)
+                if (argument)
                     this.requireAssignable(source, object, argument.span);
                 requireCount(1);
                 return nullType;
@@ -7536,11 +7553,7 @@ export class Analyzer {
                     this.requireAssignable(inferArgument(0, numberType), numberType, indexArgument.span);
                 const argument = argumentAt(1);
                 const value = inferArgument(1, object.element);
-                if (argument && object.element.kind === "unknown") {
-                    if (!this.refineCollectionInference(object, { kind: "list", element: value }))
-                        this.requireAssignable(value, object.element, argument.span);
-                }
-                else if (argument)
+                if (argument)
                     this.requireAssignable(value, object.element, argument.span);
                 requireCount(2);
                 return nullType;
@@ -7690,11 +7703,12 @@ export class Analyzer {
                 this.collectionCalls.set(member.span.end, "mapSet");
                 const keyArgument = argumentAt(0);
                 const valueArgument = argumentAt(1);
-                const key = inferArgument(0);
-                const value = inferArgument(1);
-                if (object.key.kind === "unknown" && object.value.kind === "unknown") {
-                    this.refineCollectionInference(object, { kind: "map", key, value });
-                }
+                // D85 rule 211: the receiver's declared key and value types are the
+                // contextual types of this call, exactly as `List.append` passes its
+                // element type. Without them an empty `[]`, an arrow, or any other
+                // value that reads its shape from context arrives as `unknown`.
+                const key = inferArgument(0, object.key);
+                const value = inferArgument(1, object.value);
                 if (keyArgument)
                     this.requireAssignable(key, object.key, keyArgument.span);
                 if (valueArgument)
@@ -7706,11 +7720,7 @@ export class Analyzer {
                 this.collectionCalls.set(member.span.end, "mapUpdate");
                 const argument = argumentAt(0);
                 const source = argument ? this.expandAliases(inferArgument(0)) : unknownType;
-                let inferred = false;
-                if (argument && source.kind === "map" && object.key.kind === "unknown" && object.value.kind === "unknown") {
-                    inferred = this.refineCollectionInference(object, source);
-                }
-                if (argument && !inferred)
+                if (argument)
                     this.requireAssignable(source, object, argument.span);
                 requireCount(1);
                 return nullType;
@@ -7818,25 +7828,17 @@ export class Analyzer {
                 const argument = argumentAt(0);
                 const value = inferArgument(0, object.element);
                 requireCount(1);
-                if (argument && object.element.kind === "unknown") {
-                    if (!this.refineCollectionInference(object, { kind: "set", element: value }))
-                        this.requireAssignable(value, object.element, argument.span);
-                }
-                else if (argument)
+                if (argument)
                     this.requireAssignable(value, object.element, argument.span);
                 return nullType;
             }
             if (member.property === "update") {
                 this.collectionCalls.set(member.span.end, "setUpdate");
                 const argument = argumentAt(0);
+                const accepted = { kind: "union", members: [object, { kind: "list", element: object.element }] };
                 const source = argument ? this.expandAliases(inferArgument(0)) : unknownType;
-                let inferred = false;
-                if (argument && (source.kind === "set" || source.kind === "list") && object.element.kind === "unknown") {
-                    inferred = this.refineCollectionInference(object, { kind: "set", element: source.element });
-                }
-                if (argument && !inferred) {
-                    this.requireAssignable(source, { kind: "union", members: [object, { kind: "list", element: object.element }] }, argument.span);
-                }
+                if (argument)
+                    this.requireAssignable(source, accepted, argument.span);
                 requireCount(1);
                 return nullType;
             }
@@ -9388,10 +9390,8 @@ export class Analyzer {
         return null;
     }
     requireAssignable(actual, expected, valueSpan) {
-        if (this.contextuallyAssignable(actual, expected, valueSpan)) {
-            this.freezeEscapedCollectionInference(actual, expected);
+        if (this.contextuallyAssignable(actual, expected, valueSpan))
             return;
-        }
         const expandedActual = this.expandAliases(actual);
         const expandedExpected = this.expandAliases(expected);
         const expectedCore = expandedExpected.kind === "optional" ? this.expandAliases(expandedExpected.inner) : expandedExpected;
@@ -9526,64 +9526,6 @@ export class Analyzer {
         }
         return null;
     }
-    freezeEscapedCollectionInference(actual, expected, seen = new WeakMap()) {
-        const inference = this.collectionInferenceTypes.get(actual);
-        const expectedInference = this.collectionInferenceTypes.get(expected);
-        if (inference && actual !== expected && !expectedInference)
-            inference.open = false;
-        const expandedActual = this.expandAliases(actual);
-        const expandedExpected = this.expandAliases(expected);
-        const expectedSeen = seen.get(expandedActual) ?? new WeakSet();
-        if (expectedSeen.has(expandedExpected))
-            return;
-        expectedSeen.add(expandedExpected);
-        seen.set(expandedActual, expectedSeen);
-        if (expandedExpected.kind === "optional") {
-            if (expandedActual.kind === "optional")
-                this.freezeEscapedCollectionInference(expandedActual.inner, expandedExpected.inner, seen);
-            else if (expandedActual.kind !== "null")
-                this.freezeEscapedCollectionInference(expandedActual, expandedExpected.inner, seen);
-            return;
-        }
-        if (expandedExpected.kind === "union") {
-            const target = expandedExpected.members.find((member) => isAssignable(expandedActual, member, this));
-            if (target)
-                this.freezeEscapedCollectionInference(expandedActual, target, seen);
-            return;
-        }
-        if (expandedActual.kind === "union") {
-            for (const member of expandedActual.members)
-                this.freezeEscapedCollectionInference(member, expandedExpected, seen);
-            return;
-        }
-        if ((expandedActual.kind === "list" && expandedExpected.kind === "list")
-            || (expandedActual.kind === "set" && expandedExpected.kind === "set")) {
-            this.freezeEscapedCollectionInference(expandedActual.element, expandedExpected.element, seen);
-            return;
-        }
-        if (expandedActual.kind === "map" && expandedExpected.kind === "map") {
-            this.freezeEscapedCollectionInference(expandedActual.key, expandedExpected.key, seen);
-            this.freezeEscapedCollectionInference(expandedActual.value, expandedExpected.value, seen);
-            return;
-        }
-        if (expandedActual.kind === "record" && expandedExpected.kind === "record") {
-            this.freezeEscapedCollectionInference(expandedActual.value, expandedExpected.value, seen);
-            return;
-        }
-        const actualFields = expandedActual.kind === "object" ? expandedActual.fields
-            : expandedActual.kind === "named" ? this.fieldsOf(expandedActual.identity ?? expandedActual.name)
-                : null;
-        const expectedFields = expandedExpected.kind === "object" ? expandedExpected.fields
-            : expandedExpected.kind === "named" ? this.fieldsOf(expandedExpected.identity ?? expandedExpected.name)
-                : null;
-        if (actualFields && expectedFields) {
-            for (const [name, expectedField] of expectedFields) {
-                const actualField = actualFields.get(name);
-                if (actualField)
-                    this.freezeEscapedCollectionInference(actualField, expectedField, seen);
-            }
-        }
-    }
     contextuallyAssignable(actual, expected, valueSpan) {
         if (isAssignable(actual, expected, this))
             return true;
@@ -10956,6 +10898,26 @@ export class Analyzer {
             narrowingFrame: null,
         } : null;
     }
+    /**
+     * D85 rule 207: an empty collection's element type must be settled where the
+     * collection is written — by an annotation, a contextual type, or the
+     * constructor's own arguments. Nothing infers it from a later mutation, so a
+     * binding left with no source is reported at the construction rather than
+     * kept as `unknown` for a following line to fill in.
+     */
+    requireSettledCollectionElement(initializer, declared, annotated) {
+        if (annotated)
+            return;
+        const type = this.expandAliases(declared);
+        if (!this.isFreshUnresolvedCollection(initializer, type))
+            return;
+        const [spelling, holds, example] = type.kind === "list"
+            ? ["[]", "what the List holds", "let items: List<string> = []"]
+            : type.kind === "set"
+                ? ["Set()", "what the Set holds", "const tags: Set<string> = Set()"]
+                : ["Map()", "what the Map holds", "const users: Map<string, User> = Map()"];
+        this.diagnostics.push(diagnostic("VEL4039", `Empty '${spelling}' requires an explicit type; nothing at this position says ${holds} — write '${example}'`, initializer.span));
+    }
     isFreshUnresolvedCollection(expression, type) {
         const unresolved = type.kind === "list" ? type.element.kind === "unknown"
             : type.kind === "set" ? type.element.kind === "unknown"
@@ -10963,71 +10925,20 @@ export class Analyzer {
                     : false;
         if (!unresolved)
             return false;
+        // Only a genuinely empty construction is unsettled. A populated one whose
+        // items happen to be `unknown` (`[value]` over an unchecked boundary
+        // value) says what it holds; the element type is simply that.
         if (expression.kind === "ListExpression")
-            return true;
+            return expression.elements.length === 0;
         return expression.kind === "CallExpression"
+            && expression.arguments.length === 0
+            // `Set<string>()` already told the author where the element type goes
+            // (VEL2031); reporting the missing one here would name the same mistake
+            // twice and contradict the fix the first report offers.
+            && expression.typeArgumentsRemoved !== true
             && expression.callee.kind === "IdentifierExpression"
             && (expression.callee.name === "Map" || expression.callee.name === "Set");
     }
-    joinCollectionInference(name, binding, group) {
-        group.bindings.set(binding, name);
-        this.collectionInferenceGroups.set(binding, group);
-    }
-    createCollectionInference(type) {
-        const group = { type, bindings: new Map(), open: true };
-        this.collectionInferenceTypes.set(type, group);
-        return group;
-    }
-    refineCollectionInference(current, next) {
-        const group = this.collectionInferenceTypes.get(current);
-        if (!group?.open)
-            return false;
-        if (group.type.kind === "list" && next.kind === "list") {
-            group.type.element = next.element;
-        }
-        else if (group.type.kind === "set" && next.kind === "set") {
-            group.type.element = next.element;
-        }
-        else if (group.type.kind === "map" && next.kind === "map") {
-            group.type.key = next.key;
-            group.type.value = next.value;
-        }
-        else
-            return false;
-        for (const [member, name] of group.bindings) {
-            this.recordSemanticBinding(`${member.span.start}:${name}`, group.type);
-        }
-        return true;
-    }
-    rebindCollectionInference(name, binding, value, valueType) {
-        const previous = this.collectionInferenceGroups.get(binding);
-        if (!previous)
-            return;
-        const aliasedBinding = value.kind === "IdentifierExpression" ? this.lookup(value.name) : null;
-        const aliasedGroup = aliasedBinding ? this.collectionInferenceGroups.get(aliasedBinding) : null;
-        if (previous === aliasedGroup && aliasedGroup)
-            return;
-        previous?.bindings.delete(binding);
-        this.collectionInferenceGroups.delete(binding);
-        if (aliasedGroup) {
-            binding.type = aliasedGroup.type;
-            binding.declaredType = aliasedGroup.type;
-            binding.storageType = aliasedGroup.type;
-            this.joinCollectionInference(name, binding, aliasedGroup);
-        }
-        else if (this.isFreshUnresolvedCollection(value, valueType)) {
-            binding.type = valueType;
-            binding.declaredType = valueType;
-            binding.storageType = valueType;
-            this.joinCollectionInference(name, binding, this.createCollectionInference(valueType));
-        }
-        else {
-            binding.type = valueType;
-            binding.declaredType = valueType;
-            binding.storageType = valueType;
-        }
-        this.recordSemanticBinding(`${binding.span.start}:${name}`, binding.type);
-    }
     declareBinding(name, mutable, type, declarationSpan, internal = false, declaredType = type, importSource) {
         this.pendingScopeDeclarations.at(-1)?.delete(name);
         if (!internal) {
@@ -11981,6 +11892,13 @@ export class Analyzer {
     }
     runtimeCheckedType(input, checked) {
         const source = this.expandAliases(input);
+        // D85 rule 210: `unknown` is the one checked domain that proves nothing,
+        // so a check against it leaves the subject's own type alone. Without this
+        // a membership probe against a container whose element or key type is
+        // `unknown` replaced a `string` subject with `unknown`, which is a
+        // widening — every later read of it then failed for the wrong reason.
+        if (this.expandAliases(checked).kind === "unknown")
+            return source;
         const candidates = source.kind === "union" ? source.members
             : source.kind === "optional" ? [source.inner, nullType]
                 : [source];