@saptools/service-flow 0.1.67 → 0.1.69

package/src/parsers/019-binding-assignment-targets.ts

@@ -0,0 +1,76 @@
+import ts from 'typescript';
+
+export interface BindingAssignmentEntry {
+  variableName: string;
+  arrayIndex?: number;
+  unsupported?: boolean;
+}
+
+function unsupported(
+  entries: readonly BindingAssignmentEntry[],
+): BindingAssignmentEntry[] {
+  return entries.map((entry) => ({
+    ...entry,
+    arrayIndex: undefined,
+    unsupported: true,
+  }));
+}
+
+function objectEntries(
+  property: ts.ObjectLiteralElementLike,
+): BindingAssignmentEntry[] {
+  if (ts.isShorthandPropertyAssignment(property))
+    return [{ variableName: property.name.text }];
+  if (ts.isSpreadAssignment(property))
+    return unsupported(bindingAssignmentEntries(property.expression));
+  if (!ts.isPropertyAssignment(property)) return [];
+  if (ts.isIdentifier(property.initializer))
+    return [{ variableName: property.initializer.text }];
+  return unsupported(bindingAssignmentEntries(property.initializer));
+}
+
+function arrayEntries(
+  element: ts.Expression | ts.OmittedExpression,
+  arrayIndex: number,
+): BindingAssignmentEntry[] {
+  if (ts.isOmittedExpression(element)) return [];
+  if (ts.isIdentifier(element))
+    return [{ variableName: element.text, arrayIndex }];
+  return unsupported(bindingAssignmentEntries(element));
+}
+
+function assignmentTarget(
+  expression: ts.Expression,
+): { expression: ts.Expression; unsupported: boolean } {
+  if (ts.isParenthesizedExpression(expression))
+    return assignmentTarget(expression.expression);
+  if (ts.isAsExpression(expression)
+    || ts.isSatisfiesExpression(expression)
+    || ts.isTypeAssertionExpression(expression)
+    || ts.isNonNullExpression(expression)) {
+    const target = assignmentTarget(expression.expression);
+    return { expression: target.expression, unsupported: true };
+  }
+  if (ts.isBinaryExpression(expression)
+    && expression.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+    const target = assignmentTarget(expression.left);
+    return { expression: target.expression, unsupported: true };
+  }
+  return { expression, unsupported: false };
+}
+
+export function bindingAssignmentEntries(
+  expression: ts.Expression,
+): BindingAssignmentEntry[] {
+  const target = assignmentTarget(expression);
+  let entries: BindingAssignmentEntry[] = [];
+  if (ts.isIdentifier(target.expression))
+    entries = [{ variableName: target.expression.text }];
+  if (ts.isObjectLiteralExpression(target.expression))
+    entries = target.expression.properties.flatMap(objectEntries);
+  if (ts.isArrayLiteralExpression(target.expression))
+    entries = target.expression.elements.flatMap(arrayEntries);
+  if (ts.isSpreadElement(target.expression))
+    entries = unsupported(bindingAssignmentEntries(target.expression.expression));
+  return target.unsupported ? unsupported(entries) : entries;
+}

package/src/parsers/020-stable-local-value.ts

@@ -0,0 +1,217 @@
+import ts from 'typescript';
+import {
+  identifierMatchesDeclaration,
+} from './002-symbol-import-bindings.js';
+import {
+  isUnshadowedCommonJsExportExpression,
+} from './018-package-commonjs-syntax.js';
+
+function transparentUse(node: ts.Node): ts.Node {
+  const parent = node.parent;
+  if (parent && (ts.isParenthesizedExpression(parent)
+    || ts.isAsExpression(parent)
+    || ts.isSatisfiesExpression(parent)
+    || ts.isTypeAssertionExpression(parent)
+    || ts.isNonNullExpression(parent)))
+    return transparentUse(parent);
+  return node;
+}
+
+function assignmentOperator(kind: ts.SyntaxKind): boolean {
+  return kind >= ts.SyntaxKind.FirstAssignment
+    && kind <= ts.SyntaxKind.LastAssignment;
+}
+
+function directWriteTarget(node: ts.Node): boolean {
+  const use = transparentUse(node);
+  const parent = use.parent;
+  if (!parent) return false;
+  if (ts.isBinaryExpression(parent))
+    return parent.left === use && assignmentOperator(parent.operatorToken.kind);
+  if (ts.isDeleteExpression(parent))
+    return parent.expression === use;
+  if (ts.isPrefixUnaryExpression(parent)
+    || ts.isPostfixUnaryExpression(parent))
+    return parent.operand === use;
+  return (ts.isForInStatement(parent) || ts.isForOfStatement(parent))
+    && parent.initializer === use;
+}
+
+type MemberContainer = ts.ObjectLiteralExpression | ts.ClassLikeDeclaration;
+type StableMember = ts.ObjectLiteralElementLike | ts.ClassElement;
+
+function memberContainer(
+  declaration: ts.Identifier,
+): MemberContainer | undefined {
+  const parent = declaration.parent;
+  if (ts.isClassDeclaration(parent)) return parent;
+  if (!ts.isVariableDeclaration(parent) || parent.name !== declaration
+    || !parent.initializer) return undefined;
+  return ts.isObjectLiteralExpression(parent.initializer)
+    || ts.isClassExpression(parent.initializer)
+    ? parent.initializer
+    : undefined;
+}
+
+function declaredMemberName(node: ts.Node): string | undefined {
+  if (ts.isIdentifier(node) || ts.isPrivateIdentifier(node))
+    return node.text;
+  if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)
+    || ts.isNumericLiteral(node)) return node.text;
+  return undefined;
+}
+
+function accessedMemberName(node: ts.Node): string | undefined {
+  if (ts.isPropertyAccessExpression(node)) return node.name.text;
+  if (!ts.isElementAccessExpression(node)) return undefined;
+  const argument = node.argumentExpression;
+  return argument && (ts.isStringLiteral(argument)
+    || ts.isNoSubstitutionTemplateLiteral(argument))
+    ? argument.text
+    : undefined;
+}
+
+function memberName(node: ts.Node): string | undefined {
+  return declaredMemberName(node) ?? accessedMemberName(node);
+}
+
+function matchingMember(
+  value: MemberContainer,
+  name: string,
+): StableMember | undefined {
+  const members = ts.isObjectLiteralExpression(value)
+    ? value.properties
+    : value.members.filter((member) =>
+      ts.canHaveModifiers(member)
+      && ts.getModifiers(member)?.some((modifier) =>
+        modifier.kind === ts.SyntaxKind.StaticKeyword));
+  const matches = members.filter((member) =>
+    'name' in member && member.name && memberName(member.name) === name);
+  if (matches.length === 1) return matches[0];
+  const implemented = matches.filter((member) => callableMember(member)?.body);
+  return implemented.length === 1 ? implemented[0] : undefined;
+}
+
+function callableMember(
+  member: StableMember,
+): ts.FunctionLikeDeclaration | undefined {
+  if (ts.isMethodDeclaration(member)) return member;
+  if (ts.isPropertyAssignment(member)
+    && (ts.isArrowFunction(member.initializer)
+      || ts.isFunctionExpression(member.initializer)))
+    return member.initializer;
+  if (ts.isPropertyDeclaration(member) && member.initializer
+    && (ts.isArrowFunction(member.initializer)
+      || ts.isFunctionExpression(member.initializer)))
+    return member.initializer;
+  return undefined;
+}
+
+function containsThis(node: ts.Node): boolean {
+  let found = false;
+  const visit = (child: ts.Node): void => {
+    if (found) return;
+    if (child.kind === ts.SyntaxKind.ThisKeyword) {
+      found = true;
+      return;
+    }
+    ts.forEachChild(child, visit);
+  };
+  visit(node);
+  return found;
+}
+
+function invokedMember(node: ts.Node): boolean {
+  const use = transparentUse(node);
+  const parent = use.parent;
+  return Boolean(parent && ts.isCallExpression(parent)
+    && parent.expression === use);
+}
+
+type MemberAccess = ts.PropertyAccessExpression | ts.ElementAccessExpression;
+
+function receiverAccess(
+  node: ts.Node,
+): MemberAccess | undefined {
+  const parent = node.parent;
+  if (!parent || (!ts.isPropertyAccessExpression(parent)
+    && !ts.isElementAccessExpression(parent))
+    || parent.expression !== node || directWriteTarget(parent)) return undefined;
+  return parent;
+}
+
+function stableMemberUse(
+  access: MemberAccess,
+  member: StableMember,
+): boolean {
+  if (!invokedMember(access)) return !ts.isGetAccessor(member)
+    && !ts.isSetAccessor(member);
+  const callable = callableMember(member);
+  return Boolean(callable && !containsThis(callable));
+}
+
+function memberReceiverUse(
+  node: ts.Node,
+  declaration: ts.Identifier,
+): boolean {
+  const access = receiverAccess(node);
+  if (!access) return false;
+  const name = memberName(access);
+  const value = memberContainer(declaration);
+  const member = name && value ? matchingMember(value, name) : undefined;
+  return member ? stableMemberUse(access, member) : false;
+}
+
+function commonJsExportUse(node: ts.Node): boolean {
+  const parent = node.parent;
+  return Boolean(parent && ts.isBinaryExpression(parent)
+    && parent.operatorToken.kind === ts.SyntaxKind.EqualsToken
+    && parent.right === node
+    && isUnshadowedCommonJsExportExpression(parent.left)
+    && ts.isExpressionStatement(parent.parent)
+    && ts.isSourceFile(parent.parent.parent));
+}
+
+function esmExportUse(node: ts.Node): boolean {
+  const parent = node.parent;
+  return Boolean(parent && (ts.isExportSpecifier(parent)
+    || (ts.isExportAssignment(parent) && parent.expression === node)));
+}
+
+function inertUnaryUse(node: ts.Node): boolean {
+  const parent = node.parent;
+  return Boolean(parent && ((ts.isVoidExpression(parent)
+    || ts.isTypeOfExpression(parent)) && parent.expression === node));
+}
+
+function safeReferenceUse(
+  node: ts.Identifier,
+  declaration: ts.Identifier,
+): boolean {
+  const use = transparentUse(node);
+  return memberReceiverUse(use, declaration)
+    || commonJsExportUse(use)
+    || esmExportUse(use)
+    || inertUnaryUse(use);
+}
+
+export function stableLocalValueReference(
+  source: ts.SourceFile,
+  declaration: ts.Identifier,
+): boolean {
+  const start = declaration.getStart(source);
+  const end = declaration.getEnd();
+  let stable = true;
+  const visit = (node: ts.Node): void => {
+    if (!stable) return;
+    if (ts.isIdentifier(node) && node !== declaration
+      && identifierMatchesDeclaration(node, start, end)
+      && !safeReferenceUse(node, declaration)) {
+      stable = false;
+      return;
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(source);
+  return stable;
+}

package/src/parsers/021-binding-visibility.ts

@@ -0,0 +1,168 @@
+import ts from 'typescript';
+import type { LexicalScopeFact } from '../types.js';
+import {
+  declarationAt,
+  enclosingCaseClause,
+  executionScope,
+  lexicalScopeChain,
+  sameScope,
+  type BindingLexicalIndex,
+  type BindingLexicalSite,
+  type BindingSiteCandidate,
+  type VisibleBinding,
+} from './011-binding-lexical-scope.js';
+
+function reachingSites(
+  index: BindingLexicalIndex,
+  variableName: string,
+  useStart: number,
+  useChain: readonly LexicalScopeFact[],
+  declaration: BindingLexicalSite,
+): BindingLexicalSite[] {
+  const useExecution = executionScope(useChain);
+  return index.sites.filter((site) =>
+    site.variableName === variableName
+    && site.declarationKey === declaration.declarationKey
+    && site.startOffset < useStart
+    && (site.flow === 'declaration'
+      || sameScope(site.executionScope, useExecution)))
+    .sort((left, right) =>
+      right.startOffset - left.startOffset
+      || right.endOffset - left.endOffset);
+}
+
+function enclosingLoops(node: ts.Node): ts.IterationStatement[] {
+  const loops: ts.IterationStatement[] = [];
+  let current: ts.Node | undefined = node.parent;
+  while (current && !ts.isSourceFile(current)
+    && !ts.isFunctionLike(current)) {
+    if (ts.isIterationStatement(current, false)) loops.push(current);
+    current = current.parent;
+  }
+  return loops;
+}
+
+function unsupportedAssignmentFlow(
+  index: BindingLexicalIndex,
+  variableName: string,
+  useNode: ts.Node,
+  useStart: number,
+  useChain: readonly LexicalScopeFact[],
+  declaration: BindingLexicalSite,
+): boolean {
+  const useExecution = executionScope(useChain);
+  const loops = enclosingLoops(useNode);
+  return index.sites.some((site) => {
+    if (site.flow !== 'assignment'
+      || site.variableName !== variableName
+      || site.declarationKey !== declaration.declarationKey) return false;
+    if (!sameScope(site.executionScope, useExecution)) return true;
+    return site.startOffset > useStart && loops.some((loop) =>
+      site.node.pos >= loop.pos && site.node.end <= loop.end);
+  });
+}
+
+function candidatesAtSite<T>(
+  candidates: readonly BindingSiteCandidate<T>[],
+  site: BindingLexicalSite,
+): BindingSiteCandidate<T>[] {
+  return candidates.filter((candidate) =>
+    candidate.variableName === site.variableName
+    && candidate.bindingSiteStartOffset === site.startOffset
+    && candidate.bindingSiteEndOffset === site.endOffset);
+}
+
+function helperCallDeclaration(site: BindingLexicalSite): boolean {
+  if (!ts.isVariableDeclaration(site.node) || !site.node.initializer)
+    return false;
+  let expression = site.node.initializer;
+  while (ts.isAwaitExpression(expression)
+    || ts.isParenthesizedExpression(expression)
+    || ts.isAsExpression(expression)
+    || ts.isSatisfiesExpression(expression)
+    || ts.isTypeAssertionExpression(expression))
+    expression = expression.expression;
+  return ts.isCallExpression(expression)
+    && ts.isIdentifier(expression.expression);
+}
+
+function compatibleCaseClause(
+  site: BindingLexicalSite,
+  useNode: ts.Node,
+  source: ts.SourceFile,
+): boolean {
+  if (site.caseClauseStartOffset === undefined
+    || site.caseClauseEndOffset === undefined) return true;
+  const clause = enclosingCaseClause(useNode);
+  return clause?.getStart(source) === site.caseClauseStartOffset
+    && clause.getEnd() === site.caseClauseEndOffset;
+}
+
+type VisibleBindingReason = NonNullable<VisibleBinding<unknown>['reason']>;
+
+function declarationFailure(
+  declaration: BindingLexicalSite,
+  after: boolean,
+  useNode: ts.Node,
+  source: ts.SourceFile,
+): VisibleBindingReason | undefined {
+  if (declaration.flow === 'shadow') return 'binding_flow_unsupported';
+  if (declaration.declarationKind === 'var') return 'unsupported_var_binding';
+  if (!compatibleCaseClause(declaration, useNode, source))
+    return 'binding_flow_unsupported';
+  return after ? 'binding_declared_after_call' : undefined;
+}
+
+function matchedBinding<T>(
+  candidates: readonly BindingSiteCandidate<T>[],
+  site: BindingLexicalSite,
+): VisibleBinding<T> | undefined {
+  const matches = candidatesAtSite(candidates, site);
+  if (matches.length === 0) return {
+    status: 'unresolved',
+    reason: site.flow === 'assignment'
+      ? 'unsupported_reaching_assignment'
+      : helperCallDeclaration(site)
+        ? 'binding_flow_unsupported'
+        : 'binding_not_found',
+  };
+  if (matches.length > 1) return { status: 'ambiguous' };
+  return matches[0] ? { status: 'resolved', candidate: matches[0] } : undefined;
+}
+
+export function selectVisibleBinding<T>(
+  index: BindingLexicalIndex,
+  candidates: readonly BindingSiteCandidate<T>[],
+  variableName: string,
+  useNode: ts.Node,
+): VisibleBinding<T> {
+  const useStart = useNode.getStart(index.source);
+  const useChain = lexicalScopeChain(useNode, index.source);
+  const declaration = declarationAt(index.sites, variableName, useStart, useChain);
+  if (declaration.ambiguous) return { status: 'ambiguous' };
+  if (!declaration.site) return { status: 'unresolved', reason: 'binding_not_found' };
+  const failure = declarationFailure(
+    declaration.site, declaration.after, useNode, index.source,
+  );
+  if (failure) return { status: 'unresolved', reason: failure };
+  if (unsupportedAssignmentFlow(
+    index, variableName, useNode, useStart, useChain, declaration.site,
+  )) return {
+    status: 'unresolved',
+    reason: 'unsupported_reaching_assignment',
+  };
+  const site = reachingSites(
+    index, variableName, useStart, useChain, declaration.site,
+  )[0];
+  if (!site) return { status: 'unresolved', reason: 'binding_not_found' };
+  const matched = matchedBinding(candidates, site);
+  if (!matched || matched.status !== 'resolved') return matched ?? {
+    status: 'unresolved', reason: 'binding_not_found',
+  };
+  return {
+    ...matched,
+    site,
+    declarationSite: declaration.site,
+    scopeIndex: declaration.scopeIndex,
+  };
+}