import {

__String,

AccessExpression,

addRelatedInfo,

append,

appendIfUnique,

ArrayBindingElement,

ArrayLiteralExpression,

ArrowFunction,

AssignmentDeclarationKind,

BinaryExpression,

BinaryOperatorToken,

BindableAccessExpression,

BindableObjectDefinePropertyCall,

BindablePropertyAssignmentExpression,

BindableStaticAccessExpression,

BindableStaticNameExpression,

BindableStaticPropertyAssignmentExpression,

BindingElement,

Block,

BreakOrContinueStatement,

CallChain,

CallExpression,

canHaveLocals,

canHaveSymbol,

CaseBlock,

CaseClause,

cast,

CatchClause,

ClassLikeDeclaration,

ClassStaticBlockDeclaration,

CompilerOptions,

concatenate,

ConditionalExpression,

ConditionalTypeNode,

contains,

createBinaryExpressionTrampoline,

createDiagnosticForNodeInSourceFile,

createFileDiagnostic,

createQueue,

createSymbolTable,

Debug,

Declaration,

declarationNameToString,

DeleteExpression,

DestructuringAssignment,

DiagnosticArguments,

DiagnosticCategory,

DiagnosticMessage,

DiagnosticRelatedInformation,

Diagnostics,

DiagnosticWithLocation,

DoStatement,

DynamicNamedDeclaration,

ElementAccessChain,

ElementAccessExpression,

EntityNameExpression,

EnumDeclaration,

escapeLeadingUnderscores,

every,

ExportAssignment,

exportAssignmentIsAlias,

ExportDeclaration,

ExportSpecifier,

Expression,

ExpressionStatement,

findAncestor,

FlowFlags,

FlowLabel,

FlowNode,

FlowReduceLabel,

forEach,

forEachChild,

ForInOrOfStatement,

ForStatement,

FunctionDeclaration,

FunctionExpression,

FunctionLikeDeclaration,

GetAccessorDeclaration,

getAssignedExpandoInitializer,

getAssignmentDeclarationKind,

getAssignmentDeclarationPropertyAccessKind,

getCombinedModifierFlags,

getCombinedNodeFlags,

getContainingClass,

getEffectiveContainerForJSDocTemplateTag,

getElementOrPropertyAccessName,

getEmitModuleResolutionKind,

getEmitScriptTarget,

getEnclosingBlockScopeContainer,

getErrorSpanForNode,

getEscapedTextOfIdentifierOrLiteral,

getExpandoInitializer,

getHostSignatureFromJSDoc,

getImmediatelyInvokedFunctionExpression,

getJSDocTypeTag,

getLeftmostAccessExpression,

getNameOfDeclaration,

getNameOrArgument,

getNodeId,

getRangesWhere,

getRightMostAssignedExpression,

getSourceFileOfNode,

getSourceTextOfNodeFromSourceFile,

getSpanOfTokenAtPosition,

getStrictOptionValue,

getSymbolNameForPrivateIdentifier,

getTextOfIdentifierOrLiteral,

getThisContainer,

getTokenPosOfNode,

HasContainerFlags,

hasDynamicName,

HasFlowNode,

hasJSDocNodes,

HasLocals,

hasSyntacticModifier,

Identifier,

identifierToKeywordKind,

idText,

IfStatement,

ImportClause,

InternalSymbolName,

isAliasableExpression,

isAmbientModule,

isAssignmentExpression,

isAssignmentOperator,

isAssignmentTarget,

isAsyncFunction,

isAutoAccessorPropertyDeclaration,

isBinaryExpression,

isBindableObjectDefinePropertyCall,

isBindableStaticAccessExpression,

isBindableStaticNameExpression,

isBindingPattern,

isBlock,

isBlockOrCatchScoped,

IsBlockScopedContainer,

isCallExpression,

isClassStaticBlockDeclaration,

isConditionalTypeNode,

IsContainer,

isDeclaration,

isDeclarationStatement,

isDestructuringAssignment,

isDottedName,

isElementAccessExpression,

isEmptyObjectLiteral,

isEntityNameExpression,

isEnumConst,

isEnumDeclaration,

isExportAssignment,

isExportDeclaration,

isExportsIdentifier,

isExportSpecifier,

isExpression,

isExpressionOfOptionalChainRoot,

isExternalModule,

isExternalOrCommonJsModule,

isForInOrOfStatement,

isFunctionDeclaration,

isFunctionLike,

isFunctionLikeDeclaration,

isFunctionLikeOrClassStaticBlockDeclaration,

isFunctionSymbol,

isGlobalScopeAugmentation,

isIdentifier,

isIdentifierName,

isInJSFile,

isInTopLevelContext,

isJSDocConstructSignature,

isJSDocEnumTag,

isJSDocTemplateTag,

isJSDocTypeAlias,

isJsonSourceFile,

isLeftHandSideExpression,

isLogicalOrCoalescingAssignmentExpression,

isLogicalOrCoalescingAssignmentOperator,

isLogicalOrCoalescingBinaryExpression,

isLogicalOrCoalescingBinaryOperator,

isModuleAugmentationExternal,

isModuleBlock,

isModuleDeclaration,

isModuleExportsAccessExpression,

isNamedDeclaration,

isNamespaceExport,

isNonNullExpression,

isNullishCoalesce,

isObjectLiteralExpression,

isObjectLiteralMethod,

isObjectLiteralOrClassExpressionMethodOrAccessor,

isOmittedExpression,

isOptionalChain,

isOptionalChainRoot,

isOutermostOptionalChain,

isParameterDeclaration,

isParameterPropertyDeclaration,

isParenthesizedExpression,

isPartOfTypeQuery,

isPrefixUnaryExpression,

isPrivateIdentifier,

isPrologueDirective,

isPropertyAccessEntityNameExpression,

isPropertyAccessExpression,

isPropertyNameLiteral,

isPrototypeAccess,

isPushOrUnshiftIdentifier,

isRequireCall,

isShorthandPropertyAssignment,

isSignedNumericLiteral,

isSourceFile,

isSpecialPropertyDeclaration,

isStatement,

isStatementButNotDeclaration,

isStatic,

isString,

isStringLiteralLike,

isStringOrNumericLiteralLike,

isThisInitializedDeclaration,

isTypeAliasDeclaration,

isTypeOfExpression,

isVariableDeclaration,

isVariableDeclarationInitializedToBareOrAccessedRequire,

isVariableStatement,

JSDocCallbackTag,

JSDocClassTag,

JSDocEnumTag,

JSDocFunctionType,

JSDocOverloadTag,

JSDocParameterTag,

JSDocPropertyLikeTag,

JSDocSignature,

JSDocTypedefTag,

JSDocTypeLiteral,

JsxAttribute,

JsxAttributes,

LabeledStatement,

length,

LiteralLikeElementAccessExpression,

MappedTypeNode,

MetaProperty,

MethodDeclaration,

ModifierFlags,

ModuleBlock,

ModuleDeclaration,

ModuleResolutionKind,

Mutable,

NamespaceExportDeclaration,

Node,

NodeArray,

NodeFlags,

nodeHasName,

nodeIsMissing,

nodeIsPresent,

NonNullChain,

NonNullExpression,

NumericLiteral,

objectAllocator,

ObjectLiteralExpression,

OptionalChain,

ParameterDeclaration,

ParenthesizedExpression,

Pattern,

PatternAmbientModule,

perfLogger,

PostfixUnaryExpression,

PrefixUnaryExpression,

PrivateIdentifier,

PropertyAccessChain,

PropertyAccessEntityNameExpression,

PropertyAccessExpression,

PropertyDeclaration,

PropertySignature,

QualifiedName,

removeFileExtension,

ReturnStatement,

ScriptTarget,

SetAccessorDeclaration,

setParent,

setParentRecursive,

setValueDeclaration,

ShorthandPropertyAssignment,

shouldPreserveConstEnums,

SignatureDeclaration,

skipParentheses,

sliceAfter,

some,

SourceFile,

SpreadElement,

Statement,

StringLiteral,

SuperExpression,

SwitchStatement,

Symbol,

SymbolFlags,

symbolName,

SymbolTable,

SyntaxKind,

TextRange,

ThisExpression,

ThrowStatement,

TokenFlags,

tokenToString,

tracing,

TracingNode,

tryCast,

tryParsePattern,

TryStatement,

TypeLiteralNode,

TypeOfExpression,

TypeParameterDeclaration,

unescapeLeadingUnderscores,

unreachableCodeIsError,

unusedLabelIsError,

VariableDeclaration,

WhileStatement,

WithStatement,

} from "./_namespaces/ts";

import * as performance from "./_namespaces/ts.performance";

/** @internal */

export const enum ModuleInstanceState {

NonInstantiated = 0,

Instantiated = 1,

ConstEnumOnly = 2

}

interface ActiveLabel {

next: ActiveLabel | undefined;

name: __String;

breakTarget: FlowLabel;

continueTarget: FlowLabel | undefined;

referenced: boolean;

}

/** @internal */

export function getModuleInstanceState(node: ModuleDeclaration, visited?: Map<number, ModuleInstanceState | undefined>): ModuleInstanceState {

if (node.body && !node.body.parent) {

// getModuleInstanceStateForAliasTarget needs to walk up the parent chain, so parent pointers must be set on this tree already

setParent(node.body, node);

setParentRecursive(node.body, /*incremental*/ false);

}

return node.body ? getModuleInstanceStateCached(node.body, visited) : ModuleInstanceState.Instantiated;

}

function getModuleInstanceStateCached(node: Node, visited = new Map<number, ModuleInstanceState | undefined>()) {

const nodeId = getNodeId(node);

if (visited.has(nodeId)) {

return visited.get(nodeId) || ModuleInstanceState.NonInstantiated;

}

visited.set(nodeId, undefined);

const result = getModuleInstanceStateWorker(node, visited);

visited.set(nodeId, result);

return result;

}

function getModuleInstanceStateWorker(node: Node, visited: Map<number, ModuleInstanceState | undefined>): ModuleInstanceState {

// A module is uninstantiated if it contains only

switch (node.kind) {

// 1. interface declarations, type alias declarations

case SyntaxKind.InterfaceDeclaration:

case SyntaxKind.TypeAliasDeclaration:

return ModuleInstanceState.NonInstantiated;

// 2. const enum declarations

case SyntaxKind.EnumDeclaration:

if (isEnumConst(node as EnumDeclaration)) {

return ModuleInstanceState.ConstEnumOnly;

}

break;

// 3. non-exported import declarations

case SyntaxKind.ImportDeclaration:

case SyntaxKind.ImportEqualsDeclaration:

if (!(hasSyntacticModifier(node, ModifierFlags.Export))) {

return ModuleInstanceState.NonInstantiated;

}

break;

// 4. Export alias declarations pointing at only uninstantiated modules or things uninstantiated modules contain

case SyntaxKind.ExportDeclaration:

const exportDeclaration = node as ExportDeclaration;

if (!exportDeclaration.moduleSpecifier && exportDeclaration.exportClause && exportDeclaration.exportClause.kind === SyntaxKind.NamedExports) {

let state = ModuleInstanceState.NonInstantiated;

for (const specifier of exportDeclaration.exportClause.elements) {

const specifierState = getModuleInstanceStateForAliasTarget(specifier, visited);

if (specifierState > state) {

state = specifierState;

}

if (state === ModuleInstanceState.Instantiated) {

return state;

}

}

return state;

}

break;

// 5. other uninstantiated module declarations.

case SyntaxKind.ModuleBlock: {

let state = ModuleInstanceState.NonInstantiated;

forEachChild(node, n => {

const childState = getModuleInstanceStateCached(n, visited);

switch (childState) {

case ModuleInstanceState.NonInstantiated:

// child is non-instantiated - continue searching

return;

case ModuleInstanceState.ConstEnumOnly:

// child is const enum only - record state and continue searching

state = ModuleInstanceState.ConstEnumOnly;

return;

case ModuleInstanceState.Instantiated:

// child is instantiated - record state and stop

state = ModuleInstanceState.Instantiated;

return true;

default:

Debug.assertNever(childState);

}

});

return state;

}

case SyntaxKind.ModuleDeclaration:

return getModuleInstanceState(node as ModuleDeclaration, visited);

case SyntaxKind.Identifier:

// Only jsdoc typedef definition can exist in jsdoc namespace, and it should

// be considered the same as type alias

if (node.flags & NodeFlags.IdentifierIsInJSDocNamespace) {

return ModuleInstanceState.NonInstantiated;

}

}

return ModuleInstanceState.Instantiated;

}

function getModuleInstanceStateForAliasTarget(specifier: ExportSpecifier, visited: Map<number, ModuleInstanceState | undefined>) {

const name = specifier.propertyName || specifier.name;

let p: Node | undefined = specifier.parent;

while (p) {

if (isBlock(p) || isModuleBlock(p) || isSourceFile(p)) {

const statements = p.statements;

let found: ModuleInstanceState | undefined;

for (const statement of statements) {

if (nodeHasName(statement, name)) {

if (!statement.parent) {

setParent(statement, p);

setParentRecursive(statement, /*incremental*/ false);

}

const state = getModuleInstanceStateCached(statement, visited);

if (found === undefined || state > found) {

found = state;

}

if (found === ModuleInstanceState.Instantiated) {

return found;

}

}

}

if (found !== undefined) {

return found;

}

}

p = p.parent;

}

return ModuleInstanceState.Instantiated; // Couldn't locate, assume could refer to a value

}

const enum ContainerFlags {

// The current node is not a container, and no container manipulation should happen before

// recursing into it.

None = 0,

// The current node is a container. It should be set as the current container (and block-

// container) before recursing into it. The current node does not have locals. Examples:

//

// Classes, ObjectLiterals, TypeLiterals, Interfaces...

IsContainer = 1 << 0,

// The current node is a block-scoped-container. It should be set as the current block-

// container before recursing into it. Examples:

//

// Blocks (when not parented by functions), Catch clauses, For/For-in/For-of statements...

IsBlockScopedContainer = 1 << 1,

// The current node is the container of a control flow path. The current control flow should

// be saved and restored, and a new control flow initialized within the container.

IsControlFlowContainer = 1 << 2,

IsFunctionLike = 1 << 3,

IsFunctionExpression = 1 << 4,

HasLocals = 1 << 5,

IsInterface = 1 << 6,

IsObjectLiteralOrClassExpressionMethodOrAccessor = 1 << 7,

}

function initFlowNode<T extends FlowNode>(node: T) {

Debug.attachFlowNodeDebugInfo(node);

return node;

}

const binder = /* @__PURE__ */ createBinder();

/** @internal */

export function bindSourceFile(file: SourceFile, options: CompilerOptions) {

performance.mark("beforeBind");

perfLogger?.logStartBindFile("" + file.fileName);

binder(file, options);

perfLogger?.logStopBindFile();

performance.mark("afterBind");

performance.measure("Bind", "beforeBind", "afterBind");

}

function createBinder(): (file: SourceFile, options: CompilerOptions) => void {

// Why var? It avoids TDZ checks in the runtime which can be costly.

// See: https://github.com/microsoft/TypeScript/issues/52924

/* eslint-disable no-var */

var file: SourceFile;

var options: CompilerOptions;

var languageVersion: ScriptTarget;

var parent: Node;

var container: IsContainer | EntityNameExpression;

var thisParentContainer: IsContainer | EntityNameExpression; // Container one level up

var blockScopeContainer: IsBlockScopedContainer;

var lastContainer: HasLocals;

var delayedTypeAliases: (JSDocTypedefTag | JSDocCallbackTag | JSDocEnumTag)[];

var seenThisKeyword: boolean;

// state used by control flow analysis

var currentFlow: FlowNode;

var currentBreakTarget: FlowLabel | undefined;

var currentContinueTarget: FlowLabel | undefined;

var currentReturnTarget: FlowLabel | undefined;

var currentTrueTarget: FlowLabel | undefined;

var currentFalseTarget: FlowLabel | undefined;

var currentExceptionTarget: FlowLabel | undefined;

var preSwitchCaseFlow: FlowNode | undefined;

var activeLabelList: ActiveLabel | undefined;

var hasExplicitReturn: boolean;

// state used for emit helpers

var emitFlags: NodeFlags;

// If this file is an external module, then it is automatically in strict-mode according to

// ES6. If it is not an external module, then we'll determine if it is in strict mode or

// not depending on if we see "use strict" in certain places or if we hit a class/namespace

// or if compiler options contain alwaysStrict.

var inStrictMode: boolean;

// If we are binding an assignment pattern, we will bind certain expressions differently.

var inAssignmentPattern = false;

var symbolCount = 0;

var Symbol: new (flags: SymbolFlags, name: __String) => Symbol;

var classifiableNames: Set<__String>;

var unreachableFlow: FlowNode = { flags: FlowFlags.Unreachable };

var reportedUnreachableFlow: FlowNode = { flags: FlowFlags.Unreachable };

var bindBinaryExpressionFlow = createBindBinaryExpressionFlow();

/* eslint-enable no-var */

return bindSourceFile;

/**

* Inside the binder, we may create a diagnostic for an as-yet unbound node (with potentially no parent pointers, implying no accessible source file)

* If so, the node _must_ be in the current file (as that's the only way anything could have traversed to it to yield it as the error node)

* This version of `createDiagnosticForNode` uses the binder's context to account for this, and always yields correct diagnostics even in these situations.

*/

function createDiagnosticForNode(node: Node, message: DiagnosticMessage, ...args: DiagnosticArguments): DiagnosticWithLocation {

return createDiagnosticForNodeInSourceFile(getSourceFileOfNode(node) || file, node, message, ...args);

}

function bindSourceFile(f: SourceFile, opts: CompilerOptions) {

file = f;

options = opts;

languageVersion = getEmitScriptTarget(options);

inStrictMode = bindInStrictMode(file, opts);

classifiableNames = new Set();

symbolCount = 0;

Symbol = objectAllocator.getSymbolConstructor();

// Attach debugging information if necessary

Debug.attachFlowNodeDebugInfo(unreachableFlow);

Debug.attachFlowNodeDebugInfo(reportedUnreachableFlow);

if (!file.locals) {

tracing?.push(tracing.Phase.Bind, "bindSourceFile", { path: file.path }, /*separateBeginAndEnd*/ true);

bind(file);

tracing?.pop();

file.symbolCount = symbolCount;

file.classifiableNames = classifiableNames;

delayedBindJSDocTypedefTag();

}

file = undefined!;

options = undefined!;

languageVersion = undefined!;

parent = undefined!;

container = undefined!;

thisParentContainer = undefined!;

blockScopeContainer = undefined!;

lastContainer = undefined!;

delayedTypeAliases = undefined!;

seenThisKeyword = false;

currentFlow = undefined!;

currentBreakTarget = undefined;

currentContinueTarget = undefined;

currentReturnTarget = undefined;

currentTrueTarget = undefined;

currentFalseTarget = undefined;

currentExceptionTarget = undefined;

activeLabelList = undefined;

hasExplicitReturn = false;

inAssignmentPattern = false;

emitFlags = NodeFlags.None;

}

function bindInStrictMode(file: SourceFile, opts: CompilerOptions): boolean {

if (getStrictOptionValue(opts, "alwaysStrict") && !file.isDeclarationFile) {

// bind in strict mode source files with alwaysStrict option

return true;

}

else {

return !!file.externalModuleIndicator;

}

}

function createSymbol(flags: SymbolFlags, name: __String): Symbol {

symbolCount++;

return new Symbol(flags, name);

}

function addDeclarationToSymbol(symbol: Symbol, node: Declaration, symbolFlags: SymbolFlags) {

symbol.flags |= symbolFlags;

node.symbol = symbol;

symbol.declarations = appendIfUnique(symbol.declarations, node);

if (symbolFlags & (SymbolFlags.Class | SymbolFlags.Enum | SymbolFlags.Module | SymbolFlags.Variable) && !symbol.exports) {

symbol.exports = createSymbolTable();

}

if (symbolFlags & (SymbolFlags.Class | SymbolFlags.Interface | SymbolFlags.TypeLiteral | SymbolFlags.ObjectLiteral) && !symbol.members) {

symbol.members = createSymbolTable();

}

// On merge of const enum module with class or function, reset const enum only flag (namespaces will already recalculate)

if (symbol.constEnumOnlyModule && (symbol.flags & (SymbolFlags.Function | SymbolFlags.Class | SymbolFlags.RegularEnum))) {

symbol.constEnumOnlyModule = false;

}

if (symbolFlags & SymbolFlags.Value) {

setValueDeclaration(symbol, node);

}

}

// Should not be called on a declaration with a computed property name,

// unless it is a well known Symbol.

function getDeclarationName(node: Declaration): __String | undefined {

if (node.kind === SyntaxKind.ExportAssignment) {

return (node as ExportAssignment).isExportEquals ? InternalSymbolName.ExportEquals : InternalSymbolName.Default;

}

const name = getNameOfDeclaration(node);

if (name) {

if (isAmbientModule(node)) {

const moduleName = getTextOfIdentifierOrLiteral(name as Identifier | StringLiteral);

return (isGlobalScopeAugmentation(node as ModuleDeclaration) ? "__global" : `"${moduleName}"`) as __String;

}

if (name.kind === SyntaxKind.ComputedPropertyName) {

const nameExpression = name.expression;

// treat computed property names where expression is string/numeric literal as just string/numeric literal

if (isStringOrNumericLiteralLike(nameExpression)) {

return escapeLeadingUnderscores(nameExpression.text);

}

if (isSignedNumericLiteral(nameExpression)) {

return tokenToString(nameExpression.operator) + nameExpression.operand.text as __String;

}

else {

Debug.fail("Only computed properties with literal names have declaration names");

}

}

if (isPrivateIdentifier(name)) {

// containingClass exists because private names only allowed inside classes

const containingClass = getContainingClass(node);

if (!containingClass) {

// we can get here in cases where there is already a parse error.

return undefined;

}

const containingClassSymbol = containingClass.symbol;

return getSymbolNameForPrivateIdentifier(containingClassSymbol, name.escapedText);

}

return isPropertyNameLiteral(name) ? getEscapedTextOfIdentifierOrLiteral(name) : undefined;

}

switch (node.kind) {

case SyntaxKind.Constructor:

return InternalSymbolName.Constructor;

case SyntaxKind.FunctionType:

case SyntaxKind.CallSignature:

case SyntaxKind.JSDocSignature:

return InternalSymbolName.Call;

case SyntaxKind.ConstructorType:

case SyntaxKind.ConstructSignature:

return InternalSymbolName.New;

case SyntaxKind.IndexSignature:

return InternalSymbolName.Index;

case SyntaxKind.ExportDeclaration:

return InternalSymbolName.ExportStar;

case SyntaxKind.SourceFile:

// json file should behave as

// module.exports = ...

return InternalSymbolName.ExportEquals;

case SyntaxKind.BinaryExpression:

if (getAssignmentDeclarationKind(node as BinaryExpression) === AssignmentDeclarationKind.ModuleExports) {

// module.exports = ...

return InternalSymbolName.ExportEquals;

}

Debug.fail("Unknown binary declaration kind");

break;

case SyntaxKind.JSDocFunctionType:

return (isJSDocConstructSignature(node) ? InternalSymbolName.New : InternalSymbolName.Call);

case SyntaxKind.Parameter:

// Parameters with names are handled at the top of this function. Parameters

// without names can only come from JSDocFunctionTypes.

Debug.assert(node.parent.kind === SyntaxKind.JSDocFunctionType, "Impossible parameter parent kind", () => `parent is: ${Debug.formatSyntaxKind(node.parent.kind)}, expected JSDocFunctionType`);

const functionType = node.parent as JSDocFunctionType;

const index = functionType.parameters.indexOf(node as ParameterDeclaration);

return "arg" + index as __String;

}

}

function getDisplayName(node: Declaration): string {

return isNamedDeclaration(node) ? declarationNameToString(node.name) : unescapeLeadingUnderscores(Debug.checkDefined(getDeclarationName(node)));

}

/**

* Declares a Symbol for the node and adds it to symbols. Reports errors for conflicting identifier names.

* @param symbolTable - The symbol table which node will be added to.

* @param parent - node's parent declaration.

* @param node - The declaration to be added to the symbol table

* @param includes - The SymbolFlags that node has in addition to its declaration type (eg: export, ambient, etc.)

* @param excludes - The flags which node cannot be declared alongside in a symbol table. Used to report forbidden declarations.

*/

function declareSymbol(symbolTable: SymbolTable, parent: Symbol | undefined, node: Declaration, includes: SymbolFlags, excludes: SymbolFlags, isReplaceableByMethod?: boolean, isComputedName?: boolean): Symbol {

Debug.assert(isComputedName || !hasDynamicName(node));

const isDefaultExport = hasSyntacticModifier(node, ModifierFlags.Default) || isExportSpecifier(node) && node.name.escapedText === "default";

// The exported symbol for an export default function/class node is always named "default"

const name = isComputedName ? InternalSymbolName.Computed

: isDefaultExport && parent ? InternalSymbolName.Default

: getDeclarationName(node);

let symbol: Symbol | undefined;

if (name === undefined) {

symbol = createSymbol(SymbolFlags.None, InternalSymbolName.Missing);

}

else {

// Check and see if the symbol table already has a symbol with this name. If not,

// create a new symbol with this name and add it to the table. Note that we don't

// give the new symbol any flags *yet*. This ensures that it will not conflict

// with the 'excludes' flags we pass in.

//

// If we do get an existing symbol, see if it conflicts with the new symbol we're

// creating. For example, a 'var' symbol and a 'class' symbol will conflict within

// the same symbol table. If we have a conflict, report the issue on each

// declaration we have for this symbol, and then create a new symbol for this

// declaration.

//

// Note that when properties declared in Javascript constructors

// (marked by isReplaceableByMethod) conflict with another symbol, the property loses.

// Always. This allows the common Javascript pattern of overwriting a prototype method

// with an bound instance method of the same type: `this.method = this.method.bind(this)`

//

// If we created a new symbol, either because we didn't have a symbol with this name

// in the symbol table, or we conflicted with an existing symbol, then just add this

// node as the sole declaration of the new symbol.

//

// Otherwise, we'll be merging into a compatible existing symbol (for example when

// you have multiple 'vars' with the same name in the same container). In this case

// just add this node into the declarations list of the symbol.

symbol = symbolTable.get(name);

if (includes & SymbolFlags.Classifiable) {

classifiableNames.add(name);

}

if (!symbol) {

symbolTable.set(name, symbol = createSymbol(SymbolFlags.None, name));

if (isReplaceableByMethod) symbol.isReplaceableByMethod = true;

}

else if (isReplaceableByMethod && !symbol.isReplaceableByMethod) {

// A symbol already exists, so don't add this as a declaration.

return symbol;

}

else if (symbol.flags & excludes) {

if (symbol.isReplaceableByMethod) {

// Javascript constructor-declared symbols can be discarded in favor of

// prototype symbols like methods.

symbolTable.set(name, symbol = createSymbol(SymbolFlags.None, name));

}

else if (!(includes & SymbolFlags.Variable && symbol.flags & SymbolFlags.Assignment)) {

// Assignment declarations are allowed to merge with variables, no matter what other flags they have.

if (isNamedDeclaration(node)) {

setParent(node.name, node);

}

// Report errors every position with duplicate declaration

// Report errors on previous encountered declarations

let message = symbol.flags & SymbolFlags.BlockScopedVariable

? Diagnostics.Cannot_redeclare_block_scoped_variable_0

: Diagnostics.Duplicate_identifier_0;

let messageNeedsName = true;

if (symbol.flags & SymbolFlags.Enum || includes & SymbolFlags.Enum) {

message = Diagnostics.Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations;

messageNeedsName = false;

}

let multipleDefaultExports = false;

if (length(symbol.declarations)) {

// If the current node is a default export of some sort, then check if

// there are any other default exports that we need to error on.

// We'll know whether we have other default exports depending on if `symbol` already has a declaration list set.

if (isDefaultExport) {

message = Diagnostics.A_module_cannot_have_multiple_default_exports;

messageNeedsName = false;

multipleDefaultExports = true;

}

else {

// This is to properly report an error in the case "export default { }" is after export default of class declaration or function declaration.

// Error on multiple export default in the following case:

// 1. multiple export default of class declaration or function declaration by checking NodeFlags.Default

// 2. multiple export default of export assignment. This one doesn't have NodeFlags.Default on (as export default doesn't considered as modifiers)

if (symbol.declarations && symbol.declarations.length &&

(node.kind === SyntaxKind.ExportAssignment && !(node as ExportAssignment).isExportEquals)) {

message = Diagnostics.A_module_cannot_have_multiple_default_exports;

messageNeedsName = false;

multipleDefaultExports = true;

}

}

}

const relatedInformation: DiagnosticRelatedInformation[] = [];

if (isTypeAliasDeclaration(node) && nodeIsMissing(node.type) && hasSyntacticModifier(node, ModifierFlags.Export) && symbol.flags & (SymbolFlags.Alias | SymbolFlags.Type | SymbolFlags.Namespace)) {

// export type T; - may have meant export type { T }?

relatedInformation.push(createDiagnosticForNode(node, Diagnostics.Did_you_mean_0, `export type { ${unescapeLeadingUnderscores(node.name.escapedText)} }`));

}

const declarationName = getNameOfDeclaration(node) || node;

forEach(symbol.declarations, (declaration, index) => {

const decl = getNameOfDeclaration(declaration) || declaration;

const diag = messageNeedsName ? createDiagnosticForNode(decl, message, getDisplayName(declaration)) : createDiagnosticForNode(decl, message);

file.bindDiagnostics.push(

multipleDefaultExports ? addRelatedInfo(diag, createDiagnosticForNode(declarationName, index === 0 ? Diagnostics.Another_export_default_is_here : Diagnostics.and_here)) : diag

);

if (multipleDefaultExports) {

relatedInformation.push(createDiagnosticForNode(decl, Diagnostics.The_first_export_default_is_here));

}

});

const diag = messageNeedsName ? createDiagnosticForNode(declarationName, message, getDisplayName(node)) : createDiagnosticForNode(declarationName, message);

file.bindDiagnostics.push(addRelatedInfo(diag, ...relatedInformation));

symbol = createSymbol(SymbolFlags.None, name);

}

}

}

addDeclarationToSymbol(symbol, node, includes);

if (symbol.parent) {

Debug.assert(symbol.parent === parent, "Existing symbol parent should match new one");

}

else {

symbol.parent = parent;

}

return symbol;

}

function declareModuleMember(node: Declaration, symbolFlags: SymbolFlags, symbolExcludes: SymbolFlags): Symbol {

const hasExportModifier = !!(getCombinedModifierFlags(node) & ModifierFlags.Export) || jsdocTreatAsExported(node);

if (symbolFlags & SymbolFlags.Alias) {

if (node.kind === SyntaxKind.ExportSpecifier || (node.kind === SyntaxKind.ImportEqualsDeclaration && hasExportModifier)) {

return declareSymbol(container.symbol.exports!, container.symbol, node, symbolFlags, symbolExcludes);

}

else {

Debug.assertNode(container, canHaveLocals);

return declareSymbol(container.locals!, /*parent*/ undefined, node, symbolFlags, symbolExcludes);

}

}

else {

// Exported module members are given 2 symbols: A local symbol that is classified with an ExportValue flag,

// and an associated export symbol with all the correct flags set on it. There are 2 main reasons:

//

// 1. We treat locals and exports of the same name as mutually exclusive within a container.

// That means the binder will issue a Duplicate Identifier error if you mix locals and exports

// with the same name in the same container.

// TODO: Make this a more specific error and decouple it from the exclusion logic.

// 2. When we checkIdentifier in the checker, we set its resolved symbol to the local symbol,

// but return the export symbol (by calling getExportSymbolOfValueSymbolIfExported). That way

// when the emitter comes back to it, it knows not to qualify the name if it was found in a containing scope.

// NOTE: Nested ambient modules always should go to to 'locals' table to prevent their automatic merge

// during global merging in the checker. Why? The only case when ambient module is permitted inside another module is module augmentation

// and this case is specially handled. Module augmentations should only be merged with original module definition

// and should never be merged directly with other augmentation, and the latter case would be possible if automatic merge is allowed.

if (isJSDocTypeAlias(node)) Debug.assert(isInJSFile(node)); // We shouldn't add symbols for JSDoc nodes if not in a JS file.

if (!isAmbientModule(node) && (hasExportModifier || container.flags & NodeFlags.ExportContext)) {

if (!canHaveLocals(container) || !container.locals || (hasSyntacticModifier(node, ModifierFlags.Default) && !getDeclarationName(node))) {

return declareSymbol(container.symbol.exports!, container.symbol, node, symbolFlags, symbolExcludes); // No local symbol for an unnamed default!

}

const exportKind = symbolFlags & SymbolFlags.Value ? SymbolFlags.ExportValue : 0;

const local = declareSymbol(container.locals, /*parent*/ undefined, node, exportKind, symbolExcludes);

local.exportSymbol = declareSymbol(container.symbol.exports!, container.symbol, node, symbolFlags, symbolExcludes);

node.localSymbol = local;

return local;

}

else {

Debug.assertNode(container, canHaveLocals);

return declareSymbol(container.locals!, /*parent*/ undefined, node, symbolFlags, symbolExcludes);

}

}

}

function jsdocTreatAsExported(node: Node) {

if (node.parent && isModuleDeclaration(node)) {

node = node.parent;

}

if (!isJSDocTypeAlias(node)) return false;

// jsdoc typedef handling is a bit of a doozy, but to summarize, treat the typedef as exported if:

// 1. It has an explicit name (since by default typedefs are always directly exported, either at the top level or in a container), or

if (!isJSDocEnumTag(node) && !!node.fullName) return true;

// 2. The thing a nameless typedef pulls its name from is implicitly a direct export (either by assignment or actual export flag).

const declName = getNameOfDeclaration(node);

if (!declName) return false;

if (isPropertyAccessEntityNameExpression(declName.parent) && isTopLevelNamespaceAssignment(declName.parent)) return true;

if (isDeclaration(declName.parent) && getCombinedModifierFlags(declName.parent) & ModifierFlags.Export) return true;

// This could potentially be simplified by having `delayedBindJSDocTypedefTag` pass in an override for `hasExportModifier`, since it should

// already have calculated and branched on most of this.

return false;

}

// All container nodes are kept on a linked list in declaration order. This list is used by

// the getLocalNameOfContainer function in the type checker to validate that the local name

// used for a container is unique.

function bindContainer(node: Mutable<HasContainerFlags>, containerFlags: ContainerFlags) {

// Before we recurse into a node's children, we first save the existing parent, container

// and block-container. Then after we pop out of processing the children, we restore

// these saved values.

const saveContainer = container;

const saveThisParentContainer = thisParentContainer;

const savedBlockScopeContainer = blockScopeContainer;

// Depending on what kind of node this is, we may have to adjust the current container

// and block-container. If the current node is a container, then it is automatically

// considered the current block-container as well. Also, for containers that we know

// may contain locals, we eagerly initialize the .locals field. We do this because

// it's highly likely that the .locals will be needed to place some child in (for example,

// a parameter, or variable declaration).

//

// However, we do not proactively create the .locals for block-containers because it's

// totally normal and common for block-containers to never actually have a block-scoped

// variable in them. We don't want to end up allocating an object for every 'block' we

// run into when most of them won't be necessary.

//

// Finally, if this is a block-container, then we clear out any existing .locals object

// it may contain within it. This happens in incremental scenarios. Because we can be

// reusing a node from a previous compilation, that node may have had 'locals' created

// for it. We must clear this so we don't accidentally move any stale data forward from

// a previous compilation.

if (containerFlags & ContainerFlags.IsContainer) {

if (node.kind !== SyntaxKind.ArrowFunction) {

thisParentContainer = container;

}

container = blockScopeContainer = node as IsContainer;

if (containerFlags & ContainerFlags.HasLocals) {

(container as HasLocals).locals = createSymbolTable();

addToContainerChain(container as HasLocals);

}

}

else if (containerFlags & ContainerFlags.IsBlockScopedContainer) {

blockScopeContainer = node as IsBlockScopedContainer;

if (containerFlags & ContainerFlags.HasLocals) {

(blockScopeContainer as HasLocals).locals = undefined;

}

}

if (containerFlags & ContainerFlags.IsControlFlowContainer) {

const saveCurrentFlow = currentFlow;

const saveBreakTarget = currentBreakTarget;

const saveContinueTarget = currentContinueTarget;

const saveReturnTarget = currentReturnTarget;

const saveExceptionTarget = currentExceptionTarget;

const saveActiveLabelList = activeLabelList;

const saveHasExplicitReturn = hasExplicitReturn;

const isImmediatelyInvoked =

(containerFlags & ContainerFlags.IsFunctionExpression &&

!hasSyntacticModifier(node, ModifierFlags.Async) &&

!(node as FunctionLikeDeclaration).asteriskToken &&

!!getImmediatelyInvokedFunctionExpression(node)) ||

node.kind === SyntaxKind.ClassStaticBlockDeclaration;

// A non-async, non-generator IIFE is considered part of the containing control flow. Return statements behave

// similarly to break statements that exit to a label just past the statement body.

if (!isImmediatelyInvoked) {

currentFlow = initFlowNode({ flags: FlowFlags.Start });

if (containerFlags & (ContainerFlags.IsFunctionExpression | ContainerFlags.IsObjectLiteralOrClassExpressionMethodOrAccessor)) {

currentFlow.node = node as FunctionExpression | ArrowFunction | MethodDeclaration | GetAccessorDeclaration | SetAccessorDeclaration;

}

}