@flighthq/tool-compiler 0.5.1-edge.1687.b63c819

package/dist/packages/compiler-lowering/src/compilerVariableHoistingInitialization.js

@@ -0,0 +1,724 @@
+import { createCompilerLoweringFailure } from './compilerLoweringPass.js';
+import { combineCompilerVariableInitializationSets, createCompilerVariableInitializationCompletionAlternative, createCompilerVariableInitializationCompletionWithState, } from './compilerVariableInitializationCompletion.js';
+export function validateIrFunctionVariableInitialization(statements, variables, sourceIdentity) {
+    const analysisVariables = new Map(variables);
+    analysisVariables.deferredClosures = collectIrDeferredClosureVariableInitialization(statements);
+    const initialized = new Set([...variables].flatMap(([identity, variable]) => (variable.initialValue === 'undefined' ? [identity] : [])));
+    analyzeIrStatementListVariableInitialization(statements, initialized, analysisVariables, sourceIdentity);
+}
+function addIrExpressionAssignmentTargetVariableInitialization(expression, initialized, variables) {
+    if (expression.kind === 'identifier' &&
+        expression.reference.kind === 'binding' &&
+        variables.has(expression.reference.binding.id)) {
+        initialized.add(expression.reference.binding.id);
+    }
+}
+function analyzeIrExpressionAssignmentTargetVariableInitialization(expression, initialized, variables, sourceIdentity, completion) {
+    if (expression.kind === 'identifier')
+        return;
+    if (expression.kind === 'property') {
+        analyzeIrExpressionVariableInitialization(expression.object, initialized, variables, sourceIdentity, completion);
+        addIrVariableInitializationCompletion(completion, 'throw', initialized);
+        return;
+    }
+    if (expression.kind === 'element') {
+        analyzeIrExpressionVariableInitialization(expression.object, initialized, variables, sourceIdentity, completion);
+        analyzeIrExpressionVariableInitialization(expression.index, initialized, variables, sourceIdentity, completion);
+        addIrVariableInitializationCompletion(completion, 'throw', initialized);
+        return;
+    }
+    analyzeIrExpressionVariableInitialization(expression, initialized, variables, sourceIdentity, completion);
+}
+function analyzeIrExpressionVariableInitialization(expression, initialized, variables, sourceIdentity, completion) {
+    switch (expression.kind) {
+        case 'array':
+            expression.elements.forEach((element) => {
+                if (element) {
+                    analyzeIrExpressionVariableInitialization(element, initialized, variables, sourceIdentity, completion);
+                }
+            });
+            return;
+        case 'assignment':
+            if (expression.operator === '=') {
+                analyzeIrExpressionAssignmentTargetVariableInitialization(expression.left, initialized, variables, sourceIdentity, completion);
+            }
+            else {
+                analyzeIrExpressionVariableInitialization(expression.left, initialized, variables, sourceIdentity, completion);
+            }
+            analyzeIrExpressionVariableInitialization(expression.right, initialized, variables, sourceIdentity, completion);
+            if (expression.left.kind !== 'identifier' ||
+                (expression.operator !== '=' &&
+                    expression.operator !== '&&=' &&
+                    expression.operator !== '||=' &&
+                    expression.operator !== '??=')) {
+                addIrVariableInitializationCompletion(completion, 'throw', initialized);
+            }
+            addIrExpressionAssignmentTargetVariableInitialization(expression.left, initialized, variables);
+            return;
+        case 'await':
+        case 'spread':
+            analyzeIrExpressionVariableInitialization(expression.expression, initialized, variables, sourceIdentity, completion);
+            addIrVariableInitializationCompletion(completion, 'throw', initialized);
+            return;
+        case 'cast':
+            analyzeIrExpressionVariableInitialization(expression.expression, initialized, variables, sourceIdentity, completion);
+            return;
+        case 'binary':
+            analyzeIrExpressionVariableInitialization(expression.left, initialized, variables, sourceIdentity, completion);
+            analyzeIrExpressionVariableInitialization(expression.right, expression.operator === '&&' || expression.operator === '||' || expression.operator === '??'
+                ? new Set(initialized)
+                : initialized, variables, sourceIdentity, completion);
+            if (expression.operator !== ',' &&
+                expression.operator !== '&&' &&
+                expression.operator !== '||' &&
+                expression.operator !== '??' &&
+                expression.operator !== '===' &&
+                expression.operator !== '!==') {
+                addIrVariableInitializationCompletion(completion, 'throw', initialized);
+            }
+            return;
+        case 'call':
+        case 'new': {
+            const immediatelyInvoked = expression.callee.kind === 'function' ? expression.callee : undefined;
+            const deferredClosure = expression.callee.kind === 'identifier' && expression.callee.reference.kind === 'binding'
+                ? getIrDeferredClosureVariableInitialization(expression.callee.reference.binding.id, variables)
+                : undefined;
+            if (!immediatelyInvoked && !deferredClosure) {
+                analyzeIrExpressionVariableInitialization(expression.callee, initialized, variables, sourceIdentity, completion);
+            }
+            expression.arguments.forEach((argument) => analyzeIrExpressionVariableInitialization(argument, initialized, variables, sourceIdentity, completion));
+            if (immediatelyInvoked && expression.kind === 'call' && expression.semantics.statementValue) {
+                const invoked = analyzeIrStatementListVariableInitialization(immediatelyInvoked.body, new Set(initialized), variables, sourceIdentity);
+                addIrVariableInitializationCompletion(completion, 'throw', invoked.throw);
+                const returned = combineCompilerVariableInitializationSets(invoked.normal, invoked.return);
+                if (returned)
+                    replaceIrVariableInitializationSet(initialized, returned);
+                return;
+            }
+            if (immediatelyInvoked) {
+                assertIrExpressionFunctionCaptureVariableInitialization(immediatelyInvoked, initialized, variables, sourceIdentity);
+            }
+            else if (deferredClosure) {
+                assertIrExpressionFunctionCaptureVariableInitialization(deferredClosure, initialized, variables, sourceIdentity);
+            }
+            addIrVariableInitializationCompletion(completion, 'throw', initialized);
+            return;
+        }
+        case 'conditional': {
+            analyzeIrExpressionVariableInitialization(expression.condition, initialized, variables, sourceIdentity, completion);
+            const whenTrue = new Set(initialized);
+            const whenFalse = new Set(initialized);
+            analyzeIrExpressionVariableInitialization(expression.whenTrue, whenTrue, variables, sourceIdentity, completion);
+            analyzeIrExpressionVariableInitialization(expression.whenFalse, whenFalse, variables, sourceIdentity, completion);
+            replaceIrVariableInitializationSet(initialized, combineCompilerVariableInitializationSets(whenTrue, whenFalse));
+            return;
+        }
+        case 'element':
+            analyzeIrExpressionVariableInitialization(expression.object, initialized, variables, sourceIdentity, completion);
+            analyzeIrExpressionVariableInitialization(expression.index, initialized, variables, sourceIdentity, completion);
+            addIrVariableInitializationCompletion(completion, 'throw', initialized);
+            return;
+        case 'function':
+            assertIrExpressionFunctionCaptureVariableInitialization(expression, initialized, variables, sourceIdentity);
+            return;
+        case 'identifier':
+            if (expression.reference.kind === 'binding') {
+                assertIrBindingVariableInitialization(expression.reference.binding.id, initialized, variables, sourceIdentity);
+                const deferredClosure = getIrDeferredClosureVariableInitialization(expression.reference.binding.id, variables);
+                if (deferredClosure) {
+                    assertIrExpressionFunctionCaptureVariableInitialization(deferredClosure, initialized, variables, sourceIdentity);
+                }
+            }
+            return;
+        case 'object':
+            expression.members.forEach((member) => analyzeIrObjectMemberVariableInitialization(member, initialized, variables, sourceIdentity, completion));
+            return;
+        case 'objectRest':
+            analyzeIrExpressionVariableInitialization(expression.object, initialized, variables, sourceIdentity, completion);
+            expression.excluded.forEach((key) => {
+                if (key.kind === 'computed') {
+                    analyzeIrExpressionVariableInitialization(key.expression, initialized, variables, sourceIdentity, completion);
+                }
+            });
+            addIrVariableInitializationCompletion(completion, 'throw', initialized);
+            return;
+        case 'property':
+            analyzeIrExpressionVariableInitialization(expression.object, initialized, variables, sourceIdentity, completion);
+            addIrVariableInitializationCompletion(completion, 'throw', initialized);
+            return;
+        case 'template':
+            expression.parts.forEach((part) => {
+                if (typeof part !== 'string') {
+                    analyzeIrExpressionVariableInitialization(part, initialized, variables, sourceIdentity, completion);
+                    addIrVariableInitializationCompletion(completion, 'throw', initialized);
+                }
+            });
+            return;
+        case 'tuple':
+            expression.elements.forEach((element) => {
+                if (element.expression) {
+                    analyzeIrExpressionVariableInitialization(element.expression, initialized, variables, sourceIdentity, completion);
+                }
+            });
+            return;
+        case 'tupleSpread':
+            expression.segments.forEach((segment) => {
+                const value = segment.kind === 'spread' ? segment.expression : segment.element.expression;
+                if (value) {
+                    analyzeIrExpressionVariableInitialization(value, initialized, variables, sourceIdentity, completion);
+                }
+                if (segment.kind === 'spread')
+                    addIrVariableInitializationCompletion(completion, 'throw', initialized);
+            });
+            return;
+        case 'tupleRest':
+        case 'tupleSuffix':
+            analyzeIrExpressionVariableInitialization(expression.object, initialized, variables, sourceIdentity, completion);
+            addIrVariableInitializationCompletion(completion, 'throw', initialized);
+            return;
+        case 'unary':
+            analyzeIrExpressionVariableInitialization(expression.operand, initialized, variables, sourceIdentity, completion);
+            if (expression.operator !== '!' && expression.operator !== 'typeof' && expression.operator !== 'void') {
+                addIrVariableInitializationCompletion(completion, 'throw', initialized);
+            }
+            if (expression.operator === '++' || expression.operator === '--') {
+                addIrExpressionAssignmentTargetVariableInitialization(expression.operand, initialized, variables);
+            }
+            return;
+        case 'undefinedDefault':
+            analyzeIrExpressionVariableInitialization(expression.value, initialized, variables, sourceIdentity, completion);
+            analyzeIrExpressionVariableInitialization(expression.fallback, new Set(initialized), variables, sourceIdentity, completion);
+            return;
+        case 'literal':
+        case 'regexp':
+        case 'undefinedValue':
+            return;
+        default:
+            assertNeverVariableHoistingInitialization(expression);
+    }
+}
+function analyzeIrObjectMemberVariableInitialization(member, initialized, variables, sourceIdentity, completion) {
+    switch (member.kind) {
+        case 'computedProperty':
+            analyzeIrExpressionVariableInitialization(member.key, initialized, variables, sourceIdentity, completion);
+            addIrVariableInitializationCompletion(completion, 'throw', initialized);
+            analyzeIrExpressionVariableInitialization(member.value, initialized, variables, sourceIdentity, completion);
+            return;
+        case 'getAccessor':
+        case 'property':
+            analyzeIrExpressionVariableInitialization(member.value, initialized, variables, sourceIdentity, completion);
+            return;
+        case 'spread':
+            analyzeIrExpressionVariableInitialization(member.expression, initialized, variables, sourceIdentity, completion);
+            addIrVariableInitializationCompletion(completion, 'throw', initialized);
+            return;
+        default:
+            assertNeverVariableHoistingInitialization(member);
+    }
+}
+function analyzeIrStatementListVariableInitialization(statements, initialized, variables, sourceIdentity) {
+    const completion = { normal: initialized };
+    for (const statement of statements) {
+        const current = completion.normal;
+        if (!current)
+            break;
+        delete completion.normal;
+        mergeIrVariableInitializationCompletions(completion, analyzeIrStatementVariableInitialization(statement, current, variables, sourceIdentity));
+    }
+    return completion;
+}
+function analyzeIrStatementVariableInitialization(statement, initialized, variables, sourceIdentity) {
+    switch (statement.kind) {
+        case 'block':
+            return analyzeIrStatementListVariableInitialization(statement.statements, initialized, variables, sourceIdentity);
+        case 'do': {
+            const body = analyzeIrStatementVariableInitialization(statement.body, new Set(initialized), variables, sourceIdentity);
+            const completion = getIrVariableInitializationAbruptLoopCompletions(body);
+            const backEdge = combineCompilerVariableInitializationSets(body.normal, body.continue);
+            if (backEdge) {
+                analyzeIrExpressionVariableInitialization(statement.condition, backEdge, variables, sourceIdentity, completion);
+                addIrVariableInitializationCompletion(completion, 'normal', backEdge);
+            }
+            addIrVariableInitializationCompletion(completion, 'normal', body.break);
+            return completion;
+        }
+        case 'expression': {
+            const completion = {};
+            analyzeIrExpressionVariableInitialization(statement.expression, initialized, variables, sourceIdentity, completion);
+            addIrVariableInitializationCompletion(completion, 'normal', initialized);
+            return completion;
+        }
+        case 'for': {
+            const completion = {};
+            if (Array.isArray(statement.initializer)) {
+                statement.initializer.forEach((variable) => analyzeIrVariableVariableInitialization(variable, initialized, variables, sourceIdentity, completion));
+            }
+            else if (statement.initializer) {
+                analyzeIrExpressionVariableInitialization(statement.initializer, initialized, variables, sourceIdentity, completion);
+            }
+            if (statement.condition) {
+                analyzeIrExpressionVariableInitialization(statement.condition, initialized, variables, sourceIdentity, completion);
+            }
+            const body = analyzeIrStatementVariableInitialization(statement.body, new Set(initialized), variables, sourceIdentity);
+            const backEdge = combineCompilerVariableInitializationSets(body.normal, body.continue);
+            if (backEdge) {
+                if (statement.increment) {
+                    analyzeIrExpressionVariableInitialization(statement.increment, backEdge, variables, sourceIdentity, completion);
+                }
+                if (statement.condition) {
+                    analyzeIrExpressionVariableInitialization(statement.condition, backEdge, variables, sourceIdentity, completion);
+                }
+            }
+            mergeIrVariableInitializationCompletions(completion, getIrVariableInitializationAbruptLoopCompletions(body));
+            if (statement.condition)
+                addIrVariableInitializationCompletion(completion, 'normal', initialized);
+            addIrVariableInitializationCompletion(completion, 'normal', body.break);
+            return completion;
+        }
+        case 'forIn': {
+            const completion = {};
+            analyzeIrExpressionVariableInitialization(statement.object, initialized, variables, sourceIdentity, completion);
+            addIrVariableInitializationCompletion(completion, 'throw', initialized);
+            const bodyState = new Set(initialized);
+            addIrIterationVariableVariableInitialization(statement.variable, bodyState, variables);
+            const body = analyzeIrStatementVariableInitialization(statement.body, bodyState, variables, sourceIdentity);
+            mergeIrVariableInitializationCompletions(completion, getIrVariableInitializationAbruptLoopCompletions(body));
+            addIrVariableInitializationCompletion(completion, 'normal', initialized);
+            addIrVariableInitializationCompletion(completion, 'normal', body.break);
+            return completion;
+        }
+        case 'forOf': {
+            const completion = {};
+            analyzeIrExpressionVariableInitialization(statement.iterable, initialized, variables, sourceIdentity, completion);
+            addIrVariableInitializationCompletion(completion, 'throw', initialized);
+            const bodyState = new Set(initialized);
+            addIrIterationVariableVariableInitialization(statement.variable, bodyState, variables);
+            const body = analyzeIrStatementVariableInitialization(statement.body, bodyState, variables, sourceIdentity);
+            mergeIrVariableInitializationCompletions(completion, getIrVariableInitializationAbruptLoopCompletions(body));
+            addIrVariableInitializationCompletion(completion, 'normal', initialized);
+            addIrVariableInitializationCompletion(completion, 'normal', body.break);
+            return completion;
+        }
+        case 'if': {
+            const completion = {};
+            analyzeIrExpressionVariableInitialization(statement.condition, initialized, variables, sourceIdentity, completion);
+            const consequent = analyzeIrStatementVariableInitialization(statement.consequent, new Set(initialized), variables, sourceIdentity);
+            const otherwise = statement.otherwise
+                ? analyzeIrStatementVariableInitialization(statement.otherwise, new Set(initialized), variables, sourceIdentity)
+                : { normal: new Set(initialized) };
+            mergeIrVariableInitializationCompletions(completion, createCompilerVariableInitializationCompletionAlternative(consequent, otherwise));
+            return completion;
+        }
+        case 'return': {
+            const completion = {};
+            if (statement.expression) {
+                analyzeIrExpressionVariableInitialization(statement.expression, initialized, variables, sourceIdentity, completion);
+            }
+            addIrVariableInitializationCompletion(completion, 'return', initialized);
+            return completion;
+        }
+        case 'switch': {
+            const completion = {};
+            analyzeIrExpressionVariableInitialization(statement.expression, initialized, variables, sourceIdentity, completion);
+            const directEntries = [];
+            let defaultIndex;
+            const selectionState = new Set(initialized);
+            statement.cases.forEach((switchCase, index) => {
+                if (switchCase.expression) {
+                    analyzeIrExpressionVariableInitialization(switchCase.expression, selectionState, variables, sourceIdentity, completion);
+                    directEntries[index] = new Set(selectionState);
+                }
+                else {
+                    defaultIndex = index;
+                }
+            });
+            if (defaultIndex !== undefined)
+                directEntries[defaultIndex] = new Set(selectionState);
+            if (defaultIndex === undefined) {
+                addIrVariableInitializationCompletion(completion, 'normal', selectionState);
+            }
+            let fallthrough;
+            statement.cases.forEach((switchCase, index) => {
+                const entry = combineCompilerVariableInitializationSets(directEntries[index], fallthrough);
+                if (!entry)
+                    return;
+                const item = analyzeIrStatementListVariableInitialization(switchCase.statements, entry, variables, sourceIdentity);
+                fallthrough = item.normal;
+                addIrVariableInitializationCompletion(completion, 'normal', item.break);
+                addIrVariableInitializationCompletion(completion, 'continue', item.continue);
+                addIrVariableInitializationCompletion(completion, 'return', item.return);
+                addIrVariableInitializationCompletion(completion, 'throw', item.throw);
+            });
+            addIrVariableInitializationCompletion(completion, 'normal', fallthrough);
+            return completion;
+        }
+        case 'throw': {
+            const completion = {};
+            analyzeIrExpressionVariableInitialization(statement.expression, initialized, variables, sourceIdentity, completion);
+            addIrVariableInitializationCompletion(completion, 'throw', initialized);
+            return completion;
+        }
+        case 'try': {
+            const tryCompletion = analyzeIrStatementVariableInitialization(statement.tryBody, new Set(initialized), variables, sourceIdentity);
+            const catchCompletion = statement.catchClause && tryCompletion.throw
+                ? analyzeIrStatementVariableInitialization(statement.catchClause.body, new Set(tryCompletion.throw), variables, sourceIdentity)
+                : undefined;
+            const combined = catchCompletion
+                ? createCompilerVariableInitializationCompletionAlternative(getIrVariableInitializationNonThrowCompletions(tryCompletion), catchCompletion)
+                : statement.catchClause
+                    ? getIrVariableInitializationNonThrowCompletions(tryCompletion)
+                    : tryCompletion;
+            if (!statement.finallyBody)
+                return combined;
+            const afterFinally = {};
+            for (const kind of variableInitializationCompletionKinds) {
+                const state = combined[kind];
+                if (!state)
+                    continue;
+                const finallyCompletion = analyzeIrStatementVariableInitialization(statement.finallyBody, new Set(state), variables, sourceIdentity);
+                addIrVariableInitializationCompletion(afterFinally, kind, finallyCompletion.normal);
+                addIrVariableInitializationCompletion(afterFinally, 'break', finallyCompletion.break);
+                addIrVariableInitializationCompletion(afterFinally, 'continue', finallyCompletion.continue);
+                addIrVariableInitializationCompletion(afterFinally, 'return', finallyCompletion.return);
+                addIrVariableInitializationCompletion(afterFinally, 'throw', finallyCompletion.throw);
+            }
+            return afterFinally;
+        }
+        case 'variable': {
+            const completion = {};
+            statement.declarations.forEach((variable) => analyzeIrVariableVariableInitialization(variable, initialized, variables, sourceIdentity, completion));
+            addIrVariableInitializationCompletion(completion, 'normal', initialized);
+            return completion;
+        }
+        case 'while': {
+            const completion = {};
+            analyzeIrExpressionVariableInitialization(statement.condition, initialized, variables, sourceIdentity, completion);
+            const body = analyzeIrStatementVariableInitialization(statement.body, new Set(initialized), variables, sourceIdentity);
+            const backEdge = combineCompilerVariableInitializationSets(body.normal, body.continue);
+            if (backEdge) {
+                analyzeIrExpressionVariableInitialization(statement.condition, backEdge, variables, sourceIdentity, completion);
+            }
+            mergeIrVariableInitializationCompletions(completion, getIrVariableInitializationAbruptLoopCompletions(body));
+            addIrVariableInitializationCompletion(completion, 'normal', initialized);
+            addIrVariableInitializationCompletion(completion, 'normal', body.break);
+            return completion;
+        }
+        case 'break':
+            return { break: initialized };
+        case 'continue':
+            return { continue: initialized };
+    }
+}
+function addIrIterationVariableVariableInitialization(variable, initialized, variables) {
+    if (!('pattern' in variable) && variables.has(variable.binding.id)) {
+        initialized.add(variable.binding.id);
+    }
+}
+function addIrVariableInitializationCompletion(completion, kind, initialized) {
+    const combined = createCompilerVariableInitializationCompletionWithState(completion, kind, initialized)[kind];
+    if (combined)
+        completion[kind] = new Set(combined);
+}
+function getIrVariableInitializationAbruptLoopCompletions(completion) {
+    return {
+        ...(completion.return ? { return: new Set(completion.return) } : {}),
+        ...(completion.throw ? { throw: new Set(completion.throw) } : {}),
+    };
+}
+function getIrVariableInitializationNonThrowCompletions(completion) {
+    return {
+        ...(completion.break ? { break: new Set(completion.break) } : {}),
+        ...(completion.continue ? { continue: new Set(completion.continue) } : {}),
+        ...(completion.normal ? { normal: new Set(completion.normal) } : {}),
+        ...(completion.return ? { return: new Set(completion.return) } : {}),
+    };
+}
+function mergeIrVariableInitializationCompletions(target, source) {
+    for (const kind of variableInitializationCompletionKinds) {
+        addIrVariableInitializationCompletion(target, kind, source[kind]);
+    }
+}
+function analyzeIrVariableVariableInitialization(variable, initialized, variables, sourceIdentity, completion) {
+    if (variable.initializer) {
+        const deferredClosure = 'binding' in variable ? getIrDeferredClosureVariableInitialization(variable.binding.id, variables) : undefined;
+        if (variable.initializer !== deferredClosure) {
+            analyzeIrExpressionVariableInitialization(variable.initializer, initialized, variables, sourceIdentity, completion);
+        }
+    }
+    if (!('pattern' in variable) && variable.initializer && variables.has(variable.binding.id)) {
+        initialized.add(variable.binding.id);
+    }
+}
+function collectIrDeferredClosureVariableInitialization(statements) {
+    const closures = new Map();
+    const visitVariable = (variable) => {
+        if ('binding' in variable && variable.initializer?.kind === 'function') {
+            closures.set(variable.binding.id, variable.initializer);
+        }
+    };
+    const visitStatement = (statement) => {
+        switch (statement.kind) {
+            case 'block':
+                statement.statements.forEach(visitStatement);
+                return;
+            case 'do':
+            case 'while':
+                visitStatement(statement.body);
+                return;
+            case 'for':
+                if (Array.isArray(statement.initializer))
+                    statement.initializer.forEach(visitVariable);
+                visitStatement(statement.body);
+                return;
+            case 'forIn':
+            case 'forOf':
+                visitVariable(statement.variable);
+                visitStatement(statement.body);
+                return;
+            case 'if':
+                visitStatement(statement.consequent);
+                if (statement.otherwise)
+                    visitStatement(statement.otherwise);
+                return;
+            case 'switch':
+                statement.cases.forEach((switchCase) => switchCase.statements.forEach(visitStatement));
+                return;
+            case 'try':
+                visitStatement(statement.tryBody);
+                if (statement.catchClause)
+                    visitStatement(statement.catchClause.body);
+                if (statement.finallyBody)
+                    visitStatement(statement.finallyBody);
+                return;
+            case 'variable':
+                statement.declarations.forEach(visitVariable);
+                return;
+            case 'break':
+            case 'continue':
+            case 'expression':
+            case 'return':
+            case 'throw':
+                return;
+            default:
+                assertNeverVariableHoistingInitialization(statement);
+        }
+    };
+    statements.forEach(visitStatement);
+    return closures;
+}
+function getIrDeferredClosureVariableInitialization(identity, variables) {
+    return variables.deferredClosures?.get(identity);
+}
+function assertIrBindingVariableInitialization(identity, initialized, variables, sourceIdentity) {
+    const variable = variables.get(identity);
+    if (!variable || initialized.has(identity))
+        return;
+    throw createCompilerLoweringFailure('unsupported-ir', compilerLoweringPassNameVariableHoisting, sourceIdentity, `function-scoped variable ${variable.binding.name} may be read before initialization; undefined-preserving lowering is required`);
+}
+function assertIrExpressionFunctionCaptureVariableInitialization(expression, initialized, variables, sourceIdentity) {
+    const visit = (value) => {
+        if (value.kind === 'identifier' && value.reference.kind === 'binding') {
+            assertIrBindingVariableInitialization(value.reference.binding.id, initialized, variables, sourceIdentity);
+            return;
+        }
+        if (value.kind === 'function')
+            return;
+        visitIrExpressionChildrenVariableInitialization(value, visit);
+    };
+    expression.parameters.forEach((parameter) => {
+        if (parameter.initializer)
+            visit(parameter.initializer);
+    });
+    expression.body.forEach((statement) => visitIrStatementExpressionsVariableInitialization(statement, visit));
+    if (expression.expression)
+        visit(expression.expression);
+}
+function replaceIrVariableInitializationSet(target, source) {
+    target.clear();
+    source.forEach((identity) => target.add(identity));
+}
+function visitIrExpressionChildrenVariableInitialization(expression, visit) {
+    switch (expression.kind) {
+        case 'array':
+            expression.elements.forEach((element) => {
+                if (element)
+                    visit(element);
+            });
+            return;
+        case 'assignment':
+        case 'binary':
+            visit(expression.left);
+            visit(expression.right);
+            return;
+        case 'await':
+        case 'cast':
+        case 'spread':
+            visit(expression.expression);
+            return;
+        case 'call':
+        case 'new':
+            visit(expression.callee);
+            expression.arguments.forEach(visit);
+            return;
+        case 'conditional':
+            visit(expression.condition);
+            visit(expression.whenFalse);
+            visit(expression.whenTrue);
+            return;
+        case 'element':
+            visit(expression.object);
+            visit(expression.index);
+            return;
+        case 'function':
+            return;
+        case 'object':
+            expression.members.forEach((member) => {
+                if (member.kind === 'computedProperty')
+                    visit(member.key);
+                if (member.kind === 'spread')
+                    visit(member.expression);
+                else
+                    visit(member.value);
+            });
+            return;
+        case 'objectRest':
+            visit(expression.object);
+            expression.excluded.forEach((key) => {
+                if (key.kind === 'computed')
+                    visit(key.expression);
+            });
+            return;
+        case 'property':
+            visit(expression.object);
+            return;
+        case 'template':
+            expression.parts.forEach((part) => {
+                if (typeof part !== 'string')
+                    visit(part);
+            });
+            return;
+        case 'tuple':
+            expression.elements.forEach((element) => {
+                if (element.expression)
+                    visit(element.expression);
+            });
+            return;
+        case 'tupleSpread':
+            expression.segments.forEach((segment) => {
+                const value = segment.kind === 'spread' ? segment.expression : segment.element.expression;
+                if (value)
+                    visit(value);
+            });
+            return;
+        case 'tupleRest':
+        case 'tupleSuffix':
+            visit(expression.object);
+            return;
+        case 'unary':
+            visit(expression.operand);
+            return;
+        case 'undefinedDefault':
+            visit(expression.value);
+            visit(expression.fallback);
+            return;
+        case 'identifier':
+        case 'literal':
+        case 'regexp':
+        case 'undefinedValue':
+            return;
+        default:
+            assertNeverVariableHoistingInitialization(expression);
+    }
+}
+function visitIrStatementExpressionsVariableInitialization(statement, visit) {
+    switch (statement.kind) {
+        case 'block':
+            statement.statements.forEach((child) => visitIrStatementExpressionsVariableInitialization(child, visit));
+            return;
+        case 'do':
+        case 'while':
+            visitIrStatementExpressionsVariableInitialization(statement.body, visit);
+            visit(statement.condition);
+            return;
+        case 'expression':
+        case 'throw':
+            visit(statement.expression);
+            return;
+        case 'for':
+            if (Array.isArray(statement.initializer)) {
+                statement.initializer.forEach((variable) => {
+                    if (variable.initializer)
+                        visit(variable.initializer);
+                });
+            }
+            else if (statement.initializer)
+                visit(statement.initializer);
+            if (statement.condition)
+                visit(statement.condition);
+            if (statement.increment)
+                visit(statement.increment);
+            visitIrStatementExpressionsVariableInitialization(statement.body, visit);
+            return;
+        case 'forIn':
+            if (statement.variable.initializer)
+                visit(statement.variable.initializer);
+            visit(statement.object);
+            visitIrStatementExpressionsVariableInitialization(statement.body, visit);
+            return;
+        case 'forOf':
+            if (statement.variable.initializer)
+                visit(statement.variable.initializer);
+            visit(statement.iterable);
+            visitIrStatementExpressionsVariableInitialization(statement.body, visit);
+            return;
+        case 'if':
+            visit(statement.condition);
+            visitIrStatementExpressionsVariableInitialization(statement.consequent, visit);
+            if (statement.otherwise)
+                visitIrStatementExpressionsVariableInitialization(statement.otherwise, visit);
+            return;
+        case 'return':
+            if (statement.expression)
+                visit(statement.expression);
+            return;
+        case 'switch':
+            visit(statement.expression);
+            statement.cases.forEach((switchCase) => {
+                if (switchCase.expression)
+                    visit(switchCase.expression);
+                switchCase.statements.forEach((child) => visitIrStatementExpressionsVariableInitialization(child, visit));
+            });
+            return;
+        case 'try':
+            visitIrStatementExpressionsVariableInitialization(statement.tryBody, visit);
+            if (statement.catchClause)
+                visitIrStatementExpressionsVariableInitialization(statement.catchClause.body, visit);
+            if (statement.finallyBody)
+                visitIrStatementExpressionsVariableInitialization(statement.finallyBody, visit);
+            return;
+        case 'variable':
+            statement.declarations.forEach((variable) => {
+                if (variable.initializer)
+                    visit(variable.initializer);
+            });
+            return;
+        case 'break':
+        case 'continue':
+            return;
+        default:
+            assertNeverVariableHoistingInitialization(statement);
+    }
+}
+const compilerLoweringPassNameVariableHoisting = 'variable-hoisting';
+const variableInitializationCompletionKinds = [
+    'break',
+    'continue',
+    'normal',
+    'return',
+    'throw',
+];
+function assertNeverVariableHoistingInitialization(value) {
+    const kind = value.kind;
+    throw new TypeError(`Unknown neutral IR kind ${String(kind)}`);
+}
+//# sourceMappingURL=compilerVariableHoistingInitialization.js.map