poe-code 4.0.57 → 4.0.59

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poe-code",
-  "version": "4.0.57",
+  "version": "4.0.59",
   "description": "CLI tool to configure Poe API for developer workflows.",
   "license": "MIT",
   "type": "module",

package/packages/safejs/dist/graph-depth.js

@@ -1,5 +1,6 @@
 import { replaceErrorStack } from "./error/shape.js";
 import { SandboxError } from "./interp/budget.js";
+import { getSandboxArgumentEntries, isSandboxArguments } from "./interp/arguments.js";
 export const MAX_DATA_DEPTH = 1_024;
 export class SnapshotBudgetError extends Error {
     code = "budgetExceeded";
@@ -60,6 +61,9 @@ function walkGraphDepth(root, rootPath, assertDepth) {
     }
 }
 function graphEntries(value) {
+    if (isSandboxArguments(value)) {
+        return getSandboxArgumentEntries(value).map(([key, entry]) => [`.${key}`, entry]);
+    }
     if (Array.isArray(value))
         return value.map((entry, index) => [`[${index}]`, entry]);
     if (value instanceof Map) {

package/packages/safejs/dist/interp/arguments.d.ts

@@ -0,0 +1,10 @@
+import type { SandboxObject, SandboxValue } from "./values.js";
+declare const sandboxArgumentsBrand: unique symbol;
+export type SandboxArguments = SandboxObject & {
+    readonly [sandboxArgumentsBrand]: true;
+};
+export declare function createSandboxArguments(values: readonly SandboxValue[]): SandboxArguments;
+export declare function isSandboxArguments(value: unknown): value is SandboxArguments;
+export declare function getSandboxArgumentEntries(value: SandboxObject): Array<[string, SandboxValue]>;
+export declare function copySandboxArgumentProperties(source: SandboxObject, target: object, copyValue: (value: SandboxValue, key: string) => unknown): void;
+export {};

package/packages/safejs/dist/interp/arguments.js

@@ -0,0 +1,44 @@
+const sandboxArgumentsBrand = Symbol("SandboxArguments");
+export function createSandboxArguments(values) {
+    const result = (function () {
+        return arguments;
+    })();
+    for (let index = 0; index < values.length; index += 1) {
+        result[index] = values[index];
+    }
+    result.length = values.length;
+    Object.defineProperty(result, sandboxArgumentsBrand, { value: true });
+    return result;
+}
+export function isSandboxArguments(value) {
+    return typeof value === "object" && value !== null && Object.hasOwn(value, sandboxArgumentsBrand);
+}
+export function getSandboxArgumentEntries(value) {
+    return Object.entries(Object.getOwnPropertyDescriptors(value)).flatMap(([key, descriptor]) => "value" in descriptor ? [[key, descriptor.value]] : []);
+}
+export function copySandboxArgumentProperties(source, target, copyValue) {
+    const names = Object.getOwnPropertyNames(source);
+    if (!names.includes("length") || names.indexOf("length") > names.indexOf("callee")) {
+        Reflect.deleteProperty(target, "length");
+    }
+    for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(source))) {
+        if (!("value" in descriptor)) {
+            if (key !== "callee")
+                throw new TypeError(`Cannot copy arguments accessor '${key}'.`);
+            continue;
+        }
+        Object.defineProperty(target, key, { ...descriptor, value: copyValue(descriptor.value, key) });
+    }
+    const iterator = Object.getOwnPropertyDescriptor(source, Symbol.iterator);
+    if (iterator === undefined) {
+        Reflect.deleteProperty(target, Symbol.iterator);
+    }
+    else {
+        if (iterator.value !== Array.prototype.values) {
+            throw new TypeError("Cannot copy a replaced arguments iterator.");
+        }
+        Object.defineProperty(target, Symbol.iterator, iterator);
+    }
+    if (!Object.isExtensible(source))
+        Object.preventExtensions(target);
+}

package/packages/safejs/dist/interp/async.js

@@ -3,7 +3,7 @@ import { getBoundOtelSpan } from "../observability/otel.js";
 import { bindPattern } from "./patterns.js";
 import { resolveSandboxValue } from "./promise.js";
 import { hoistVarDeclarations } from "./var-hoist.js";
-import { createSandboxClosure, createSandboxGenerator, createSandboxPromise, isSandboxPromise } from "./values.js";
+import { createSandboxArguments, createSandboxClosure, createSandboxGenerator, createSandboxPromise, isSandboxPromise } from "./values.js";
 export function emitResumeBreakpoint(context, breakpoint) {
     context.onYield?.({
         ...breakpoint,
@@ -154,6 +154,8 @@ async function createClosureScope(node, args, thisValue, context, evaluateNode)
     const scope = context.scope.child({}, { functionBoundary: true });
     if (node.type !== "ArrowFunctionExpression") {
         scope.declare("this", "const", thisValue);
+        context.budget.allocateArrayLength(args.length);
+        scope.declare("arguments", "let", createSandboxArguments(args));
     }
     await bindParameters(node.params, args, scope, context, evaluateNode);
     hoistVarDeclarations(node.body, scope);

package/packages/safejs/dist/interp/values.d.ts

@@ -1,6 +1,7 @@
 import type { Budget } from "./budget.js";
 import type { GeneratorChannel } from "./generator.js";
 import { type RegexPattern } from "./regex/parse.js";
+export { createSandboxArguments, isSandboxArguments } from "./arguments.js";
 declare const sandboxClosureBrand: unique symbol;
 declare const sandboxGeneratorBrand: unique symbol;
 declare const sandboxMapBrand: unique symbol;
@@ -111,4 +112,3 @@ export declare function allocateProducedSandboxValue(value: SandboxValue, budget
 export declare function measureSandboxData(values: Iterable<unknown>): number;
 export declare function deepCopyFromSandbox(value: SandboxPromise, options?: CopyFromSandboxOptions): Promise<unknown>;
 export declare function deepCopyFromSandbox(value: SandboxValue, options?: CopyFromSandboxOptions): unknown;
-export {};

package/packages/safejs/dist/interp/values.js

@@ -3,6 +3,8 @@ import { SandboxError } from "./budget.js";
 import { trackSandboxPromise } from "./promise-tracker.js";
 import { parseRegex } from "./regex/parse.js";
 import { assertSandboxDataDepth } from "../graph-depth.js";
+import { copySandboxArgumentProperties, createSandboxArguments, getSandboxArgumentEntries, isSandboxArguments } from "./arguments.js";
+export { createSandboxArguments, isSandboxArguments } from "./arguments.js";
 const sandboxClosureBrand = Symbol("SandboxClosure");
 const sandboxGeneratorBrand = Symbol("SandboxGenerator");
 const sandboxMapBrand = Symbol("SandboxMap");
@@ -203,7 +205,9 @@ export function measureSandboxData(values) {
             usage += value.source.length + value.flags.length;
             return;
         }
-        const entries = Object.entries(value);
+        const entries = isSandboxArguments(value)
+            ? getSandboxArgumentEntries(value)
+            : Object.entries(value);
         usage += entries.length;
         for (const [key, entry] of entries) {
             usage += key.length;
@@ -302,6 +306,15 @@ function copyToSandbox(value, state, path = "<root>", cloneSandboxCollections =
         }
         return copy;
     }
+    if (isSandboxArguments(value)) {
+        const existing = state.seen.get(value);
+        if (existing !== undefined)
+            return existing;
+        const copy = createSandboxArguments([]);
+        state.seen.set(value, copy);
+        copySandboxArgumentProperties(value, copy, (entry, key) => copyToSandbox(entry, state, joinPath(path, key), cloneSandboxCollections, depth + 1));
+        return copy;
+    }
     if (isPlainObject(value)) {
         const existing = state.seen.get(value);
         if (existing !== undefined) {
@@ -382,6 +395,15 @@ function copyFromSandbox(value, state, path = "<root>", options, depth = 0) {
         }
         return copy;
     }
+    if (isSandboxArguments(value)) {
+        const existing = state.seen.get(value);
+        if (existing !== undefined)
+            return existing;
+        const copy = createSandboxArguments([]);
+        state.seen.set(value, copy);
+        copySandboxArgumentProperties(value, copy, (entry, key) => copyFromSandbox(entry, state, joinPath(path, key), options, depth + 1));
+        return copy;
+    }
     if (isPlainObject(value)) {
         const existing = state.seen.get(value);
         if (existing !== undefined) {
@@ -457,7 +479,10 @@ function allocateSandboxValue(value, budget, seen) {
         return;
     }
     seen.add(value);
-    for (const entry of Object.values(value)) {
+    const entries = isSandboxArguments(value)
+        ? getSandboxArgumentEntries(value).map(([, entry]) => entry)
+        : Object.values(value);
+    for (const entry of entries) {
         allocateSandboxValue(entry, budget, seen);
     }
 }

package/packages/safejs/dist/lint/index.js

@@ -1,5 +1,4 @@
 import { AS001 } from "./rules/AS001.js";
-import { AS002 } from "./rules/AS002.js";
 import { AS003 } from "./rules/AS003.js";
 import { AS004 } from "./rules/AS004.js";
 import { AS005 } from "./rules/AS005.js";
@@ -8,7 +7,6 @@ import { AS008 } from "./rules/AS008.js";
 import { AS009 } from "./rules/AS009.js";
 import { AS010 } from "./rules/AS010.js";
 import { AS011 } from "./rules/AS011.js";
-import { AS012 } from "./rules/AS012.js";
 import { AS013 } from "./rules/AS013.js";
 import { AS015 } from "./rules/AS015.js";
 import { AS_ASYNC_NOT_NEEDED } from "./rules/AS-async-not-needed.js";
@@ -30,7 +28,6 @@ import { AS_UNUSED_IMPORT } from "./rules/AS-unused-import.js";
 import { collectComments, tokenize } from "../parse/tokenizer.js";
 import { parseModule } from "../parse/parser.js";
 const RULES = [
-    AS002,
     AS003,
     AS004,
     AS005,
@@ -42,7 +39,6 @@ const RULES = [
     AS009,
     AS010,
     AS011,
-    AS012,
     AS013,
     AS015,
     AS_IMPORT_CYCLE,

package/packages/safejs/dist/lint/rules/AS-async-not-needed.d.ts

@@ -12,7 +12,7 @@ export type Diagnostic = {
         replacement: string;
     };
 };
-export declare const AS_ASYNC_NOT_NEEDED_MESSAGE = "Async arrow functions without await should remove the async keyword.";
+export declare const AS_ASYNC_NOT_NEEDED_MESSAGE = "Async functions without await should remove the async keyword.";
 export declare function AS_ASYNC_NOT_NEEDED(source: string, options?: {
     filename?: string;
 }): Diagnostic[];

package/packages/safejs/dist/lint/rules/AS-async-not-needed.js

@@ -1,5 +1,5 @@
 import { parseModule } from "../../parse/parser.js";
-export const AS_ASYNC_NOT_NEEDED_MESSAGE = "Async arrow functions without await should remove the async keyword.";
+export const AS_ASYNC_NOT_NEEDED_MESSAGE = "Async functions without await should remove the async keyword.";
 export function AS_ASYNC_NOT_NEEDED(source, options = {}) {
     return new ASAsyncNotNeededScanner(source, options.filename ?? "<input>").scan();
 }
@@ -33,6 +33,9 @@ class ASAsyncNotNeededScanner {
     }
     visitStatement(node) {
         switch (node.type) {
+            case "FunctionDeclaration":
+                this.visitFunctionExpression(node);
+                return;
             case "BlockStatement":
                 this.visitBlockStatement(node);
                 return;
@@ -73,6 +76,10 @@ class ASAsyncNotNeededScanner {
                     this.visitArrowFunction(node.declaration, true);
                     return;
                 }
+                if (node.declaration.type === "FunctionExpression") {
+                    this.visitFunctionExpression(node.declaration, true);
+                    return;
+                }
                 this.visitExpression(node.declaration);
                 return;
             case "ImportDeclaration":
@@ -160,6 +167,11 @@ class ASAsyncNotNeededScanner {
     }
     visitExpression(node) {
         switch (node.type) {
+            case "YieldExpression":
+                if (node.argument !== undefined) {
+                    this.visitExpression(node.argument);
+                }
+                return;
             case "ArrowFunctionExpression":
                 this.visitArrowFunction(node, false);
                 return;
@@ -224,8 +236,8 @@ class ASAsyncNotNeededScanner {
         }
         this.visitExpression(node.body);
     }
-    visitFunctionExpression(node) {
-        if (node.async && !bodyContainsAwait(node.body)) {
+    visitFunctionExpression(node, isDefaultExport = false) {
+        if (node.async && !isDefaultExport && !bodyContainsAwait(node.body)) {
             this.report(createAsyncKeywordSpan(node.span));
         }
         for (const param of node.params) {

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

@@ -19,6 +19,9 @@ class ASAwaitNonPromiseScanner {
     }
     visitStatement(node) {
         switch (node.type) {
+            case "FunctionDeclaration":
+                this.visitArrowFunction(node);
+                return;
             case "BlockStatement":
                 this.visitBlockStatement(node);
                 return;
@@ -135,6 +138,12 @@ class ASAwaitNonPromiseScanner {
     }
     visitExpression(node) {
         switch (node.type) {
+            case "YieldExpression":
+                if (node.argument !== undefined) {
+                    this.visitExpression(node.argument);
+                }
+                return;
+            case "FunctionExpression":
             case "ArrowFunctionExpression":
                 this.visitArrowFunction(node);
                 return;
@@ -274,6 +283,7 @@ class ASAwaitNonPromiseScanner {
 }
 function isKnownNonPromiseExpression(node) {
     switch (node.type) {
+        case "FunctionExpression":
         case "ArrowFunctionExpression":
         case "ArrayExpression":
         case "BinaryExpression":

package/packages/safejs/dist/lint/rules/AS-destructure-null-default.js

@@ -21,6 +21,9 @@ class ASDestructureNullDefaultScanner {
     }
     visitStatement(node) {
         switch (node.type) {
+            case "FunctionDeclaration":
+                this.visitArrowFunction(node);
+                return;
             case "BlockStatement":
                 this.visitBlockStatement(node);
                 return;
@@ -145,6 +148,12 @@ class ASDestructureNullDefaultScanner {
     }
     visitExpression(node) {
         switch (node.type) {
+            case "YieldExpression":
+                if (node.argument !== undefined) {
+                    this.visitExpression(node.argument);
+                }
+                return;
+            case "FunctionExpression":
             case "ArrowFunctionExpression":
                 this.visitArrowFunction(node);
                 return;

package/packages/safejs/dist/lint/rules/AS-export-import-meta.js

@@ -36,6 +36,12 @@ class Scanner {
     }
     visitStatement(node) {
         switch (node.type) {
+            case "FunctionDeclaration":
+                for (const param of node.params) {
+                    this.visitAssignmentTarget(param);
+                }
+                this.visitStatement(node.body);
+                return;
             case "ExportNamedDeclaration":
                 this.visitExportNamedDeclaration(node.declaration);
                 return;
@@ -171,7 +177,15 @@ class Scanner {
     }
     visitExpression(node) {
         switch (node.type) {
+            case "YieldExpression":
+                if (node.argument !== undefined) {
+                    this.visitExpression(node.argument);
+                }
+                return;
             case "ArrowFunctionExpression":
+                for (const param of node.params) {
+                    this.visitAssignmentTarget(param);
+                }
                 if (node.body.type === "BlockStatement") {
                     this.visitStatement(node.body);
                 }
@@ -180,6 +194,9 @@ class Scanner {
                 }
                 return;
             case "FunctionExpression":
+                for (const param of node.params) {
+                    this.visitAssignmentTarget(param);
+                }
                 this.visitStatement(node.body);
                 return;
             case "AwaitExpression":

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

@@ -29,6 +29,9 @@ class ASFloatingPromiseScanner {
     }
     visitStatement(node) {
         switch (node.type) {
+            case "FunctionDeclaration":
+                this.visitArrowFunction(node);
+                return;
             case "BlockStatement":
                 this.visitBlockStatement(node);
                 return;
@@ -161,6 +164,12 @@ class ASFloatingPromiseScanner {
     }
     visitExpression(node) {
         switch (node.type) {
+            case "YieldExpression":
+                if (node.argument !== undefined) {
+                    this.visitExpression(node.argument);
+                }
+                return;
+            case "FunctionExpression":
             case "ArrowFunctionExpression":
                 this.visitArrowFunction(node);
                 return;
@@ -369,6 +378,7 @@ class ASFloatingPromiseScanner {
                 this.reportUnhandledLikelyPromiseStatementExpression(node.alternate);
                 return;
             case "CallExpression":
+            case "FunctionExpression":
             case "ArrowFunctionExpression":
             case "AwaitExpression":
             case "ArrayExpression":
@@ -481,6 +491,11 @@ class ASFloatingPromiseScanner {
     }
     collectBlockBindings(statements) {
         return statements.flatMap((statement) => {
+            if (statement.type === "FunctionDeclaration") {
+                return [
+                    { async: statement.async && !statement.generator, kind: "local", name: statement.id.name }
+                ];
+            }
             if (statement.type === "VariableDeclaration") {
                 return this.collectDeclarationBindings(statement);
             }
@@ -492,7 +507,9 @@ class ASFloatingPromiseScanner {
     }
     collectDeclarationBindings(node) {
         return node.declarations.flatMap((declarator) => this.collectDeclaratorBindings(declarator).map((name) => ({
-            async: declarator.init?.type === "ArrowFunctionExpression" && declarator.init.async,
+            async: (declarator.init?.type === "ArrowFunctionExpression" ||
+                (declarator.init?.type === "FunctionExpression" && !declarator.init.generator)) &&
+                declarator.init.async,
             kind: "local",
             name
         })));
@@ -501,11 +518,15 @@ class ASFloatingPromiseScanner {
         return this.collectPatternBindingNames(node.id);
     }
     collectArrowFunctionBindings(node) {
-        return node.params.flatMap((param) => this.collectParameterBindingNames(param).map((name) => ({
+        const bindings = node.params.flatMap((param) => this.collectParameterBindingNames(param).map((name) => ({
             async: false,
             kind: "local",
             name
         })));
+        if (node.type === "FunctionExpression" && node.id !== undefined) {
+            bindings.unshift({ async: node.async && !node.generator, kind: "local", name: node.id.name });
+        }
+        return bindings;
     }
     collectPatternBindings(node) {
         return this.collectPatternBindingNames(node).map((name) => ({

package/packages/safejs/dist/lint/rules/AS-frontmatter-field-unused.js

@@ -35,6 +35,9 @@ class ASFrontmatterFieldUnusedScanner {
     }
     visitStatement(node) {
         switch (node.type) {
+            case "FunctionDeclaration":
+                this.visitArrowFunction(node);
+                return;
             case "BlockStatement":
                 this.visitBlockStatement(node);
                 return;
@@ -160,6 +163,12 @@ class ASFrontmatterFieldUnusedScanner {
     }
     visitExpression(node) {
         switch (node.type) {
+            case "YieldExpression":
+                if (node.argument !== undefined) {
+                    this.visitExpression(node.argument);
+                }
+                return;
+            case "FunctionExpression":
             case "ArrowFunctionExpression":
                 this.visitArrowFunction(node);
                 return;

package/packages/safejs/dist/lint/rules/AS-jsdoc-type.js

@@ -28,6 +28,9 @@ class ASJsdocTypeScanner {
     }
     visitStatement(node) {
         switch (node.type) {
+            case "FunctionDeclaration":
+                this.visitArrowFunction(node);
+                return;
             case "BlockStatement":
                 this.visitBlockStatement(node);
                 return;
@@ -164,6 +167,12 @@ class ASJsdocTypeScanner {
     }
     visitExpression(node) {
         switch (node.type) {
+            case "YieldExpression":
+                if (node.argument !== undefined) {
+                    this.visitExpression(node.argument);
+                }
+                return;
+            case "FunctionExpression":
             case "ArrowFunctionExpression":
                 this.visitArrowFunction(node);
                 return;
@@ -632,6 +641,7 @@ function inferExpressionKind(expression) {
                 return "boolean";
             }
             return undefined;
+        case "FunctionExpression":
         case "ArrowFunctionExpression":
         case "AssignmentExpression":
         case "AwaitExpression":

package/packages/safejs/dist/lint/rules/AS-large-literal.js

@@ -22,6 +22,9 @@ class ASLargeLiteralScanner {
     }
     visitStatement(node) {
         switch (node.type) {
+            case "FunctionDeclaration":
+                this.visitArrowFunction(node);
+                return;
             case "BlockStatement":
                 this.visitBlockStatement(node);
                 return;
@@ -142,6 +145,12 @@ class ASLargeLiteralScanner {
     }
     visitExpression(node) {
         switch (node.type) {
+            case "YieldExpression":
+                if (node.argument !== undefined) {
+                    this.visitExpression(node.argument);
+                }
+                return;
+            case "FunctionExpression":
             case "ArrowFunctionExpression":
                 this.visitArrowFunction(node);
                 return;

package/packages/safejs/dist/lint/rules/AS-missing-async.d.ts

@@ -12,7 +12,7 @@ export type Diagnostic = {
         replacement: string;
     };
 };
-export declare const AS_MISSING_ASYNC_MESSAGE = "Arrow functions that contain await must be marked async.";
+export declare const AS_MISSING_ASYNC_MESSAGE = "Functions that contain await must be marked async.";
 export declare function AS_MISSING_ASYNC(source: string, options?: {
     filename?: string;
 }): Diagnostic[];

package/packages/safejs/dist/lint/rules/AS-missing-async.js

@@ -1,5 +1,5 @@
 import { parseModule } from "../../parse/parser.js";
-export const AS_MISSING_ASYNC_MESSAGE = "Arrow functions that contain await must be marked async.";
+export const AS_MISSING_ASYNC_MESSAGE = "Functions that contain await must be marked async.";
 export function AS_MISSING_ASYNC(source, options = {}) {
     return new ASMissingAsyncScanner(options.filename ?? "<input>").scan(source);
 }
@@ -28,6 +28,9 @@ class ASMissingAsyncScanner {
     }
     visitStatement(node) {
         switch (node.type) {
+            case "FunctionDeclaration":
+                this.visitFunctionExpression(node);
+                return;
             case "BlockStatement":
                 this.visitBlockStatement(node);
                 return;
@@ -148,6 +151,11 @@ class ASMissingAsyncScanner {
     }
     visitExpression(node) {
         switch (node.type) {
+            case "YieldExpression":
+                if (node.argument !== undefined) {
+                    this.visitExpression(node.argument);
+                }
+                return;
             case "ArrowFunctionExpression":
                 this.visitArrowFunction(node);
                 return;

package/packages/safejs/dist/lint/rules/AS-mutating-frozen.js

@@ -33,6 +33,9 @@ class ASMutatingFrozenScanner {
     }
     visitStatement(node) {
         switch (node.type) {
+            case "FunctionDeclaration":
+                this.visitArrowFunction(node);
+                return;
             case "BlockStatement":
                 this.visitBlockStatement(node);
                 return;
@@ -170,6 +173,12 @@ class ASMutatingFrozenScanner {
     }
     visitExpression(node) {
         switch (node.type) {
+            case "YieldExpression":
+                if (node.argument !== undefined) {
+                    this.visitExpression(node.argument);
+                }
+                return;
+            case "FunctionExpression":
             case "ArrowFunctionExpression":
                 this.visitArrowFunction(node);
                 return;

package/packages/safejs/dist/lint/rules/AS-needless-template.js

@@ -45,6 +45,9 @@ class ASNeedlessTemplateScanner {
     }
     visitStatement(node) {
         switch (node.type) {
+            case "FunctionDeclaration":
+                this.visitArrowFunction(node);
+                return;
             case "BlockStatement":
                 this.visitBlockStatement(node);
                 return;
@@ -168,6 +171,12 @@ class ASNeedlessTemplateScanner {
     }
     visitExpression(node) {
         switch (node.type) {
+            case "YieldExpression":
+                if (node.argument !== undefined) {
+                    this.visitExpression(node.argument);
+                }
+                return;
+            case "FunctionExpression":
             case "ArrowFunctionExpression":
                 this.visitArrowFunction(node);
                 return;

package/packages/safejs/dist/lint/rules/AS-shadow-global.js

@@ -22,6 +22,9 @@ class ASShadowGlobalScanner {
     }
     visitStatement(node) {
         switch (node.type) {
+            case "FunctionDeclaration":
+                this.visitArrowFunctionExpression(node);
+                return;
             case "BlockStatement":
                 this.visitBlockStatement(node);
                 return;
@@ -145,6 +148,12 @@ class ASShadowGlobalScanner {
     }
     visitExpression(node) {
         switch (node.type) {
+            case "YieldExpression":
+                if (node.argument !== undefined) {
+                    this.visitExpression(node.argument);
+                }
+                return;
+            case "FunctionExpression":
             case "ArrowFunctionExpression":
                 this.visitArrowFunctionExpression(node);
                 return;
@@ -196,6 +205,9 @@ class ASShadowGlobalScanner {
         }
     }
     visitArrowFunctionExpression(node) {
+        if (node.type !== "ArrowFunctionExpression" && node.id !== undefined) {
+            this.reportIfGlobalShadow(node.id);
+        }
         for (const parameter of node.params) {
             this.visitBindingElement(parameter);
         }

package/packages/safejs/dist/lint/rules/AS-unbounded-loop.js

@@ -21,6 +21,9 @@ class ASUnboundedLoopScanner {
     }
     visitStatement(node) {
         switch (node.type) {
+            case "FunctionDeclaration":
+                this.visitArrowFunction(node);
+                return;
             case "BlockStatement":
                 this.visitBlockStatement(node);
                 return;
@@ -157,6 +160,12 @@ class ASUnboundedLoopScanner {
     }
     visitExpression(node) {
         switch (node.type) {
+            case "YieldExpression":
+                if (node.argument !== undefined) {
+                    this.visitExpression(node.argument);
+                }
+                return;
+            case "FunctionExpression":
             case "ArrowFunctionExpression":
                 this.visitArrowFunction(node);
                 return;