@velarscript/compiler 0.11.1 → 0.12.0

package/dist/parser.js

@@ -162,9 +162,7 @@ export class Parser {
             return expression;
         const operatorToken = this.advance();
         this.diagnostics.push(recoveredDiagnostic("VEL2028", "Assignment is a statement, not an expression; write it on its own line inside a function, action, or handler body", operatorToken.span));
-        if (expression.kind !== "IdentifierExpression" && expression.kind !== "MemberExpression" && expression.kind !== "IndexExpression") {
-            this.diagnostics.push(diagnostic("VEL2005", "Assignment target must be a name, member, or index", expression.span));
-        }
+        this.reportInvalidAssignmentTarget(expression);
         const value = this.recoverExpressionAssignment(this.parseExpression());
         return { kind: "AssignmentExpression", target: expression, operator, value, span: span(expression.span.start, value.span.end) };
     }
@@ -445,9 +443,7 @@ export class Parser {
         const operator = assignmentOperators[this.current().kind];
         if (operator) {
             this.advance();
-            if (expression.kind !== "IdentifierExpression" && expression.kind !== "MemberExpression" && expression.kind !== "IndexExpression") {
-                this.diagnostics.push(diagnostic("VEL2005", "Assignment target must be a name, member, or index", expression.span));
-            }
+            this.reportInvalidAssignmentTarget(expression);
             const value = this.parseExpression();
             return {
                 kind: "AssignmentStatement",
@@ -1512,18 +1508,16 @@ export class Parser {
         this.consumeNewlines();
         while (!this.check("dedent") && !this.check("eof")) {
             const methodStart = this.current().span.start;
-            // D43 item 67/69 + D68 rule 177: an `@name` member belongs to the
-            // language. `@dispose:` and `@iterate:` are the two a class declares;
-            // anything else gets the closed vocabulary named back. Both are parsed
-            // and validated on one path because they are one idea — a question the
-            // language asks the type, answered in a block that is not a method.
+            // `@` always selects the contextual compiler namespace. In a class that
+            // closed namespace contains `dispose` and `iterate`; their behavior
+            // differs, but their resolution, rejection, and collision rules do not.
             if (this.check("at")) {
                 const marker = this.advance();
-                const memberName = this.expect("identifier", "Expected a compiler-known class member name after '@'");
+                const memberName = this.expect("identifier", "Expected a compiler-owned class name after '@'");
                 const keywordSpan = span(marker.span.start, memberName.span.end);
                 const known = memberName.value === "dispose" || memberName.value === "iterate";
                 if (!known) {
-                    this.diagnostics.push(diagnostic("VEL2022", `Unknown language member '@${memberName.value}'; a class declares '@dispose:' and '@iterate:', and no other '@' member`, keywordSpan));
+                    this.diagnostics.push(diagnostic("VEL2022", `Unknown compiler-owned name '@${memberName.value}' in a class; the class namespace contains only '@dispose:' and '@iterate:'`, keywordSpan));
                 }
                 const body = this.parseBlock();
                 const blockSpan = span(methodStart, body.at(-1)?.span.end ?? this.previous().span.end);
@@ -2590,6 +2584,17 @@ export class Parser {
             this.advance();
             return this.withParseDepth(() => this.parseUnary());
         }
+        if (this.match("bang")) {
+            // D86 rule 212: a `!` reached here stands before its operand, so it is
+            // the JavaScript negation, not the required-value unwrap the postfix
+            // loop reads. D54 rule 118 keeps that reading a teaching diagnostic.
+            this.reportPrefixBang(this.previous());
+            const operator = this.previous();
+            return this.withParseDepth(() => {
+                const operand = this.parseUnary();
+                return { kind: "UnaryExpression", operator: "not", operand, span: span(operator.span.start, operand.span.end) };
+            });
+        }
         if (this.match("not") || this.match("plus") || this.match("minus") || this.match("tilde")) {
             const operator = this.previous();
             return this.withParseDepth(() => {
@@ -2635,7 +2640,7 @@ export class Parser {
             return this.parsePostfix();
         const operator = this.previous();
         return this.withParseDepth(() => {
-            const operand = this.check("not") || this.check("plus") || this.check("minus") || this.check("tilde")
+            const operand = this.check("not") || this.check("bang") || this.check("plus") || this.check("minus") || this.check("tilde")
                 ? this.parseUnary()
                 : this.parsePowerBase();
             return {
@@ -2648,6 +2653,7 @@ export class Parser {
     }
     parsePostfix() {
         let expression = this.parsePrimary();
+        let typeArgumentsRemoved = false;
         while (true) {
             const explicitTypeArgumentsEnd = this.explicitTypeArgumentsEnd(expression);
             if (explicitTypeArgumentsEnd !== null) {
@@ -2657,7 +2663,26 @@ export class Parser {
                 const name = expression.kind === "IdentifierExpression" ? expression.name
                     : expression.kind === "MemberExpression" ? expression.property
                         : "function";
-                this.diagnostics.push(recoveredDiagnostic("VEL2031", `Type arguments are inferred at each call site; write '${name}(...)' without '<...>'`, span(start, this.previous().span.end), mechanicalFix(span(start, this.previous().span.end), "", "Remove the explicit type arguments")));
+                // D85 rule 207: an empty `Set<string>()` has no argument to infer from,
+                // so "remove the type arguments" alone would leave the author with
+                // code the analyzer rejects. Name where the type belongs instead, and
+                // withhold the mechanical fix that would not reach working source.
+                const emptyCollection = (name === "Set" || name === "Map")
+                    && this.check("leftParen") && this.peekKind(1) === "rightParen";
+                this.diagnostics.push(recoveredDiagnostic("VEL2031", emptyCollection
+                    ? `Type arguments are inferred at each call site; an empty '${name}()' takes its type from the binding — write 'const values: ${name === "Set" ? "Set<string>" : "Map<string, number>"} = ${name}()'`
+                    : `Type arguments are inferred at each call site; write '${name}(...)' without '<...>'`, span(start, this.previous().span.end), ...(emptyCollection
+                    ? []
+                    : [mechanicalFix(span(start, this.previous().span.end), "", "Remove the explicit type arguments")])));
+                typeArgumentsRemoved = true;
+                continue;
+            }
+            // D86 rule 212: a `!` that follows an operand is the required-value
+            // unwrap. It binds with the rest of the postfix chain, so `a!.b` unwraps
+            // `a` and then reads `b`, and `a.b!` unwraps the field.
+            if (this.match("bang")) {
+                const bang = this.previous();
+                expression = { kind: "RequiredExpression", value: expression, span: span(expression.span.start, bang.span.end) };
                 continue;
             }
             let call = false;
@@ -2717,8 +2742,10 @@ export class Parser {
                     arguments: arguments_,
                     ...(sawNamed ? { argumentNames } : {}),
                     optional: optionalCall,
+                    ...(typeArgumentsRemoved ? { typeArgumentsRemoved: true } : {}),
                     span: span(expression.span.start, close.span.end),
                 };
+                typeArgumentsRemoved = false;
                 continue;
             }
             if (this.check("optionalDot") && this.peekKind(1) === "leftBracket") {
@@ -3031,13 +3058,12 @@ export class Parser {
                     }
                     return { kind: "LiteralExpression", value: null, raw: "null", span: token.span };
                 }
-                // D43 item 67: '@name' is the language's own namespace for members that
-                // sit where user names also sit. Outside a declaration body it is not an
-                // expression, so the reader is told what the marker means instead of
-                // receiving a bare 'Expected an expression'.
+                // `@name` is resolved only by a compiler-owned syntax context. Here it
+                // cannot become an expression or runtime value, so name the namespace
+                // rule instead of reporting a bare 'Expected an expression'.
                 if (token.kind === "at") {
                     const name = this.check("identifier") ? this.advance().value : "";
-                    this.diagnostics.push(diagnostic("VEL2002", `'@${name}' names a language-owned member and appears only inside a declaration body, such as a component's '@mounted:' block`, span(token.span.start, this.previous().span.end)));
+                    this.diagnostics.push(diagnostic("VEL2002", `'@${name}' is a compiler-owned contextual name and is not valid here; use it only in a context that defines it, such as a component's '@mounted:' block`, span(token.span.start, this.previous().span.end)));
                     this.skipMistypedDeclaration();
                     return { kind: "LiteralExpression", value: null, raw: "null", span: token.span };
                 }
@@ -3593,6 +3619,33 @@ export class Parser {
         }
         return token;
     }
+    /**
+     * D54 rule 118 keeps prefix `!` a teaching diagnostic rather than a second
+     * spelling of `not`; D86 rule 212 moved the report here because only the
+     * parser knows the `!` stood before its operand. The rewrite carries the
+     * spacing the word form needs, exactly as the lexer's own word-operator
+     * fixes do: `!ready` becomes `not ready`, `and!ready` becomes `and not ready`.
+     */
+    /**
+     * D86 rule 212: `value! = next` names the unwrap on the left of a write. The
+     * unwrap reads a value and proves it present; a write has neither a result
+     * to unwrap nor a fact to prove, and assigning `null` back into an optional
+     * is legitimate — so the target is the location itself.
+     */
+    reportInvalidAssignmentTarget(expression) {
+        if (expression.kind === "IdentifierExpression" || expression.kind === "MemberExpression" || expression.kind === "IndexExpression")
+            return;
+        if (expression.kind === "RequiredExpression") {
+            this.diagnostics.push(diagnostic("VEL2005", "'!' unwraps a value that is read, so it cannot stand on an assignment target; assign to the location itself", expression.span, mechanicalFix(span(expression.span.end - 1, expression.span.end), "", "Remove the '!'")));
+            return;
+        }
+        this.diagnostics.push(diagnostic("VEL2005", "Assignment target must be a name, member, or index", expression.span));
+    }
+    reportPrefixBang(bang) {
+        const spaceBefore = this.tokens[this.index - 2]?.span.end === bang.span.start ? " " : "";
+        const spaceAfter = this.current().span.start === bang.span.end ? " " : "";
+        this.diagnostics.push(recoveredDiagnostic("VEL1005", "Use 'not'; VelarScript uses readable logical operators", bang.span, mechanicalFix(bang.span, `${spaceBefore}not${spaceAfter}`, "Use readable 'not'")));
+    }
     current() {
         return this.tokens[this.index] ?? this.tokens[this.tokens.length - 1];
     }