@scriptc/compiler 0.4.8 → 0.4.9

package/dist/frontend/lowering/class-protocols.js

@@ -9,6 +9,8 @@ export class ClassProtocols {
     answers = new Map();
     /** The program classes each Pick or Omit view accepts (classesAcceptedBy). */
     accepted = new Map();
+    /** copiedArgument's answers, per call and argument position. */
+    copiedArguments = new Map();
     /** What markIdentityFlows learned about the program, while it runs. */
     facts = null;
     /** The value types of the string-keyed dictionaries that keep checked
@@ -19,6 +21,9 @@ export class ClassProtocols {
      * without protocol dispatch: their members are invoked on the collection
      * itself, not read from a property bag. */
     collectionViews = new Set();
+    /** The mapped views a receiver-dependent literal is used as, whose source
+     * cannot carry the marking (see index). */
+    literalViews = new Set();
     constructor(checker, sources) {
         this.checker = checker;
         this.sources = sources;
@@ -29,6 +34,23 @@ export class ClassProtocols {
         const protocols = new Set();
         this.implemented = protocols;
         const add = (type) => {
+            // A homomorphic mapped view's own symbol is the shared mapped
+            // `__type` that every mapped type in the program uses: marking it
+            // would make every Pick, Omit, Partial and Readonly a view. Mark the
+            // type the view maps instead when that is a structural type. A source
+            // that cannot carry the marking keeps its own representation: a class
+            // instance would make every instance a view, and an intersection has
+            // no symbol. The VIEW type itself is recorded for those, so a
+            // receiver-dependent literal typed as it still keeps checked identity
+            // and protocol answers it through that record.
+            const mapped = this.mappedViewSource(type);
+            if (mapped !== null) {
+                if (!this.isStructuralTarget(mapped)) {
+                    this.literalViews.add(type);
+                    return;
+                }
+                type = mapped;
+            }
             const symbol = type.getSymbol();
             if (!symbol || protocols.has(symbol))
                 return;
@@ -106,10 +128,11 @@ export class ClassProtocols {
      * checked-dynamic view, where the accessor stays live, `Object.keys`
      * lists it, and `JSON.stringify` calls it — Node's own model.
      *
-     * Only the TARGET is marked: the literal then takes the checked-dynamic
-     * literal path (`lowerDynObjectLiteral`), which defines an accessor member
-     * as a live get/set property and a data member as a plain property, so
-     * both directions construct live objects. */
+     * Only the TARGET is marked (for an intersection or union, its object
+     * constituents): the literal then takes the checked-dynamic literal path
+     * (`lowerDynObjectLiteral`), which defines an accessor member as a live
+     * get/set property and a data member as a plain property, so both
+     * directions construct live objects. */
     markMemberKindViews(literal, accessorNames, add) {
         const members = [];
         for (const property of literal.properties.nodes) {
@@ -134,29 +157,127 @@ export class ClassProtocols {
         const contextual = attempt(() => this.checker.getContextualType(literal));
         if (contextual === undefined)
             return;
-        // Only one object type can be the one the literal converts into: a union
-        // with several arms picks its arm from the value itself, and an
-        // intersection merges members, so neither has the single layout the
-        // literal would have to disagree with. Nullish arms are ignored, so
-        // `Counter | undefined` still names Counter.
+        // The literal converts into an object PART of its contextual type, so
+        // both composites are resolved part by part. An intersection needs the
+        // views of every constituent that declares a disagreeing member. A
+        // union keeps checked identity only as a whole (usesCheckedIdentity
+        // answers it when every present arm does), so it becomes a view only
+        // when NO present arm can hold the literal natively: every present arm
+        // declares a disagreeing member. An arm that agrees is the arm the
+        // literal is, and marking the union anyway would make a program whose
+        // literals already match their arms dynamic for nothing. Nullish arms
+        // are ignored, so `Counter | undefined` still names Counter.
         const present = contextual.isUnionType()
             ? ts
                 .constituentTypes(contextual)
                 .filter((part) => (part.flags & (ts.TypeFlags.Undefined | ts.TypeFlags.Null)) === 0)
             : [contextual];
-        const target = present.length === 1 ? present[0] : undefined;
-        if (target === undefined || target.isIntersectionType())
-            return;
-        if ((target.flags & ts.TypeFlags.TypeParameter) !== 0)
+        if (present.length === 0)
             return;
-        if (!this.isStructuralTarget(target))
+        const union = present.length > 1;
+        if (union && !present.every((part) => this.memberKindDisagrees(part, members)))
             return;
-        const disagrees = members.some((member) => {
+        const targets = [];
+        for (const arm of present) {
+            const found = this.viewTargets(arm, members, union);
+            // An arm that cannot become a view leaves the union native; marking
+            // the other arms alone would not give it checked identity.
+            if (found === null)
+                return;
+            targets.push(...found);
+        }
+        for (const target of targets)
+            add(target);
+    }
+    /** The view targets `target` needs for a literal with these member kinds,
+     * or null when `target` cannot become a view. An intersection needs the
+     * targets of every constituent. A homomorphic mapped view (Partial, Pick,
+     * Omit, Readonly) has no symbol of its own — its symbol is the shared
+     * mapped `__type`, which every mapped type in the program uses — so the
+     * type it maps is the target instead, and `protocol` answers the view
+     * through that marking. `force` targets a union arm that must keep
+     * checked identity even when it agrees with the literal by itself. */
+    viewTargets(target, members, force) {
+        if (target.isIntersectionType()) {
+            const targets = [];
+            for (const part of ts.constituentTypes(target)) {
+                const found = this.viewTargets(part, members, force);
+                if (found === null)
+                    return null;
+                targets.push(...found);
+            }
+            return targets;
+        }
+        if ((target.flags & ts.TypeFlags.TypeParameter) !== 0)
+            return null;
+        const source = this.mappedViewSource(target) ?? target;
+        if (!this.isStructuralTarget(source))
+            return null;
+        if (!force && !this.memberKindDisagrees(target, members))
+            return [];
+        return [source];
+    }
+    /** Whether any of the literal's member kinds disagrees with the member
+     * `target` declares under that name (a missing member never disagrees). */
+    memberKindDisagrees(target, members) {
+        return members.some((member) => {
             const kind = attempt(() => this.memberKind(target, member.name));
             return kind == null ? false : (kind === "accessor") !== member.accessor;
         });
-        if (disagrees)
-            add(target);
+    }
+    /** The structural type a homomorphic mapped VIEW maps — Partial, Pick,
+     * Omit or Readonly over a program type. Mapped types share one `__type`
+     * symbol, so a view is identified through the alias it is spelled with;
+     * program aliases of views (`type A = B`, `type B = Partial<X>`) are
+     * followed through their declarations, and nested views
+     * (`Partial<Omit<X, K>>`) resolve to the type carrying the members.
+     * Null for everything else. */
+    mappedViewSource(type, depth = 0) {
+        if (depth > 8)
+            return null;
+        const alias = type.getAliasSymbol();
+        if (alias === undefined)
+            return null;
+        if (this.isHomomorphicMappedAlias(alias)) {
+            const [source] = type.getAliasTypeArguments();
+            if (source === undefined)
+                return null;
+            return this.mappedViewSource(source, depth + 1) ?? source;
+        }
+        const declaration = this.programTypeAlias(alias);
+        return declaration === null ? null : this.mappedViewSourceNode(declaration.type, depth + 1);
+    }
+    /** mappedViewSource for a view spelled as a type node (a program alias's
+     * declaration, whose resolved type is the alias itself). */
+    mappedViewSourceNode(node, depth) {
+        if (depth > 8)
+            return null;
+        while (ts.isParenthesizedTypeNode(node))
+            node = node.type;
+        if (!ts.isTypeReferenceNode(node))
+            return null;
+        const symbol = attempt(() => this.checker.getSymbolAtLocation(node.typeName));
+        if (symbol === undefined)
+            return null;
+        if (this.isHomomorphicMappedAlias(symbol)) {
+            const sourceNode = node.typeArguments?.nodes[0];
+            if (sourceNode === undefined)
+                return null;
+            const source = attempt(() => this.checker.getTypeFromTypeNode(sourceNode));
+            if (source === undefined)
+                return null;
+            return this.mappedViewSource(source, depth + 1) ?? source;
+        }
+        const declaration = this.programTypeAlias(symbol);
+        return declaration === null ? null : this.mappedViewSourceNode(declaration.type, depth + 1);
+    }
+    /** The lib's homomorphic mapped utility types. */
+    isHomomorphicMappedAlias(symbol) {
+        const name = ts.symbolName(symbol);
+        if (name !== "Pick" && name !== "Omit" && name !== "Partial" && name !== "Readonly")
+            return false;
+        return (symbol.declarations.length > 0 &&
+            symbol.declarations.every((declaration) => declaration.getSourceFile().isDeclarationFile));
     }
     /** The member kind `type` declares at `name` — an accessor (get/set pair)
      * or a data property — or null when it declares no member by that name. */
@@ -207,9 +328,9 @@ export class ClassProtocols {
          * signature's parameter) flows into the declared parameter type. */
         const callbackParams = [];
         const contextual = (expr) => () => this.checker.getContextualType(expr);
-        const flow = (expr) => {
+        const flow = (expr, call) => {
             if (expr !== undefined)
-                sites.push({ source: expr, target: contextual(expr), contextual: expr });
+                sites.push({ source: expr, target: contextual(expr), contextual: expr, call });
         };
         const write = (target) => {
             while (ts.isParenthesizedExpression(target) || ts.isNonNullExpression(target))
@@ -303,7 +424,7 @@ export class ClassProtocols {
         const visit = (node) => {
             observe(node);
             if (ts.isCallExpression(node) || ts.isNewExpression(node))
-                node.arguments?.nodes.forEach(flow);
+                node.arguments?.nodes.forEach((argument, index) => flow(argument, { node, index }));
             else if (ts.isVariableDeclaration(node) && node.type !== undefined)
                 flow(node.initializer);
             else if (ts.isPropertyDeclaration(node) && node.type !== undefined)
@@ -330,7 +451,11 @@ export class ClassProtocols {
                 !ts.isObjectLiteralExpression(node.left) &&
                 !ts.isArrayLiteralExpression(node.left)) {
                 const left = node.left;
-                sites.push({ source: node.right, target: () => this.checker.getTypeAtLocation(left) });
+                sites.push({
+                    source: node.right,
+                    target: () => this.checker.getTypeAtLocation(left),
+                    call: undefined,
+                });
             }
             else if ((ts.isAsExpression(node) || ts.isTypeAssertion(node)) && !accessedInPlace(node)) {
                 const typeNode = node.type;
@@ -338,6 +463,7 @@ export class ClassProtocols {
                     source: node.expression,
                     target: () => this.checker.getTypeFromTypeNode(typeNode),
                     assertion: true,
+                    call: undefined,
                 });
             }
             if (ts.isArrowFunction(node) || ts.isFunctionExpression(node))
@@ -377,6 +503,8 @@ export class ClassProtocols {
             origins: new Map(),
             targets: new Map(),
             flows: new Map(),
+            callSites: new Map(),
+            otherSites: new Set(),
             genericObservers: new Set(),
         };
         const typeOf = (node) => attempt(() => this.checker.getTypeAtLocation(node));
@@ -449,7 +577,7 @@ export class ClassProtocols {
                 const target = attempt(site.target);
                 if (target !== undefined)
                     for (const { classType, view } of attempt(() => this.methodViewSources(target)) ?? []) {
-                        pending.push({ sourceType: classType, target: () => view });
+                        pending.push({ sourceType: classType, target: () => view, call: undefined });
                         const symbol = view.getSymbol();
                         if (symbol !== undefined)
                             methodViews.add(symbol);
@@ -457,8 +585,8 @@ export class ClassProtocols {
                 continue;
             }
             pending.push(site.contextual === undefined
-                ? { sourceType, target: site.target }
-                : { sourceType, target: site.target, contextual: site.contextual });
+                ? { sourceType, target: site.target, call: site.call }
+                : { sourceType, target: site.target, contextual: site.contextual, call: site.call });
         }
         for (const { fn, index, name } of callbackParams) {
             attempt(() => {
@@ -478,6 +606,7 @@ export class ClassProtocols {
                     pending.push({
                         sourceType: this.checker.getTypeOfSymbol(parameter),
                         target: () => declared,
+                        call: undefined,
                     });
                 }
             });
@@ -504,7 +633,7 @@ export class ClassProtocols {
                     targets.set(i, attempt(entry.target));
                 const target = targets.get(i);
                 if (target !== undefined &&
-                    attempt(() => this.markTarget(entry.sourceType, target, marked)) === true)
+                    attempt(() => this.markTarget(entry.sourceType, target, marked, entry.call ?? null, true)) === true)
                     changed = true;
             }
         }
@@ -709,7 +838,11 @@ export class ClassProtocols {
         const writesNames = (written) => written === "all" || [...written].some((name) => names.has(name));
         for (const origin of origins) {
             const written = facts.written.get(origin);
-            if (written !== undefined && writesNames(written))
+            // A field written after construction would be stale in a copy — unless
+            // every value of the view arrives as a call argument the callee reads
+            // and nothing else, where the copy answers the same reads the instance
+            // would (copiedAtEverySite).
+            if (written !== undefined && writesNames(written) && !this.copiedAtEverySite(symbol, facts))
                 return true;
             // An accessor runs on every read of the instance: a copy would keep
             // the value of one call.
@@ -740,6 +873,191 @@ export class ClassProtocols {
                         (declaration.parent !== undefined && facts.genericObservers.has(declaration.parent))));
             }) === true);
     }
+    /** Whether every value of the view arrives as a call argument whose
+     * callee only reads it: then the record copy the boundary builds answers
+     * the same reads the instance itself would, and later writes to the
+     * instance cannot be observed through the view. */
+    copiedAtEverySite(symbol, facts) {
+        if (facts.otherSites.has(symbol))
+            return false;
+        const sites = facts.callSites.get(symbol);
+        if (sites === undefined || sites.length === 0)
+            return false;
+        return sites.every((site) => this.isProgramClassInstance(site.source) && this.copiedArgument(site.node, site.index));
+    }
+    /** Whether argument `index` of `call` can be copied into the parameter's
+     * record: the callee is a program function whose body reads the instance
+     * only through declared fields of primitive type, keeps no reference to
+     * it, and runs no code that could write to it (assignments only to its
+     * own locals, no await or yield, and every call a numeric builtin). */
+    copiedArgument(call, index) {
+        let byIndex = this.copiedArguments.get(call);
+        if (byIndex === undefined) {
+            byIndex = [];
+            this.copiedArguments.set(call, byIndex);
+        }
+        const cached = byIndex[index];
+        if (cached !== undefined)
+            return cached;
+        const answer = attempt(() => this.copiedArgumentNow(call, index)) === true;
+        byIndex[index] = answer;
+        return answer;
+    }
+    copiedArgumentNow(call, index) {
+        const args = call.arguments?.nodes ?? [];
+        if (index >= args.length || args.some((argument) => ts.isSpreadElement(argument)))
+            return false;
+        const signature = this.checker.getResolvedSignature(call);
+        const declaration = signature?.declaration;
+        if (declaration === undefined)
+            return false;
+        if (!ts.isFunctionDeclaration(declaration) &&
+            !ts.isFunctionExpression(declaration) &&
+            !ts.isArrowFunction(declaration))
+            return false;
+        if (declaration.body === undefined)
+            return false;
+        if (!this.fixedCallee(declaration, call))
+            return false;
+        if (declaration.asteriskToken !== undefined)
+            return false;
+        if (declaration.modifiers?.nodes.some((modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword) === true)
+            return false;
+        // Defaults run in the callee's frame, after the arguments, and may write
+        // the instance; a parameter pattern reads members the same way.
+        if (declaration.parameters.nodes.some((parameter) => !ts.isIdentifier(parameter.name) || parameter.initializer !== undefined))
+            return false;
+        const parameter = declaration.parameters.nodes[index];
+        if (parameter === undefined || !ts.isIdentifier(parameter.name))
+            return false;
+        if (parameter.dotDotDotToken !== undefined || parameter.questionToken !== undefined)
+            return false;
+        // Arguments evaluated after this one run while the copy stands: code in
+        // them may write the instance before the callee reads the copy.
+        for (let position = index + 1; position < args.length; position++) {
+            const argument = args[position];
+            if (argument !== undefined && containsProgramCode(argument, this.checker))
+                return false;
+        }
+        return this.readsParameterOnlyFields(declaration, parameter.name.text);
+    }
+    /** Whether the function whose body is inspected is the one this call runs:
+     * the callee is the function itself, the identifier of the function
+     * declaration, or the identifier of the `const` binding that holds it.
+     * A `let` binding, a property, or another binding of the same signature
+     * could run a body this analysis never saw. */
+    fixedCallee(fn, call) {
+        const callee = unwrapExpression(call.expression);
+        if (callee === fn)
+            return true;
+        if (!ts.isIdentifier(callee))
+            return false;
+        const symbol = attempt(() => this.checker.getSymbolAtLocation(callee));
+        if (ts.isFunctionDeclaration(fn))
+            return symbol?.declarations?.some((declaration) => declaration === fn) === true;
+        const parent = fn.parent;
+        const list = parent?.parent;
+        if (!ts.isVariableDeclaration(parent) ||
+            parent.initializer !== fn ||
+            list === undefined ||
+            (list.flags & ts.NodeFlags.Const) === 0)
+            return false;
+        return symbol?.declarations?.some((declaration) => declaration === parent) === true;
+    }
+    /** The body of `declaration` mentions `name` only as the receiver of a
+     * property read whose value is a primitive, and never stores, returns,
+     * passes on or compares the value itself. */
+    readsParameterOnlyFields(declaration, name) {
+        const body = declaration.body;
+        if (body === undefined)
+            return false;
+        const locals = new Set();
+        for (const parameter of declaration.parameters.nodes)
+            if (ts.isIdentifier(parameter.name))
+                locals.add(parameter.name.text);
+        ts.walkPreorder(body, (node) => {
+            if (ts.isFunctionLike(node))
+                return "skip";
+            if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name))
+                locals.add(node.name.text);
+            return undefined;
+        });
+        let ok = true;
+        ts.walkPreorder(body, (node) => {
+            if (!ok)
+                return "stop";
+            if (ts.isTypeNode(node))
+                return "skip";
+            if (ts.isFunctionLike(node)) {
+                // A nested function that mentions the parameter captures the value,
+                // so the copy would be told apart from the instance.
+                if (mentionsBinding(node, name))
+                    ok = false;
+                return "skip";
+            }
+            if (ts.isBinaryExpression(node) &&
+                node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
+                node.operatorToken.kind <= ts.SyntaxKind.LastAssignment) {
+                // Only the body's own locals may be written: a write through any
+                // other value could reach the instance. A compound assignment also
+                // coerces both sides, and a non-primitive operand runs its value
+                // hook.
+                const left = unwrapExpression(node.left);
+                if (!ts.isIdentifier(left) || !locals.has(left.text)) {
+                    ok = false;
+                    return "stop";
+                }
+                if (node.operatorToken.kind !== ts.SyntaxKind.EqualsToken &&
+                    !primitiveOperands(left, node.right, this.checker)) {
+                    ok = false;
+                    return "stop";
+                }
+                return undefined;
+            }
+            if ((ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node)) &&
+                (node.operator === ts.SyntaxKind.PlusPlusToken ||
+                    node.operator === ts.SyntaxKind.MinusMinusToken)) {
+                const operand = unwrapExpression(node.operand);
+                if (!ts.isIdentifier(operand) ||
+                    !locals.has(operand.text) ||
+                    !primitiveNode(operand, this.checker)) {
+                    ok = false;
+                    return "stop";
+                }
+                return undefined;
+            }
+            // Calls, await and yield, element access, accessors, dynamic member
+            // access, iteration and value coercion can all run program code while
+            // the copy is the callee's parameter.
+            if (expressionRunsCode(node, this.checker)) {
+                ok = false;
+                return "stop";
+            }
+            if (ts.isIdentifier(node) && node.text === name) {
+                if (isMemberName(node))
+                    return "skip";
+                const receiver = unwrapExpression(node);
+                const access = receiver.parent;
+                if (access === undefined ||
+                    !ts.isPropertyAccessExpression(access) ||
+                    access.expression !== receiver) {
+                    ok = false;
+                    return "stop";
+                }
+                if (!primitiveValue(this.checker.getTypeAtLocation(access))) {
+                    ok = false;
+                    return "stop";
+                }
+                if (isWrittenAccess(access)) {
+                    ok = false;
+                    return "stop";
+                }
+                return "skip";
+            }
+            return undefined;
+        });
+        return ok;
+    }
     /** Whether one of `names` is a member the collection type itself
      * declares (`has`, `get`, `size`, `keys`, ...). */
     exposesCollectionMember(collection, names) {
@@ -1109,6 +1427,9 @@ export class ClassProtocols {
         // A live Pick or Omit view of a program class holds the instance itself.
         if (this.pickOfProgramClass(type) && this.usesCheckedIdentity(type))
             return true;
+        // A homomorphic mapped view of a marked type is the live view itself.
+        if (this.mappedViewSource(type) !== null && this.protocol(type))
+            return true;
         const symbol = type.getSymbol();
         if (symbol === undefined)
             return false;
@@ -1141,11 +1462,12 @@ export class ClassProtocols {
     }
     /** Marks the structural parts of `target` that the identity-carrying
      * parts of `source` flow into. Answers whether anything new was marked. */
-    markTarget(source, target, marked) {
+    markTarget(source, target, marked, site, record) {
         if (source.isUnionType()) {
             let changed = false;
             for (const part of ts.constituentTypes(source))
-                if (this.carriesIdentity(part, marked) && this.markTarget(part, target, marked))
+                if (this.carriesIdentity(part, marked) &&
+                    this.markTarget(part, target, marked, site, false))
                     changed = true;
             return changed;
         }
@@ -1167,14 +1489,14 @@ export class ClassProtocols {
             }
             let changed = false;
             for (const part of accepting)
-                if (this.markTarget(source, part, marked))
+                if (this.markTarget(source, part, marked, site, false))
                     changed = true;
             return changed;
         }
         if (this.checker.isArrayType(source) && this.checker.isArrayType(target)) {
             const [from] = this.checker.getTypeArguments(source);
             const [to] = this.checker.getTypeArguments(target);
-            return from !== undefined && to !== undefined && this.markTarget(from, to, marked);
+            return (from !== undefined && to !== undefined && this.markTarget(from, to, marked, site, false));
         }
         if (!this.isStructuralTarget(target))
             return false;
@@ -1214,6 +1536,19 @@ export class ClassProtocols {
                 facts.flows.set(from, flows);
             }
         }
+        if (facts !== null) {
+            // Every top-level site that reaches this view is remembered: a view
+            // whose values only ever arrive as a call argument the callee reads can
+            // keep the record shape its type declares (copiedAtEverySite).
+            if (site === null || !record)
+                facts.otherSites.add(symbol);
+            else {
+                const recorded = facts.callSites.get(symbol) ?? [];
+                if (!recorded.some((entry) => entry.node === site.node && entry.index === site.index))
+                    recorded.push({ node: site.node, index: site.index, source });
+                facts.callSites.set(symbol, recorded);
+            }
+        }
         // A view marked earlier that becomes a collection view still changes
         // the fixpoint: the views its values flow into are asked again.
         if (marked.has(symbol))
@@ -1267,6 +1602,17 @@ export class ClassProtocols {
         const properties = this.checker.getPropertiesOfType(type);
         if (symbol && protocols.has(symbol))
             return true;
+        // A mapped view whose source cannot carry the marking was recorded
+        // itself (index): the receiver-dependent literal typed as it needs the
+        // live object, and no other view of that source does.
+        if (this.literalViews.has(type))
+            return true;
+        // A homomorphic mapped view (Partial, Pick, Omit, Readonly) has no
+        // symbol of its own to mark, so it is a view exactly when the type it
+        // maps is one.
+        const mapped = this.mappedViewSource(type);
+        if (mapped !== null && this.protocol(mapped))
+            return true;
         if (!this.pickOfProgramClass(type) &&
             (!symbol ||
                 !symbol.declarations.some((declaration) => ts.isInterfaceDeclaration(declaration) &&
@@ -1436,6 +1782,227 @@ function attempt(query) {
         return undefined;
     }
 }
+/** Ground numeric calls: they cannot run program code, so a callee that
+ * only uses them cannot observe a write to an instance it was handed. */
+const PURE_CALLS = new Set(["parseInt", "parseFloat", "isNaN", "isFinite"]);
+/** The identifier names a member (`o.value`), not the binding `o`. */
+function isMemberName(node) {
+    const parent = node.parent;
+    if (parent === undefined || ts.isShorthandPropertyAssignment(parent))
+        return false;
+    if (parent.name === node)
+        return true;
+    return ts.isBindingElement(parent) && parent.propertyName === node;
+}
+/** The node with parentheses, non-null assertions and type assertions
+ * peeled off. */
+function unwrapExpression(node) {
+    let outer = node;
+    for (;;) {
+        const parent = outer.parent;
+        if (parent === undefined)
+            return outer;
+        if (!ts.isParenthesizedExpression(parent) &&
+            !ts.isNonNullExpression(parent) &&
+            !ts.isAssertionExpression(parent))
+            return outer;
+        outer = parent;
+    }
+}
+/** A number, string, boolean, bigint, null or undefined (or a union of
+ * them): a value a record copy carries by value. */
+function primitiveValue(type) {
+    if (type.isUnionType())
+        return ts.constituentTypes(type).every(primitiveValue);
+    return ((type.flags &
+        (ts.TypeFlags.Number |
+            ts.TypeFlags.NumberLiteral |
+            ts.TypeFlags.String |
+            ts.TypeFlags.StringLiteral |
+            ts.TypeFlags.Boolean |
+            ts.TypeFlags.BooleanLiteral |
+            ts.TypeFlags.BigInt |
+            ts.TypeFlags.BigIntLiteral |
+            ts.TypeFlags.Null |
+            ts.TypeFlags.Undefined)) !==
+        0);
+}
+/** Whether the property read `access` is assigned, updated or deleted. */
+function isWrittenAccess(access) {
+    let outer = access;
+    for (;;) {
+        const parent = outer.parent;
+        if (parent !== undefined &&
+            (ts.isParenthesizedExpression(parent) || ts.isNonNullExpression(parent))) {
+            outer = parent;
+            continue;
+        }
+        if (parent === undefined)
+            return false;
+        if (ts.isBinaryExpression(parent))
+            return (parent.left === outer &&
+                parent.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
+                parent.operatorToken.kind <= ts.SyntaxKind.LastAssignment);
+        if (ts.isPrefixUnaryExpression(parent) || ts.isPostfixUnaryExpression(parent))
+            return parent.operand === outer;
+        return ts.isDeleteExpression(parent);
+    }
+}
+/** Whether `call` is one of the calls a copying callee may make: a numeric
+ * builtin or console printer the program does not shadow, over values of
+ * primitive type only (a coercion runs no hook on them). */
+function pureCall(call, checker) {
+    const callee = call.expression;
+    const global = (node) => libSymbol(attempt(() => checker.getSymbolAtLocation(node)));
+    if (ts.isIdentifier(callee)) {
+        if (!PURE_CALLS.has(callee.text) || !global(callee))
+            return false;
+    }
+    else if (ts.isPropertyAccessExpression(callee) && ts.isIdentifier(callee.expression)) {
+        const owner = callee.expression.text;
+        if (owner !== "Math" && owner !== "Number" && owner !== "console")
+            return false;
+        if (!global(callee.expression) || !global(callee.name))
+            return false;
+    }
+    else
+        return false;
+    const args = call.arguments?.nodes ?? [];
+    return args.every((argument) => {
+        if (ts.isSpreadElement(argument))
+            return false;
+        const type = attempt(() => checker.getTypeAtLocation(argument));
+        return type !== undefined && primitiveValue(type);
+    });
+}
+/** Whether every declaration of `symbol` is in a declaration file: the
+ * binding is the library's own, not one the program shadows it with. */
+function libSymbol(symbol) {
+    const declarations = symbol?.declarations;
+    return (declarations !== undefined &&
+        declarations.length > 0 &&
+        declarations.every((declaration) => declaration.getSourceFile().isDeclarationFile));
+}
+/** Whether evaluating `node` can run program code — a call, a constructor, a
+ * getter or a dynamic member read, an iterator, a coercion hook — and so
+ * write an instance a copy was made of. */
+function expressionRunsCode(node, checker) {
+    if (ts.isCallExpression(node))
+        return !pureCall(node, checker);
+    if (ts.isNewExpression(node))
+        return true;
+    if (ts.isElementAccessExpression(node))
+        return true;
+    if (ts.isPropertyAccessExpression(node))
+        return accessRunsCode(node, checker);
+    if (ts.isTemplateExpression(node)) {
+        for (const span of node.templateSpans.nodes)
+            if (!primitiveNode(span.expression, checker))
+                return true;
+        return false;
+    }
+    if (ts.isBinaryExpression(node)) {
+        const operator = node.operatorToken.kind;
+        if (operator === ts.SyntaxKind.InstanceOfKeyword)
+            return true;
+        if (operator >= ts.SyntaxKind.FirstAssignment && operator <= ts.SyntaxKind.LastAssignment)
+            return true;
+        return !primitiveOperands(node.left, node.right, checker);
+    }
+    if (ts.isPrefixUnaryExpression(node)) {
+        const operator = node.operator;
+        if (operator === ts.SyntaxKind.PlusPlusToken || operator === ts.SyntaxKind.MinusMinusToken)
+            return true;
+        if (operator !== ts.SyntaxKind.PlusToken &&
+            operator !== ts.SyntaxKind.MinusToken &&
+            operator !== ts.SyntaxKind.TildeToken)
+            return false;
+        return !primitiveNode(node.operand, checker);
+    }
+    if (ts.isPostfixUnaryExpression(node))
+        return true;
+    if (ts.isDeleteExpression(node) || ts.isAwaitExpression(node) || ts.isYieldExpression(node))
+        return true;
+    if (ts.isTaggedTemplateExpression(node))
+        return true;
+    if (ts.isForOfStatement(node))
+        return true;
+    if (ts.isSpreadElement(node) || ts.isSpreadAssignment(node))
+        return true;
+    return false;
+}
+/** Whether reading `access` can run program code: a getter, or a member of
+ * a value the analysis knows nothing static about. */
+function accessRunsCode(access, checker) {
+    const symbol = attempt(() => checker.getSymbolAtLocation(access.name));
+    if (symbol === undefined)
+        return true;
+    if ((symbol.flags & (ts.SymbolFlags.GetAccessor | ts.SymbolFlags.SetAccessor)) !== 0)
+        return true;
+    const receiver = valueType(access.expression, checker);
+    if (receiver === undefined)
+        return true;
+    return ((receiver.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.TypeParameter)) !== 0);
+}
+/** Whether both operand types are primitive, so an operator between them
+ * runs no value coercion. */
+function primitiveOperands(left, right, checker) {
+    return primitiveNode(left, checker) && primitiveNode(right, checker);
+}
+/** The type of `node`'s value, ignoring parentheses, non-null assertions and
+ * type assertions: a cast does not change what the value is at run time. */
+function valueType(node, checker) {
+    let current = node;
+    while (ts.isParenthesizedExpression(current) ||
+        ts.isNonNullExpression(current) ||
+        ts.isAssertionExpression(current))
+        current = current.expression;
+    return attempt(() => checker.getTypeAtLocation(current));
+}
+/** Whether the value of `node` has a primitive type, so coercing it runs no
+ * value hook. */
+function primitiveNode(node, checker) {
+    const type = valueType(node, checker);
+    return type !== undefined && primitiveValue(type);
+}
+/** Whether `root` contains an expression that runs program code. */
+function containsProgramCode(root, checker) {
+    let runs = false;
+    ts.walkPreorder(root, (node) => {
+        if (runs)
+            return "stop";
+        if (ts.isTypeNode(node))
+            return "skip";
+        if (ts.isFunctionLike(node))
+            return "skip";
+        // A class body's computed keys and static fields run when the class is
+        // evaluated.
+        if (ts.isClassDeclaration(node) || ts.isClassExpression(node)) {
+            runs = true;
+            return "stop";
+        }
+        if (expressionRunsCode(node, checker)) {
+            runs = true;
+            return "stop";
+        }
+        return undefined;
+    });
+    return runs;
+}
+/** Whether `node` mentions the binding `name`. */
+function mentionsBinding(node, name) {
+    let found = false;
+    ts.walkPreorder(node, (child) => {
+        if (found)
+            return "stop";
+        if (ts.isIdentifier(child) && child.text === name && !isMemberName(child)) {
+            found = true;
+            return "stop";
+        }
+        return undefined;
+    });
+    return found;
+}
 /** The static property name a member declares, or null for a computed key
  * (its name is not a compile-time fact). */
 function propertyNameText(name) {