poe-code 6.0.0 → 7.0.0

package/packages/safejs/dist/parse/bindings.js

@@ -0,0 +1,90 @@
+export function* boundIdentifiers(pattern) {
+    switch (pattern.type) {
+        case "Identifier":
+            yield pattern;
+            return;
+        case "AssignmentPattern":
+            yield* boundIdentifiers(pattern.left);
+            return;
+        case "RestElement":
+            yield* boundIdentifiers(pattern.argument);
+            return;
+        case "ArrayPattern":
+            for (const element of pattern.elements) {
+                if (element !== null)
+                    yield* boundIdentifiers(element);
+            }
+            return;
+        case "ObjectPattern":
+            for (const property of pattern.properties) {
+                yield* boundIdentifiers(property.type === "RestElement" ? property : property.value);
+            }
+            return;
+        case "MemberExpression":
+            return;
+    }
+}
+export function containsParameterExpression(pattern) {
+    switch (pattern.type) {
+        case "AssignmentPattern":
+        case "MemberExpression":
+            return true;
+        case "RestElement":
+            return containsParameterExpression(pattern.argument);
+        case "ArrayPattern":
+            return pattern.elements.some((element) => element !== null && containsParameterExpression(element));
+        case "ObjectPattern":
+            return pattern.properties.some((property) => property.type === "RestElement"
+                ? containsParameterExpression(property.argument)
+                : property.computed || containsParameterExpression(property.value));
+        case "Identifier":
+            return false;
+    }
+}
+export function* hoistedVarDeclarations(nodes) {
+    for (const node of nodes) {
+        switch (node.type) {
+            case "VariableDeclaration":
+                if (node.kind === "var")
+                    yield node;
+                break;
+            case "BlockStatement":
+                yield* hoistedVarDeclarations(node.body);
+                break;
+            case "IfStatement":
+                yield* hoistedVarDeclarations([node.consequent]);
+                if (node.alternate !== undefined)
+                    yield* hoistedVarDeclarations([node.alternate]);
+                break;
+            case "ForStatement":
+                if (node.init?.type === "VariableDeclaration")
+                    yield* hoistedVarDeclarations([node.init]);
+                yield* hoistedVarDeclarations([node.body]);
+                break;
+            case "ForInStatement":
+            case "ForOfStatement":
+                if (node.left.type === "VariableDeclaration")
+                    yield* hoistedVarDeclarations([node.left]);
+                yield* hoistedVarDeclarations([node.body]);
+                break;
+            case "WhileStatement":
+            case "DoWhileStatement":
+                yield* hoistedVarDeclarations([node.body]);
+                break;
+            case "TryStatement":
+                yield* hoistedVarDeclarations([node.block]);
+                if (node.handler !== undefined)
+                    yield* hoistedVarDeclarations([node.handler.body]);
+                if (node.finalizer !== undefined)
+                    yield* hoistedVarDeclarations([node.finalizer]);
+                break;
+            case "SwitchStatement":
+                for (const switchCase of node.cases)
+                    yield* hoistedVarDeclarations(switchCase.consequent);
+                break;
+            case "ExportNamedDeclaration":
+                yield* hoistedVarDeclarations([node.declaration]);
+                break;
+        }
+    }
+}

package/packages/safejs/dist/parse/parser.js

@@ -1,3 +1,4 @@
+import { boundIdentifiers } from "./bindings.js";
 import { tokenize } from "./tokenizer.js";
 import { assignIds } from "./assign-ids.js";
 import { formatParseError } from "./format-error.js";
@@ -104,8 +105,11 @@ class Parser {
     loopDepth = 0;
     generatorBody = false;
     scopes = [new Map()];
+    functionScopes = new WeakSet();
+    varNames = new WeakMap();
     constructor(tokens) {
         this.tokens = tokens;
+        this.functionScopes.add(this.scopes[0]);
     }
     parseTopLevel() {
         if (this.isExportToken(this.currentToken())) {
@@ -244,8 +248,14 @@ class Parser {
         return undefined;
     }
     finishArrowFunctionExpression(start, isAsync, params) {
+        this.withScope(() => {
+            for (const param of params) {
+                for (const identifier of boundIdentifiers(param))
+                    this.declareBinding(identifier);
+            }
+        });
         this.expectPunctuator("=>");
-        const body = this.parseArrowFunctionBody();
+        const body = this.parseArrowFunctionBody(params);
         return {
             type: "ArrowFunctionExpression",
             async: isAsync,
@@ -284,15 +294,27 @@ class Parser {
             this.conditionalExpressionDepth -= 1;
         }
     }
-    parseArrowFunctionBody() {
+    parseArrowFunctionBody(params) {
         if (this.currentToken().type === "punctuator" && this.currentToken().value === "{") {
-            return this.withFunctionContext(false, () => this.parseBlockStatement());
+            return this.withFunctionContext(false, () => this.parseBlockStatement(params));
         }
         return this.withFunctionContext(false, () => this.parseExpression().node);
     }
-    parseBlockStatement() {
+    parseBlockStatement(params, catchParam) {
         const start = this.expectPunctuator("{");
-        return this.withScope(() => this.parseBlockStatementBody(start));
+        return this.withScope(() => {
+            for (const param of params ?? []) {
+                for (const identifier of boundIdentifiers(param)) {
+                    this.declareBinding(identifier, "parameter");
+                }
+            }
+            if (catchParam !== undefined) {
+                for (const identifier of boundIdentifiers(catchParam)) {
+                    this.declareBinding(identifier, catchParam.type === "Identifier" ? "catch" : "lexical");
+                }
+            }
+            return this.parseBlockStatementBody(start);
+        }, params !== undefined);
     }
     parseBlockStatementBody(start) {
         const body = [];
@@ -819,7 +841,7 @@ class Parser {
             param = this.parseBindingTarget();
             this.expectPunctuator(")");
         }
-        const body = this.parseBlockStatement();
+        const body = this.parseBlockStatement(undefined, param);
         return {
             type: "CatchClause",
             param,
@@ -840,6 +862,11 @@ class Parser {
             if (kindToken.value !== "var") {
                 this.declarePatternBindings(declarator.id);
             }
+            else {
+                for (const identifier of boundIdentifiers(declarator.id)) {
+                    this.declareVarBinding(identifier);
+                }
+            }
             declarations.push(declarator);
             const comma = this.consumePunctuator(",");
             if (comma === undefined) {
@@ -861,18 +888,18 @@ class Parser {
             throw new Error(`async function* is not supported at line ${asyncToken.start.line}, column ${asyncToken.start.column}.`);
         }
         const id = this.parseBindingIdentifier();
-        this.declareBinding(id);
+        this.declareBinding(id, "function");
         const params = this.withScope(() => {
             const parsedParams = this.parseArrowParameters();
             for (const param of parsedParams) {
-                for (const identifier of collectBindingIdentifiers(param)) {
+                for (const identifier of boundIdentifiers(param)) {
                     this.declareBinding(identifier);
                 }
             }
             return parsedParams;
         });
         const generator = generatorToken !== undefined;
-        const body = this.withFunctionContext(generator, () => this.parseBlockStatement());
+        const body = this.withFunctionContext(generator, () => this.parseBlockStatement(params));
         return {
             type: "FunctionDeclaration",
             async: asyncToken !== undefined,
@@ -1809,14 +1836,14 @@ class Parser {
         const params = this.withScope(() => {
             const parsedParams = this.parseArrowParameters();
             for (const param of parsedParams) {
-                for (const identifier of collectBindingIdentifiers(param)) {
+                for (const identifier of boundIdentifiers(param)) {
                     this.declareBinding(identifier);
                 }
             }
             return parsedParams;
         });
         const generator = generatorToken !== undefined;
-        const body = this.withFunctionContext(generator, () => this.parseBlockStatement());
+        const body = this.withFunctionContext(generator, () => this.parseBlockStatement(params));
         return {
             type: "FunctionExpression",
             async: asyncToken !== undefined,
@@ -2071,13 +2098,13 @@ class Parser {
         const params = this.withScope(() => {
             const parsedParams = this.parseArrowParameters();
             for (const param of parsedParams) {
-                for (const identifier of collectBindingIdentifiers(param)) {
+                for (const identifier of boundIdentifiers(param)) {
                     this.declareBinding(identifier);
                 }
             }
             return parsedParams;
         });
-        const body = this.withFunctionContext(false, () => this.parseBlockStatement());
+        const body = this.withFunctionContext(false, () => this.parseBlockStatement(params));
         return {
             type: "FunctionExpression",
             async: asyncToken !== undefined,
@@ -2524,8 +2551,11 @@ class Parser {
             this.breakableDepth -= 1;
         }
     }
-    withScope(callback) {
-        this.scopes.push(new Map());
+    withScope(callback, functionBody = false) {
+        const scope = new Map();
+        if (functionBody)
+            this.functionScopes.add(scope);
+        this.scopes.push(scope);
         try {
             return callback();
         }
@@ -2534,19 +2564,40 @@ class Parser {
         }
     }
     declarePatternBindings(pattern) {
-        for (const identifier of collectBindingIdentifiers(pattern)) {
+        for (const identifier of boundIdentifiers(pattern)) {
             this.declareBinding(identifier);
         }
     }
-    declareBinding(identifier) {
+    declareBinding(identifier, kind = "lexical") {
         const scope = this.scopes[this.scopes.length - 1];
         if (scope === undefined) {
             return;
         }
-        if (scope.has(identifier.name)) {
+        const existing = scope.get(identifier.name);
+        const variableFunction = kind === "function" && this.functionScopes.has(scope);
+        if ((existing !== undefined &&
+            !(variableFunction && (existing === "function" || existing === "parameter"))) ||
+            (!variableFunction && this.varNames.get(scope)?.has(identifier.name))) {
             throw new Error(`Cannot redeclare binding '${identifier.name}' at line ${identifier.span.start.line}, column ${identifier.span.start.column}.`);
         }
-        scope.set(identifier.name, identifier.span.start);
+        scope.set(identifier.name, kind);
+    }
+    declareVarBinding(identifier) {
+        for (let index = this.scopes.length - 1; index >= 0; index--) {
+            const scope = this.scopes[index];
+            const existing = scope.get(identifier.name);
+            if (existing === "lexical" || (existing === "function" && !this.functionScopes.has(scope))) {
+                throw new Error(`Cannot redeclare binding '${identifier.name}' at line ${identifier.span.start.line}, column ${identifier.span.start.column}.`);
+            }
+            let names = this.varNames.get(scope);
+            if (names === undefined) {
+                names = new Set();
+                this.varNames.set(scope, names);
+            }
+            names.add(identifier.name);
+            if (this.functionScopes.has(scope))
+                return;
+        }
     }
     consumePunctuator(value) {
         const token = this.currentToken();
@@ -2638,24 +2689,6 @@ function createIdentifierName(token) {
         span: createTokenSpan(token)
     };
 }
-function collectBindingIdentifiers(pattern) {
-    switch (pattern.type) {
-        case "Identifier":
-            return [pattern];
-        case "MemberExpression":
-            return [];
-        case "AssignmentPattern":
-            return collectBindingIdentifiers(pattern.left);
-        case "RestElement":
-            return collectBindingIdentifiers(pattern.argument);
-        case "ArrayPattern":
-            return pattern.elements.flatMap((element) => element === null ? [] : collectBindingIdentifiers(element));
-        case "ObjectPattern":
-            return pattern.properties.flatMap((property) => property.type === "RestElement"
-                ? collectBindingIdentifiers(property)
-                : collectBindingIdentifiers(property.value));
-    }
-}
 function createLoopLabelFields(labels) {
     if (labels === undefined || labels.length === 0) {
         return {};

package/packages/safejs/dist/snapshot/dump-format.d.ts

@@ -1,5 +1,5 @@
 export declare const DUMP_FORMAT_VERSION = 1;
-export declare const EXECUTION_SEMANTICS = "jobs-v2";
+export declare const EXECUTION_SEMANTICS = "jobs-v3";
 export type DumpableSnapshot = {
     sourceHash: string;
     [key: string]: unknown;

package/packages/safejs/dist/snapshot/dump-format.js

@@ -1,5 +1,5 @@
 export const DUMP_FORMAT_VERSION = 1;
-export const EXECUTION_SEMANTICS = "jobs-v2";
+export const EXECUTION_SEMANTICS = "jobs-v3";
 import { assertSnapshotGraphDepth } from "../graph-depth.js";
 import { getSandboxArgumentEntries, isSandboxArguments } from "../interp/arguments.js";
 import { serializeArguments } from "./arguments.js";

package/packages/safejs/dist/lint/rules/AS-await-non-promise.d.ts

@@ -1,13 +0,0 @@
-import { type SourceSpan } from "../../parse/parser.js";
-export type Diagnostic = {
-    code: "AS-AWAIT-NON-PROMISE";
-    severity: "warning";
-    message: string;
-    filename: string;
-    line: number;
-    column: number;
-    span: SourceSpan;
-};
-export declare function AS_AWAIT_NON_PROMISE(source: string, options?: {
-    filename?: string;
-}): Diagnostic[];

package/packages/safejs/dist/lint/rules/AS-await-non-promise.js

@@ -1,301 +0,0 @@
-import { parseModule } from "../../parse/parser.js";
-export function AS_AWAIT_NON_PROMISE(source, options = {}) {
-    return new ASAwaitNonPromiseScanner(options.filename ?? "<input>").scan(source);
-}
-class ASAwaitNonPromiseScanner {
-    filename;
-    diagnostics = [];
-    constructor(filename) {
-        this.filename = filename;
-    }
-    scan(source) {
-        this.visitModule(parseModule(source, this.filename));
-        return this.diagnostics;
-    }
-    visitModule(node) {
-        for (const statement of node.body) {
-            this.visitStatement(statement);
-        }
-    }
-    visitStatement(node) {
-        switch (node.type) {
-            case "FunctionDeclaration":
-                this.visitArrowFunction(node);
-                return;
-            case "BlockStatement":
-                this.visitBlockStatement(node);
-                return;
-            case "ExpressionStatement":
-                this.visitExpression(node.expression);
-                return;
-            case "IfStatement":
-                this.visitIfStatement(node);
-                return;
-            case "ForStatement":
-                this.visitForStatement(node);
-                return;
-            case "ForInStatement":
-            case "ForOfStatement":
-                this.visitForOfStatement(node);
-                return;
-            case "WhileStatement":
-            case "DoWhileStatement":
-                this.visitWhileStatement(node);
-                return;
-            case "TryStatement":
-                this.visitTryStatement(node);
-                return;
-            case "VariableDeclaration":
-                this.visitVariableDeclaration(node);
-                return;
-            case "ReturnStatement":
-                this.visitReturnStatement(node);
-                return;
-            case "ThrowStatement":
-                this.visitThrowStatement(node);
-                return;
-            case "ExportNamedDeclaration":
-                this.visitVariableDeclaration(node.declaration);
-                return;
-            case "ExportDefaultDeclaration":
-                this.visitExpression(node.declaration);
-                return;
-            case "ImportDeclaration":
-            case "BreakStatement":
-            case "ContinueStatement":
-                return;
-        }
-    }
-    visitBlockStatement(node) {
-        for (const statement of node.body) {
-            this.visitStatement(statement);
-        }
-    }
-    visitIfStatement(node) {
-        this.visitExpression(node.test);
-        this.visitStatement(node.consequent);
-        if (node.alternate !== undefined) {
-            this.visitStatement(node.alternate);
-        }
-    }
-    visitForStatement(node) {
-        if (node.init !== undefined) {
-            if (node.init.type === "VariableDeclaration") {
-                this.visitVariableDeclaration(node.init);
-            }
-            else {
-                this.visitExpression(node.init);
-            }
-        }
-        if (node.test !== undefined) {
-            this.visitExpression(node.test);
-        }
-        if (node.update !== undefined) {
-            this.visitExpression(node.update);
-        }
-        this.visitStatement(node.body);
-    }
-    visitForOfStatement(node) {
-        if (node.left.type === "VariableDeclaration") {
-            this.visitVariableDeclaration(node.left);
-        }
-        this.visitExpression(node.right);
-        this.visitStatement(node.body);
-    }
-    visitWhileStatement(node) {
-        this.visitExpression(node.test);
-        this.visitStatement(node.body);
-    }
-    visitTryStatement(node) {
-        this.visitBlockStatement(node.block);
-        if (node.handler !== undefined) {
-            this.visitCatchClause(node.handler);
-        }
-        if (node.finalizer !== undefined) {
-            this.visitBlockStatement(node.finalizer);
-        }
-    }
-    visitCatchClause(node) {
-        this.visitBlockStatement(node.body);
-    }
-    visitVariableDeclaration(node) {
-        for (const declarator of node.declarations) {
-            this.visitVariableDeclarator(declarator);
-        }
-    }
-    visitVariableDeclarator(node) {
-        if (node.init !== undefined) {
-            this.visitExpression(node.init);
-        }
-    }
-    visitReturnStatement(node) {
-        if (node.argument !== undefined) {
-            this.visitExpression(node.argument);
-        }
-    }
-    visitThrowStatement(node) {
-        this.visitExpression(node.argument);
-    }
-    visitExpression(node) {
-        switch (node.type) {
-            case "YieldExpression":
-                if (node.argument !== undefined) {
-                    this.visitExpression(node.argument);
-                }
-                return;
-            case "FunctionExpression":
-            case "ArrowFunctionExpression":
-                this.visitArrowFunction(node);
-                return;
-            case "AwaitExpression":
-                this.visitAwaitExpression(node);
-                return;
-            case "ArrayExpression":
-                this.visitArrayExpression(node);
-                return;
-            case "ObjectExpression":
-                this.visitObjectExpression(node);
-                return;
-            case "UnaryExpression":
-                this.visitUnaryExpression(node);
-                return;
-            case "BinaryExpression":
-            case "LogicalExpression":
-                this.visitBinaryLikeExpression(node);
-                return;
-            case "ConditionalExpression":
-                this.visitConditionalExpression(node);
-                return;
-            case "MemberExpression":
-                this.visitMemberExpression(node);
-                return;
-            case "AssignmentExpression":
-                this.visitAssignmentExpression(node);
-                return;
-            case "CallExpression":
-                this.visitCallExpression(node);
-                return;
-            case "TemplateLiteral":
-                this.visitTemplateLiteral(node);
-                return;
-            case "TaggedTemplateExpression":
-                this.visitTaggedTemplateExpression(node);
-                return;
-            case "Identifier":
-            case "BooleanLiteral":
-            case "MetaProperty":
-            case "NullLiteral":
-            case "NumericLiteral":
-            case "RegexLiteral":
-            case "StringLiteral":
-            case "UndefinedLiteral":
-                return;
-        }
-    }
-    visitArrowFunction(node) {
-        if (node.body.type === "BlockStatement") {
-            this.visitBlockStatement(node.body);
-            return;
-        }
-        this.visitExpression(node.body);
-    }
-    visitAwaitExpression(node) {
-        if (isKnownNonPromiseExpression(node.argument)) {
-            this.report(node.argument.span);
-        }
-        this.visitExpression(node.argument);
-    }
-    visitArrayExpression(node) {
-        for (const element of node.elements) {
-            if (element.type === "SpreadElement") {
-                this.visitExpression(element.argument);
-                continue;
-            }
-            this.visitExpression(element);
-        }
-    }
-    visitObjectExpression(node) {
-        for (const property of node.properties) {
-            if (property.type === "SpreadElement") {
-                this.visitExpression(property.argument);
-                continue;
-            }
-            this.visitProperty(property);
-        }
-    }
-    visitProperty(node) {
-        if (node.computed) {
-            this.visitExpression(node.key);
-        }
-        this.visitExpression(node.value);
-    }
-    visitUnaryExpression(node) {
-        this.visitExpression(node.argument);
-    }
-    visitBinaryLikeExpression(node) {
-        this.visitExpression(node.left);
-        this.visitExpression(node.right);
-    }
-    visitConditionalExpression(node) {
-        this.visitExpression(node.test);
-        this.visitExpression(node.consequent);
-        this.visitExpression(node.alternate);
-    }
-    visitMemberExpression(node) {
-        this.visitExpression(node.object);
-        if (node.computed) {
-            this.visitExpression(node.property);
-        }
-    }
-    visitAssignmentExpression(node) {
-        this.visitExpression(node.right);
-    }
-    visitCallExpression(node) {
-        this.visitExpression(node.callee);
-        for (const argument of node.arguments) {
-            if (argument.type === "SpreadElement") {
-                this.visitExpression(argument.argument);
-                continue;
-            }
-            this.visitExpression(argument);
-        }
-    }
-    visitTemplateLiteral(node) {
-        for (const expression of node.expressions) {
-            this.visitExpression(expression);
-        }
-    }
-    visitTaggedTemplateExpression(node) {
-        this.visitExpression(node.tag);
-        this.visitTemplateLiteral(node.quasi);
-    }
-    report(span) {
-        this.diagnostics.push({
-            code: "AS-AWAIT-NON-PROMISE",
-            severity: "warning",
-            message: "Awaiting a known non-promise value has no effect.",
-            filename: this.filename,
-            line: span.start.line,
-            column: span.start.column,
-            span
-        });
-    }
-}
-function isKnownNonPromiseExpression(node) {
-    switch (node.type) {
-        case "FunctionExpression":
-        case "ArrowFunctionExpression":
-        case "ArrayExpression":
-        case "BinaryExpression":
-        case "BooleanLiteral":
-        case "NullLiteral":
-        case "NumericLiteral":
-        case "ObjectExpression":
-        case "StringLiteral":
-        case "TemplateLiteral":
-        case "UnaryExpression":
-            return true;
-        default:
-            return false;
-    }
-}

package/packages/safejs/dist/lint/rules/AS008.d.ts

@@ -1,13 +0,0 @@
-import { type SourceSpan } from "../../parse/parser.js";
-export type Diagnostic = {
-    code: "AS008";
-    severity: "error";
-    message: string;
-    filename: string;
-    line: number;
-    column: number;
-    span: SourceSpan;
-};
-export declare function AS008(source: string, options?: {
-    filename?: string;
-}): Diagnostic[];