@soundscript/soundscript 0.1.13 → 0.1.15

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

@@ -0,0 +1,601 @@
+import ts from 'typescript';
+export function createFlowFact(kind, path, sourceNode, polarity = 'positive') {
+    return {
+        kind,
+        path,
+        polarity,
+        sourceNode,
+    };
+}
+export function analyzeConditionExpression(context, expression, state, environment) {
+    return analyzeConditionStructure(context, getFlowConditionStructure(context, expression), state, environment);
+}
+export function getFlowConditionStructure(context, expression) {
+    return context.facts.getFlowConditionStructure(expression, () => parseConditionStructure(context, expression));
+}
+export function analyzeConditionStructure(context, structure, state, environment) {
+    return resolveConditionStructure(context, structure, state, environment);
+}
+function resolveConditionStructure(context, structure, state, environment) {
+    if (structure.kind === 'none') {
+        return { facts: [] };
+    }
+    if (structure.kind === 'facts') {
+        return {
+            facts: materializeFlowFacts(context, structure.facts, state, environment),
+        };
+    }
+    const left = resolveConditionStructure(context, structure.left, state, environment);
+    const right = resolveConditionStructure(context, structure.right, state, environment);
+    const leftFacts = left.facts.filter((fact) => !environment.escapingExpressionAffectsNarrow(context, structure.rightExpression, fact.path, state));
+    return {
+        facts: [...leftFacts, ...right.facts],
+        invalidatingNode: left.invalidatingNode ??
+            (left.facts.some((fact) => environment.escapingExpressionAffectsNarrow(context, structure.rightExpression, fact.path, state))
+                ? structure.rightExpression
+                : right.invalidatingNode),
+        invalidatedFact: left.invalidatedFact ??
+            left.facts.find((fact) => environment.escapingExpressionAffectsNarrow(context, structure.rightExpression, fact.path, state)) ??
+            right.invalidatedFact,
+    };
+}
+function materializeFlowFacts(context, facts, state, environment) {
+    const materialized = [];
+    for (const fact of facts) {
+        if (fact.kind === 'inProperty') {
+            const basePath = environment.normalizeExpressionPath(context, fact.subjectExpression, state);
+            if (!basePath) {
+                continue;
+            }
+            const path = environment.appendSegment(basePath, fact.propertySegment);
+            if (!environment.shouldTrackFact(context, path, state)) {
+                continue;
+            }
+            materialized.push(createFlowFact('inProperty', path, fact.sourceNode, fact.polarity));
+            continue;
+        }
+        const path = environment.normalizeWholeValueFactPath(context, fact.subjectExpression, state);
+        if (!path || !environment.shouldTrackFact(context, path, state)) {
+            continue;
+        }
+        materialized.push(createFlowFact(fact.kind, path, fact.sourceNode, fact.polarity));
+    }
+    return materialized;
+}
+export function extractSequentialFacts(context, statement, state, environment, options = {}) {
+    return materializeConditionStructures(context, getSequentialConditionStructures(context, statement, options), state, environment).facts;
+}
+export function materializeConditionStructures(context, structures, state, environment) {
+    const facts = [];
+    let invalidatingNode;
+    let invalidatedFact;
+    for (const structure of structures) {
+        const analysis = analyzeConditionStructure(context, structure, state, environment);
+        facts.push(...analysis.facts);
+        invalidatingNode ?? (invalidatingNode = analysis.invalidatingNode);
+        invalidatedFact ?? (invalidatedFact = analysis.invalidatedFact);
+    }
+    return { facts, invalidatingNode, invalidatedFact };
+}
+export function getSequentialConditionStructures(context, statement, options = {}) {
+    const structure = getFlowStatementStructure(context, statement);
+    if (ts.isIfStatement(statement) &&
+        structure.kind === 'if' &&
+        structure.elseExitKinds.length === 0 &&
+        exitKindsSatisfyOptions(structure.thenExitKinds, options)) {
+        return [getFallthroughConditionStructure(context, statement.expression)];
+    }
+    if (ts.isIfStatement(statement) &&
+        structure.kind === 'if' &&
+        structure.elseExitKinds.length > 0 &&
+        exitKindsSatisfyOptions(structure.elseExitKinds, options)) {
+        return [structure.condition];
+    }
+    if (structure.kind === 'expressionCall') {
+        return [structure.condition];
+    }
+    if (structure.kind === 'try' &&
+        structure.exitKinds.length === 0 &&
+        (!structure.hasCatch ||
+            (structure.catchExitKinds.length > 0 &&
+                exitKindsSatisfyOptions(structure.catchExitKinds, options)))) {
+        return structure.tryTerminalConditions;
+    }
+    return [];
+}
+export function getFlowStatementStructure(context, statement) {
+    return context.facts.getFlowStatementStructure(statement, () => parseStatementStructure(context, statement));
+}
+export function getFlowBranchStructure(context, statement) {
+    return context.facts.getFlowBranchStructure(statement, () => createFlowBranchStructure(context, statement));
+}
+export function getFlowChildRegionStructure(context, statement) {
+    return context.facts.getFlowChildRegionStructure(statement, () => createFlowChildRegionStructure(context, statement));
+}
+export function getFlowRegionStructure(context, regionNode, statements, options = {}) {
+    return context.facts.getFlowRegionStructure(regionNode, getStatementOptionsKey(options), () => createFlowRegionStructure(context, statements, options));
+}
+function createFlowBranchStructure(context, statement) {
+    if (ts.isIfStatement(statement)) {
+        const structure = getFlowStatementStructure(context, statement);
+        const entries = [{
+                entryConditions: structure.kind === 'if' ? [structure.condition] : [],
+                regionNode: getStatementRegionNode(statement.thenStatement),
+                statements: getStatementStatements(statement.thenStatement),
+            }];
+        if (statement.elseStatement) {
+            entries.push({
+                entryConditions: structure.kind === 'if' ? [structure.condition] : [],
+                regionNode: getStatementRegionNode(statement.elseStatement),
+                statements: getStatementStatements(statement.elseStatement),
+            });
+        }
+        return { entries };
+    }
+    if (ts.isWhileStatement(statement) ||
+        ts.isDoStatement(statement) ||
+        ts.isForStatement(statement) ||
+        ts.isForOfStatement(statement) ||
+        ts.isForInStatement(statement)) {
+        const structure = getFlowStatementStructure(context, statement);
+        return {
+            entries: [{
+                    entryConditions: structure.kind === 'loop' && structure.condition
+                        ? [structure.condition]
+                        : [],
+                    regionNode: getStatementRegionNode(statement.statement),
+                    statements: getStatementStatements(statement.statement),
+                }],
+        };
+    }
+    if (ts.isSwitchStatement(statement)) {
+        const switchStructure = getFlowStatementStructure(context, statement);
+        let defaultEntryConditions = [];
+        return {
+            entries: statement.caseBlock.clauses.map((clause, clauseIndex) => {
+                const entryConditions = switchStructure.kind === 'switch' &&
+                    switchStructure.caseConditions[clauseIndex]
+                    ? [switchStructure.caseConditions[clauseIndex]]
+                    : defaultEntryConditions;
+                if (switchStructure.kind === 'switch' && switchStructure.isSwitchTrue) {
+                    if (ts.isCaseClause(clause) &&
+                        exitKindsSatisfyOptions(getStatementsExitKinds(context, clause.statements), {
+                            treatBreakAsExit: true,
+                        })) {
+                        defaultEntryConditions = [
+                            ...defaultEntryConditions,
+                            getFallthroughConditionStructure(context, clause.expression),
+                        ];
+                    }
+                    else {
+                        defaultEntryConditions = [];
+                    }
+                }
+                return {
+                    entryConditions,
+                    regionNode: clause,
+                    statements: clause.statements,
+                };
+            }),
+        };
+    }
+    return { entries: [] };
+}
+function createFlowChildRegionStructure(context, statement) {
+    if (ts.isBlock(statement)) {
+        return {
+            entries: [{
+                    entryConditions: [],
+                    regionNode: statement,
+                    statements: statement.statements,
+                    treatBreakAsExit: false,
+                    treatContinueAsExit: false,
+                }],
+        };
+    }
+    if (ts.isTryStatement(statement)) {
+        const entries = [{
+                entryConditions: [],
+                regionNode: statement.tryBlock,
+                statements: statement.tryBlock.statements,
+                treatBreakAsExit: false,
+                treatContinueAsExit: false,
+            }];
+        if (statement.catchClause) {
+            entries.push({
+                entryConditions: [],
+                regionNode: statement.catchClause.block,
+                statements: statement.catchClause.block.statements,
+                treatBreakAsExit: false,
+                treatContinueAsExit: false,
+            });
+        }
+        if (statement.finallyBlock) {
+            entries.push({
+                entryConditions: [],
+                regionNode: statement.finallyBlock,
+                statements: statement.finallyBlock.statements,
+                treatBreakAsExit: false,
+                treatContinueAsExit: false,
+            });
+        }
+        return { entries };
+    }
+    if (ts.isIfStatement(statement) ||
+        ts.isSwitchStatement(statement) ||
+        ts.isWhileStatement(statement) ||
+        ts.isDoStatement(statement) ||
+        ts.isForStatement(statement) ||
+        ts.isForOfStatement(statement) ||
+        ts.isForInStatement(statement)) {
+        const branchStructure = getFlowBranchStructure(context, statement);
+        return {
+            entries: branchStructure.entries.map((entry) => ({
+                entryConditions: entry.entryConditions,
+                regionNode: entry.regionNode,
+                statements: entry.statements,
+                treatBreakAsExit: ts.isWhileStatement(statement) ||
+                    ts.isDoStatement(statement) ||
+                    ts.isForStatement(statement) ||
+                    ts.isForOfStatement(statement) ||
+                    ts.isForInStatement(statement),
+                treatContinueAsExit: ts.isWhileStatement(statement) ||
+                    ts.isDoStatement(statement) ||
+                    ts.isForStatement(statement) ||
+                    ts.isForOfStatement(statement) ||
+                    ts.isForInStatement(statement),
+            })),
+        };
+    }
+    return { entries: [] };
+}
+function createFlowRegionStructure(context, statements, options) {
+    const entries = [];
+    let sequentialConditions = [];
+    for (const statement of statements) {
+        if (context.isGeneratedNode(statement)) {
+            continue;
+        }
+        entries.push({
+            statement,
+            sequentialConditions,
+        });
+        sequentialConditions = [
+            ...sequentialConditions,
+            ...getSequentialConditionStructures(context, statement, options),
+        ];
+    }
+    return {
+        entries,
+        terminalConditions: sequentialConditions,
+    };
+}
+function getStatementStatements(statement) {
+    return ts.isBlock(statement) ? statement.statements : [statement];
+}
+function getStatementRegionNode(statement) {
+    return statement;
+}
+function parseStatementStructure(context, statement) {
+    if (ts.isReturnStatement(statement) || ts.isThrowStatement(statement)) {
+        return { kind: 'other', exitKinds: ['returnThrow'] };
+    }
+    if (ts.isBreakStatement(statement)) {
+        return { kind: 'other', exitKinds: ['break'] };
+    }
+    if (ts.isContinueStatement(statement)) {
+        return { kind: 'other', exitKinds: ['continue'] };
+    }
+    if (ts.isBlock(statement)) {
+        return { kind: 'other', exitKinds: getStatementsExitKinds(context, statement.statements) };
+    }
+    if (ts.isIfStatement(statement)) {
+        const thenExitKinds = getFlowStatementStructure(context, statement.thenStatement).exitKinds;
+        const elseExitKinds = statement.elseStatement
+            ? getFlowStatementStructure(context, statement.elseStatement).exitKinds
+            : [];
+        const exitKinds = elseExitKinds.length > 0 ? mergeExitKinds(thenExitKinds, elseExitKinds) : [];
+        return {
+            kind: 'if',
+            condition: getFlowConditionStructure(context, statement.expression),
+            thenExitKinds,
+            elseExitKinds,
+            exitKinds,
+        };
+    }
+    if (ts.isWhileStatement(statement) ||
+        ts.isDoStatement(statement) ||
+        ts.isForStatement(statement)) {
+        const condition = ts.isForStatement(statement) ? statement.condition : statement.expression;
+        return {
+            kind: 'loop',
+            condition: condition ? getFlowConditionStructure(context, condition) : undefined,
+            exitKinds: [],
+        };
+    }
+    if (ts.isForOfStatement(statement) || ts.isForInStatement(statement)) {
+        return { kind: 'loop', exitKinds: [] };
+    }
+    if (ts.isSwitchStatement(statement)) {
+        return {
+            kind: 'switch',
+            isSwitchTrue: statement.expression.kind === ts.SyntaxKind.TrueKeyword,
+            caseConditions: statement.caseBlock.clauses.map((clause) => getSwitchClauseConditionStructure(context, statement, clause)),
+            exitKinds: [],
+        };
+    }
+    if (ts.isTryStatement(statement)) {
+        const finallyExitKinds = statement.finallyBlock
+            ? getStatementsExitKinds(context, statement.finallyBlock.statements)
+            : [];
+        return {
+            kind: 'try',
+            tryTerminalConditions: getFlowRegionStructure(context, statement.tryBlock, statement.tryBlock.statements).terminalConditions,
+            catchExitKinds: statement.catchClause
+                ? getStatementsExitKinds(context, statement.catchClause.block.statements)
+                : [],
+            exitKinds: finallyExitKinds,
+            hasCatch: !!statement.catchClause,
+        };
+    }
+    if (ts.isExpressionStatement(statement) && ts.isCallExpression(statement.expression)) {
+        return {
+            kind: 'expressionCall',
+            condition: getFlowConditionStructure(context, statement.expression),
+            exitKinds: [],
+        };
+    }
+    return { kind: 'other', exitKinds: [] };
+}
+function mergeExitKinds(left, right) {
+    if (left.length === 0 || right.length === 0) {
+        return [];
+    }
+    return [...new Set([...left, ...right])];
+}
+function exitKindsSatisfyOptions(exitKinds, options) {
+    return exitKinds.length > 0 &&
+        exitKinds.every((kind) => kind === 'returnThrow' ||
+            (kind === 'break' && !!options.treatBreakAsExit) ||
+            (kind === 'continue' && !!options.treatContinueAsExit));
+}
+function getStatementOptionsKey(options) {
+    return `break:${options.treatBreakAsExit ? '1' : '0'}|continue:${options.treatContinueAsExit ? '1' : '0'}`;
+}
+function getSwitchClauseConditionStructure(context, statement, clause) {
+    if (statement.expression.kind === ts.SyntaxKind.TrueKeyword) {
+        return ts.isCaseClause(clause)
+            ? getFlowConditionStructure(context, clause.expression)
+            : undefined;
+    }
+    const discriminant = statement.expression;
+    const subjectExpression = ts.isTypeOfExpression(discriminant)
+        ? discriminant.expression
+        : discriminant;
+    if ((ts.isIdentifier(subjectExpression) ||
+        ts.isPropertyAccessExpression(subjectExpression) ||
+        ts.isElementAccessExpression(subjectExpression)) &&
+        (ts.isDefaultClause(clause) ||
+            (ts.isCaseClause(clause) && isSwitchCaseLiteral(clause.expression)))) {
+        const kind = ts.isTypeOfExpression(discriminant) ? 'typeof' : 'truthy';
+        return {
+            kind: 'facts',
+            facts: [{
+                    kind,
+                    polarity: 'positive',
+                    sourceNode: clause,
+                    subjectExpression,
+                }],
+        };
+    }
+    return undefined;
+}
+function parseConditionStructure(context, expression) {
+    if (ts.isParenthesizedExpression(expression)) {
+        return parseConditionStructure(context, expression.expression);
+    }
+    if (ts.isPrefixUnaryExpression(expression) && expression.operator === ts.SyntaxKind.ExclamationToken) {
+        return invertConditionStructure(parseConditionStructure(context, expression.operand));
+    }
+    if (ts.isBinaryExpression(expression) &&
+        expression.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
+        return {
+            kind: 'and',
+            left: parseConditionStructure(context, expression.left),
+            right: parseConditionStructure(context, expression.right),
+            rightExpression: expression.right,
+        };
+    }
+    const directFacts = parseDirectConditionFacts(context, expression);
+    return directFacts.length > 0 ? { kind: 'facts', facts: directFacts } : { kind: 'none' };
+}
+function getFallthroughConditionStructure(context, expression) {
+    if (ts.isParenthesizedExpression(expression)) {
+        return getFallthroughConditionStructure(context, expression.expression);
+    }
+    if (ts.isPrefixUnaryExpression(expression) && expression.operator === ts.SyntaxKind.ExclamationToken) {
+        return invertConditionStructure(getFallthroughConditionStructure(context, expression.operand));
+    }
+    if (ts.isBinaryExpression(expression) &&
+        expression.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
+        return {
+            kind: 'and',
+            left: getFallthroughConditionStructure(context, expression.left),
+            right: getFallthroughConditionStructure(context, expression.right),
+            rightExpression: expression.right,
+        };
+    }
+    return getFlowConditionStructure(context, expression);
+}
+function invertConditionStructure(structure) {
+    if (structure.kind === 'none') {
+        return structure;
+    }
+    if (structure.kind === 'and') {
+        return {
+            kind: 'and',
+            left: invertConditionStructure(structure.left),
+            right: invertConditionStructure(structure.right),
+            rightExpression: structure.rightExpression,
+        };
+    }
+    return {
+        kind: 'facts',
+        facts: structure.facts.map((fact) => ({
+            ...fact,
+            polarity: fact.polarity === 'positive' ? 'negative' : 'positive',
+        })),
+    };
+}
+function parseDirectConditionFacts(context, expression) {
+    if (ts.isCallExpression(expression)) {
+        const signature = context.checker.getResolvedSignature(expression);
+        const predicate = signature
+            ? context.checker.getTypePredicateOfSignature(signature)
+            : undefined;
+        if (!predicate) {
+            return [];
+        }
+        if (predicate.parameterIndex !== undefined) {
+            const argument = expression.arguments[predicate.parameterIndex];
+            if (!argument) {
+                return [];
+            }
+            const kind = predicate.kind === ts.TypePredicateKind.AssertsIdentifier
+                ? 'assertionCall'
+                : 'predicateCall';
+            return [{
+                    kind,
+                    polarity: 'positive',
+                    sourceNode: expression,
+                    subjectExpression: argument,
+                }];
+        }
+        if (predicate.kind === ts.TypePredicateKind.AssertsThis ||
+            predicate.kind === ts.TypePredicateKind.This) {
+            const callee = expression.expression;
+            const receiver = ts.isPropertyAccessExpression(callee) || ts.isElementAccessExpression(callee)
+                ? callee.expression
+                : undefined;
+            return receiver
+                ? [{
+                        kind: 'assertionCall',
+                        polarity: 'positive',
+                        sourceNode: expression,
+                        subjectExpression: receiver,
+                    }]
+                : [];
+        }
+    }
+    if (ts.isBinaryExpression(expression) &&
+        expression.operatorToken.kind === ts.SyntaxKind.InstanceOfKeyword) {
+        return [{
+                kind: 'instanceof',
+                polarity: 'positive',
+                sourceNode: expression,
+                subjectExpression: expression.left,
+            }];
+    }
+    if (ts.isBinaryExpression(expression) &&
+        (expression.operatorToken.kind === ts.SyntaxKind.EqualsEqualsEqualsToken ||
+            expression.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsEqualsToken ||
+            expression.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsToken) &&
+        ((ts.isTypeOfExpression(expression.left) && ts.isStringLiteral(expression.right)) ||
+            (ts.isStringLiteral(expression.left) && ts.isTypeOfExpression(expression.right)))) {
+        return [{
+                kind: 'typeof',
+                polarity: 'positive',
+                sourceNode: expression,
+                subjectExpression: ts.isTypeOfExpression(expression.left)
+                    ? expression.left.expression
+                    : expression.right.expression,
+            }];
+    }
+    if (ts.isBinaryExpression(expression) &&
+        expression.operatorToken.kind === ts.SyntaxKind.EqualsEqualsEqualsToken &&
+        (((ts.isPropertyAccessExpression(expression.left) ||
+            ts.isElementAccessExpression(expression.left) ||
+            ts.isIdentifier(expression.left)) &&
+            isSwitchCaseLiteral(expression.right)) ||
+            ((ts.isPropertyAccessExpression(expression.right) ||
+                ts.isElementAccessExpression(expression.right) ||
+                ts.isIdentifier(expression.right)) &&
+                isSwitchCaseLiteral(expression.left)))) {
+        return [{
+                kind: 'discriminantLiteral',
+                polarity: 'positive',
+                sourceNode: expression,
+                subjectExpression: ts.isPropertyAccessExpression(expression.left) ||
+                    ts.isElementAccessExpression(expression.left) ||
+                    ts.isIdentifier(expression.left)
+                    ? expression.left
+                    : expression.right,
+            }];
+    }
+    if (ts.isBinaryExpression(expression) &&
+        expression.operatorToken.kind === ts.SyntaxKind.InKeyword &&
+        (ts.isStringLiteral(expression.left) || ts.isNumericLiteral(expression.left))) {
+        return [{
+                kind: 'inProperty',
+                polarity: 'positive',
+                propertySegment: expression.left.text,
+                sourceNode: expression,
+                subjectExpression: expression.right,
+            }];
+    }
+    if (ts.isBinaryExpression(expression) &&
+        (expression.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsEqualsToken ||
+            expression.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsToken ||
+            expression.operatorToken.kind === ts.SyntaxKind.EqualsEqualsEqualsToken)) {
+        const leftIsUndefined = ts.isIdentifier(expression.left) &&
+            expression.left.text === 'undefined';
+        const rightIsUndefined = ts.isIdentifier(expression.right) &&
+            expression.right.text === 'undefined';
+        const leftIsNull = expression.left.kind === ts.SyntaxKind.NullKeyword;
+        const rightIsNull = expression.right.kind === ts.SyntaxKind.NullKeyword;
+        const subjectExpression = leftIsUndefined
+            ? expression.right
+            : rightIsUndefined
+                ? expression.left
+                : leftIsNull
+                    ? expression.right
+                    : rightIsNull
+                        ? expression.left
+                        : undefined;
+        return subjectExpression
+            ? [{
+                    kind: 'nonNull',
+                    polarity: 'positive',
+                    sourceNode: expression,
+                    subjectExpression,
+                }]
+            : [];
+    }
+    if (ts.isIdentifier(expression) || ts.isPropertyAccessExpression(expression) ||
+        ts.isElementAccessExpression(expression)) {
+        return [{
+                kind: 'truthy',
+                polarity: 'positive',
+                sourceNode: expression,
+                subjectExpression: expression,
+            }];
+    }
+    return [];
+}
+function isSwitchCaseLiteral(expression) {
+    return ts.isStringLiteral(expression) ||
+        ts.isNumericLiteral(expression) ||
+        ts.isNoSubstitutionTemplateLiteral(expression) ||
+        expression.kind === ts.SyntaxKind.TrueKeyword ||
+        expression.kind === ts.SyntaxKind.FalseKeyword ||
+        expression.kind === ts.SyntaxKind.NullKeyword;
+}
+function getStatementsExitKinds(context, statements) {
+    for (const child of statements) {
+        const childStructure = getFlowStatementStructure(context, child);
+        if (childStructure.exitKinds.length > 0) {
+            return childStructure.exitKinds;
+        }
+    }
+    return [];
+}