@soundscript/soundscript 0.1.12 → 0.1.15

package/project-transform/src/checker/rules/foreign_boundary.js

@@ -0,0 +1,120 @@
+import ts from 'typescript';
+import { isForeignPackageSourceFile, isForeignResolvedModule, resolveSoundScriptAwareModule, } from '../../soundscript_packages.js';
+import { isSoundscriptSourceFile, toSourceFileName } from '../../frontend/project_frontend.js';
+export function isRequireCall(node) {
+    return ts.isIdentifier(node.expression) &&
+        node.expression.text === 'require' &&
+        node.arguments.length === 1 &&
+        ts.isStringLiteral(node.arguments[0]);
+}
+export function isImportCall(node) {
+    return node.expression.kind === ts.SyntaxKind.ImportKeyword &&
+        node.arguments.length === 1 &&
+        ts.isStringLiteral(node.arguments[0]);
+}
+export function getUnwrappedBoundaryExpression(expression) {
+    return ts.isParenthesizedExpression(expression)
+        ? getUnwrappedBoundaryExpression(expression.expression)
+        : expression;
+}
+export function resolveImportedModule(context, moduleSpecifier, containingSourceFile) {
+    const resolvedModule = resolveSoundScriptAwareModule(moduleSpecifier.text, containingSourceFile.fileName, context.program.getCompilerOptions(), ts.sys);
+    if (!resolvedModule) {
+        return { isForeign: false };
+    }
+    return {
+        importedSourceFile: context.program.getSourceFile(resolvedModule.resolvedFileName),
+        isForeign: isForeignResolvedModule(moduleSpecifier.text, resolvedModule, ts.sys),
+    };
+}
+export function isUnsoundImportedModule(containingSourceFile, resolution) {
+    const importedSourceFile = resolution.importedSourceFile;
+    const importedFileName = importedSourceFile?.fileName ?? '';
+    const importedIsTrustedPackageArtifact = (importedFileName.includes('/node_modules/') || importedFileName.includes('\\node_modules\\')) &&
+        !isForeignPackageSourceFile(importedFileName, ts.sys);
+    if (resolution.isForeign) {
+        return true;
+    }
+    if (importedSourceFile?.isDeclarationFile) {
+        return !importedIsTrustedPackageArtifact;
+    }
+    return isSoundscriptSourceFile(toSourceFileName(containingSourceFile.fileName)) &&
+        !!importedSourceFile &&
+        !isSoundscriptSourceFile(toSourceFileName(importedFileName)) &&
+        !importedIsTrustedPackageArtifact;
+}
+export function getForeignImportBindingInfos(context, statement, containingSourceFile) {
+    if (ts.isImportDeclaration(statement)) {
+        if (!statement.importClause || statement.importClause.isTypeOnly ||
+            !ts.isStringLiteral(statement.moduleSpecifier)) {
+            return [];
+        }
+        const resolution = resolveImportedModule(context, statement.moduleSpecifier, containingSourceFile);
+        const results = [];
+        if (statement.importClause.name) {
+            results.push({
+                bindingName: statement.importClause.name,
+                kind: 'valueImport',
+                moduleSpecifier: statement.moduleSpecifier,
+                resolution,
+            });
+        }
+        const namedBindings = statement.importClause.namedBindings;
+        if (!namedBindings) {
+            return results;
+        }
+        if (ts.isNamespaceImport(namedBindings)) {
+            results.push({
+                bindingName: namedBindings.name,
+                kind: 'namespaceImport',
+                moduleSpecifier: statement.moduleSpecifier,
+                resolution,
+            });
+            return results;
+        }
+        for (const element of namedBindings.elements) {
+            if (element.isTypeOnly) {
+                continue;
+            }
+            results.push({
+                bindingName: element.name,
+                kind: 'valueImport',
+                moduleSpecifier: statement.moduleSpecifier,
+                resolution,
+            });
+        }
+        return results;
+    }
+    if (ts.isImportEqualsDeclaration(statement) &&
+        ts.isExternalModuleReference(statement.moduleReference) &&
+        ts.isStringLiteral(statement.moduleReference.expression)) {
+        return [{
+                bindingName: statement.name,
+                kind: 'namespaceImport',
+                moduleSpecifier: statement.moduleReference.expression,
+                resolution: resolveImportedModule(context, statement.moduleReference.expression, containingSourceFile),
+            }];
+    }
+    return [];
+}
+export function getDirectUnsoundImportNamespaceExpression(context, expression) {
+    const current = getUnwrappedBoundaryExpression(expression);
+    if (ts.isAwaitExpression(current)) {
+        return getDirectUnsoundImportNamespaceExpression(context, current.expression);
+    }
+    if (!ts.isCallExpression(current)) {
+        return undefined;
+    }
+    let moduleSpecifier;
+    if (isImportCall(current)) {
+        moduleSpecifier = current.arguments[0];
+    }
+    else if (isRequireCall(current)) {
+        moduleSpecifier = current.arguments[0];
+    }
+    if (!moduleSpecifier) {
+        return undefined;
+    }
+    const resolution = resolveImportedModule(context, moduleSpecifier, current.getSourceFile());
+    return isUnsoundImportedModule(current.getSourceFile(), resolution) ? current : undefined;
+}

package/project-transform/src/checker/rules/foreign_boundary.ts

@@ -0,0 +1,196 @@
+import ts from 'typescript';
+
+import type { AnalysisContext } from '../engine/types.ts';
+import {
+  isForeignPackageSourceFile,
+  isForeignResolvedModule,
+  resolveSoundScriptAwareModule,
+} from '../../soundscript_packages.ts';
+import { isSoundscriptSourceFile, toSourceFileName } from '../../frontend/project_frontend.ts';
+
+export interface ImportedModuleResolution {
+  importedSourceFile?: ts.SourceFile;
+  isForeign: boolean;
+}
+
+export interface ForeignImportBindingInfo {
+  bindingName: ts.Identifier;
+  kind: 'namespaceImport' | 'valueImport';
+  moduleSpecifier: ts.StringLiteral;
+  resolution: ImportedModuleResolution;
+}
+
+export function isRequireCall(node: ts.CallExpression): node is ts.CallExpression & {
+  expression: ts.Identifier;
+  arguments: [ts.StringLiteral];
+} {
+  return ts.isIdentifier(node.expression) &&
+    node.expression.text === 'require' &&
+    node.arguments.length === 1 &&
+    ts.isStringLiteral(node.arguments[0]);
+}
+
+export function isImportCall(node: ts.CallExpression): node is ts.CallExpression & {
+  arguments: [ts.StringLiteral];
+} {
+  return node.expression.kind === ts.SyntaxKind.ImportKeyword &&
+    node.arguments.length === 1 &&
+    ts.isStringLiteral(node.arguments[0]);
+}
+
+export function getUnwrappedBoundaryExpression(expression: ts.Expression): ts.Expression {
+  return ts.isParenthesizedExpression(expression)
+    ? getUnwrappedBoundaryExpression(expression.expression)
+    : expression;
+}
+
+export function resolveImportedModule(
+  context: AnalysisContext,
+  moduleSpecifier: ts.StringLiteral,
+  containingSourceFile: ts.SourceFile,
+): ImportedModuleResolution {
+  const resolvedModule = resolveSoundScriptAwareModule(
+    moduleSpecifier.text,
+    containingSourceFile.fileName,
+    context.program.getCompilerOptions(),
+    ts.sys,
+  );
+
+  if (!resolvedModule) {
+    return { isForeign: false };
+  }
+
+  return {
+    importedSourceFile: context.program.getSourceFile(resolvedModule.resolvedFileName),
+    isForeign: isForeignResolvedModule(moduleSpecifier.text, resolvedModule, ts.sys),
+  };
+}
+
+export function isUnsoundImportedModule(
+  containingSourceFile: ts.SourceFile,
+  resolution: ImportedModuleResolution,
+): boolean {
+  const importedSourceFile = resolution.importedSourceFile;
+  const importedFileName = importedSourceFile?.fileName ?? '';
+  const importedIsTrustedPackageArtifact =
+    (importedFileName.includes('/node_modules/') || importedFileName.includes('\\node_modules\\')) &&
+    !isForeignPackageSourceFile(importedFileName, ts.sys);
+
+  if (resolution.isForeign) {
+    return true;
+  }
+
+  if (importedSourceFile?.isDeclarationFile) {
+    return !importedIsTrustedPackageArtifact;
+  }
+
+  return isSoundscriptSourceFile(toSourceFileName(containingSourceFile.fileName)) &&
+    !!importedSourceFile &&
+    !isSoundscriptSourceFile(toSourceFileName(importedFileName)) &&
+    !importedIsTrustedPackageArtifact;
+}
+
+export function getForeignImportBindingInfos(
+  context: AnalysisContext,
+  statement: ts.Statement,
+  containingSourceFile: ts.SourceFile,
+): readonly ForeignImportBindingInfo[] {
+  if (ts.isImportDeclaration(statement)) {
+    if (
+      !statement.importClause || statement.importClause.isTypeOnly ||
+      !ts.isStringLiteral(statement.moduleSpecifier)
+    ) {
+      return [];
+    }
+
+    const resolution = resolveImportedModule(context, statement.moduleSpecifier, containingSourceFile);
+    const results: ForeignImportBindingInfo[] = [];
+
+    if (statement.importClause.name) {
+      results.push({
+        bindingName: statement.importClause.name,
+        kind: 'valueImport',
+        moduleSpecifier: statement.moduleSpecifier,
+        resolution,
+      });
+    }
+
+    const namedBindings = statement.importClause.namedBindings;
+    if (!namedBindings) {
+      return results;
+    }
+
+    if (ts.isNamespaceImport(namedBindings)) {
+      results.push({
+        bindingName: namedBindings.name,
+        kind: 'namespaceImport',
+        moduleSpecifier: statement.moduleSpecifier,
+        resolution,
+      });
+      return results;
+    }
+
+    for (const element of namedBindings.elements) {
+      if (element.isTypeOnly) {
+        continue;
+      }
+
+      results.push({
+        bindingName: element.name,
+        kind: 'valueImport',
+        moduleSpecifier: statement.moduleSpecifier,
+        resolution,
+      });
+    }
+
+    return results;
+  }
+
+  if (
+    ts.isImportEqualsDeclaration(statement) &&
+    ts.isExternalModuleReference(statement.moduleReference) &&
+    ts.isStringLiteral(statement.moduleReference.expression)
+  ) {
+    return [{
+      bindingName: statement.name,
+      kind: 'namespaceImport',
+      moduleSpecifier: statement.moduleReference.expression,
+      resolution: resolveImportedModule(
+        context,
+        statement.moduleReference.expression,
+        containingSourceFile,
+      ),
+    }];
+  }
+
+  return [];
+}
+
+export function getDirectUnsoundImportNamespaceExpression(
+  context: AnalysisContext,
+  expression: ts.Expression,
+): ts.Expression | undefined {
+  const current = getUnwrappedBoundaryExpression(expression);
+
+  if (ts.isAwaitExpression(current)) {
+    return getDirectUnsoundImportNamespaceExpression(context, current.expression);
+  }
+
+  if (!ts.isCallExpression(current)) {
+    return undefined;
+  }
+
+  let moduleSpecifier: ts.StringLiteral | undefined;
+  if (isImportCall(current)) {
+    moduleSpecifier = current.arguments[0];
+  } else if (isRequireCall(current)) {
+    moduleSpecifier = current.arguments[0];
+  }
+
+  if (!moduleSpecifier) {
+    return undefined;
+  }
+
+  const resolution = resolveImportedModule(context, moduleSpecifier, current.getSourceFile());
+  return isUnsoundImportedModule(current.getSourceFile(), resolution) ? current : undefined;
+}

package/project-transform/src/checker/rules/foreign_projection.js

@@ -0,0 +1,279 @@
+import ts from 'typescript';
+import { getDirectUnsoundImportNamespaceExpression, getForeignImportBindingInfos, getUnwrappedBoundaryExpression, } from './foreign_boundary.js';
+import { hasDirectInteropAnnotation } from './trust.js';
+function isAnyType(type) {
+    return (type.flags & ts.TypeFlags.Any) !== 0;
+}
+function isUnknownType(type) {
+    return (type.flags & ts.TypeFlags.Unknown) !== 0;
+}
+function isAnyOrUnknownType(type) {
+    return isAnyType(type) || isUnknownType(type);
+}
+function getSymbolIdAtLocation(context, node) {
+    const symbol = context.checker.getSymbolAtLocation(node);
+    return symbol ? context.getSymbolId(symbol) : undefined;
+}
+function getAliasedBindingSymbol(context, bindingName) {
+    if (!ts.isIdentifier(bindingName)) {
+        return undefined;
+    }
+    return context.checker.getSymbolAtLocation(bindingName);
+}
+function forEachBindingIdentifier(bindingName, visit) {
+    if (ts.isIdentifier(bindingName)) {
+        visit(bindingName);
+        return;
+    }
+    for (const element of bindingName.elements) {
+        if (!ts.isBindingElement(element)) {
+            continue;
+        }
+        forEachBindingIdentifier(element.name, visit);
+    }
+}
+function isBindingDeclaredUnknown(context, bindingName) {
+    if (!ts.isIdentifier(bindingName)) {
+        return false;
+    }
+    return isUnknownType(context.checker.getTypeAtLocation(bindingName));
+}
+function markProjectedUnknownBindingIdentifiers(context, bindingName) {
+    let changed = false;
+    forEachBindingIdentifier(bindingName, (identifier) => {
+        if (!isAnyType(context.checker.getTypeAtLocation(identifier))) {
+            return;
+        }
+        const symbol = context.checker.getSymbolAtLocation(identifier);
+        if (!symbol || getForeignProjection(context, symbol).projection !== 'none') {
+            return;
+        }
+        setForeignProjection(context, symbol, 'projectedUnknown');
+        changed = true;
+    });
+    return changed;
+}
+function findEnclosingFunctionLike(node) {
+    let current = node.parent;
+    while (current) {
+        if (ts.isFunctionLike(current)) {
+            return current;
+        }
+        current = current.parent;
+    }
+    return undefined;
+}
+function getCallArgumentExpectedType(context, callLike, expression) {
+    const argumentIndex = callLike.arguments?.findIndex((argument) => argument === expression) ?? -1;
+    if (argumentIndex < 0) {
+        return undefined;
+    }
+    const signature = context.checker.getResolvedSignature(callLike);
+    const parameter = signature?.parameters[argumentIndex] ??
+        (signature?.parameters.length
+            ? signature.parameters[signature.parameters.length - 1]
+            : undefined);
+    if (!parameter) {
+        return undefined;
+    }
+    return context.checker.getTypeOfSymbolAtLocation(parameter, callLike);
+}
+export function isAllowedProjectedUnknownUse(context, node) {
+    const parent = node.parent;
+    if (ts.isTypeOfExpression(parent) && parent.expression === node) {
+        return true;
+    }
+    if (((ts.isVariableDeclaration(parent) && parent.initializer === node) ||
+        (ts.isPropertyDeclaration(parent) && parent.initializer === node) ||
+        (ts.isParameter(parent) && parent.initializer === node)) &&
+        parent.type) {
+        return isUnknownType(context.checker.getTypeFromTypeNode(parent.type));
+    }
+    if (ts.isBinaryExpression(parent) &&
+        parent.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+        parent.right === node) {
+        return isUnknownType(context.checker.getTypeAtLocation(parent.left));
+    }
+    if ((ts.isCallExpression(parent) || ts.isNewExpression(parent)) && parent.arguments?.includes(node)) {
+        const expectedType = getCallArgumentExpectedType(context, parent, node);
+        return expectedType !== undefined && isUnknownType(expectedType);
+    }
+    if (ts.isReturnStatement(parent) && parent.expression === node) {
+        const functionLike = findEnclosingFunctionLike(parent);
+        if (!functionLike?.type) {
+            return false;
+        }
+        return isUnknownType(context.checker.getTypeFromTypeNode(functionLike.type));
+    }
+    return false;
+}
+function getForeignProjection(context, symbol) {
+    return context.facts.getForeignProjection(symbol, () => ({
+        symbolId: context.getSymbolId(symbol),
+        projection: 'none',
+    }));
+}
+function setForeignProjection(context, symbol, projection) {
+    return context.facts.setForeignProjection(symbol, {
+        symbolId: context.getSymbolId(symbol),
+        projection,
+    });
+}
+function isNamespaceProjectionExpression(context, expression) {
+    const current = getUnwrappedBoundaryExpression(expression);
+    if (ts.isIdentifier(current)) {
+        const symbol = context.checker.getSymbolAtLocation(current);
+        return !!symbol && getForeignProjection(context, symbol).projection === 'namespaceImport';
+    }
+    if (ts.isPropertyAccessExpression(current) || ts.isElementAccessExpression(current)) {
+        return isNamespaceProjectionExpression(context, current.expression);
+    }
+    return false;
+}
+function isProjectedUnknownSourceExpression(context, expression) {
+    const current = getUnwrappedBoundaryExpression(expression);
+    if (ts.isIdentifier(current)) {
+        const symbol = context.checker.getSymbolAtLocation(current);
+        if (!symbol) {
+            return false;
+        }
+        const projection = getForeignProjection(context, symbol).projection;
+        return projection === 'projectedUnknown' || projection === 'namespaceImport';
+    }
+    if (ts.isPropertyAccessExpression(current) || ts.isElementAccessExpression(current)) {
+        return isProjectedUnknownSourceExpression(context, current.expression);
+    }
+    if (ts.isAwaitExpression(current)) {
+        return isProjectedUnknownSourceExpression(context, current.expression);
+    }
+    if (getDirectUnsoundImportNamespaceExpression(context, current)) {
+        return true;
+    }
+    return false;
+}
+function isProjectedUnknownExpression(context, expression) {
+    const current = getUnwrappedBoundaryExpression(expression);
+    return isAnyOrUnknownType(context.checker.getTypeAtLocation(current)) &&
+        isProjectedUnknownSourceExpression(context, current);
+}
+function propagateNamespaceImportAliases(context) {
+    let changed = true;
+    while (changed) {
+        changed = false;
+        context.forEachSourceFile((sourceFile) => {
+            context.traverse(sourceFile, (node) => {
+                if (!ts.isVariableDeclaration(node) || !node.initializer) {
+                    return;
+                }
+                if (!isNamespaceProjectionExpression(context, node.initializer)) {
+                    return;
+                }
+                const symbol = getAliasedBindingSymbol(context, node.name);
+                if (!symbol || getForeignProjection(context, symbol).projection === 'namespaceImport') {
+                    return;
+                }
+                setForeignProjection(context, symbol, 'namespaceImport');
+                changed = true;
+            });
+        });
+    }
+}
+function propagateProjectedUnknownAliases(context) {
+    let changed = true;
+    while (changed) {
+        changed = false;
+        context.forEachSourceFile((sourceFile) => {
+            context.traverse(sourceFile, (node) => {
+                if (!ts.isVariableDeclaration(node) || !node.initializer) {
+                    return;
+                }
+                if (!ts.isIdentifier(node.name) &&
+                    (isProjectedUnknownExpression(context, node.initializer) ||
+                        isNamespaceProjectionExpression(context, node.initializer) ||
+                        (hasDirectInteropAnnotation(context, node) &&
+                            getDirectUnsoundImportNamespaceExpression(context, node.initializer) !== undefined))) {
+                    if (markProjectedUnknownBindingIdentifiers(context, node.name)) {
+                        changed = true;
+                    }
+                    return;
+                }
+                if (!isProjectedUnknownExpression(context, node.initializer)) {
+                    return;
+                }
+                const symbol = getAliasedBindingSymbol(context, node.name);
+                if (!symbol || getForeignProjection(context, symbol).projection !== 'none' ||
+                    isBindingDeclaredUnknown(context, node.name)) {
+                    return;
+                }
+                setForeignProjection(context, symbol, 'projectedUnknown');
+                changed = true;
+            });
+        });
+    }
+}
+export function initializeForeignProjectionFacts(context, unsoundSymbolIds) {
+    context.forEachSourceFile((sourceFile) => {
+        for (const statement of sourceFile.statements) {
+            if (context.isGeneratedNode(statement)) {
+                continue;
+            }
+            for (const bindingInfo of getForeignImportBindingInfos(context, statement, sourceFile)) {
+                const bindingName = bindingInfo.bindingName;
+                const symbol = context.checker.getSymbolAtLocation(bindingName);
+                if (!symbol) {
+                    continue;
+                }
+                if (bindingInfo.kind === 'namespaceImport') {
+                    setForeignProjection(context, symbol, 'namespaceImport');
+                }
+                if (unsoundSymbolIds.has(context.getSymbolId(symbol))) {
+                    continue;
+                }
+                const importedType = context.checker.getTypeAtLocation(bindingName);
+                if (bindingInfo.kind !== 'namespaceImport' &&
+                    isAnyType(importedType) &&
+                    getForeignProjection(context, symbol).projection === 'none') {
+                    setForeignProjection(context, symbol, 'projectedUnknown');
+                }
+            }
+        }
+    });
+    context.forEachSourceFile((sourceFile) => {
+        context.traverse(sourceFile, (node) => {
+            if (!ts.isVariableDeclaration(node) ||
+                !node.initializer ||
+                !hasDirectInteropAnnotation(context, node)) {
+                return;
+            }
+            if (!getDirectUnsoundImportNamespaceExpression(context, node.initializer)) {
+                return;
+            }
+            if (!ts.isIdentifier(node.name)) {
+                markProjectedUnknownBindingIdentifiers(context, node.name);
+                return;
+            }
+            const symbol = context.checker.getSymbolAtLocation(node.name);
+            if (symbol) {
+                setForeignProjection(context, symbol, 'namespaceImport');
+            }
+        });
+    });
+    propagateNamespaceImportAliases(context);
+    propagateProjectedUnknownAliases(context);
+}
+export function isProjectedUnknownMemberExpression(context, node) {
+    return (ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node)) &&
+        isProjectedUnknownExpression(context, node);
+}
+export function isProjectedUnknownIdentifier(context, node) {
+    const symbol = context.checker.getSymbolAtLocation(node);
+    if (!symbol) {
+        return false;
+    }
+    return getForeignProjection(context, symbol).projection === 'projectedUnknown';
+}
+export function isNestedMemberAccessExpression(node) {
+    return (ts.isPropertyAccessExpression(node.parent) ||
+        ts.isElementAccessExpression(node.parent)) &&
+        node.parent.expression === node;
+}