@harmoniclabs/pebble 0.1.10 → 0.2.0

package/dist/parser/Parser.js

@@ -21,13 +21,14 @@ import { LitThisExpr } from "../ast/nodes/expr/litteral/LitThisExpr.js";
 import { LitTrueExpr } from "../ast/nodes/expr/litteral/LitTrueExpr.js";
 import { ParentesizedExpr } from "../ast/nodes/expr/ParentesizedExpr.js";
 import { ArrowKind } from "../ast/nodes/expr/functions/ArrowKind.js";
-import { FuncExpr } from "../ast/nodes/expr/functions/FuncExpr.js";
+import { FuncExpr, TypeParamDecl } from "../ast/nodes/expr/functions/FuncExpr.js";
 import { AstBooleanType, AstBytesType, AstListType, AstIntType, AstNativeOptionalType, AstVoidType, AstLinearMapType, AstFuncType } from "../ast/nodes/types/AstNativeTypeExpr.js";
 import { AstNamedTypeExpr } from "../ast/nodes/types/AstNamedTypeExpr.js";
 import { LitArrExpr } from "../ast/nodes/expr/litteral/LitArrExpr.js";
 import { LitNamedObjExpr } from "../ast/nodes/expr/litteral/LitNamedObjExpr.js";
 import { LitObjExpr } from "../ast/nodes/expr/litteral/LitObjExpr.js";
 import { LitStrExpr } from "../ast/nodes/expr/litteral/LitStrExpr.js";
+import { TemplateStrExpr } from "../ast/nodes/expr/litteral/TemplateStrExpr.js";
 import { LitIntExpr } from "../ast/nodes/expr/litteral/LitIntExpr.js";
 import { LitHexBytesExpr } from "../ast/nodes/expr/litteral/LitHexBytesExpr.js";
 import { CallExpr } from "../ast/nodes/expr/functions/CallExpr.js";
@@ -44,6 +45,7 @@ import { FailStmt } from "../ast/nodes/statements/FailStmt.js";
 import { TraceStmt } from "../ast/nodes/statements/TraceStmt.js";
 import { AssertStmt } from "../ast/nodes/statements/AssertStmt.js";
 import { TestStmt } from "../ast/nodes/statements/TestStmt.js";
+import { TestParam } from "../ast/nodes/statements/TestParam.js";
 import { MatchStmt, MatchStmtCase, MatchStmtElseCase } from "../ast/nodes/statements/MatchStmt.js";
 import { WhileStmt } from "../ast/nodes/statements/WhileStmt.js";
 import { CaseExpr, CaseExprMatcher, CaseWildcardMatcher } from "../ast/nodes/expr/CaseExpr.js";
@@ -65,7 +67,8 @@ import { makePropAccessExpr } from "../ast/nodes/expr/PropAccessExpr.js";
 import { makeBinaryExpr } from "../ast/nodes/expr/binary/BinaryExpr.js";
 import { isAssignmentStmt, makeAssignmentStmt } from "../ast/nodes/statements/AssignmentStmt.js";
 import { hoistStatementsInplace } from "./hoistStatementsInplace.js";
-import { UsingStmt, UsingStmtDeclaredConstructor } from "../ast/nodes/statements/UsingStmt.js";
+import { UsingAliasStmt, UsingPath, UsingStmt, UsingStmtDeclaredConstructor } from "../ast/nodes/statements/UsingStmt.js";
+import { NamespaceDecl, NamespaceMember } from "../ast/nodes/statements/declarations/NamespaceDecl.js";
 import { IncrStmt } from "../ast/nodes/statements/IncrStmt.js";
 import { DecrStmt } from "../ast/nodes/statements/DecrStmt.js";
 import { ExportStmt } from "../ast/nodes/statements/ExportStmt.js";
@@ -151,9 +154,15 @@ export class Parser extends DiagnosticEmitter {
                 break;
             }
             case Token.Using: {
+                tn.next(); // skip `using`
                 statement = this.parseUsingDecl();
                 break;
             }
+            case Token.Namespace: {
+                tn.next(); // skip `namespace`
+                statement = this.parseNamespaceDecl(startPos);
+                break;
+            }
             case Token.Enum: {
                 tn.next();
                 statement = this.parseEnum(flags, startPos);
@@ -374,8 +383,19 @@ export class Parser extends DiagnosticEmitter {
     parseUsingDecl() {
         const tn = this.tn;
         const startPos = tn.tokenPos;
-        if (!tn.skip(Token.OpenBrace))
-            return this.error(DiagnosticCode._0_expected, tn.range(), "{");
+        // alias form: `using <ident> = <NamespacePath>;`
+        if (!tn.skip(Token.OpenBrace)) {
+            if (!tn.skipIdentifier())
+                return this.error(DiagnosticCode._0_expected, tn.range(), "{");
+            const alias = new Identifier(tn.readIdentifier(), tn.range());
+            if (!tn.skip(Token.Equals))
+                return this.error(DiagnosticCode._0_expected, tn.range(), "=");
+            const path = this.parseUsingPath();
+            if (!path)
+                return undefined;
+            return new UsingAliasStmt(alias, path, tn.range(startPos, tn.pos));
+        }
+        // destructure form: `using { a, b: c } = <rhs>;`
         const members = new Array();
         while (!tn.skip(Token.CloseBrace)) {
             const thisStartPos = tn.tokenPos;
@@ -397,10 +417,169 @@ export class Parser extends DiagnosticEmitter {
         }
         if (!tn.skip(Token.Equals))
             return this.error(DiagnosticCode._0_expected, tn.range(), "=");
-        const structTypeExpr = this.parseTypeExpr();
-        if (!structTypeExpr)
+        const rhs = this.parseUsingRhs();
+        if (!rhs)
             return undefined;
-        return new UsingStmt(members, structTypeExpr, tn.range(startPos, tn.pos));
+        return new UsingStmt(members, rhs, tn.range(startPos, tn.pos));
+    }
+    /**
+     * parse a dotted chain of identifiers: `A`, `A.B`, `A.B.C`, ...
+     * used for namespace paths on the RHS of `using` statements.
+     */
+    parseUsingPath() {
+        const tn = this.tn;
+        const startPos = tn.tokenPos;
+        if (!tn.skipIdentifier())
+            return this.error(DiagnosticCode.Identifier_expected, tn.range());
+        const segments = [
+            new Identifier(tn.readIdentifier(), tn.range())
+        ];
+        while (tn.skip(Token.Dot)) {
+            if (!tn.skipIdentifier())
+                return this.error(DiagnosticCode.Identifier_expected, tn.range());
+            segments.push(new Identifier(tn.readIdentifier(), tn.range()));
+        }
+        return new UsingPath(segments, tn.range(startPos, tn.pos));
+    }
+    /**
+     * parse the RHS of `using { ... } = <rhs>;`:
+     *  - if it begins with a native type keyword (or a generic struct
+     *    with type args), it's parsed as `AstTypeExpr` (legacy
+     *    struct-destructure behavior)
+     *  - if it's a single identifier followed by `<`, it's also parsed as
+     *    a generic type expression
+     *  - otherwise, it's parsed as a dotted `UsingPath`
+     *    (a namespace path; the compiler decides whether it's a struct
+     *    type or a namespace based on what the head identifier resolves to)
+     */
+    parseUsingRhs() {
+        const tn = this.tn;
+        const next = tn.peek();
+        // native type keywords always go through parseTypeExpr
+        if (next === Token.Void
+            || next === Token.Boolean
+            || next === Token.Int
+            || next === Token.Bytes
+            || next === Token.Optional
+            || next === Token.List
+            || next === Token.LinearMap) {
+            const t = this.parseTypeExpr();
+            if (!t)
+                return undefined;
+            return t;
+        }
+        const path = this.parseUsingPath();
+        if (!path)
+            return undefined;
+        // single-segment path followed by `<...>` → generic struct type expression
+        if (path.segments.length === 1
+            && tn.peek() === Token.LessThan) {
+            tn.next(); // consume `<`
+            const tyArgs = [];
+            do {
+                const ty = this.parseTypeExpr();
+                if (!ty)
+                    return undefined;
+                tyArgs.push(ty);
+            } while (tn.skip(Token.Comma));
+            if (!tn.skip(Token.GreaterThan))
+                return this.error(DiagnosticCode._0_expected, tn.range(), ">");
+            return new AstNamedTypeExpr(path.segments[0], tyArgs, tn.range(path.range.start, tn.pos));
+        }
+        return path;
+    }
+    /**
+     * parse a namespace body: `{ (private? <member-decl>)* }`
+     *
+     * called with `namespace` already consumed; `startPos` is the position
+     * of the `namespace` keyword.
+     */
+    parseNamespaceDecl(startPos) {
+        const tn = this.tn;
+        if (!tn.skipIdentifier())
+            return this.error(DiagnosticCode.Identifier_expected, tn.range());
+        const name = new Identifier(tn.readIdentifier(), tn.range());
+        if (!tn.skip(Token.OpenBrace))
+            return this.error(DiagnosticCode._0_expected, tn.range(), "{");
+        const members = [];
+        while (!tn.skip(Token.CloseBrace)) {
+            tn.skip(Token.Semicolon);
+            if (tn.skip(Token.CloseBrace))
+                break;
+            const memberStartPos = tn.tokenPos;
+            const isPrivate = tn.skip(Token.Private);
+            const member = this.parseNamespaceMember();
+            if (!member)
+                return undefined;
+            members.push(new NamespaceMember(isPrivate, member, tn.range(memberStartPos, tn.pos)));
+            tn.skip(Token.Semicolon);
+        }
+        return new NamespaceDecl(name, members, tn.range(startPos, tn.pos));
+    }
+    /**
+     * parse a single namespace body member. delegates to the relevant
+     * top-level-style parser based on the next token, but rejects
+     * declarations that aren't allowed inside a namespace body
+     * (no `export`, no `import`, no `using`, no `contract`, no `test`).
+     */
+    parseNamespaceMember() {
+        const tn = this.tn;
+        const startPos = tn.tokenPos;
+        const flags = CommonFlags.None;
+        const first = tn.peek();
+        switch (first) {
+            case Token.Namespace: {
+                tn.next();
+                return this.parseNamespaceDecl(startPos);
+            }
+            case Token.Function: {
+                tn.next();
+                return this.parseFuncDecl(flags, startPos);
+            }
+            case Token.Interface: {
+                tn.next();
+                return this.parseInterface(flags, startPos);
+            }
+            case Token.Var:
+            case Token.Let:
+            case Token.Const: {
+                tn.next();
+                return this.parseVarStmt(first === Token.Const ? CommonFlags.Const : CommonFlags.Let, startPos);
+            }
+            case Token.Enum: {
+                tn.next();
+                return this.parseEnum(flags, startPos);
+            }
+            case Token.Struct: {
+                tn.next();
+                return this.parseStruct(StructDeclAstFlags.none, flags, startPos);
+            }
+            case Token.Data: {
+                tn.next();
+                if (tn.peek() !== Token.Struct)
+                    return this.error(DiagnosticCode._0_expected, tn.range(), "struct");
+                tn.next();
+                return this.parseStruct(StructDeclAstFlags.onlyDataEncoding, flags, startPos);
+            }
+            case Token.Runtime: {
+                tn.next();
+                if (tn.peek() !== Token.Struct)
+                    return this.error(DiagnosticCode._0_expected, tn.range(), "struct");
+                tn.next();
+                return this.parseStruct(StructDeclAstFlags.onlySopEncoding, flags, startPos);
+            }
+            case Token.Type: {
+                tn.next();
+                const stmt = this.parseTypeStmt(flags, startPos);
+                if (!stmt)
+                    return undefined;
+                if (!(stmt instanceof TypeAliasDecl))
+                    return this.error(DiagnosticCode._0_expected, stmt.range, "type alias declaration");
+                return stmt;
+            }
+            default:
+                return this.error(DiagnosticCode._0_expected, tn.range(), "namespace member declaration");
+        }
     }
     parseTypeParameters() {
         const tn = this.tn;
@@ -419,6 +598,41 @@ export class Parser extends DiagnosticEmitter {
         }
         return typeParams;
     }
+    /**
+     * Parses a function's type-parameter list with optional `implements`
+     * interface constraints:
+     *   `<T, U implements ToData, V implements Foo>`
+     *
+     * Returns `TypeParamDecl[]` so the compiler can read each param's
+     * optional constraint at template-registration time. Struct/interface
+     * decls keep using the simpler {@link parseTypeParameters} which
+     * returns bare `Identifier[]`.
+     */
+    parseFuncTypeParameters() {
+        const tn = this.tn;
+        // at '<': TypeParamDecl (',' TypeParamDecl)* '>'
+        const typeParams = new Array();
+        while (!tn.skip(Token.GreaterThan)) {
+            const startPos = tn.tokenPos;
+            if (!tn.skipIdentifier())
+                return this.error(DiagnosticCode.Identifier_expected, tn.range());
+            const name = new Identifier(tn.readIdentifier(), tn.range());
+            let constraint = undefined;
+            if (tn.skip(Token.Implements)) {
+                constraint = this.parseTypeExpr();
+                if (!constraint)
+                    return undefined;
+            }
+            typeParams.push(new TypeParamDecl(name, constraint, tn.range(startPos, tn.pos)));
+            if (tn.skip(Token.Comma))
+                continue;
+            if (tn.skip(Token.GreaterThan))
+                break;
+            else
+                return this.error(DiagnosticCode._0_expected, tn.range(), ">");
+        }
+        return typeParams;
+    }
     parseTypeArguments() {
         const tn = this.tn;
         // at '<': TypeParameter (',' TypeParameter)* '>'
@@ -537,7 +751,11 @@ export class Parser extends DiagnosticEmitter {
             const body = this.parseBlockStmt();
             if (!body)
                 return undefined;
-            members.push(new InterfaceMethodImpl(methodName, typeParams ?? [], sig, body, tn.range(startPos, tn.pos)));
+            members.push(new InterfaceMethodImpl(methodName, 
+            // InterfaceMethodImpl still uses bare Identifier[];
+            // strip any constraint clauses (method-decl constraints
+            // would be a separate feature).
+            typeParams?.map(p => p.name) ?? [], sig, body, tn.range(startPos, tn.pos)));
         }
         tn.skip(Token.Semicolon); // if any
         return new TypeImplementsStmt(typeId, interfaceType, members, tn.range());
@@ -747,7 +965,7 @@ export class Parser extends DiagnosticEmitter {
         let typeParams = undefined;
         if (tn.skip(Token.LessThan)) {
             sigStart = tn.tokenPos;
-            typeParams = this.parseTypeParameters();
+            typeParams = this.parseFuncTypeParameters();
             if (!typeParams || typeParams.length === 0)
                 return undefined;
             // flags |= CommonFlags.Generic;
@@ -776,15 +994,11 @@ export class Parser extends DiagnosticEmitter {
         const namedSig = this.parseNamedFuncSig(flags, startPos, defaultReturnType);
         if (!namedSig)
             return undefined;
-        const [name, typeArgs, sig] = namedSig;
-        const nParams = typeArgs?.length ?? 0;
-        const typeParams = new Array(nParams);
-        for (let i = 0; i < nParams; ++i) {
-            const arg = typeArgs[i];
-            if (!(arg instanceof AstNamedTypeExpr))
-                return this.error(DiagnosticCode.Type_parameters_must_be_identifiers, arg.range);
-            typeParams[i] = arg.name;
-        }
+        const [name, typeParamsRaw, sig] = namedSig;
+        // `parseNamedFuncSig` returns `TypeParamDecl[]` (with optional
+        // `implements` constraint per param) — `FuncExpr.typeParams` carries
+        // them through to template registration.
+        const typeParams = typeParamsRaw ?? [];
         if (!tn.skip(Token.OpenBrace))
             return this.error(DiagnosticCode.Function_implementation_is_missing_or_not_immediately_following_the_declaration, tn.range());
         const body = this.parseBlockStmt();
@@ -792,7 +1006,7 @@ export class Parser extends DiagnosticEmitter {
             return undefined;
         const endPos = tn.pos;
         tn.skip(Token.Semicolon); // if any
-        const expr = new FuncExpr(name, flags, typeParams ?? [], sig, body, ArrowKind.None, tn.range(startPos, endPos));
+        const expr = new FuncExpr(name, flags, typeParams, sig, body, ArrowKind.None, tn.range(startPos, endPos));
         return new FuncDecl(expr);
     }
     parseEnum(flags, startPos) {
@@ -1113,11 +1327,15 @@ export class Parser extends DiagnosticEmitter {
         switch (token) {
             case Token.Void: return new AstVoidType(currRange);
             // case Token.True:
-            // case Token.False: 
+            // case Token.False:
             case Token.Boolean: return new AstBooleanType(currRange);
             case Token.Int: return new AstIntType(currRange);
             // case Token.Number: return new AstIntType( currRange )
             case Token.Bytes: return new AstBytesType(currRange);
+            // `data` is registered in the prelude as a named type; expose it
+            // as a plain `AstNamedTypeExpr` so it can be written in type
+            // position (e.g. `function f(x: data): ...`).
+            case Token.Data: return new AstNamedTypeExpr(new Identifier("data", currRange), [], currRange);
             case Token.Optional: {
                 if (!tn.skip(Token.LessThan)) {
                     canError && this.error(DiagnosticCode._0_expected, currRange, "Type argument for Optional");
@@ -1308,7 +1526,10 @@ export class Parser extends DiagnosticEmitter {
                     if (tn.skipIdentifier(IdentifierHandling.Always)) {
                         prop = new Identifier(tn.readIdentifier(), tn.range());
                         expr = makePropAccessExpr(token, expr, prop, tn.range(startPos, tn.pos));
-                        expr = this.tryParseCallExprOrReturnSame(expr);
+                        // pass `true` so we attempt `<TypeArgs>` parsing —
+                        // generic calls on dotted paths (e.g. `std.x.f<T>(a)`)
+                        // need this to consume the type arguments.
+                        expr = this.tryParseCallExprOrReturnSame(expr, true);
                         break;
                     }
                     const state = tn.mark();
@@ -1578,9 +1799,7 @@ export class Parser extends DiagnosticEmitter {
                 return new LitStrExpr(tn.readString(), tn.range(startPos, tn.pos));
             }
             case Token.StringTemplateLiteralQuote: {
-                this.error(DiagnosticCode.Not_implemented_0, tn.range(), "string template literals");
-                return undefined;
-                // return this.parseTemplateLiteral();
+                return this.parseTemplateLiteral(startPos);
             }
             case Token.IntegerLiteral: {
                 const value = tn.readInteger();
@@ -2340,17 +2559,63 @@ export class Parser extends DiagnosticEmitter {
     }
     parseTestStatement() {
         const tn = this.tn;
-        // at 'test': string? BlockStmt
-        const startPost = tn.pos;
-        let testName = undefined;
-        if (tn.skip(Token.StringLiteral)) {
-            const value = tn.readString();
-            testName = new LitStrExpr(value, tn.range(startPost, tn.pos));
-        }
-        let body = this.parseBlockStmt(true);
+        // at 'test': Identifier '(' TestParam (',' TestParam)* ')' '{' BlockStmt
+        const startPos = tn.pos;
+        if (!tn.skipIdentifier())
+            return this.error(DiagnosticCode.Identifier_expected, tn.range());
+        const testName = new Identifier(tn.readIdentifier(), tn.range());
+        if (!tn.skip(Token.OpenParen))
+            return this.error(DiagnosticCode._0_expected, tn.range(), "(");
+        const params = this.parseTestParameters();
+        if (!params)
+            return undefined;
+        if (!tn.skip(Token.OpenBrace))
+            return this.error(DiagnosticCode.Tests_must_be_specified_in_a_block_statement, tn.range());
+        let body = this.parseBlockStmt();
         if (!body)
             return this.error(DiagnosticCode.Tests_must_be_specified_in_a_block_statement, tn.range());
-        return new TestStmt(testName, body, tn.range(startPost, tn.pos));
+        return new TestStmt(testName, params, body, tn.range(startPos, tn.pos));
+    }
+    /**
+     * Parses the parameter list of a `test` declaration:
+     * `( <id>: <type> ('via' <expr>)? (, <id>: <type> ('via' <expr>)? )* )?`
+     *
+     * Assumes the opening `(` has already been consumed by the caller.
+     * Consumes the closing `)` on success.
+     *
+     * `via` is recognised here ONLY — function/method/contract parameter
+     * parsing uses `parseParameters()` which never looks for `Token.Via`.
+     */
+    parseTestParameters() {
+        const tn = this.tn;
+        const params = [];
+        if (tn.skip(Token.CloseParen))
+            return params;
+        while (true) {
+            const paramStart = tn.pos;
+            if (!tn.skipIdentifier())
+                return this.error(DiagnosticCode.Identifier_expected, tn.range());
+            const name = new Identifier(tn.readIdentifier(), tn.range());
+            if (!tn.skip(Token.Colon))
+                return this.error(DiagnosticCode._0_expected, tn.range(), ":");
+            const type = this.parseTypeExpr();
+            if (!type)
+                return undefined;
+            let viaExpr = undefined;
+            if (tn.skip(Token.Via)) {
+                const expr = this.parseExpr();
+                if (!expr)
+                    return undefined;
+                viaExpr = expr;
+            }
+            params.push(new TestParam(name, type, viaExpr, tn.range(paramStart, tn.pos)));
+            if (tn.skip(Token.Comma))
+                continue;
+            if (tn.skip(Token.CloseParen))
+                break;
+            return this.error(DiagnosticCode._0_expected, tn.range(), ")");
+        }
+        return params;
     }
     parseMatchStatement() {
         const tn = this.tn;
@@ -2416,6 +2681,41 @@ export class Parser extends DiagnosticEmitter {
             return this.error(DiagnosticCode.Expression_expected, tn.range());
         return new TraceStmt(expr, tn.range());
     }
+    /**
+     * Parse a backtick-delimited template literal:
+     *
+     *   `text ${expr1} more text ${expr2} ...`
+     *
+     * Tokenizer state: on entry, the current token is
+     * `Token.StringTemplateLiteralQuote`; the tokenizer is positioned at
+     * the opening backtick. `readString()` (called with no arg) consumes
+     * the backtick + the first fragment up to `${` or to the closing
+     * backtick; if it stopped at `${` it sets `readingTemplateString = true`
+     * and the parser must consume an expression + `}` and then call
+     * `readString(CharCode.Backtick)` to read the next fragment.
+     */
+    parseTemplateLiteral(startPos) {
+        const tn = this.tn;
+        const parts = [];
+        const exprs = [];
+        // First fragment — readString advances past the opening backtick.
+        let fragment = tn.readString();
+        parts.push(fragment);
+        while (tn.readingTemplateString) {
+            // Just consumed `${`. Parse the interpolated expression.
+            const interp = this.parseExpr();
+            if (!interp)
+                return this.error(DiagnosticCode.Expression_expected, tn.range());
+            exprs.push(interp);
+            if (!tn.skip(Token.CloseBrace))
+                return this.error(DiagnosticCode._0_expected, tn.range(), "}");
+            // Read the next fragment up to the next `${` or the closing
+            // backtick. `readingTemplateString` is set inside readString.
+            fragment = tn.readString(96 /* CharCode.Backtick */);
+            parts.push(fragment);
+        }
+        return new TemplateStrExpr(parts, exprs, tn.range(startPos, tn.pos));
+    }
     parseAssertStatement() {
         const tn = this.tn;
         const startPos = tn.tokenPos;