@saptools/service-flow 0.1.66 → 0.1.68

package/src/parsers/015-service-binding-collector.ts

@@ -0,0 +1,693 @@
+import ts from 'typescript';
+import type { ServiceBindingFact } from '../types.js';
+import { normalizePath } from '../utils/path-utils.js';
+import {
+  connectFactFromCall,
+  lineOf,
+  transactionReceiverName,
+  unwrapCall,
+  unwrapIdentityExpression,
+  type ClassHelperReturn,
+  type HelperBinding,
+  type ImportBinding,
+} from './service-binding-parser-helpers.js';
+import {
+  createBindingLexicalIndex,
+  type BindingLexicalIndex,
+  type BindingSiteCandidate,
+} from './011-binding-lexical-scope.js';
+import { selectVisibleBinding } from './021-binding-visibility.js';
+import {
+  arrayAssignmentName,
+  arrayBindingName,
+  bindingValueAtSite,
+  collectReturnedObjectBindings,
+  directConnectFactFromFunctionLike,
+  functionLikeInitializer,
+} from './014-service-binding-helper-flow.js';
+
+type ResolvedHelper = { helper: HelperBinding; imp?: ImportBinding };
+type BindingEvent = {
+  pos: number;
+  node: ts.VariableDeclaration | ts.BinaryExpression;
+};
+
+export interface ServiceBindingCollectorInput {
+  source: ts.SourceFile;
+  filePath: string;
+  imports: ImportBinding[];
+  classHelpers: ClassHelperReturn[];
+  loadHelperBindings: (filePath: string) => Promise<HelperBinding[]>;
+}
+
+function bindingAtSite(
+  fact: ServiceBindingFact,
+  node: ts.Node,
+  source: ts.SourceFile,
+): ServiceBindingFact {
+  return {
+    ...fact,
+    bindingSiteStartOffset: node.getStart(source),
+    bindingSiteEndOffset: node.getEnd(),
+  };
+}
+
+function bindingEvents(source: ts.SourceFile): BindingEvent[] {
+  const events: BindingEvent[] = [];
+  function visit(node: ts.Node): void {
+    if (ts.isVariableDeclaration(node))
+      events.push({ pos: node.getStart(source), node });
+    if (ts.isBinaryExpression(node)
+      && node.operatorToken.kind === ts.SyntaxKind.EqualsToken)
+      events.push({ pos: node.getStart(source), node });
+    ts.forEachChild(node, visit);
+  }
+  visit(source);
+  return events.sort((left, right) => left.pos - right.pos);
+}
+
+function destructuredTarget(
+  property: ts.ObjectLiteralElementLike,
+): { propertyName?: string; targetName?: string } {
+  if (ts.isShorthandPropertyAssignment(property))
+    return {
+      propertyName: property.name.text,
+      targetName: property.name.text,
+    };
+  if (!ts.isPropertyAssignment(property)) return {};
+  const propertyName = ts.isIdentifier(property.name)
+    || ts.isStringLiteralLike(property.name)
+    ? property.name.text
+    : undefined;
+  return {
+    propertyName,
+    targetName: ts.isIdentifier(property.initializer)
+      ? property.initializer.text
+      : undefined,
+  };
+}
+
+class ServiceBindingCollector {
+  private readonly sourceFile: string;
+  private readonly lexicalIndex: BindingLexicalIndex;
+  private readonly out: ServiceBindingFact[] = [];
+  private readonly helperCache = new Map<string, HelperBinding[]>();
+  private readonly localObjectHelpers = new Map<string, HelperBinding[]>();
+  private readonly localDirectHelpers = new Map<string, HelperBinding>();
+  private readonly objectHelperVariables: Array<BindingSiteCandidate<
+    ResolvedHelper[]
+  >> = [];
+
+  constructor(private readonly input: ServiceBindingCollectorInput) {
+    this.sourceFile = normalizePath(input.filePath);
+    this.lexicalIndex = createBindingLexicalIndex(input.source);
+  }
+
+  async collect(): Promise<ServiceBindingFact[]> {
+    this.collectLocalHelpers();
+    for (const event of bindingEvents(this.input.source))
+      if (ts.isVariableDeclaration(event.node))
+        await this.recordDeclaration(event.node);
+      else
+        await this.recordAssignment(event.node);
+    return this.out;
+  }
+
+  private helperFact(
+    name: string,
+    node: ts.Node,
+    helper: ts.FunctionLikeDeclaration,
+  ): void {
+    const direct = directConnectFactFromFunctionLike(helper);
+    if (direct)
+      this.localDirectHelpers.set(name, {
+        ...direct,
+        exportedName: name,
+        sourceFile: this.sourceFile,
+        sourceLine: lineOf(this.input.source, node),
+      });
+    const rows = [...collectReturnedObjectBindings(helper)]
+      .map(([returnedProperty, fact]): HelperBinding => ({
+        ...fact,
+        exportedName: name,
+        returnedProperty,
+        sourceFile: this.sourceFile,
+        sourceLine: lineOf(this.input.source, node),
+      }));
+    if (rows.length > 0) this.localObjectHelpers.set(name, rows);
+  }
+
+  private collectLocalHelpers(): void {
+    for (const statement of this.input.source.statements) {
+      if (ts.isFunctionDeclaration(statement) && statement.name)
+        this.helperFact(statement.name.text, statement, statement);
+      if (!ts.isVariableStatement(statement)) continue;
+      for (const declaration of statement.declarationList.declarations) {
+        if (!ts.isIdentifier(declaration.name)) continue;
+        const helper = functionLikeInitializer(declaration.initializer);
+        if (helper) this.helperFact(
+          declaration.name.text, declaration, helper,
+        );
+      }
+    }
+  }
+
+  private async importedHelpers(localName: string): Promise<ResolvedHelper[]> {
+    const imported = this.input.imports.find((item) =>
+      item.localName === localName && item.sourceFile);
+    if (!imported?.sourceFile) return [];
+    if (!this.helperCache.has(imported.sourceFile))
+      this.helperCache.set(
+        imported.sourceFile,
+        await this.input.loadHelperBindings(imported.sourceFile),
+      );
+    return (this.helperCache.get(imported.sourceFile) ?? [])
+      .filter((helper) => helper.exportedName === imported.exportedName)
+      .map((helper) => ({ imp: imported, helper }));
+  }
+
+  private async importedHelper(localName: string): Promise<ResolvedHelper | undefined> {
+    return (await this.importedHelpers(localName))
+      .find((row) => !row.helper.returnedProperty);
+  }
+
+  private bindingCandidates(): Array<BindingSiteCandidate<ServiceBindingFact>> {
+    return this.out.map((fact) => ({
+      variableName: fact.variableName,
+      bindingSiteStartOffset: fact.bindingSiteStartOffset,
+      bindingSiteEndOffset: fact.bindingSiteEndOffset,
+      value: fact,
+    }));
+  }
+
+  private bindingForVariable(
+    variableName: string,
+    node: ts.Node,
+  ): ServiceBindingFact | undefined {
+    const selected = selectVisibleBinding(
+      this.lexicalIndex, this.bindingCandidates(), variableName, node,
+    );
+    if (!selected.site?.deterministic
+      || selected.declarationSite?.declarationKind === 'var') return undefined;
+    return selected.candidate?.value;
+  }
+
+  private cloneAlias(
+    targetName: string,
+    sourceName: string,
+    aliasKind: 'identity' | 'identity-assignment' | 'transaction',
+    node: ts.Node,
+  ): void {
+    const existing = this.bindingForVariable(sourceName, node);
+    if (!existing) return;
+    const helperChain = [...(existing.helperChain ?? []), {
+      callerVariable: targetName,
+      aliasOf: sourceName,
+      aliasKind,
+      scopeRule: 'exact_lexical_scope',
+      ...(aliasKind === 'transaction'
+        ? { transactionAliasSource: sourceName }
+        : {}),
+    }];
+    this.out.push(bindingAtSite({
+      ...existing,
+      variableName: targetName,
+      sourceLine: lineOf(this.input.source, node),
+      helperChain,
+    }, node, this.input.source));
+  }
+
+  private recordIdentityAlias(declaration: ts.VariableDeclaration): void {
+    if (!ts.isIdentifier(declaration.name) || !declaration.initializer) return;
+    const source = unwrapIdentityExpression(declaration.initializer);
+    if (ts.isIdentifier(source))
+      this.cloneAlias(
+        declaration.name.text, source.text, 'identity', declaration,
+      );
+  }
+
+  private directBinding(
+    targetName: string,
+    call: ts.CallExpression,
+    node: ts.Node,
+    flow: 'declaration' | 'assignment',
+  ): boolean {
+    const direct = connectFactFromCall(call);
+    if (!direct) return false;
+    const helperChain = flow === 'assignment'
+      ? [{
+          callerVariable: targetName,
+          assignedFrom: call.expression.getText(this.input.source),
+          aliasKind: flow,
+          scopeRule: 'exact_lexical_scope',
+        }]
+      : undefined;
+    this.out.push(bindingAtSite({
+      variableName: targetName,
+      ...direct,
+      sourceFile: this.sourceFile,
+      sourceLine: lineOf(this.input.source, node),
+      helperChain,
+    }, node, this.input.source));
+    return true;
+  }
+
+  private helperBindingFact(
+    targetName: string,
+    resolved: ResolvedHelper,
+    call: ts.CallExpression,
+    node: ts.Node,
+    flow: 'declaration' | 'assignment',
+  ): ServiceBindingFact {
+    const assignment = flow === 'assignment'
+      ? {
+          assignedFrom: call.expression.getText(this.input.source),
+          aliasKind: flow,
+          scopeRule: 'exact_lexical_scope',
+        }
+      : {};
+    return {
+      variableName: targetName,
+      alias: resolved.helper.alias,
+      aliasExpr: resolved.helper.aliasExpr,
+      destinationExpr: resolved.helper.destinationExpr,
+      servicePathExpr: resolved.helper.servicePathExpr,
+      isDynamic: resolved.helper.isDynamic,
+      placeholders: resolved.helper.placeholders,
+      sourceFile: this.sourceFile,
+      sourceLine: lineOf(this.input.source, node),
+      helperChain: [...(resolved.helper.helperChain ?? []), {
+        callerVariable: targetName,
+        ...assignment,
+        importedHelper: call.expression.getText(this.input.source),
+        importSource: resolved.imp?.sourceFile,
+        exportedSymbol: resolved.imp?.exportedName
+          ?? resolved.helper.exportedName,
+        helperSourceFile: resolved.helper.sourceFile,
+        helperSourceLine: resolved.helper.sourceLine,
+      }],
+    };
+  }
+
+  private async recordExpression(
+    targetName: string,
+    expression: ts.Expression,
+    node: ts.Node,
+    flow: 'declaration' | 'assignment',
+  ): Promise<void> {
+    const call = unwrapCall(expression);
+    if (!call || this.directBinding(targetName, call, node, flow)) return;
+    if (!ts.isIdentifier(call.expression)) return;
+    const local = this.localDirectHelpers.get(call.expression.text);
+    const resolved = local
+      ? { helper: local }
+      : await this.importedHelper(call.expression.text);
+    if (resolved)
+      this.out.push(bindingAtSite(
+        this.helperBindingFact(targetName, resolved, call, node, flow),
+        node,
+        this.input.source,
+      ));
+  }
+
+  private async helpersForCall(call: ts.CallExpression): Promise<ResolvedHelper[]> {
+    if (!ts.isIdentifier(call.expression)) return [];
+    const local = this.localObjectHelpers.get(call.expression.text) ?? [];
+    const imported = await this.importedHelpers(call.expression.text);
+    return [...local.map((helper) => ({ helper })), ...imported];
+  }
+
+  private async rememberObjectHelper(declaration: ts.VariableDeclaration): Promise<void> {
+    if (!ts.isIdentifier(declaration.name) || !declaration.initializer) return;
+    const call = unwrapCall(declaration.initializer);
+    if (!call) return;
+    const helpers = (await this.helpersForCall(call))
+      .filter((row) => row.helper.returnedProperty);
+    if (helpers.length > 0)
+      this.objectHelperVariables.push(bindingValueAtSite(
+        declaration.name.text, declaration, this.input.source, helpers,
+      ));
+  }
+
+  private visibleObjectHelpers(variableName: string, node: ts.Node): ResolvedHelper[] {
+    const selected = selectVisibleBinding(
+      this.lexicalIndex, this.objectHelperVariables, variableName, node,
+    );
+    if (!selected.site?.deterministic
+      || selected.declarationSite?.declarationKind === 'var') return [];
+    return selected.candidate?.value ?? [];
+  }
+
+  private objectPropertyFact(
+    targetName: string,
+    expression: ts.PropertyAccessExpression,
+    resolved: ResolvedHelper,
+    node: ts.Node,
+  ): ServiceBindingFact {
+    return {
+      variableName: targetName,
+      alias: resolved.helper.alias,
+      aliasExpr: resolved.helper.aliasExpr,
+      destinationExpr: resolved.helper.destinationExpr,
+      servicePathExpr: resolved.helper.servicePathExpr,
+      isDynamic: resolved.helper.isDynamic,
+      placeholders: resolved.helper.placeholders,
+      sourceFile: this.sourceFile,
+      sourceLine: lineOf(this.input.source, node),
+      helperChain: [...(resolved.helper.helperChain ?? []), {
+        callerVariable: targetName,
+        sourceVariable: expression.expression.getText(this.input.source),
+        returnedProperty: expression.name.text,
+        assignedFromProperty: expression.getText(this.input.source),
+        importSource: resolved.imp?.sourceFile,
+        exportedSymbol: resolved.imp?.exportedName,
+        helperSourceFile: resolved.helper.sourceFile,
+        helperSourceLine: resolved.helper.sourceLine,
+      }],
+    };
+  }
+
+  private recordObjectProperty(
+    targetName: string,
+    expression: ts.Expression,
+    node: ts.Node,
+  ): boolean {
+    const unwrapped = unwrapIdentityExpression(expression);
+    if (!ts.isPropertyAccessExpression(unwrapped)
+      || !ts.isIdentifier(unwrapped.expression)) return false;
+    const matches = this.visibleObjectHelpers(
+      unwrapped.expression.text, node,
+    ).filter((row) => row.helper.returnedProperty === unwrapped.name.text);
+    const resolved = matches.length === 1 ? matches[0] : undefined;
+    if (!resolved) return false;
+    this.out.push(bindingAtSite(
+      this.objectPropertyFact(targetName, unwrapped, resolved, node),
+      node,
+      this.input.source,
+    ));
+    return true;
+  }
+
+  private returnedHelperFact(
+    targetName: string,
+    propertyName: string,
+    resolved: ResolvedHelper,
+    call: ts.CallExpression,
+    node: ts.Node,
+    assignment: boolean,
+  ): ServiceBindingFact {
+    return {
+      variableName: targetName,
+      alias: resolved.helper.alias,
+      aliasExpr: resolved.helper.aliasExpr,
+      destinationExpr: resolved.helper.destinationExpr,
+      servicePathExpr: resolved.helper.servicePathExpr,
+      isDynamic: resolved.helper.isDynamic,
+      placeholders: resolved.helper.placeholders,
+      sourceFile: this.sourceFile,
+      sourceLine: lineOf(this.input.source, node),
+      helperChain: [...(resolved.helper.helperChain ?? []), {
+        callerVariable: targetName,
+        ...(assignment ? {
+          assignedFrom: call.expression.getText(this.input.source),
+          aliasKind: 'assignment',
+          scopeRule: 'exact_lexical_scope',
+        } : { helperFunction: call.expression.getText(this.input.source) }),
+        returnedProperty: propertyName,
+        importSource: resolved.imp?.sourceFile,
+        exportedSymbol: resolved.imp?.exportedName,
+        helperSourceFile: resolved.helper.sourceFile,
+        helperSourceLine: resolved.helper.sourceLine,
+      }],
+    };
+  }
+
+  private async recordDestructuredHelper(
+    declaration: ts.VariableDeclaration,
+  ): Promise<void> {
+    if (!ts.isObjectBindingPattern(declaration.name)
+      || !declaration.initializer) return;
+    const call = unwrapCall(declaration.initializer);
+    if (!call) return;
+    const helpers = await this.helpersForCall(call);
+    for (const element of declaration.name.elements) {
+      if (!ts.isIdentifier(element.name)) continue;
+      const propertyName = element.propertyName
+        && ts.isIdentifier(element.propertyName)
+        ? element.propertyName.text
+        : element.name.text;
+      const matches = helpers.filter((row) =>
+        row.helper.returnedProperty === propertyName);
+      const resolved = matches.length === 1 ? matches[0] : undefined;
+      if (resolved)
+        this.out.push(bindingAtSite(
+          this.returnedHelperFact(
+            element.name.text, propertyName, resolved,
+            call, declaration, false,
+          ),
+          declaration,
+          this.input.source,
+        ));
+    }
+  }
+
+  private async recordDestructuredAssignment(
+    pattern: ts.ObjectLiteralExpression,
+    expression: ts.Expression,
+    node: ts.Node,
+  ): Promise<void> {
+    const call = unwrapCall(expression);
+    if (!call) return;
+    const helpers = await this.helpersForCall(call);
+    for (const property of pattern.properties) {
+      const target = destructuredTarget(property);
+      if (!target.propertyName || !target.targetName) continue;
+      const matches = helpers.filter((row) =>
+        row.helper.returnedProperty === target.propertyName);
+      const resolved = matches.length === 1 ? matches[0] : undefined;
+      if (resolved)
+        this.out.push(bindingAtSite(
+          this.returnedHelperFact(
+            target.targetName, target.propertyName, resolved,
+            call, node, true,
+          ),
+          node,
+          this.input.source,
+        ));
+    }
+  }
+
+  private recordClassHelper(declaration: ts.VariableDeclaration): void {
+    if (!ts.isObjectBindingPattern(declaration.name)
+      || !declaration.initializer) return;
+    const call = unwrapCall(declaration.initializer);
+    if (!call || !ts.isPropertyAccessExpression(call.expression)
+      || call.expression.expression.kind !== ts.SyntaxKind.ThisKeyword) return;
+    for (const element of declaration.name.elements)
+      this.recordClassHelperElement(
+        declaration, element, call.expression.name.text,
+      );
+  }
+
+  private recordClassHelperElement(
+    declaration: ts.VariableDeclaration,
+    element: ts.BindingElement,
+    helperName: string,
+  ): void {
+    if (!ts.isIdentifier(element.name)) return;
+    const propertyName = element.propertyName
+      && ts.isIdentifier(element.propertyName)
+      ? element.propertyName.text
+      : element.name.text;
+    const helper = this.input.classHelpers.find((row) =>
+      row.helperName === helperName && row.propertyName === propertyName);
+    if (!helper) return;
+    this.out.push(bindingAtSite({
+      variableName: element.name.text,
+      ...helper.fact,
+      sourceFile: this.sourceFile,
+      sourceLine: lineOf(this.input.source, declaration),
+      helperChain: [{
+        callerVariable: element.name.text,
+        className: helper.className,
+        classHelper: helper.helperName,
+        returnedProperty: helper.propertyName,
+        helperVariable: helper.variableName,
+        helperSourceFile: this.sourceFile,
+        helperSourceLine: helper.sourceLine,
+      }],
+    }, declaration, this.input.source));
+  }
+
+  private arrayElements(expression: ts.Expression): {
+    elements: ts.NodeArray<ts.Expression>;
+    promiseAll: boolean;
+  } | undefined {
+    const unwrapped = unwrapIdentityExpression(expression);
+    if (ts.isArrayLiteralExpression(unwrapped))
+      return { elements: unwrapped.elements, promiseAll: false };
+    const call = unwrapCall(expression);
+    if (!call || !ts.isPropertyAccessExpression(call.expression)
+      || call.expression.name.text !== 'all'
+      || call.expression.expression.getText(this.input.source) !== 'Promise')
+      return undefined;
+    const first = call.arguments[0];
+    const container = first ? unwrapIdentityExpression(first) : undefined;
+    return container && ts.isArrayLiteralExpression(container)
+      ? { elements: container.elements, promiseAll: true }
+      : undefined;
+  }
+
+  private appendArrayStep(
+    fact: ServiceBindingFact,
+    targetName: string,
+    arrayIndex: number,
+    promiseAll: boolean,
+    sourceVariable?: string,
+  ): void {
+    fact.helperChain = [...(fact.helperChain ?? []), {
+      callerVariable: targetName,
+      targetVariable: targetName,
+      ...(sourceVariable ? {
+        sourceVariable,
+        aliasKind: 'array-destructuring',
+      } : {}),
+      arrayIndex,
+      promiseAll,
+      arrayContainer: promiseAll ? 'Promise.all' : 'array_literal',
+    }];
+  }
+
+  private async recordArrayElement(
+    targetName: string,
+    expression: ts.Expression,
+    node: ts.Node,
+    arrayIndex: number,
+    promiseAll: boolean,
+  ): Promise<void> {
+    const before = this.out.length;
+    await this.recordExpression(targetName, expression, node, 'declaration');
+    const direct = this.out.length > before ? this.out.at(-1) : undefined;
+    if (direct) {
+      this.appendArrayStep(direct, targetName, arrayIndex, promiseAll);
+      return;
+    }
+    const unwrapped = unwrapIdentityExpression(expression);
+    if (!ts.isIdentifier(unwrapped)) return;
+    const existing = this.bindingForVariable(unwrapped.text, node);
+    if (!existing) return;
+    const fact = bindingAtSite({
+      ...existing,
+      variableName: targetName,
+      sourceLine: lineOf(this.input.source, node),
+    }, node, this.input.source);
+    this.appendArrayStep(
+      fact, targetName, arrayIndex, promiseAll, unwrapped.text,
+    );
+    this.out.push(fact);
+  }
+
+  private async recordArrayDeclaration(
+    declaration: ts.VariableDeclaration,
+  ): Promise<void> {
+    if (!ts.isArrayBindingPattern(declaration.name)
+      || !declaration.initializer) return;
+    const container = this.arrayElements(declaration.initializer);
+    if (!container) return;
+    for (let index = 0; index < declaration.name.elements.length; index += 1) {
+      const targetName = arrayBindingName(
+        declaration.name.elements[index],
+      );
+      const expression = container.elements[index];
+      if (targetName && expression && !ts.isOmittedExpression(expression))
+        await this.recordArrayElement(
+          targetName, expression, declaration,
+          index, container.promiseAll,
+        );
+    }
+  }
+
+  private async recordArrayAssignment(
+    pattern: ts.ArrayLiteralExpression,
+    expression: ts.Expression,
+    node: ts.Node,
+  ): Promise<void> {
+    const container = this.arrayElements(expression);
+    if (!container) return;
+    for (let index = 0; index < pattern.elements.length; index += 1) {
+      const targetName = arrayAssignmentName(pattern.elements[index]);
+      const source = container.elements[index];
+      if (!targetName || !source || ts.isOmittedExpression(source)) continue;
+      await this.recordArrayElement(
+        targetName, source, node, index, container.promiseAll,
+      );
+    }
+  }
+
+  private async recordDeclaration(
+    declaration: ts.VariableDeclaration,
+  ): Promise<void> {
+    await this.recordDestructuredHelper(declaration);
+    await this.recordArrayDeclaration(declaration);
+    this.recordClassHelper(declaration);
+    await this.rememberObjectHelper(declaration);
+    if (ts.isIdentifier(declaration.name) && declaration.initializer)
+      this.recordObjectProperty(
+        declaration.name.text, declaration.initializer, declaration,
+      );
+    if (ts.isIdentifier(declaration.name) && declaration.initializer)
+      await this.recordExpression(
+        declaration.name.text, declaration.initializer,
+        declaration, 'declaration',
+      );
+    this.recordIdentityAlias(declaration);
+    if (!ts.isIdentifier(declaration.name) || !declaration.initializer) return;
+    const source = transactionReceiverName(declaration.initializer);
+    if (source)
+      this.cloneAlias(
+        declaration.name.text, source, 'transaction', declaration,
+      );
+  }
+
+  private async recordIdentifierAssignment(
+    assignment: ts.BinaryExpression,
+  ): Promise<void> {
+    if (!ts.isIdentifier(assignment.left)) return;
+    const right = unwrapIdentityExpression(assignment.right);
+    if (ts.isIdentifier(right)) {
+      this.cloneAlias(
+        assignment.left.text, right.text,
+        'identity-assignment', assignment,
+      );
+      return;
+    }
+    if (this.recordObjectProperty(
+      assignment.left.text, assignment.right, assignment,
+    )) return;
+    await this.recordExpression(
+      assignment.left.text, assignment.right, assignment, 'assignment',
+    );
+  }
+
+  private async recordAssignment(assignment: ts.BinaryExpression): Promise<void> {
+    if (ts.isIdentifier(assignment.left)) {
+      await this.recordIdentifierAssignment(assignment);
+      return;
+    }
+    const left = ts.isParenthesizedExpression(assignment.left)
+      ? assignment.left.expression
+      : assignment.left;
+    if (ts.isObjectLiteralExpression(left))
+      await this.recordDestructuredAssignment(
+        left, assignment.right, assignment,
+      );
+    if (ts.isArrayLiteralExpression(left))
+      await this.recordArrayAssignment(left, assignment.right, assignment);
+  }
+}
+
+export async function collectServiceBindings(
+  input: ServiceBindingCollectorInput,
+): Promise<ServiceBindingFact[]> {
+  return new ServiceBindingCollector(input).collect();
+}