@saptools/service-flow 0.1.66 → 0.1.68

package/src/parsers/016-local-symbol-reference.ts

@@ -0,0 +1,261 @@
+import ts from 'typescript';
+import type { ExecutableSymbolFact } from '../types.js';
+import {
+  lexicalIdentifierDeclaration,
+  lexicalIdentifierDeclarations,
+} from './002-symbol-import-bindings.js';
+import { stableLocalValueReference } from './020-stable-local-value.js';
+
+export interface LocalSymbolTargetIdentity {
+  sourceFile: string;
+  qualifiedName: string;
+  startOffset: number;
+  endOffset: number;
+}
+
+function functionTargetNode(
+  declaration: ts.Identifier,
+): ts.Node | undefined {
+  const parent = declaration.parent;
+  if (ts.isFunctionDeclaration(parent)) return parent;
+  if (!ts.isVariableDeclaration(parent)) return undefined;
+  const initializer = parent.initializer;
+  return initializer
+    && (ts.isArrowFunction(initializer)
+      || ts.isFunctionExpression(initializer))
+    ? initializer
+    : undefined;
+}
+
+function declarationKey(identifier: ts.Identifier): string {
+  return `${identifier.getStart(identifier.getSourceFile())}:${identifier.getEnd()}`;
+}
+
+function unwrapAssignmentTarget(expression: ts.Expression): ts.Expression {
+  if (ts.isParenthesizedExpression(expression)
+    || ts.isAsExpression(expression)
+    || ts.isSatisfiesExpression(expression)
+    || ts.isTypeAssertionExpression(expression)
+    || ts.isNonNullExpression(expression))
+    return unwrapAssignmentTarget(expression.expression);
+  return expression;
+}
+
+function objectAssignmentTargets(
+  expression: ts.ObjectLiteralExpression,
+): ts.Identifier[] {
+  return expression.properties.flatMap((property) => {
+    if (ts.isShorthandPropertyAssignment(property)) return [property.name];
+    if (ts.isPropertyAssignment(property))
+      return assignmentTargets(property.initializer);
+    return ts.isSpreadAssignment(property)
+      ? assignmentTargets(property.expression) : [];
+  });
+}
+
+function assignmentTargets(expression: ts.Expression): ts.Identifier[] {
+  const target = unwrapAssignmentTarget(expression);
+  if (ts.isIdentifier(target)) return [target];
+  if (ts.isSpreadElement(target))
+    return assignmentTargets(target.expression);
+  if (ts.isBinaryExpression(target)
+    && target.operatorToken.kind === ts.SyntaxKind.EqualsToken)
+    return assignmentTargets(target.left);
+  if (ts.isArrayLiteralExpression(target))
+    return target.elements.flatMap((item) =>
+      ts.isExpression(item) ? assignmentTargets(item) : []);
+  return ts.isObjectLiteralExpression(target)
+    ? objectAssignmentTargets(target) : [];
+}
+
+function assignmentOperator(kind: ts.SyntaxKind): boolean {
+  return kind >= ts.SyntaxKind.FirstAssignment
+    && kind <= ts.SyntaxKind.LastAssignment;
+}
+
+function mutationUnary(
+  node: ts.PrefixUnaryExpression | ts.PostfixUnaryExpression,
+): boolean {
+  return node.operator === ts.SyntaxKind.PlusPlusToken
+    || node.operator === ts.SyntaxKind.MinusMinusToken;
+}
+
+type DeclarationMatcher = (identifier: ts.Identifier) => boolean;
+
+function binaryWritesDeclaration(
+  node: ts.Node,
+  matches: DeclarationMatcher,
+): boolean {
+  if (!ts.isBinaryExpression(node)
+    || !assignmentOperator(node.operatorToken.kind)) return false;
+  return assignmentTargets(node.left).some(matches);
+}
+
+function unaryWritesDeclaration(
+  node: ts.Node,
+  matches: DeclarationMatcher,
+): boolean {
+  if (!ts.isPrefixUnaryExpression(node)
+    && !ts.isPostfixUnaryExpression(node)) return false;
+  return mutationUnary(node)
+    && ts.isIdentifier(node.operand)
+    && matches(node.operand);
+}
+
+function loopWritesDeclaration(
+  node: ts.Node,
+  matches: DeclarationMatcher,
+): boolean {
+  if (!ts.isForInStatement(node) && !ts.isForOfStatement(node)) return false;
+  return !ts.isVariableDeclarationList(node.initializer)
+    && assignmentTargets(node.initializer).some(matches);
+}
+
+function declarationWritten(
+  source: ts.SourceFile,
+  declarations: readonly ts.Identifier[],
+): boolean {
+  const keys = new Set(declarations.map(declarationKey));
+  let written = false;
+  const matches = (identifier: ts.Identifier): boolean =>
+    lexicalIdentifierDeclarations(identifier)
+      .some((item) => keys.has(declarationKey(item)));
+  const visit = (node: ts.Node): void => {
+    if (written) return;
+    written = binaryWritesDeclaration(node, matches)
+      || unaryWritesDeclaration(node, matches)
+      || loopWritesDeclaration(node, matches);
+    if (!written) ts.forEachChild(node, visit);
+  };
+  visit(source);
+  return written;
+}
+
+function singleImmutableDeclaration(
+  declaration: ts.Identifier | undefined,
+): boolean {
+  const parent = declaration?.parent;
+  if (parent && ts.isClassDeclaration(parent)) return true;
+  return Boolean(parent && ts.isVariableDeclaration(parent)
+    && ts.isVariableDeclarationList(parent.parent)
+    && (parent.parent.flags & ts.NodeFlags.Const) !== 0);
+}
+
+function immutableDeclarationSet(
+  declarations: readonly ts.Identifier[],
+  source: ts.SourceFile,
+): boolean {
+  if (declarations.length === 0
+    || declarationWritten(source, declarations)) return false;
+  if (declarations.every((item) => ts.isFunctionDeclaration(item.parent)))
+    return true;
+  if (declarations.length !== 1) return false;
+  return singleImmutableDeclaration(declarations[0]);
+}
+
+function propertyContainer(
+  declaration: ts.Identifier,
+): ts.Node | undefined {
+  const parent = declaration.parent;
+  if (ts.isClassDeclaration(parent)) return parent;
+  if (!ts.isVariableDeclaration(parent)) return undefined;
+  const initializer = parent.initializer;
+  return initializer
+    && (ts.isObjectLiteralExpression(initializer)
+      || ts.isClassExpression(initializer))
+    ? initializer
+    : undefined;
+}
+
+function identity(
+  symbol: ExecutableSymbolFact,
+): LocalSymbolTargetIdentity {
+  return {
+    sourceFile: symbol.sourceFile,
+    qualifiedName: symbol.qualifiedName,
+    startOffset: symbol.startOffset,
+    endOffset: symbol.endOffset,
+  };
+}
+
+function executableBody(symbol: ExecutableSymbolFact): boolean {
+  const value = symbol.importExportEvidence?.executableBodyEligibility;
+  return Boolean(value && typeof value === 'object'
+    && !Array.isArray(value)
+    && 'eligible' in value
+    && value.eligible === true);
+}
+
+function exactFunctionTarget(
+  declarations: readonly ts.Identifier[],
+  symbols: readonly ExecutableSymbolFact[],
+  source: ts.SourceFile,
+): LocalSymbolTargetIdentity | undefined {
+  if (!immutableDeclarationSet(declarations, source)) return undefined;
+  const spans = declarations.flatMap((declaration) => {
+    const target = functionTargetNode(declaration);
+    return target
+      ? [{ start: target.getStart(source), end: target.getEnd() }]
+      : [];
+  });
+  const matches = symbols.filter((symbol) =>
+    localFunctionMatches(symbol, spans, source.fileName));
+  return matches.length === 1 && matches[0]
+    ? identity(matches[0])
+    : undefined;
+}
+
+function localFunctionMatches(
+  symbol: ExecutableSymbolFact,
+  spans: readonly { start: number; end: number }[],
+  sourceFile: string,
+): boolean {
+  if (symbol.sourceFile !== sourceFile || !executableBody(symbol))
+    return false;
+  return spans.some((span) =>
+    symbol.startOffset === span.start && symbol.endOffset === span.end);
+}
+
+function exactPropertyTarget(
+  expression: ts.PropertyAccessExpression,
+  declaration: ts.Identifier,
+  symbols: readonly ExecutableSymbolFact[],
+  source: ts.SourceFile,
+): LocalSymbolTargetIdentity | undefined {
+  if (!immutableDeclarationSet([declaration], source)
+    || !stableLocalValueReference(source, declaration))
+    return undefined;
+  const container = propertyContainer(declaration);
+  if (!container) return undefined;
+  const qualifiedName = `${declaration.text}.${expression.name.text}`;
+  const start = container.getStart(source);
+  const end = container.getEnd();
+  const matches = symbols.filter((symbol) =>
+    symbol.sourceFile === source.fileName
+    && symbol.qualifiedName === qualifiedName
+    && symbol.startOffset >= start
+    && symbol.endOffset <= end
+    && executableBody(symbol));
+  return matches.length === 1 && matches[0]
+    ? identity(matches[0])
+    : undefined;
+}
+
+export function localSymbolTarget(
+  expression: ts.Expression,
+  source: ts.SourceFile,
+  symbols: readonly ExecutableSymbolFact[],
+): LocalSymbolTargetIdentity | undefined {
+  if (ts.isIdentifier(expression)) {
+    return exactFunctionTarget(
+      lexicalIdentifierDeclarations(expression), symbols, source,
+    );
+  }
+  if (!ts.isPropertyAccessExpression(expression)
+    || expression.questionDotToken
+    || !ts.isIdentifier(expression.expression)) return undefined;
+  const declaration = lexicalIdentifierDeclaration(expression.expression);
+  return declaration
+    ? exactPropertyTarget(expression, declaration, symbols, source)
+    : undefined;
+}

package/src/parsers/017-symbol-derived-contexts.ts

@@ -0,0 +1,268 @@
+import ts from 'typescript';
+import {
+  symbolCallName,
+  type SymbolCallProxy,
+  type SymbolClassInstance,
+} from './009-symbol-call-facts.js';
+import {
+  identifierMatchesDeclaration,
+  symbolImportReference,
+  type SymbolImportBinding,
+} from './002-symbol-import-bindings.js';
+
+interface DerivedContextCollection {
+  source: ts.SourceFile;
+  importBindings: readonly SymbolImportBinding[];
+  declaredClasses: ReadonlySet<string>;
+  proxies: Map<string, SymbolCallProxy[]>;
+  instances: Map<string, SymbolClassInstance[]>;
+}
+
+const builtInConstructors = new Set([
+  'Set', 'Map', 'WeakSet', 'WeakMap',
+  'Date', 'RegExp', 'URL', 'URLSearchParams',
+  'Error', 'EvalError', 'RangeError', 'ReferenceError', 'SyntaxError',
+  'TypeError', 'URIError', 'AggregateError',
+  'ArrayBuffer', 'SharedArrayBuffer', 'DataView',
+  'Int8Array', 'Uint8Array', 'Uint8ClampedArray', 'Int16Array',
+  'Uint16Array', 'Int32Array', 'Uint32Array', 'Float32Array',
+  'Float64Array', 'BigInt64Array', 'BigUint64Array',
+  'Promise', 'AbortController',
+]);
+
+function appendNamed<T>(
+  values: Map<string, T[]>,
+  name: string,
+  value: T,
+): void {
+  const matches = values.get(name) ?? [];
+  matches.push(value);
+  values.set(name, matches);
+}
+
+function assignmentOperator(kind: ts.SyntaxKind): boolean {
+  return kind >= ts.SyntaxKind.FirstAssignment
+    && kind <= ts.SyntaxKind.LastAssignment;
+}
+
+function mutationUnary(
+  node: ts.PrefixUnaryExpression | ts.PostfixUnaryExpression,
+): boolean {
+  return node.operator === ts.SyntaxKind.PlusPlusToken
+    || node.operator === ts.SyntaxKind.MinusMinusToken;
+}
+
+function receiverIdentifier(
+  expression: ts.Expression,
+): ts.Identifier | undefined {
+  let current = expression;
+  while (ts.isPropertyAccessExpression(current)
+    || ts.isElementAccessExpression(current))
+    current = current.expression;
+  return ts.isIdentifier(current) ? current : undefined;
+}
+
+function nodeWritesMember(
+  node: ts.Node,
+  matches: (expression: ts.Expression) => boolean,
+): boolean {
+  if (ts.isBinaryExpression(node))
+    return assignmentOperator(node.operatorToken.kind) && matches(node.left);
+  if (ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node))
+    return mutationUnary(node) && matches(node.operand);
+  return ts.isDeleteExpression(node) && matches(node.expression);
+}
+
+function memberWrite(
+  source: ts.SourceFile,
+  declaration: ts.Identifier,
+): boolean {
+  const start = declaration.getStart(source);
+  const end = declaration.getEnd();
+  const matches = (expression: ts.Expression): boolean => {
+    const receiver = receiverIdentifier(expression);
+    return Boolean(receiver && receiver !== expression
+      && identifierMatchesDeclaration(receiver, start, end));
+  };
+  let written = false;
+  const visit = (node: ts.Node): void => {
+    if (written) return;
+    written = nodeWritesMember(node, matches);
+    if (!written) ts.forEachChild(node, visit);
+  };
+  visit(source);
+  return written;
+}
+
+function stableVariable(
+  collection: DerivedContextCollection,
+  node: ts.VariableDeclaration,
+): node is ts.VariableDeclaration & { name: ts.Identifier } {
+  return ts.isIdentifier(node.name)
+    && ts.isVariableDeclarationList(node.parent)
+    && (node.parent.flags & ts.NodeFlags.Const) !== 0
+    && !memberWrite(collection.source, node.name);
+}
+
+function collectProxy(
+  collection: DerivedContextCollection,
+  node: ts.Node,
+): void {
+  if (!ts.isVariableDeclaration(node) || !stableVariable(collection, node)
+    || !node.initializer || !ts.isCallExpression(node.initializer)
+    || !ts.isPropertyAccessExpression(node.initializer.expression)) return;
+  const callee = symbolCallName(node.initializer.expression);
+  const binding = symbolImportReference(
+    node.initializer.expression, collection.importBindings,
+  );
+  if (!callee.member || !binding) return;
+  appendNamed(collection.proxies, node.name.text, {
+    importSource: binding.rawModuleSpecifier,
+    importBinding: binding,
+    factory: callee.expression,
+    variableName: node.name.text,
+    declarationStartOffset: node.name.getStart(collection.source),
+    declarationEndOffset: node.name.getEnd(),
+  });
+}
+
+function propertyContainer(
+  declaration: ts.Identifier | ts.PropertyName,
+  propertyName: string | undefined,
+): ts.ClassLikeDeclaration | undefined {
+  const property = propertyName && ts.isPropertyDeclaration(declaration.parent)
+    ? declaration.parent : undefined;
+  return property && ts.isClassLike(property.parent)
+    ? property.parent : undefined;
+}
+
+function eligibleClassName(
+  collection: DerivedContextCollection,
+  className: string,
+  imported: ReturnType<typeof symbolImportReference>,
+): boolean {
+  if (builtInConstructors.has(className)) return false;
+  return Boolean(imported || collection.declaredClasses.has(className));
+}
+
+function resolvedClassName(
+  className: string,
+  imported: ReturnType<typeof symbolImportReference>,
+): string {
+  const importedName = imported?.importedName;
+  return importedName && importedName !== 'default'
+    ? importedName : className;
+}
+
+function rememberInstance(
+  collection: DerivedContextCollection,
+  declaration: ts.Identifier | ts.PropertyName,
+  classExpression: ts.Identifier,
+  propertyName?: string,
+): void {
+  const className = classExpression.text;
+  const imported = symbolImportReference(
+    classExpression, collection.importBindings,
+  );
+  if (!eligibleClassName(collection, className, imported)) return;
+  const container = propertyContainer(declaration, propertyName);
+  const variableName = propertyName
+    ? `this.${propertyName}` : declaration.getText();
+  appendNamed(collection.instances, variableName, {
+    className: resolvedClassName(className, imported),
+    importSource: imported?.rawModuleSpecifier,
+    importBinding: imported,
+    propertyName,
+    declarationStartOffset: declaration.getStart(collection.source),
+    declarationEndOffset: declaration.getEnd(),
+    containerStartOffset: container?.getStart(collection.source),
+    containerEndOffset: container?.getEnd(),
+  });
+}
+
+function collectVariableInstance(
+  collection: DerivedContextCollection,
+  node: ts.Node,
+): void {
+  if (!ts.isVariableDeclaration(node) || !stableVariable(collection, node))
+    return;
+  const initializer = node.initializer;
+  if (initializer && ts.isNewExpression(initializer)
+    && ts.isIdentifier(initializer.expression))
+    rememberInstance(collection, node.name, initializer.expression);
+}
+
+function propertyName(name: ts.PropertyName): string | undefined {
+  return ts.isIdentifier(name) || ts.isStringLiteralLike(name)
+    || ts.isNumericLiteral(name) ? name.text : undefined;
+}
+
+function thisPropertyWrite(
+  expression: ts.Expression,
+  name: string,
+): boolean {
+  if (ts.isPropertyAccessExpression(expression))
+    return expression.expression.kind === ts.SyntaxKind.ThisKeyword
+      && expression.name.text === name;
+  return ts.isElementAccessExpression(expression)
+    && expression.expression.kind === ts.SyntaxKind.ThisKeyword
+    && Boolean(expression.argumentExpression
+      && ts.isStringLiteralLike(expression.argumentExpression)
+      && expression.argumentExpression.text === name);
+}
+
+function nodeWritesThisProperty(
+  node: ts.Node,
+  name: string,
+): boolean {
+  if (ts.isBinaryExpression(node))
+    return assignmentOperator(node.operatorToken.kind)
+      && thisPropertyWrite(node.left, name);
+  if (ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node))
+    return mutationUnary(node) && thisPropertyWrite(node.operand, name);
+  return ts.isDeleteExpression(node)
+    && thisPropertyWrite(node.expression, name);
+}
+
+function stableProperty(
+  node: ts.PropertyDeclaration,
+  name: string,
+): boolean {
+  const flags = ts.getCombinedModifierFlags(node);
+  if ((flags & (ts.ModifierFlags.Private | ts.ModifierFlags.Readonly)) === 0
+    || !ts.isClassLike(node.parent)) return false;
+  let written = false;
+  const visit = (child: ts.Node): void => {
+    if (written || child === node) return;
+    written = nodeWritesThisProperty(child, name);
+    if (!written) ts.forEachChild(child, visit);
+  };
+  visit(node.parent);
+  return !written;
+}
+
+function collectPropertyInstance(
+  collection: DerivedContextCollection,
+  node: ts.Node,
+): void {
+  if (!ts.isPropertyDeclaration(node)) return;
+  const initializer = node.initializer;
+  if (!initializer || !ts.isNewExpression(initializer)
+    || !ts.isIdentifier(initializer.expression)) return;
+  const name = propertyName(node.name);
+  if (name && stableProperty(node, name)) rememberInstance(
+    collection, node.name, initializer.expression, name,
+  );
+}
+
+export function collectDerivedSymbolContexts(
+  collection: DerivedContextCollection,
+): void {
+  const visit = (node: ts.Node): void => {
+    collectProxy(collection, node);
+    collectVariableInstance(collection, node);
+    collectPropertyInstance(collection, node);
+    ts.forEachChild(node, visit);
+  };
+  visit(collection.source);
+}

package/src/parsers/018-package-commonjs-syntax.ts

@@ -0,0 +1,142 @@
+import ts from 'typescript';
+import {
+  lexicalIdentifierDeclarations,
+} from './002-symbol-import-bindings.js';
+
+interface AccessPath {
+  root: ts.Identifier;
+  members: Array<string | null>;
+}
+
+function unwrap(expression: ts.Expression): ts.Expression {
+  if (ts.isParenthesizedExpression(expression)
+    || ts.isAsExpression(expression)
+    || ts.isSatisfiesExpression(expression)
+    || ts.isTypeAssertionExpression(expression)
+    || ts.isNonNullExpression(expression))
+    return unwrap(expression.expression);
+  return expression;
+}
+
+function accessPath(expression: ts.Expression): AccessPath | undefined {
+  const value = unwrap(expression);
+  if (ts.isIdentifier(value)) return { root: value, members: [] };
+  if (ts.isPropertyAccessExpression(value)) {
+    const parent = accessPath(value.expression);
+    return parent
+      ? { root: parent.root, members: [...parent.members, value.name.text] }
+      : undefined;
+  }
+  if (!ts.isElementAccessExpression(value)) return undefined;
+  const parent = accessPath(value.expression);
+  if (!parent) return undefined;
+  const argument = value.argumentExpression;
+  const member = argument && (ts.isStringLiteralLike(argument)
+    || ts.isNumericLiteral(argument)) ? argument.text : null;
+  return { root: parent.root, members: [...parent.members, member] };
+}
+
+export function isUnshadowedCommonJsExportExpression(
+  expression: ts.Expression,
+): boolean {
+  const path = accessPath(expression);
+  if (!path || lexicalIdentifierDeclarations(path.root).length > 0)
+    return false;
+  if (path.root.text === 'exports') return true;
+  return path.root.text === 'module'
+    && path.members.length > 0
+    && (path.members[0] === 'exports' || path.members[0] === null);
+}
+
+function writeTargetContainsExport(expression: ts.Expression): boolean {
+  const target = unwrap(expression);
+  if (isUnshadowedCommonJsExportExpression(target)) return true;
+  if (ts.isSpreadElement(target))
+    return writeTargetContainsExport(target.expression);
+  if (ts.isBinaryExpression(target)
+    && target.operatorToken.kind === ts.SyntaxKind.EqualsToken)
+    return writeTargetContainsExport(target.left);
+  if (ts.isArrayLiteralExpression(target))
+    return target.elements.some((item) =>
+      !ts.isOmittedExpression(item) && writeTargetContainsExport(item));
+  if (!ts.isObjectLiteralExpression(target)) return false;
+  return target.properties.some((property) => {
+    if (ts.isShorthandPropertyAssignment(property))
+      return isUnshadowedCommonJsExportExpression(property.name);
+    if (ts.isSpreadAssignment(property))
+      return writeTargetContainsExport(property.expression);
+    return ts.isPropertyAssignment(property)
+      && writeTargetContainsExport(property.initializer);
+  });
+}
+
+function isAssignmentOperator(kind: ts.SyntaxKind): boolean {
+  return kind >= ts.SyntaxKind.FirstAssignment
+    && kind <= ts.SyntaxKind.LastAssignment;
+}
+
+export function unsupportedCommonJsMutation(
+  statement: ts.ExpressionStatement,
+): boolean {
+  const expression = statement.expression;
+  if (ts.isBinaryExpression(expression)
+    && isAssignmentOperator(expression.operatorToken.kind))
+    return expression.operatorToken.kind !== ts.SyntaxKind.EqualsToken
+      ? writeTargetContainsExport(expression.left)
+      : !isUnshadowedCommonJsExportExpression(expression.left)
+        && writeTargetContainsExport(expression.left);
+  if (ts.isDeleteExpression(expression))
+    return writeTargetContainsExport(expression.expression);
+  if (ts.isPrefixUnaryExpression(expression)
+    || ts.isPostfixUnaryExpression(expression))
+    return writeTargetContainsExport(expression.operand);
+  return ts.isCallExpression(expression)
+    && expression.arguments.some(writeTargetContainsExport);
+}
+
+function topLevelDirectAssignment(node: ts.BinaryExpression): boolean {
+  return node.operatorToken.kind === ts.SyntaxKind.EqualsToken
+    && isUnshadowedCommonJsExportExpression(node.left)
+    && ts.isExpressionStatement(node.parent)
+    && ts.isSourceFile(node.parent.parent);
+}
+
+function unsupportedBinaryNode(node: ts.Node): boolean {
+  return ts.isBinaryExpression(node)
+    && isAssignmentOperator(node.operatorToken.kind)
+    && writeTargetContainsExport(node.left)
+    && !topLevelDirectAssignment(node);
+}
+
+function unsupportedMutationNode(node: ts.Node): boolean {
+  if (ts.isDeleteExpression(node))
+    return writeTargetContainsExport(node.expression);
+  if (ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node))
+    return writeTargetContainsExport(node.operand);
+  return ts.isCallExpression(node)
+    && node.arguments.some(writeTargetContainsExport);
+}
+
+function unsupportedLoopNode(node: ts.Node): boolean {
+  if (!ts.isForInStatement(node) && !ts.isForOfStatement(node))
+    return false;
+  return !ts.isVariableDeclarationList(node.initializer)
+    && writeTargetContainsExport(node.initializer);
+}
+
+function unsupportedCommonJsNode(node: ts.Node): boolean {
+  return unsupportedBinaryNode(node)
+    || unsupportedMutationNode(node)
+    || unsupportedLoopNode(node);
+}
+
+export function hasNestedCommonJsMutation(source: ts.SourceFile): boolean {
+  let unsupported = false;
+  const visit = (node: ts.Node): void => {
+    if (unsupported) return;
+    unsupported = unsupportedCommonJsNode(node);
+    if (!unsupported) ts.forEachChild(node, visit);
+  };
+  visit(source);
+  return unsupported;
+}