functions of TypeScript/src/compiler/checker.ts

checker_functions.ts

// generate
function *generateJsxAttributes(node: JsxAttributes): ElaborationIterator {
function *generateJsxChildren(node: JsxElement, getInvalidTextDiagnostic: () => DiagnosticMessage): ElaborationIterator {
function *generateLimitedTupleElements(node: ArrayLiteralExpression, target: Type): ElaborationIterator {
function *generateObjectLiteralElements(node: ObjectLiteralExpression): ElaborationIterator {

// accepts
function acceptsVoid(t: Type): boolean {
function acceptsVoidUndefinedUnknownOrAny(t: Type): boolean {
// add
function addDeclarationDiagnostic(id: string, message: DiagnosticMessage) {
function addDeclarationToLateBoundSymbol(symbol: Symbol, member: LateBoundDeclaration | BinaryExpression, symbolFlags: SymbolFlags) {
function addDeprecatedSuggestion(location: Node, declarations: Node[], deprecatedEntity: string) {
function addDeprecatedSuggestionWithSignature(location: Node, declaration: Node, deprecatedEntity: string | undefined, signatureString: string) {
function addDeprecatedSuggestionWorker(declarations: Node | Node[], diagnostic: DiagnosticWithLocation) {
function addDuplicateDeclarationError(node: Declaration, message: DiagnosticMessage, symbolName: string, relatedNodes: readonly Declaration[] | undefined) {
function addDuplicateDeclarationErrorsForSymbols(target: Symbol, message: DiagnosticMessage, symbolName: string, source: Symbol) {
function addDuplicateLocations(locs: Declaration[], symbol: Symbol): void {
function addElement(type: Type, flags: ElementFlags, declaration: NamedTupleMember | ParameterDeclaration | undefined) {
function addErrorOrSuggestion(isError: boolean, diagnostic: Diagnostic) {
function addEvolvingArrayElementType(evolvingArrayType: EvolvingArrayType, node: Expression): EvolvingArrayType {
function addExportModifier(node: Extract<HasModifiers, Statement>) {
function addImplementationSuccessElaboration(failed: Signature, diagnostic: Diagnostic) {
function addInheritedMembers(symbols: SymbolTable, baseSymbols: Symbol[]) {
function addMatch(s: number, p: number) {
function addMemberForKeyType(keyType: Type) {
function addMemberForKeyTypeWorker(keyType: Type, propNameType: Type) {
function addName(names: UnderscoreEscapedMap<DeclarationMeaning>, location: Node, name: __String, meaning: DeclarationMeaning) {
function addNamedUnions(namedUnions: Type[], types: readonly Type[]) {
function addOptionalTypeMarker(type: Type) {
function addOptionality(type: Type, isProperty = false, isOptional = true): Type {
function addPropertyToElementList(propertySymbol: Symbol, context: NodeBuilderContext, typeElements: TypeElement[]) {
function addReferencedFilesToTypeDirective(file: SourceFile, key: string) {
function addResult(node: Statement, additionalModifierFlags: ModifierFlags) {
function addSpans(texts: readonly string[], types: readonly Type[]): boolean {
function addToGroup<K, V>(map: ESMap<string, [K, V[]]>, key: K, value: V, getKey: (key: K) => number | string): void {
function addToSymbolTable(target: SymbolTable, source: SymbolTable, message: DiagnosticMessage) {
function addTypeToIntersection(typeSet: ESMap<string, Type>, includes: TypeFlags, type: Type) {
function addTypeToUnion(typeSet: Type[], includes: TypeFlags, type: Type) {
function addTypesToIntersection(typeSet: ESMap<string, Type>, includes: TypeFlags, types: readonly Type[]) {
function addTypesToUnion(typeSet: Type[], includes: TypeFlags, types: readonly Type[]): TypeFlags {
function addVisibleAlias(declaration: Declaration, aliasingStatement: LateVisibilityPaintedStatement) {

function allTypesAssignableToKind(source: Type, kind: TypeFlags, strict?: boolean): boolean {
function allowLetAndConstDeclarations(parent: Node): boolean {

// append
function appendIndexInfo(indexInfos: IndexInfo[] | undefined, newInfo: IndexInfo, union: boolean) {
function appendReferenceToType(root: TypeReferenceNode | ImportTypeNode, ref: TypeReferenceNode): TypeReferenceNode | ImportTypeNode {
function appendSignatures(signatures: Signature[] | undefined, newSignatures: readonly Signature[]) {
function appendTypeMapping(mapper: TypeMapper | undefined, source: Type, target: Type) {
function appendTypeParameters(typeParameters: TypeParameter[] | undefined, declarations: readonly TypeParameterDeclaration[]): TypeParameter[] | undefined {

// apply
function applyStringMapping(symbol: Symbol, str: string) {
function applyToParameterTypes(source: Signature, target: Signature, callback: (s: Type, t: Type) => void) {
function applyToReturnTypes(source: Signature, target: Signature, callback: (s: Type, t: Type) => void) {

// are
function areDeclarationFlagsIdentical(left: Declaration, right: Declaration) {
function areTypeParametersIdentical(declarations: readonly (ClassDeclaration | InterfaceDeclaration)[], targetParameters: TypeParameter[]) {
function areTypesComparable(type Type, type Type): boolean {

// assign
function assignBindingElementTypes(pattern: BindingPattern) {
function assignContextualParameterTypes(signature: Signature, context: Signature) {
function assignNonContextualParameterTypes(signature: Signature) {
function assignParameterType(parameter: Symbol, type?: Type) {

function associateRelatedInfo(info: DiagnosticRelatedInformation) {
function bindingNameText(name: BindingName): string {
function bothAreBigIntLike(left: Type, right: Type): boolean {
function buildVisibleNodeList(declarations: Declaration[] | undefined) {
function callLikeExpressionMayHaveTypeArguments(node: CallLikeExpression): node is CallExpression | NewExpression | TaggedTemplateExpression | JsxOpeningElement {

// can
function canConvertImportDeclarationToTypeOnly(statement: Statement) {
function canConvertImportEqualsDeclarationToTypeOnly(statement: Statement) {
function canHaveConstantValue(node: Node): node is EnumMember | AccessExpression {
function canHaveExportModifier(node: Statement): node is Extract<HasModifiers, Statement> {
function canHaveSyntheticDefault(file: SourceFile | undefined, moduleSymbol: Symbol, dontResolveAlias: boolean) {
function canQualifySymbol(symbolFromSymbolTable: Symbol, meaning: SymbolFlags) {

// capture
function captureErrorCalculationState() {
function captureLexicalThis(node: Node, container: Node): void {

function check(type: Type): boolean {
function checkAccessorDeclaration(node: AccessorDeclaration) {
function checkAliasSymbol(node: ImportEqualsDeclaration | VariableDeclaration | ImportClause | NamespaceImport | ImportSpecifier | ExportSpecifier | NamespaceExport) {
function checkAllCodePathsInNonVoidFunctionReturnOrThrow(func: FunctionLikeDeclaration | MethodSignature, returnType: Type | undefined): void {
function checkAmbientInitializer(node: VariableDeclaration | PropertyDeclaration | PropertySignature) {
function checkAndAggregateReturnExpressionTypes(func: FunctionLikeDeclaration, checkMode: CheckMode | undefined): Type[] | undefined {
function checkAndAggregateYieldOperandTypes(func: FunctionLikeDeclaration, checkMode: CheckMode | undefined) {
function checkAndReportErrorForExportingPrimitiveType(errorLocation: Node, name: __String): boolean {
function checkAndReportErrorForExtendingInterface(errorLocation: Node): boolean {
function checkAndReportErrorForMissingPrefix(errorLocation: Node, name: __String, nameArg: __String | Identifier): boolean {
function checkAndReportErrorForResolvingImportAliasToTypeOnlySymbol(node: ImportEqualsDeclaration, resolved: Symbol | undefined) {
function checkAndReportErrorForUsingNamespaceModuleAsValue(errorLocation: Node, name: __String, meaning: SymbolFlags): boolean {
function checkAndReportErrorForUsingTypeAsNamespace(errorLocation: Node, name: __String, meaning: SymbolFlags): boolean {
function checkAndReportErrorForUsingTypeAsValue(errorLocation: Node, name: __String, meaning: SymbolFlags): boolean {
function checkAndReportErrorForUsingValueAsType(errorLocation: Node, name: __String, meaning: SymbolFlags): boolean {
function checkApplicableSignatureForJsxOpeningLikeElement(
function checkArithmeticOperandType(operand: Node, type: Type, diagnostic: DiagnosticMessage, isAwaitValid = false): boolean {
function checkArrayLiteral(node: ArrayLiteralExpression, checkMode: CheckMode | undefined, forceTuple: boolean | undefined): Type {
function checkArrayLiteralAssignment(node: ArrayLiteralExpression, sourceType: Type, checkMode?: CheckMode): Type {
function checkArrayLiteralDestructuringElementAssignment(node: ArrayLiteralExpression, sourceType: Type,
function checkArrayType(node: ArrayTypeNode) {
function checkAssertion(node: AssertionExpression) {
function checkAssertionWorker(errNode: Node, type: TypeNode, expression: UnaryExpression | Expression, checkMode?: CheckMode) {
function checkAssignmentDeclaration(kind: AssignmentDeclarationKind, rightType: Type) {
function checkAssignmentOperator(valueType: Type): void {
function checkAsyncFunctionReturnType(node: FunctionLikeDeclaration | MethodSignature, returnTypeNode: TypeNode) {
function checkAwaitExpression(node: AwaitExpression): Type {
function checkAwaitedType(type: Type, errorNode: Node, diagnosticMessage: DiagnosticMessage, arg0?: string | number): Type {
function checkBaseTypeAccessibility(type: Type, node: ExpressionWithTypeArguments) {
function checkBinaryLikeExpression(left: Expression, operatorToken: Node, right: Expression, checkMode?: CheckMode, errorNode?: Node): Type {
function checkBinaryLikeExpressionWorker(
function checkBindingElement(node: BindingElement) {
function checkBlock(node: Block) {
function checkBreakOrContinueStatement(node: BreakOrContinueStatement) {
function checkCallExpression(node: CallExpression | NewExpression, checkMode?: CheckMode): Type {
function checkClassDeclaration(node: ClassDeclaration) {
function checkClassExpression(node: ClassExpression): Type {
function checkClassExpressionDeferred(node: ClassExpression) {
function checkClassForDuplicateDeclarations(node: ClassLikeDeclaration) {
function checkClassForStaticPropertyNameConflicts(node: ClassLikeDeclaration) {
function checkClassLikeDeclaration(node: ClassLikeDeclaration) {
function checkClassMember(member: ClassElement | ParameterPropertyDeclaration, memberIsParameterProperty?: boolean) {
function checkClassNameCollisionWithObject(name: Identifier): void {
function checkClassStaticBlockDeclaration(node: ClassStaticBlockDeclaration) {
function checkCollisionWithArgumentsInGeneratedCode(node: SignatureDeclaration) {
function checkCollisionWithGlobalPromiseInGeneratedCode(node: Node, name: Identifier | undefined): void {
function checkCollisionWithRequireExportsInGeneratedCode(node: Node, name: Identifier | undefined) {
function checkCollisionsForDeclarationName(node: Node, name: Identifier | undefined) {
function checkComputedPropertyName(node: ComputedPropertyName): Type {
function checkConditionalExpression(node: ConditionalExpression, checkMode?: CheckMode): Type {
function checkConditionalType(node: ConditionalTypeNode) {
function checkConstEnumAccess(node: Expression | QualifiedName, type: Type) {
function checkConstructorDeclaration(node: ConstructorDeclaration) {
function checkCrossProductUnion(types: readonly Type[]) {
function checkDeclarationInitializer(declaration: HasExpressionInitializer, contextualType?: Type | undefined) {
function checkDecorator(node: Decorator): void {
function checkDecorators(node: Node): void {
function checkDeferredNode(node: Node) {
function checkDeferredNodes(context: SourceFile) {
function checkDeleteExpression(node: DeleteExpression): Type {
function checkDeleteExpressionMustBeOptional(expr: AccessExpression, symbol: Symbol) {
function checkDeprecatedSignature(signature: Signature, node: CallLikeExpression) {
function checkDestructuringAssignment(exprOrAssignment: Expression | ShorthandPropertyAssignment, sourceType: Type, checkMode?: CheckMode, rightIsThis?: boolean): Type {
function checkDoStatement(node: DoStatement) {
function checkESModuleMarker(name: Identifier | BindingPattern): boolean {
function checkElementAccessChain(node: ElementAccessChain, checkMode: CheckMode | undefined) {
function checkElementAccessExpression(node: ElementAccessExpression, exprType: Type, checkMode: CheckMode | undefined): Type {
function checkEnumDeclaration(node: EnumDeclaration) {
function checkEnumMember(node: EnumMember) {
function checkExportAssignment(node: ExportAssignment) {
function checkExportDeclaration(node: ExportDeclaration) {
function checkExportSpecifier(node: ExportSpecifier) {
function checkExportsOnMergedDeclarations(node: Declaration): void {
function checkExpression(node: Expression | QualifiedName, checkMode?: CheckMode, forceTuple?: boolean): Type {
function checkExpressionCached(node: Expression | QualifiedName, checkMode?: CheckMode): Type {
function checkExpressionForMutableLocation(node: Expression, checkMode: CheckMode | undefined, contextualType?: Type, forceTuple?: boolean): Type {
function checkExpressionForMutableLocationWithContextualType(next: Expression, sourcePropType: Type) {
function checkExpressionStatement(node: ExpressionStatement) {
function checkExpressionWithContextualType(node: Expression, contextualType: Type, inferenceContext: InferenceContext | undefined, checkMode: CheckMode): Type {
function checkExpressionWorker(node: Expression | QualifiedName, checkMode: CheckMode | undefined, forceTuple?: boolean): Type {
function checkExternalEmitHelpers(location: Node, helpers: ExternalEmitHelpers) {
function checkExternalImportOrExportDeclaration(node: ImportDeclaration | ImportEqualsDeclaration | ExportDeclaration): boolean {
function checkExternalModuleExports(node: SourceFile | ModuleDeclaration) {
function checkFlagAgreementBetweenOverloads(overloads: Declaration[], implementation: FunctionLikeDeclaration | undefined, flagsToCheck: ModifierFlags, someOverloadFlags: ModifierFlags, allOverloadFlags: ModifierFlags): void {
function checkForDisallowedESSymbolOperand(operator: SyntaxKind): boolean {
function checkForInOrForOfVariableDeclaration(iterationStatement: ForInOrOfStatement): void {
function checkForInStatement(node: ForInStatement) {
function checkForOfStatement(node: ForOfStatement): void {
function checkForStatement(node: ForStatement) {
function checkFunctionDeclaration(node: FunctionDeclaration): void {
function checkFunctionExpressionOrObjectLiteralMethod(node: FunctionExpression | ArrowFunction | MethodDeclaration, checkMode?: CheckMode): Type {
function checkFunctionExpressionOrObjectLiteralMethodDeferred(node: ArrowFunction | FunctionExpression | MethodDeclaration) {
function checkFunctionOrConstructorSymbol(symbol: Symbol): void {
function checkFunctionOrMethodDeclaration(node: FunctionDeclaration | MethodDeclaration | MethodSignature): void {
function checkGrammarAccessor(accessor: AccessorDeclaration): boolean {
function checkGrammarArguments(args: NodeArray<Expression> | undefined): boolean {
function checkGrammarArrowFunction(node: Node, file: SourceFile): boolean {
function checkGrammarAsyncModifier(node: Node, asyncModifier: Node): boolean {
function checkGrammarBigIntLiteral(node: BigIntLiteral): boolean {
function checkGrammarBindingElement(node: BindingElement) {
function checkGrammarBreakOrContinueStatement(node: BreakOrContinueStatement): boolean {
function checkGrammarClassDeclarationHeritageClauses(node: ClassLikeDeclaration) {
function checkGrammarClassLikeDeclaration(node: ClassLikeDeclaration): boolean {
function checkGrammarComputedPropertyName(node: Node): boolean {
function checkGrammarConstructorTypeAnnotation(node: ConstructorDeclaration) {
function checkGrammarConstructorTypeParameters(node: ConstructorDeclaration) {
function checkGrammarDecorators(node: Node): boolean {
function checkGrammarDecoratorsAndModifiers(node: Node): boolean {
function checkGrammarExportDeclaration(node: ExportDeclaration): boolean {
function checkGrammarExpressionWithTypeArguments(node: ExpressionWithTypeArguments) {
function checkGrammarForAtLeastOneTypeArgument(node: Node, typeArguments: NodeArray<TypeNode> | undefined): boolean {
function checkGrammarForDisallowedLetOrConstStatement(node: VariableStatement) {
function checkGrammarForDisallowedTrailingComma(list: NodeArray<Node> | undefined, diag = Diagnostics.Trailing_comma_not_allowed): boolean {
function checkGrammarForGenerator(node: FunctionLikeDeclaration) {
function checkGrammarForInOrForOfStatement(forInOrOfStatement: ForInOrOfStatement): boolean {
function checkGrammarForInvalidDynamicName(node: DeclarationName, message: DiagnosticMessage) {
function checkGrammarForInvalidExclamationToken(exclamationToken: ExclamationToken | undefined, message: DiagnosticMessage): boolean {
function checkGrammarForInvalidQuestionMark(questionToken: QuestionToken | undefined, message: DiagnosticMessage): boolean {
function checkGrammarForOmittedArgument(args: NodeArray<Expression> | undefined): boolean {
function checkGrammarForUseStrictSimpleParameterList(node: FunctionLikeDeclaration): boolean {
function checkGrammarFunctionLikeDeclaration(node: FunctionLikeDeclaration | MethodSignature): boolean {
function checkGrammarHeritageClause(node: HeritageClause): boolean {
function checkGrammarImportCallExpression(node: ImportCall): boolean {
function checkGrammarImportClause(node: ImportClause): boolean {
function checkGrammarIndexSignature(node: SignatureDeclaration) {
function checkGrammarIndexSignatureParameters(node: SignatureDeclaration): boolean {
function checkGrammarInterfaceDeclaration(node: InterfaceDeclaration) {
function checkGrammarJsxElement(node: JsxOpeningLikeElement) {
function checkGrammarJsxExpression(node: JsxExpression) {
function checkGrammarJsxName(node: JsxTagNameExpression) {
function checkGrammarJsxNestedIdentifier(name: MemberName | ThisExpression) {
function checkGrammarMetaProperty(node: MetaProperty) {
function checkGrammarMethod(node: MethodDeclaration | MethodSignature) {
function checkGrammarModifiers(node: Node): boolean {
function checkGrammarModuleElementContext(node: Statement, errorMessage: DiagnosticMessage): boolean {
function checkGrammarNameInLetOrConstDeclarations(name: Identifier | BindingPattern): boolean {
function checkGrammarNullishCoalesceWithLogicalExpression(node: BinaryExpression) {
function checkGrammarNumericLiteral(node: NumericLiteral): boolean {
function checkGrammarObjectLiteralExpression(node: ObjectLiteralExpression, inDestructuring: boolean) {
function checkGrammarParameterList(parameters: NodeArray<ParameterDeclaration>) {
function checkGrammarProperty(node: PropertyDeclaration | PropertySignature) {
function checkGrammarSourceFile(node: SourceFile): boolean {
function checkGrammarStatementInAmbientContext(node: Node): boolean {
function checkGrammarTaggedTemplateChain(node: TaggedTemplateExpression): boolean {
function checkGrammarTopLevelElementForRequiredDeclareModifier(node: Node): boolean {
function checkGrammarTopLevelElementsForRequiredDeclareModifier(file: SourceFile): boolean {
function checkGrammarTypeArguments(node: Node, typeArguments: NodeArray<TypeNode> | undefined): boolean {
function checkGrammarTypeOperatorNode(node: TypeOperatorNode) {
function checkGrammarTypeParameterList(typeParameters: NodeArray<TypeParameterDeclaration> | undefined, file: SourceFile): boolean {
function checkGrammarVariableDeclaration(node: VariableDeclaration) {
function checkGrammarVariableDeclarationList(declarationList: VariableDeclarationList): boolean {
function checkIdentifier(node: Identifier, checkMode: CheckMode | undefined): Type {
function checkIfNewTargetIsCapturedInEnclosingScope(node: Node): void {
function checkIfStatement(node: IfStatement) {
function checkIfThisIsCapturedInEnclosingScope(node: Node): void {
function checkIfTypePredicateVariableIsDeclaredInBindingPattern(
function checkImportBinding(node: ImportEqualsDeclaration | ImportClause | NamespaceImport | ImportSpecifier) {
function checkImportCallExpression(node: ImportCall): Type {
function checkImportDeclaration(node: ImportDeclaration) {
function checkImportEqualsDeclaration(node: ImportEqualsDeclaration) {
function checkImportMetaProperty(node: MetaProperty) {
function checkImportType(node: ImportTypeNode) {
function checkImportsForTypeOnlyConversion(sourceFile: SourceFile) {
function checkInExpression(left: Expression, right: Expression, leftType: Type, rightType: Type): Type {
function checkIndexConstraintForIndexSignature(type: Type, checkInfo: IndexInfo) {
function checkIndexConstraintForProperty(type: Type, prop: Symbol, propNameType: Type, propType: Type) {
function checkIndexConstraints(type: Type, isStaticIndex?: boolean) {
function checkIndexedAccess(node: ElementAccessExpression, checkMode: CheckMode | undefined): Type {
function checkIndexedAccessIndexType(type: Type, accessNode: IndexedAccessTypeNode | ElementAccessExpression) {
function checkIndexedAccessType(node: IndexedAccessTypeNode) {
function checkInferType(node: InferTypeNode) {
function checkInheritedPropertiesAreIdentical(type: InterfaceType, typeNode: Node): boolean {
function checkInstanceOfExpression(left: Expression, right: Expression, leftType: Type, rightType: Type): Type {
function checkInterfaceDeclaration(node: InterfaceDeclaration) {
function checkIteratedTypeOrElementType(use: IterationUse, inputType: Type, sentType: Type, errorNode: Node | undefined): Type {
function checkJSDocAugmentsTag(node: JSDocAugmentsTag): void {
function checkJSDocFunctionType(node: JSDocFunctionType): void {
function checkJSDocImplementsTag(node: JSDocImplementsTag): void {
function checkJSDocParameterTag(node: JSDocParameterTag) {
function checkJSDocPropertyTag(node: JSDocPropertyTag) {
function checkJSDocTemplateTag(node: JSDocTemplateTag): void {
function checkJSDocTypeAliasTag(node: JSDocTypedefTag | JSDocCallbackTag) {
function checkJSDocTypeIsInJsFile(node: Node): void {
function checkJSDocTypeTag(node: JSDocTypeTag) {
function checkJSDocVariadicType(node: JSDocVariadicType): void {
function checkJsxAttribute(node: JsxAttribute, checkMode?: CheckMode) {
function checkJsxAttributes(node: JsxAttributes, checkMode: CheckMode | undefined) {
function checkJsxChildren(node: JsxElement | JsxFragment, checkMode?: CheckMode) {
function checkJsxElement(node: JsxElement, _checkMode: CheckMode | undefined): Type {
function checkJsxElementDeferred(node: JsxElement) {
function checkJsxExpression(node: JsxExpression, checkMode?: CheckMode) {
function checkJsxFragment(node: JsxFragment): Type {
function checkJsxOpeningLikeElementOrOpeningFragment(node: JsxOpeningLikeElement | JsxOpeningFragment) {
function checkJsxPreconditions(errorNode: Node) {
function checkJsxReturnAssignableToAppropriateBound(refKind: JsxReferenceKind, elemInstanceType: Type, openingLikeElement: JsxOpeningLikeElement) {
function checkJsxSelfClosingElement(node: JsxSelfClosingElement, _checkMode: CheckMode | undefined): Type {
function checkJsxSelfClosingElementDeferred(node: JsxSelfClosingElement) {
function checkKindsOfPropertyMemberOverrides(type: InterfaceType, baseType: BaseType): void {
function checkLabeledStatement(node: LabeledStatement) {
function checkMappedType(node: MappedTypeNode) {
function checkMembersForMissingOverrideModifier(node: ClassLikeDeclaration, type: InterfaceType, typeWithThis: Type, staticType: ObjectType) {
function checkMetaProperty(node: MetaProperty): Type {
function checkMethodDeclaration(node: MethodDeclaration | MethodSignature) {
function checkMissingDeclaration(node: Node) {
function checkModuleAugmentationElement(node: Node, isGlobalAugmentation: boolean): void {
function checkModuleDeclaration(node: ModuleDeclaration) {
function checkNamedTupleMember(node: NamedTupleMember) {
function checkNestedBlockScopedBinding(node: Identifier, symbol: Symbol): void {
function checkNewTargetMetaProperty(node: MetaProperty) {
function checkNoTypeArguments(node: NodeWithTypeArguments, symbol?: Symbol) {
function checkNodeDeferred(node: Node) {
function checkNonNullAssertion(node: NonNullExpression) {
function checkNonNullChain(node: NonNullChain) {
function checkNonNullExpression(node: Expression | QualifiedName) {
function checkNonNullNonVoidType(type: Type, node: Node): Type {
function checkNonNullType(type: Type, node: Node) {
function checkNonNullTypeWithReporter(
function checkNumericLiteralValueSize(node: NumericLiteral) {
function checkObjectLiteral(node: ObjectLiteralExpression, checkMode?: CheckMode): Type {
function checkObjectLiteralAssignment(node: ObjectLiteralExpression, sourceType: Type, rightIsThis?: boolean): Type {
function checkObjectLiteralDestructuringPropertyAssignment(node: ObjectLiteralExpression, objectLiteralType: Type, propertyIndex: number, allProperties?: NodeArray<ObjectLiteralElementLike>, rightIsThis = false) {
function checkObjectLiteralMethod(node: MethodDeclaration, checkMode?: CheckMode): Type {
function checkObjectTypeForDuplicateDeclarations(node: TypeLiteralNode | InterfaceDeclaration) {
function checkParameter(node: ParameterDeclaration) {
function checkParenthesizedExpression(node: ParenthesizedExpression, checkMode?: CheckMode): Type {
function checkPostfixUnaryExpression(node: PostfixUnaryExpression): Type {
function checkPrefixUnaryExpression(node: PrefixUnaryExpression): Type {
function checkPrivateIdentifierPropertyAccess(leftType: Type, right: PrivateIdentifier, lexicallyScopedIdentifier: Symbol | undefined): boolean {
function checkPropertyAccessChain(node: PropertyAccessChain, checkMode: CheckMode | undefined) {
function checkPropertyAccessExpression(node: PropertyAccessExpression, checkMode: CheckMode | undefined) {
function checkPropertyAccessExpressionOrQualifiedName(node: PropertyAccessExpression | QualifiedName, left: Expression | QualifiedName, leftType: Type, right: Identifier | PrivateIdentifier, checkMode: CheckMode | undefined) {
function checkPropertyAccessibility(
function checkPropertyAssignment(node: PropertyAssignment, checkMode?: CheckMode): Type {
function checkPropertyDeclaration(node: PropertyDeclaration | PropertySignature) {
function checkPropertyInitialization(node: ClassLikeDeclaration) {
function checkPropertyNotUsedBeforeDeclaration(prop: Symbol, node: PropertyAccessExpression | QualifiedName, right: Identifier | PrivateIdentifier): void {
function checkPropertySignature(node: PropertySignature) {
function checkQualifiedName(node: QualifiedName, checkMode: CheckMode | undefined) {
function checkQuestionTokenAgreementBetweenOverloads(overloads: Declaration[], implementation: FunctionLikeDeclaration | undefined, someHaveQuestionToken: boolean, allHaveQuestionToken: boolean): void {
function checkReferenceAssignment(target: Expression, sourceType: Type, checkMode?: CheckMode): Type {
function checkReferenceExpression(expr: Expression, invalidReferenceMessage: DiagnosticMessage, invalidOptionalChainMessage: DiagnosticMessage): boolean {
function checkReflectCollision(node: Node) {
function checkResolvedBlockScopedVariable(result: Symbol, errorLocation: Node): void {
function checkReturnStatement(node: ReturnStatement) {
function checkRightHandSideOfForOf(statement: ForOfStatement): Type {
function checkSignatureDeclaration(node: SignatureDeclaration) {
function checkSourceElement(node: Node | undefined): void {
function checkSourceElementWorker(node: Node): void {
function checkSourceFile(node: SourceFile) {
function checkSourceFileWorker(node: SourceFile) {
function checkSpreadExpression(node: SpreadElement, checkMode?: CheckMode): Type {
function checkSpreadPropOverrides(type: Type, props: SymbolTable, spread: SpreadAssignment | JsxSpreadAttribute) {
function checkSuperExpression(node: Node): Type {
function checkSwitchStatement(node: SwitchStatement) {
function checkSymbolUsageInExpressionContext(symbol: Symbol, name: __String, useSite: Node) {
function checkSyntheticExpression(node: SyntheticExpression): Type {
function checkTagNameDoesNotExpectTooManyArguments(): boolean {
function checkTaggedTemplateExpression(node: TaggedTemplateExpression): Type {
function checkTemplateExpression(node: TemplateExpression): Type {
function checkTemplateLiteralType(node: TemplateLiteralTypeNode) {
function checkTestingKnownTruthyCallableOrAwaitableType(condExpr: Expression, type: Type, body?: Statement | Expression) {
function checkThisBeforeSuper(node: Node, container: Node, diagnosticMessage: DiagnosticMessage) {
function checkThisExpression(node: Node): Type {
function checkThisInStaticClassFieldInitializerInDecoratedClass(thisExpression: Node, container: Node) {
function checkThisType(node: ThisTypeNode) {
function checkThrowStatement(node: ThrowStatement) {
function checkTruncationLength(context: NodeBuilderContext): boolean {
function checkTruthinessExpression(node: Expression, checkMode?: CheckMode) {
function checkTruthinessOfType(type: Type, node: Node) {
function checkTryStatement(node: TryStatement) {
function checkTupleType(node: TupleTypeNode) {
function checkTypeAliasDeclaration(node: TypeAliasDeclaration) {
function checkTypeArgumentConstraints(node: TypeReferenceNode | ExpressionWithTypeArguments, typeParameters: readonly TypeParameter[]): boolean {
function checkTypeArguments(signature: Signature, typeArgumentNodes: readonly TypeNode[], reportErrors: boolean, headMessage?: DiagnosticMessage): Type[] | undefined {
function checkTypeAssignableTo(source: Type, target: Type, errorNode: Node | undefined, headMessage?: DiagnosticMessage, containingMessageChain?: () => DiagnosticMessageChain | undefined, errorOutputObject?: { errors?: Diagnostic[] }): boolean {
function checkTypeAssignableToAndOptionallyElaborate(source: Type, target: Type, errorNode: Node | undefined, expr: Expression | undefined, headMessage?: DiagnosticMessage, containingMessageChain?: () => DiagnosticMessageChain | undefined): boolean {
function checkTypeComparableTo(source: Type, target: Type, errorNode: Node, headMessage?: DiagnosticMessage, containingMessageChain?: () => DiagnosticMessageChain | undefined): boolean {
function checkTypeForDuplicateIndexSignatures(node: Node) {
function checkTypeLiteral(node: TypeLiteralNode) {
function checkTypeNameIsReserved(name: Identifier, message: DiagnosticMessage): void {
function checkTypeOfExpression(node: TypeOfExpression): Type {
function checkTypeOperator(node: TypeOperatorNode) {
function checkTypeParameter(node: TypeParameterDeclaration) {
function checkTypeParameterListsIdentical(symbol: Symbol) {
function checkTypeParameters(typeParameterDeclarations: readonly TypeParameterDeclaration[] | undefined) {
function checkTypeParametersNotReferenced(root: TypeNode, typeParameters: readonly TypeParameterDeclaration[], index: number) {
function checkTypePredicate(node: TypePredicateNode): void {
function checkTypeQuery(node: TypeQueryNode) {
function checkTypeReferenceNode(node: TypeReferenceNode | ExpressionWithTypeArguments) {
function checkTypeRelatedTo(
function checkTypeRelatedToAndOptionallyElaborate(
function checkUnionOrIntersectionType(node: UnionOrIntersectionTypeNode) {
function checkUnusedClassMembers(node: ClassDeclaration | ClassExpression, addDiagnostic: AddUnusedDiagnostic): void {
function checkUnusedIdentifiers(potentiallyUnusedIdentifiers: readonly PotentiallyUnusedIdentifier[], addDiagnostic: AddUnusedDiagnostic) {
function checkUnusedInferTypeParameter(node: InferTypeNode, addDiagnostic: AddUnusedDiagnostic): void {
function checkUnusedLocalsAndParameters(nodeWithLocals: Node, addDiagnostic: AddUnusedDiagnostic): void {
function checkUnusedTypeParameters(node: ClassLikeDeclaration | SignatureDeclaration | InterfaceDeclaration | TypeAliasDeclaration, addDiagnostic: AddUnusedDiagnostic): void {
function checkVarDeclaredNamesNotShadowed(node: VariableDeclaration | BindingElement) {
function checkVariableDeclaration(node: VariableDeclaration) {
function checkVariableLikeDeclaration(node: ParameterDeclaration | PropertyDeclaration | PropertySignature | VariableDeclaration | BindingElement) {
function checkVariableStatement(node: VariableStatement) {
function checkVoidExpression(node: VoidExpression): Type {
function checkWeakMapSetCollision(node: Node) {
function checkWhileStatement(node: WhileStatement) {
function checkWithStatement(node: WithStatement) {
function checkYieldExpression(node: YieldExpression): Type {

// choose
function chooseOverload(candidates: Signature[], relation: ESMap<string, RelationComparisonResult>, isSingleNonGenericCandidate: boolean, signatureHelpTrailingComma = false) {

function classDeclarationExtendsNull(classDecl: ClassDeclaration): boolean {

function cleanup<T>(result: T): T {

function clearCachedInferences(inferences: InferenceInfo[]) {

// clone
function cloneBindingName(node: BindingName): BindingName {
function cloneInferenceContext<T extends InferenceContext | undefined>(context: T, extraFlags: InferenceFlags = 0): InferenceContext | T & undefined {
function cloneInferenceInfo(inference: InferenceInfo): InferenceInfo {
function cloneInferredPartOfContext(context: InferenceContext): InferenceContext | undefined {
function cloneNodeBuilderContext(context: NodeBuilderContext): NodeBuilderContext {
function cloneSignature(sig: Signature): Signature {
function cloneSymbol(symbol: Symbol): Symbol {
function cloneTypeParameter(typeParameter: TypeParameter): TypeParameter {
function cloneTypeReference(source: TypeReference): TypeReference {

function collectLinkedAliases(node: Identifier, setVisibility?: boolean): Node[] | undefined {

// combine
function combineIntersectionParameters(left: Signature, right: Signature, mapper: TypeMapper | undefined) {
function combineIntersectionThisParam(left: Symbol | undefined, right: Symbol | undefined, mapper: TypeMapper | undefined): Symbol | undefined {
function combineIterationTypes(array: (IterationTypes | undefined)[]) {
function combineSignaturesOfIntersectionMembers(left: Signature, right: Signature): Signature {
function combineSignaturesOfUnionMembers(left: Signature, right: Signature): Signature {
function combineSymbolTables(first: SymbolTable | undefined, second: SymbolTable | undefined): SymbolTable | undefined {
function combineTypeMappers(mapper TypeMapper | undefined, mapper TypeMapper): TypeMapper {
function combineUnionParameters(left: Signature, right: Signature, mapper: TypeMapper | undefined) {
function combineUnionThisParam(left: Symbol | undefined, right: Symbol | undefined, mapper: TypeMapper | undefined): Symbol | undefined {
function combineValueAndTypeSymbols(valueSymbol: Symbol, typeSymbol: Symbol): Symbol {

// compare
function compareProperties(sourceProp: Symbol, targetProp: Symbol, compareTypes: (source: Type, target: Type) => Ternary): Ternary {
function compareSignaturesIdentical(source: Signature, target: Signature, partialMatch: boolean, ignoreThisTypes: boolean, ignoreReturnTypes: boolean, compareTypes: (s: Type, t: Type) => Ternary): Ternary {
function compareSignaturesRelated(source: Signature,
function compareTypeParametersIdentical(sourceParams: readonly TypeParameter[] | undefined, targetParams: readonly TypeParameter[] | undefined): boolean {
function compareTypePredicateRelatedTo(
function compareTypePredicatesIdentical(source: TypePredicate | undefined, target: TypePredicate | undefined, compareTypes: (s: Type, t: Type) => Ternary): Ternary {
function compareTypesAssignable(source: Type, target: Type): Ternary {
function compareTypesIdentical(source: Type, target: Type): Ternary {
function compareTypesSubtypeOf(source: Type, target: Type): Ternary {

// compute
function computeBaseConstraint(t: Type): Type | undefined {
function computeConstantValue(member: EnumMember): string | number | undefined {
function computeEnumMemberValues(node: EnumDeclaration) {
function computeExhaustiveSwitchStatement(node: SwitchStatement): boolean {
function computeMemberValue(member: EnumMember, autoValue: number | undefined) {

function conditionalTypeToTypeNode(type: ConditionalType) {

function constructorVisibilitiesAreCompatible(sourceSignature: Signature, targetSignature: Signature, reportErrors: boolean) {

function containerSeemsToBeEmptyDomElement(containingType: Type) {

// contains
function containsArgumentsReference(declaration: SignatureDeclaration): boolean {
function containsGenericType(type: Type): boolean {
function containsMatchingReference(source: Node, target: Node) {
function containsMissingType(type: Type) {
function containsReference(node: Node): boolean {
function containsSameNamedThisProperty(thisProperty: Expression, expression: Expression) {
function containsTruthyCheck(source: Node, target: Node): boolean {
function containsType(types: readonly Type[], type: Type): boolean {

function contextuallyCheckFunctionExpressionOrObjectLiteralMethod(node: FunctionExpression | ArrowFunction | MethodDeclaration, checkMode?: CheckMode) {

function convertAutoToAny(type: Type) {

// copy
function copyLocallyVisibleExportSymbols(source: SymbolTable, meaning: SymbolFlags): void {
function copySymbol(symbol: Symbol, meaning: SymbolFlags): void {
function copySymbols(source: SymbolTable, meaning: SymbolFlags): void {

function couldContainTypeVariables(type: Type): boolean {

function countMessageChainBreadth(info: DiagnosticMessageChain[] | undefined): number {

function countTypes(type: Type) {

// create
function createAccessFromSymbolChain(chain: Symbol[], index: number, stopper: number): EntityName | IndexedAccessTypeNode {
function createAnonymousType(symbol: Symbol | undefined, members: SymbolTable, callSignatures: readonly Signature[], constructSignatures: readonly Signature[], indexInfos: readonly IndexInfo[]): ResolvedType {
function createAnonymousTypeNode(type: ObjectType): TypeNode {
function createArrayLiteralType(type: Type) {
function createArrayType(elementType: Type, readonly?: boolean): ObjectType {
function createBackreferenceMapper(context: InferenceContext, index: number): TypeMapper {
function createCanonicalSignature(signature: Signature) {
function createCheckBinaryExpression() {
function createCombinedSymbolForOverloadFailure(sources: readonly Symbol[], type: Type): Symbol {
function createCombinedSymbolFromTypes(sources: readonly Symbol[], types: Type[]): Symbol {
function createDeferredTypeReference(target: GenericType, node: TypeReferenceNode | ArrayTypeNode | TupleTypeNode, mapper?: TypeMapper, aliasSymbol?: Symbol, aliasTypeArguments?: readonly Type[]): DeferredTypeReference {
function createElidedInformationPlaceholder(context: NodeBuilderContext) {
function createEmptyObjectTypeFromStringLiteral(type: Type) {
function createEntityNameFromSymbolChain(chain: Symbol[], index: number): EntityName {
function createErasedSignature(signature: Signature) {
function createError(location: Node | undefined, message: DiagnosticMessage, arg0?: string | number, arg1?: string | number, arg2?: string | number, arg3?: string | number): Diagnostic {
function createEvolvingArrayType(elementType: Type): EvolvingArrayType {
function createExpressionFromSymbolChain(chain: Symbol[], index: number): Expression {
function createFinalArrayType(elementType: Type) {
function createFlowType(type: Type, incomplete: boolean): FlowType {
function createGeneratorReturnType(yieldType: Type, returnType: Type, nextType: Type, isAsyncGenerator: boolean) {
function createIndexInfo(keyType: Type, type: Type, isReadonly: boolean, declaration?: IndexSignatureDeclaration): IndexInfo {
function createIndexType(type: InstantiableType | UnionOrIntersectionType, stringsOnly: boolean) {
function createIndexedAccessType(objectType: Type, indexType: Type, accessFlags: AccessFlags, aliasSymbol: Symbol | undefined, aliasTypeArguments: readonly Type[] | undefined) {
function createInferenceContext(typeParameters: readonly TypeParameter[], signature: Signature | undefined, flags: InferenceFlags, compareTypes?: TypeComparer): InferenceContext {
function createInferenceContextWorker(inferences: InferenceInfo[], signature: Signature | undefined, flags: InferenceFlags, compareTypes: TypeComparer): InferenceContext {
function createInferenceInfo(typeParameter: TypeParameter): InferenceInfo {
function createInstantiatedSymbolTable(symbols: Symbol[], mapper: TypeMapper, mappingThisOnly: boolean): SymbolTable {
function createIntersectionType(types: Type[], aliasSymbol?: Symbol, aliasTypeArguments?: readonly Type[]) {
function createIntrinsicType(kind: TypeFlags, intrinsicName: string, objectFlags: ObjectFlags = 0): IntrinsicType {
function createIterableType(iteratedType: Type): Type {
function createIterationTypes(yieldType: Type = neverType, returnType: Type = neverType, nextType: Type = unknownType): IterationTypes {
function createJsxAttributesType() {
function createJsxAttributesTypeFromAttributesProperty(openingLikeElement: JsxOpeningLikeElement, checkMode: CheckMode | undefined) {
function createLiteralConstValue(node: VariableDeclaration | PropertyDeclaration | PropertySignature | ParameterDeclaration, tracker: SymbolTracker) {
function createLiteralType(flags: TypeFlags, value: string | number | PseudoBigInt, symbol?: Symbol, regularType?: LiteralType) {
function createMappedTypeNodeFromType(type: MappedType) {
function createNodeBuilder() {
function createNormalizedTupleType(target: TupleType, elementTypes: readonly Type[]): Type {
function createNormalizedTypeReference(target: GenericType, typeArguments: readonly Type[] | undefined) {
function createObjectLiteralType() {
function createObjectType(objectFlags: ObjectFlags, symbol?: Symbol): ObjectType {
function createOptionalCallSignature(signature: Signature, callChainFlags: SignatureFlags) {
function createOriginIndexType(type: InstantiableType | UnionOrIntersectionType) {
function createOriginType(flags: TypeFlags): Type {
function createOriginUnionOrIntersectionType(flags: TypeFlags, types: Type[]) {
function createPromiseLikeType(promisedType: Type): Type {
function createPromiseReturnType(func: FunctionLikeDeclaration | ImportCall, promisedType: Type) {
function createPromiseType(promisedType: Type): Type {
function createPropertyNameNodeForIdentifierOrLiteral(name: string, stringNamed?: boolean, singleQuote?: boolean) {
function createResolver(): EmitResolver {
function createReturnTypeOfSignatureDeclaration(signatureDeclarationIn: SignatureDeclaration, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker) {
function createReverseMappedType(source: Type, target: MappedType, constraint: IndexType) {
function createSignature(
function createSignatureForJSXIntrinsic(node: JsxOpeningLikeElement, result: Type): Signature {
function createSignatureInstantiation(signature: Signature, typeArguments: readonly Type[] | undefined): Signature {
function createSignatureTypeMapper(signature: Signature, typeArguments: readonly Type[] | undefined): TypeMapper {
function createStringMappingType(symbol: Symbol, type: Type) {
function createSymbol(flags: SymbolFlags, name: __String, checkFlags?: CheckFlags) {
function createSymbolWithType(source: Symbol, type: Type | undefined) {
function createSyntheticExpression(parent: Node, type: Type, isSpread?: boolean, tupleNameSource?: ParameterDeclaration | NamedTupleMember) {
function createTemplateLiteralType(texts: readonly string[], types: readonly Type[]) {
function createTupleTargetType(elementFlags: readonly ElementFlags[], readonly: boolean, namedMemberDeclarations: readonly (NamedTupleMember | ParameterDeclaration)[] | undefined): TupleType {
function createTupleType(elementTypes: readonly Type[], elementFlags?: readonly ElementFlags[], readonly = false, namedMemberDeclarations?: readonly (NamedTupleMember | ParameterDeclaration)[]) {
function createType(flags: TypeFlags): Type {
function createTypeChecker(host: TypeCheckerHost, produceDiagnostics: boolean): TypeChecker {
function createTypeEraser(sources: readonly TypeParameter[]): TypeMapper {
function createTypeFromGenericGlobalType(genericGlobalType: GenericType, typeArguments: readonly Type[]): ObjectType {
function createTypeMapper(sources: readonly TypeParameter[], targets: readonly Type[] | undefined): TypeMapper {
function createTypeNodeFromObjectType(type: ObjectType): TypeNode {
function createTypeNodesFromResolvedType(resolvedType: ResolvedType): TypeElement[] | undefined {
function createTypeOfDeclaration(declarationIn: AccessorDeclaration | VariableLikeDeclaration | PropertyAccessExpression, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker, addUndefined?: boolean) {
function createTypeOfExpression(exprIn: Expression, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker) {
function createTypeParameter(symbol?: Symbol) {
function createTypePredicate(kind: TypePredicateKind, parameterName: string | undefined, parameterIndex: number | undefined, type: Type | undefined): TypePredicate {
function createTypePredicateFromTypePredicateNode(node: TypePredicateNode, signature: Signature): TypePredicate {
function createTypeReference(target: GenericType, typeArguments: readonly Type[] | undefined): TypeReference {
function createTypedPropertyDescriptorType(propertyType: Type): Type {
function createTypeofType() {
function createUnionOfSignaturesForOverloadFailure(candidates: readonly Signature[]): Signature {
function createUnionOrIntersectionProperty(containingType: UnionOrIntersectionType, name: __String, skipObjectFunctionPropertyAugment?: boolean): Symbol | undefined {
function createUnionSignature(signature: Signature, unionSignatures: Signature[]) {
function createUniqueESSymbolType(symbol: Symbol) {
function createWideningContext(parent: WideningContext | undefined, propertyName: __String | undefined, siblings: Type[] | undefined): WideningContext {

function declarationBelongsToPrivateAmbientMember(declaration: VariableLikeDeclaration) {

function deepCloneOrReuseNode(node: Node): Node {

function determineIfDeclarationIsVisible() {

function diagnosticName(nameArg: __String | Identifier | PrivateIdentifier) {

// discriminate
function discriminateContextualTypeByJSXAttributes(node: JsxAttributes, contextualType: UnionType) {
function discriminateContextualTypeByObjectMembers(node: ObjectLiteralExpression, contextualType: UnionType) {
function discriminateTypeByDiscriminableItems(target: UnionType, discriminators: [() => Type, __String][], related: (source: Type, target: Type) => boolean | Ternary, defaultValue: Type, skipPartial?: boolean): Type;
function discriminateTypeByDiscriminableItems(target: UnionType, discriminators: [() => Type, __String][], related: (source: Type, target: Type) => boolean | Ternary, defaultValue?: Type, skipPartial?: boolean) {
function discriminateTypeByDiscriminableItems(target: UnionType, discriminators: [() => Type, __String][], related: (source: Type, target: Type) => boolean | Ternary, defaultValue?: undefined, skipPartial?: boolean): Type | undefined;
function distributeIndexOverObjectType(objectType: Type, indexType: Type, writing: boolean) {
function distributeObjectOverIndexType(objectType: Type, indexType: Type, writing: boolean) {

function doesAccessorHaveCorrectParameterCount(accessor: AccessorDeclaration) {


// each
function eachTypeContainedIn(source: Type, types: Type[]) {
function eachTypeRelatedToSomeType(source: UnionOrIntersectionType, target: UnionOrIntersectionType): Ternary {
function eachTypeRelatedToType(source: UnionOrIntersectionType, target: Type, reportErrors: boolean, intersectionState: IntersectionState): Ternary {
function eachUnionContains(unionTypes: UnionType[], type: Type) {

// elaborate
function elaborateArrayLiteral(
function elaborateArrowFunction(
function elaborateDidYouMeanToCallOrConstruct(
function elaborateElementwise(
function elaborateError(
function elaborateJsxComponents(
function elaborateNeverIntersection(errorInfo: DiagnosticMessageChain | undefined, type: Type) {
function elaborateObjectLiteral(

function elideInitializerAndSetEmitFlags(node: Node): Node {

// error
function error(location: Node | undefined, message: DiagnosticMessage, arg0?: string | number, arg1?: string | number, arg2?: string | number, arg3?: string | number): Diagnostic {
function errorAndMaybeSuggestAwait(
function errorIfWritingToReadonlyIndex(indexInfo: IndexInfo | undefined): void {
function errorNextVariableOrPropertyDeclarationMustHaveSameType(firstDeclaration: Declaration | undefined, firstType: Type, nextDeclaration: Declaration, nextType: Type): void {
function errorOnImplicitAnyModule(isError: boolean, errorNode: Node, { packageId, resolvedFileName }: ResolvedModuleFull, moduleReference: string): void {
function errorOrSuggestion(isError: boolean, location: Node, message: DiagnosticMessage | DiagnosticMessageChain, arg0?: string | number, arg1?: string | number, arg2?: string | number, arg3?: string | number): void {
function errorSkippedOn(key: keyof CompilerOptions, location: Node | undefined, message: DiagnosticMessage, arg0?: string | number, arg1?: string | number, arg2?: string | number, arg3?: string | number): Diagnostic {
function errorUnusedLocal(declaration: Declaration, name: string, addDiagnostic: AddUnusedDiagnostic) {

// evaluate
function evaluate(expr: Expression): string | number | undefined {
function evaluateEnumMember(expr: Expression, enumSymbol: Symbol, name: __String) {

function everyContainedType(type: Type, f: (t: Type) => boolean): boolean {

function everyType(type: Type, f: (t: Type) => boolean): boolean {

function excludeProperties(properties: Symbol[], excludedProperties: Set<__String> | undefined) {

function existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing: TypeNode, type: Type) {

function expandSignatureParametersWithTupleMembers(restType: TupleTypeReference, restIndex: number) {

function extendExportSymbols(target: SymbolTable, source: SymbolTable | undefined, lookupTable?: ExportCollisionTrackerTable, exportNode?: ExportDeclaration) {

// extract
function extractDefinitelyFalsyTypes(type: Type): Type {
function extractIrreducible(types: Type[], flag: TypeFlags) {
function extractRedundantTemplateLiterals(types: Type[]): boolean {
function extractTypesOfKind(type: Type, kind: TypeFlags) {
function extractUnitType(type: Type) {

function fileSymbolIfFileSymbolExportEqualsContainer(d: Declaration) {

// fill
function fillMissingTypeArguments(typeArguments: readonly Type[] | undefined, typeParameters: readonly TypeParameter[] | undefined, minTypeArgumentCount: number, isJavaScriptImplicitAny: boolean) {
function fillMissingTypeArguments(typeArguments: readonly Type[] | undefined, typeParameters: readonly TypeParameter[] | undefined, minTypeArgumentCount: number, isJavaScriptImplicitAny: boolean): Type[] | undefined;
function fillMissingTypeArguments(typeArguments: readonly Type[], typeParameters: readonly TypeParameter[] | undefined, minTypeArgumentCount: number, isJavaScriptImplicitAny: boolean): Type[];

// filter
function filterPrimitivesIfContainsNonPrimitive(type: UnionType) {
function filterType(type: Type, f: (t: Type) => boolean): Type {

function finalizeEvolvingArrayType(type: Type): Type {

// find
function findApplicableIndexInfo(indexInfos: readonly IndexInfo[], keyType: Type) {
function findBestTypeForInvokable(source: Type, unionTarget: UnionOrIntersectionType) {
function findBestTypeForObjectLiteral(source: Type, unionTarget: UnionOrIntersectionType) {
function findConstructorDeclaration(node: ClassLikeDeclaration): ConstructorDeclaration | undefined {
function findDiscriminantProperties(sourceProperties: Symbol[], target: Type): Symbol[] | undefined {
function findFirstSuperCall(node: Node): SuperCall | undefined {
function findIndexInfo(indexInfos: readonly IndexInfo[], keyType: Type) {
function findMatchingDiscriminantType(source: Type, target: Type, isRelatedTo: (source: Type, target: Type) => Ternary, skipPartial?: boolean) {
function findMatchingSignature(signatureList: readonly Signature[], signature: Signature, partialMatch: boolean, ignoreThisTypes: boolean, ignoreReturnTypes: boolean): Signature | undefined {
function findMatchingSignatures(signatureLists: readonly (readonly Signature[])[], signature: Signature, listIndex: number): Signature[] | undefined {
function findMatchingTypeReferenceOrTypeAliasReference(source: Type, unionTarget: UnionOrIntersectionType) {
function findMixins(types: readonly Type[]): readonly boolean[] {
function findMostOverlappyType(source: Type, unionTarget: UnionOrIntersectionType) {
function findResolutionCycleStartIndex(target: TypeSystemEntity, propertyName: TypeSystemPropertyName): number {

function flattenExportAssignedNamespace(statements: Statement[]) {

function foldState(state: WorkArea, result: Type | undefined, _side: "left" | "right") {

// forEach
function forEachEnclosingClass<T>(node: Node, callback: (node: Node) => T | undefined): T | undefined {
function forEachProperty<T>(prop: Symbol, callback: (p: Symbol) => T): T | undefined {
function forEachSymbolTableInScope<T>(enclosingDeclaration: Node | undefined, callback: (symbolTable: SymbolTable, ignoreQualification?: boolean, isLocalNameLookup?: boolean, scopeNode?: Node) => T): T {
function forEachType<T>(type: Type, f: (t: Type) => T | undefined): T | undefined {

function formatUnionTypes(types: readonly Type[]): Type[] {

function functionHasImplicitReturn(func: FunctionLikeDeclaration) {

function generateInitialErrorChain(): DiagnosticMessageChain {

// get
function getAccessStack(ref: TypeReferenceNode): Identifier[] {
function getAccessedPropertyName(access: AccessExpression | BindingElement): __String | undefined {
function getAccessibleSymbolChain(symbol: Symbol | undefined, enclosingDeclaration: Node | undefined, meaning: SymbolFlags, useOnlyExternalAliasing: boolean, visitedSymbolTablesMap: ESMap<SymbolId, SymbolTable[]> = new Map()): Symbol[] | undefined {
function getAccessibleSymbolChainFromSymbolTable(symbols: SymbolTable, ignoreQualification?: boolean, isLocalNameLookup?: boolean): Symbol[] | undefined {
function getAccessorThisParameter(accessor: AccessorDeclaration): ParameterDeclaration | undefined {
function getActualTypeVariable(type: Type): Type {
function getAliasForSymbolInContainer(container: Symbol, symbol: Symbol) {
function getAliasId(aliasSymbol: Symbol | undefined, aliasTypeArguments: readonly Type[] | undefined) {
function getAliasSymbolForTypeNode(node: Node) {
function getAliasVariances(symbol: Symbol) {
function getAllPossiblePropertiesOfTypes(types: readonly Type[]): Symbol[] {
function getAlternativeContainingModules(symbol: Symbol, enclosingDeclaration: Node): Symbol[] {
function getAmbientModules(): Symbol[] {
function getAnnotatedAccessorThisParameter(accessor: AccessorDeclaration): Symbol | undefined {
function getAnnotatedAccessorType(accessor: AccessorDeclaration | undefined): Type | undefined {
function getAnnotatedAccessorTypeNode(accessor: AccessorDeclaration | undefined): TypeNode | undefined {
function getAnnotatedTypeForAssignmentDeclaration(declaredType: Type | undefined, expression: Expression, symbol: Symbol, declaration: Declaration) {
function getAnonymousPartialType(type: Type) {
function getAnyImportSyntax(node: Node): AnyImportSyntax | undefined {
function getApparentType(type: Type): Type {
function getApparentTypeOfContextualType(node: Expression | MethodDeclaration, contextFlags?: ContextFlags): Type | undefined {
function getApparentTypeOfIntersectionType(type: IntersectionType) {
function getApparentTypeOfMappedType(type: MappedType) {
function getApplicableIndexInfo(type: Type, keyType: Type): IndexInfo | undefined {
function getApplicableIndexInfoForName(type: Type, name: __String): IndexInfo | undefined {
function getApplicableIndexInfos(type: Type, keyType: Type): IndexInfo[] {
function getArgumentArityError(node: CallLikeExpression, signatures: readonly Signature[], args: readonly Expression[]) {
function getArrayElementTypeNode(node: TypeNode): TypeNode | undefined {
function getArrayOrTupleTargetType(node: ArrayTypeNode | TupleTypeNode): GenericType {
function getAssignedClassSymbol(decl: Declaration): Symbol | undefined {
function getAssignedJSPrototype(node: Node) {
function getAssignedType(node: Expression): Type {
function getAssignedTypeOfArrayLiteralElement(node: ArrayLiteralExpression, element: Expression): Type {
function getAssignedTypeOfBinaryExpression(node: BinaryExpression): Type {
function getAssignedTypeOfPropertyAssignment(node: PropertyAssignment | ShorthandPropertyAssignment): Type {
function getAssignedTypeOfShorthandPropertyAssignment(node: ShorthandPropertyAssignment): Type {
function getAssignedTypeOfSpreadExpression(node: SpreadElement): Type {
function getAssignmentDeclarationLocation(node: TypeReferenceNode): Node | undefined {
function getAssignmentReducedType(declaredType: UnionType, assignedType: Type) {
function getAsyncFromSyncIterationTypes(iterationTypes: IterationTypes, errorNode: Node | undefined) {
function getAugmentedPropertiesOfType(type: Type): Symbol[] {
function getAwaitedType(type: Type, errorNode?: Node, diagnosticMessage?: DiagnosticMessage, arg0?: string | number): Type | undefined {
function getAwaitedTypeOfPromise(type: Type, errorNode?: Node, diagnosticMessage?: DiagnosticMessage, arg0?: string | number): Type | undefined {
function getAwaitedTypeWorker(type: Type, errorNode?: Node, diagnosticMessage?: DiagnosticMessage, arg0?: string | number): Type | undefined {
function getBaseConstraint(t: Type): Type | undefined {
function getBaseConstraintOfType(type: Type): Type | undefined {
function getBaseConstraintOrType(type: Type) {
function getBaseConstructorTypeOfClass(type: InterfaceType): Type {
function getBaseSignature(signature: Signature) {
function getBaseTypeNodeOfClass(type: InterfaceType): ExpressionWithTypeArguments | undefined {
function getBaseTypeOfEnumLiteralType(type: Type) {
function getBaseTypeOfLiteralType(type: Type): Type {
function getBaseTypeVariableOfClass(symbol: Symbol) {
function getBaseTypes(type: InterfaceType): BaseType[] {
function getBaseTypesIfUnrelated(leftType: Type, rightType: Type, isRelated: (left: Type, right: Type) => boolean): [Type, Type] {
function getBestMatchIndexedAccessTypeOrUndefined(source: Type, target: Type, nameType: Type) {
function getBestMatchingType(source: Type, target: UnionOrIntersectionType, isRelatedTo = compareTypesAssignable) {
function getBigIntLiteralType(value: PseudoBigInt): BigIntLiteralType {
function getCachedIterationTypes(type: Type, cacheKey: MatchingKeys<IterableOrIteratorType, IterationTypes | undefined>) {
function getCandidateForOverloadFailure(
function getCandidateListForSymbol(symbolFromSymbolTable: Symbol, resolvedImportedSymbol: Symbol, ignoreQualification: boolean | undefined) {
function getCandidateName(candidate: Symbol) {
function getCannotFindNameDiagnosticForName(node: Identifier): DiagnosticMessage {
function getCanonicalOverload(overloads: Declaration[], implementation: FunctionLikeDeclaration | undefined): Declaration {
function getCanonicalSignature(signature: Signature): Signature {
function getClassElementPropertyKeyType(element: ClassElement) {
function getClassNameFromPrototypeMethod(container: Node) {
function getClassOrInterfaceDeclarationsOfSymbol(symbol: Symbol) {
function getCombinedMappedTypeOptionality(type: MappedType): number {
function getCommonJSPropertyAccess(node: Node) {
function getCommonJsExportEquals(exported: Symbol | undefined, moduleSymbol: Symbol): Symbol | undefined {
function getCommonSubtype(types: Type[]) {
function getCommonSupertype(types: Type[]): Type {
function getConditionalFlowTypeOfType(type: Type, node: Node) {
function getConditionalType(root: ConditionalRoot, mapper: TypeMapper | undefined, aliasSymbol?: Symbol, aliasTypeArguments?: readonly Type[]): Type {
function getConditionalTypeInstantiation(type: ConditionalType, mapper: TypeMapper, aliasSymbol?: Symbol, aliasTypeArguments?: readonly Type[]): Type {
function getConstantValue(node: EnumMember | AccessExpression): string | number | undefined {
function getConstituentCount(type: Type) {
function getConstituentTypeForKeyType(unionType: UnionType, keyType: Type) {
function getConstraintDeclaration(type: TypeParameter): TypeNode | undefined {
function getConstraintDeclarationForMappedType(type: MappedType) {
function getConstraintFromConditionalType(type: ConditionalType) {
function getConstraintFromIndexedAccess(type: IndexedAccessType) {
function getConstraintFromTypeParameter(typeParameter: TypeParameter): Type | undefined {
function getConstraintOfConditionalType(type: ConditionalType) {
function getConstraintOfDistributiveConditionalType(type: ConditionalType): Type | undefined {
function getConstraintOfIndexedAccess(type: IndexedAccessType) {
function getConstraintOfType(type: InstantiableType | UnionOrIntersectionType): Type | undefined {
function getConstraintOfTypeParameter(typeParameter: TypeParameter): Type | undefined {
function getConstraintTypeFromMappedType(type: MappedType) {
function getConstructorDefinedThisAssignmentTypes(types: Type[], declarations: Declaration[]): Type[] | undefined {
function getConstructorsForTypeArguments(type: Type, typeArgumentNodes: readonly TypeNode[] | undefined, location: Node): readonly Signature[] {
function getContainersOfSymbol(symbol: Symbol, enclosingDeclaration: Node | undefined, meaning: SymbolFlags): Symbol[] | undefined {
function getContainingObjectLiteral(func: SignatureDeclaration): ObjectLiteralExpression | undefined {
function getContextFreeTypeOfExpression(node: Expression) {
function getContextNode(node: Expression): Node {
function getContextualCallSignature(type: Type, node: SignatureDeclaration): Signature | undefined {
function getContextualIterationType(kind: IterationTypeKind, functionDecl: SignatureDeclaration): Type | undefined {
function getContextualJsxElementAttributesType(node: JsxOpeningLikeElement, contextFlags?: ContextFlags) {
function getContextualReturnType(functionDecl: SignatureDeclaration): Type | undefined {
function getContextualSignature(node: FunctionExpression | ArrowFunction | MethodDeclaration): Signature | undefined {
function getContextualSignatureForFunctionLikeDeclaration(node: FunctionLikeDeclaration): Signature | undefined {
function getContextualThisParameterType(func: SignatureDeclaration): Type | undefined {
function getContextualType(node: Expression, contextFlags?: ContextFlags): Type | undefined {
function getContextualTypeForArgument(callTarget: CallLikeExpression, arg: Expression): Type | undefined {
function getContextualTypeForArgumentAtIndex(callTarget: CallLikeExpression, argIndex: number): Type {
function getContextualTypeForAssignmentDeclaration(binaryExpression: BinaryExpression): Type | undefined {
function getContextualTypeForAwaitOperand(node: AwaitExpression, contextFlags?: ContextFlags): Type | undefined {
function getContextualTypeForBinaryOperand(node: Expression, contextFlags?: ContextFlags): Type | undefined {
function getContextualTypeForBindingElement(declaration: BindingElement): Type | undefined {
function getContextualTypeForChildJsxExpression(node: JsxElement, child: JsxChild) {
function getContextualTypeForConditionalOperand(node: Expression, contextFlags?: ContextFlags): Type | undefined {
function getContextualTypeForElementExpression(arrayContextualType: Type | undefined, index: number): Type | undefined {
function getContextualTypeForInitializerExpression(node: Expression, contextFlags?: ContextFlags): Type | undefined {
function getContextualTypeForJsxAttribute(attribute: JsxAttribute | JsxSpreadAttribute): Type | undefined {
function getContextualTypeForJsxExpression(node: JsxExpression): Type | undefined {
function getContextualTypeForObjectLiteralElement(element: ObjectLiteralElementLike, contextFlags?: ContextFlags) {
function getContextualTypeForObjectLiteralMethod(node: MethodDeclaration, contextFlags?: ContextFlags): Type | undefined {
function getContextualTypeForReturnExpression(node: Expression): Type | undefined {
function getContextualTypeForStaticPropertyDeclaration(declaration: PropertyDeclaration): Type | undefined {
function getContextualTypeForSubstitutionExpression(template: TemplateExpression, substitutionExpression: Expression) {
function getContextualTypeForThisPropertyAssignment(binaryExpression: BinaryExpression): Type | undefined {
function getContextualTypeForVariableLikeDeclaration(declaration: VariableLikeDeclaration): Type | undefined {
function getContextualTypeForYieldOperand(node: YieldExpression): Type | undefined {
function getContextuallyTypedParameterType(parameter: ParameterDeclaration): Type | undefined {
function getContravariantInference(inference: InferenceInfo) {
function getControlFlowContainer(node: Node): Node {
function getCovariantInference(inference: InferenceInfo, signature: Signature) {
function getCrossProductIntersections(types: readonly Type[]) {
function getCrossProductUnionSize(types: readonly Type[]) {
function getDeclarationContainer(node: Node): Node {
function getDeclarationNodeFlagsFromSymbol(s: Symbol): NodeFlags {
function getDeclarationOfAliasSymbol(symbol: Symbol): Declaration | undefined {
function getDeclarationOfJSPrototypeContainer(symbol: Symbol) {
function getDeclarationSpaces(decl: Declaration): DeclarationSpaces {
function getDeclarationWithTypeAnnotation(symbol: Symbol, enclosingDeclaration: Node | undefined) {
function getDeclaredTypeOfAlias(symbol: Symbol): Type {
function getDeclaredTypeOfClassOrInterface(symbol: Symbol): InterfaceType {
function getDeclaredTypeOfEnum(symbol: Symbol): Type {
function getDeclaredTypeOfEnumMember(symbol: Symbol): Type {
function getDeclaredTypeOfSymbol(symbol: Symbol): Type {
function getDeclaredTypeOfTypeAlias(symbol: Symbol): Type {
function getDeclaredTypeOfTypeParameter(symbol: Symbol): TypeParameter {
function getDeclaringClass(prop: Symbol) {
function getDeclaringConstructor(symbol: Symbol) {
function getDecoratorArgumentCount(node: Decorator, signature: Signature) {
function getDefaultConstraintOfConditionalType(type: ConditionalType) {
function getDefaultConstructSignatures(classType: InterfaceType): Signature[] {
function getDefaultFromTypeParameter(typeParameter: TypeParameter): Type | undefined {
function getDefaultTypeArgumentType(isInJavaScriptFile: boolean): Type {
function getDefinitelyFalsyPartOfType(type: Type): Type {
function getDeprecatedSuggestionNode(node: Node): Node {
function getDestructuringPropertyName(node: BindingElement | PropertyAssignment | ShorthandPropertyAssignment | Expression) {
function getDiagnosticForCallNode(node: CallLikeExpression, message: DiagnosticMessage, arg0?: string | number, arg1?: string | number, arg2?: string | number, arg3?: string | number): DiagnosticWithLocation {
function getDiagnosticHeadMessageForDecoratorResolution(node: Decorator) {
function getDiagnosticSpanForCallNode(node: CallExpression, doNotIncludeArguments?: boolean) {
function getDiagnostics(sourceFile: SourceFile, ct: CancellationToken): Diagnostic[] {
function getDiagnosticsWorker(sourceFile: SourceFile): Diagnostic[] {
function getDiscriminantPropertyAccess(expr: Expression, computedType: Type) {
function getESSymbolLikeTypeForNode(node: Node) {
function getEffectiveCallArguments(node: CallLikeExpression): readonly Expression[] {
function getEffectiveConstraintOfIntersection(types: readonly Type[], targetIsUnion: boolean) {
function getEffectiveDeclarationFlags(n: Declaration, flagsToCheck: ModifierFlags): ModifierFlags {
function getEffectiveDecoratorArguments(node: Decorator): readonly Expression[] {
function getEffectiveDotDotDotForParameter(p: ParameterDeclaration) {
function getEffectiveFirstArgumentForJsxSignature(signature: Signature, node: JsxOpeningLikeElement) {
function getEffectiveRestType(signature: Signature) {
function getEffectiveTypeArguments(node: TypeReferenceNode | ExpressionWithTypeArguments, typeParameters: readonly TypeParameter[]): Type[] {
function getEffectsSignature(node: CallExpression) {
function getElaborationElementForJsxChild(child: JsxChild, nameType: LiteralType, getInvalidTextDiagnostic: () => DiagnosticMessage) {
function getElementTypeOfArrayType(type: Type): Type | undefined {
function getElementTypeOfEvolvingArrayType(type: Type) {
function getElementTypeOfSliceOfTupleType(type: TupleTypeReference, index: number, endSkipCount = 0, writing = false) {
function getEmitResolver(sourceFile: SourceFile, cancellationToken: CancellationToken) {
function getEnclosingIterationStatement(node: Node): Node | undefined {
function getEndElementCount(type: TupleType, flags: ElementFlags) {
function getEntityNameForDecoratorMetadata(node: TypeNode | undefined): EntityName | undefined {
function getEntityNameForDecoratorMetadataFromTypeList(types: readonly TypeNode[]): EntityName | undefined {
function getEntityNameForExtendingInterface(node: Node): EntityNameExpression | undefined {
function getEnumKind(symbol: Symbol): EnumKind {
function getEnumLiteralType(value: string | number, enumId: number, symbol: Symbol): LiteralType {
function getEnumMemberValue(node: EnumMember): string | number | undefined {
function getErasedSignature(signature: Signature): Signature {
function getEvolvingArrayType(elementType: Type): EvolvingArrayType {
function getExcludedSymbolFlags(flags: SymbolFlags): SymbolFlags {
function getExpandedParameters(sig: Signature, skipUnionExpanding?: boolean): readonly (readonly Symbol[])[] {
function getExpandoSymbol(symbol: Symbol): Symbol | undefined {
function getExplicitThisType(node: Expression) {
function getExplicitTypeOfSymbol(symbol: Symbol, diagnostic?: Diagnostic) {
function getExportOfModule(symbol: Symbol, name: Identifier, specifier: Declaration, dontResolveAlias: boolean): Symbol | undefined {
function getExportSpecifierLocalTargetSymbol(node: ExportSpecifier | Identifier): Symbol | undefined {
function getExportSymbolOfValueSymbolIfExported(symbol: Symbol | undefined): Symbol | undefined {
function getExportSymbolOfValueSymbolIfExported(symbol: Symbol | undefined): Symbol | undefined;
function getExportSymbolOfValueSymbolIfExported(symbol: Symbol): Symbol;
function getExportsAndPropertiesOfModule(moduleSymbol: Symbol): Symbol[] {
function getExportsOfModule(moduleSymbol: Symbol): SymbolTable {
function getExportsOfModuleAsArray(moduleSymbol: Symbol): Symbol[] {
function getExportsOfModuleWorker(moduleSymbol: Symbol): SymbolTable {
function getExportsOfSymbol(symbol: Symbol): SymbolTable {
function getExternalModuleContainer(declaration: Node) {
function getExternalModuleFileFromDeclaration(declaration: AnyImportOrReExport | ModuleDeclaration | ImportTypeNode | ImportCall): SourceFile | undefined {
function getExternalModuleMember(node: ImportDeclaration | ExportDeclaration | VariableDeclaration, specifier: ImportOrExportSpecifier | BindingElement | PropertyAccessExpression, dontResolveAlias = false): Symbol | undefined {
function getExtractStringType(type: Type) {
function getFactsFromTypeofSwitch(start: number, end: number, witnesses: string[], hasDefault: boolean): TypeFacts {
function getFalseTypeFromConditionalType(type: ConditionalType) {
function getFalsyFlags(type: Type): TypeFlags {
function getFalsyFlagsOfTypes(types: Type[]): TypeFlags {
function getFileSymbolIfFileSymbolExportEqualsContainer(d: Declaration, container: Symbol) {
function getFinalArrayType(evolvingArrayType: EvolvingArrayType): Type {
function getFirstNonAmbientClassOrFunctionDeclaration(symbol: Symbol): Declaration | undefined {
function getFirstNonModuleExportsIdentifier(node: EntityNameOrEntityNameExpression): Identifier {
function getFlowCacheKey(node: Node, declaredType: Type, initialType: Type, flowContainer: Node | undefined): string | undefined {
function getFlowNodeId(flow: FlowNode): number {
function getFlowTypeFromCommonJSExport(symbol: Symbol) {
function getFlowTypeInConstructor(symbol: Symbol, constructor: ConstructorDeclaration) {
function getFlowTypeInStaticBlocks(symbol: Symbol, staticBlocks: readonly ClassStaticBlockDeclaration[]) {
function getFlowTypeOfAccessExpression(node: ElementAccessExpression | PropertyAccessExpression | QualifiedName, prop: Symbol | undefined, propType: Type, errorNode: Node, checkMode: CheckMode | undefined) {
function getFlowTypeOfDestructuring(node: BindingElement | PropertyAssignment | ShorthandPropertyAssignment | Expression, declaredType: Type) {
function getFlowTypeOfProperty(reference: Node, prop: Symbol | undefined) {
function getFlowTypeOfReference(reference: Node, declaredType: Type, initialType = declaredType, flowContainer?: Node) {
function getForInVariableSymbol(node: ForInStatement): Symbol | undefined {
function getFreshTypeOfLiteralType(type: Type): Type {
function getFullyQualifiedName(symbol: Symbol, containingLocation?: Node): string {
function getGlobalAsyncGeneratorType(reportErrors: boolean) {
function getGlobalAsyncIterableIteratorType(reportErrors: boolean) {
function getGlobalAsyncIterableType(reportErrors: boolean) {
function getGlobalAsyncIteratorType(reportErrors: boolean) {
function getGlobalBigIntType(reportErrors: boolean) {
function getGlobalDiagnostics(): Diagnostic[] {
function getGlobalESSymbolConstructorSymbol(reportErrors: boolean) {
function getGlobalESSymbolConstructorTypeSymbol(reportErrors: boolean) {
function getGlobalESSymbolType(reportErrors: boolean) {
function getGlobalExtractSymbol(): Symbol {
function getGlobalGeneratorType(reportErrors: boolean) {
function getGlobalImportMetaType() {
function getGlobalIterableIteratorType(reportErrors: boolean) {
function getGlobalIterableType(reportErrors: boolean) {
function getGlobalIteratorReturnResultType(reportErrors: boolean) {
function getGlobalIteratorType(reportErrors: boolean) {
function getGlobalIteratorYieldResultType(reportErrors: boolean) {
function getGlobalNonNullableTypeInstantiation(type: Type) {
function getGlobalOmitSymbol(): Symbol {
function getGlobalPromiseConstructorLikeType(reportErrors: boolean) {
function getGlobalPromiseConstructorSymbol(reportErrors: boolean): Symbol | undefined {
function getGlobalPromiseLikeType(reportErrors: boolean) {
function getGlobalPromiseType(reportErrors: boolean) {
function getGlobalSymbol(name: __String, meaning: SymbolFlags, diagnostic: DiagnosticMessage | undefined): Symbol | undefined {
function getGlobalTemplateStringsArrayType() {
function getGlobalType(name: __String, arity: 0, reportErrors: boolean): ObjectType;
function getGlobalType(name: __String, arity: number, reportErrors: boolean): GenericType;
function getGlobalType(name: __String, arity: number, reportErrors: boolean): ObjectType | undefined {
function getGlobalTypeOrUndefined(name: __String, arity = 0): ObjectType | undefined {
function getGlobalTypeSymbol(name: __String, reportErrors: boolean): Symbol | undefined {
function getGlobalTypedPropertyDescriptorType() {
function getGlobalValueSymbol(name: __String, reportErrors: boolean): Symbol | undefined {
function getHelperName(helper: ExternalEmitHelpers) {
function getHomomorphicTypeVariable(type: MappedType) {
function getIdentifierChain(node: EntityName): Identifier[] {
function getIdentifierFromEntityNameExpression(node: Expression): Identifier | PrivateIdentifier | undefined {
function getIdentifierFromEntityNameExpression(node: Expression): Identifier | PrivateIdentifier | undefined;
function getIdentifierFromEntityNameExpression(node: Identifier | PropertyAccessExpression): Identifier | PrivateIdentifier;
function getImmediateAliasedSymbol(symbol: Symbol): Symbol | undefined {
function getImmediateBaseConstraint(t: Type): Type {
function getImmediateRootSymbols(symbol: Symbol): readonly Symbol[] | undefined {
function getImplementsTypes(type: InterfaceType): BaseType[] {
function getImpliedConstraint(type: Type, checkNode: TypeNode, extendsNode: TypeNode): Type | undefined {
function getImpliedTypeFromTypeofGuard(type: Type, text: string) {
function getIndexInfoOfType(type: Type, keyType: Type): IndexInfo | undefined {
function getIndexInfoWithReadonly(info: IndexInfo, readonly: boolean) {
function getIndexInfosAtLocation(node: Node): readonly IndexInfo[] | undefined {
function getIndexInfosOfIndexSymbol(indexSymbol: Symbol): IndexInfo[] {
function getIndexInfosOfStructuredType(type: Type): readonly IndexInfo[] {
function getIndexInfosOfSymbol(symbol: Symbol): IndexInfo[] {
function getIndexInfosOfType(type: Type): readonly IndexInfo[] {
function getIndexNodeForAccessExpression(accessNode: ElementAccessExpression | IndexedAccessTypeNode | PropertyName | BindingName | SyntheticExpression) {
function getIndexSymbol(symbol: Symbol): Symbol | undefined {
function getIndexSymbolFromSymbolTable(symbolTable: SymbolTable): Symbol | undefined {
function getIndexType(type: Type, stringsOnly = keyofStringsOnly, noIndexSignatures?: boolean): Type {
function getIndexTypeForGenericType(type: InstantiableType | UnionOrIntersectionType, stringsOnly: boolean) {
function getIndexTypeForMappedType(type: MappedType, noIndexSignatures: boolean | undefined) {
function getIndexTypeOfType(type: Type, keyType: Type): Type | undefined {
function getIndexTypeOrString(type: Type): Type {
function getIndexedAccessType(objectType: Type, indexType: Type, accessFlags = AccessFlags.None, accessNode?: ElementAccessExpression | IndexedAccessTypeNode | PropertyName | BindingName | SyntheticExpression, aliasSymbol?: Symbol, aliasTypeArguments?: readonly Type[]): Type {
function getIndexedAccessTypeOrUndefined(objectType: Type, indexType: Type, accessFlags = AccessFlags.None, accessNode?: ElementAccessExpression | IndexedAccessTypeNode | PropertyName | BindingName | SyntheticExpression, aliasSymbol?: Symbol, aliasTypeArguments?: readonly Type[]): Type | undefined {
function getInferTypeParameters(node: ConditionalTypeNode): TypeParameter[] | undefined {
function getInferenceContext(node: Node) {
function getInferenceInfoForType(type: Type) {
function getInferredTrueTypeFromConditionalType(type: ConditionalType) {
function getInferredType(context: InferenceContext, index: number): Type {
function getInferredTypeParameterConstraint(typeParameter: TypeParameter) {
function getInferredTypes(context: InferenceContext): Type[] {
function getInitialOrAssignedType(flow: FlowAssignment) {
function getInitialType(node: VariableDeclaration | BindingElement) {
function getInitialTypeOfBindingElement(node: BindingElement): Type {
function getInitialTypeOfVariableDeclaration(node: VariableDeclaration) {
function getInitializerTypeFromAssignmentDeclaration(symbol: Symbol, resolvedSymbol: Symbol | undefined, expression: BinaryExpression | CallExpression, kind: AssignmentDeclarationKind) {
function getInstantiatedConstructorsForTypeArguments(type: Type, typeArgumentNodes: readonly TypeNode[] | undefined, location: Node): readonly Signature[] {
function getIntendedTypeFromJSDocTypeReference(node: TypeReferenceNode): Type | undefined {
function getInternalSymbolName(symbol: Symbol, localName: string) {
function getIntersectedSignatures(signatures: readonly Signature[]) {
function getIntersectionType(types: readonly Type[], aliasSymbol?: Symbol, aliasTypeArguments?: readonly Type[]): Type {
function getIntrinsicAttributesTypeFromJsxOpeningLikeElement(node: JsxOpeningLikeElement): Type {
function getIntrinsicAttributesTypeFromStringLiteralType(type: StringLiteralType, location: Node): Type | undefined {
function getIntrinsicTagSymbol(node: JsxOpeningLikeElement | JsxClosingElement): Symbol {
function getInvalidTextualChildDiagnostic() {
function getIsDeclarationVisible(declaration: Declaration) {
function getIsDeferredContext(location: Node, lastLocation: Node | undefined): boolean {
function getIsLateCheckFlag(s: Symbol): CheckFlags {
function getIteratedTypeOrElementType(use: IterationUse, inputType: Type, sentType: Type, errorNode: Node | undefined, checkAssignability: boolean): Type | undefined {
function getIterationDiagnosticDetails(allowsStrings: boolean, downlevelIteration: boolean | undefined): [DiagnosticMessage, boolean] {
function getIterationTypeOfGeneratorFunctionReturnType(kind: IterationTypeKind, returnType: Type, isAsyncGenerator: boolean): Type | undefined {
function getIterationTypeOfIterable(use: IterationUse, typeKind: IterationTypeKind, inputType: Type, errorNode: Node | undefined): Type | undefined {
function getIterationTypesKeyFromIterationTypeKind(typeKind: IterationTypeKind) {
function getIterationTypesOfGeneratorFunctionReturnType(type: Type, isAsyncGenerator: boolean) {
function getIterationTypesOfGlobalIterableType(globalType: Type, resolver: IterationTypesResolver) {
function getIterationTypesOfIterable(type: Type, use: IterationUse, errorNode: Node | undefined) {
function getIterationTypesOfIterableCached(type: Type, resolver: IterationTypesResolver) {
function getIterationTypesOfIterableFast(type: Type, resolver: IterationTypesResolver) {
function getIterationTypesOfIterableSlow(type: Type, resolver: IterationTypesResolver, errorNode: Node | undefined) {
function getIterationTypesOfIterableWorker(type: Type, use: IterationUse, errorNode: Node | undefined) {
function getIterationTypesOfIterator(type: Type, resolver: IterationTypesResolver, errorNode: Node | undefined) {
function getIterationTypesOfIteratorCached(type: Type, resolver: IterationTypesResolver) {
function getIterationTypesOfIteratorFast(type: Type, resolver: IterationTypesResolver) {
function getIterationTypesOfIteratorResult(type: Type) {
function getIterationTypesOfIteratorSlow(type: Type, resolver: IterationTypesResolver, errorNode: Node | undefined) {
function getIterationTypesOfMethod(type: Type, resolver: IterationTypesResolver, methodName: "next" | "return" | "throw", errorNode: Node | undefined): IterationTypes | undefined {
function getJSContainerObjectType(decl: Node, symbol: Symbol, init: Expression | undefined): Type | undefined {
function getJsxElementChildrenPropertyName(jsxNamespace: Symbol): __String | undefined {
function getJsxElementClassTypeAt(location: Node): Type | undefined {
function getJsxElementPropertiesName(jsxNamespace: Symbol) {
function getJsxElementTypeAt(location: Node): Type {
function getJsxFactoryEntity(location: Node): EntityName | undefined {
function getJsxFragmentFactoryEntity(location: Node): EntityName | undefined {
function getJsxIntrinsicTagNamesAt(location: Node): Symbol[] {
function getJsxLibraryManagedAttributes(jsxNamespace: Symbol) {
function getJsxManagedAttributesFromLocatedAttributes(context: JsxOpeningLikeElement, ns: Symbol, attributesType: Type) {
function getJsxNamespace(location: Node | undefined): __String {
function getJsxNamespaceAt(location: Node | undefined): Symbol {
function getJsxNamespaceContainerForImplicitImport(location: Node | undefined): Symbol | undefined {
function getJsxPropsTypeForSignatureFromMember(sig: Signature, forcedLookupLocation: __String) {
function getJsxPropsTypeFromCallSignature(sig: Signature, context: JsxOpeningLikeElement) {
function getJsxPropsTypeFromClassType(sig: Signature, context: JsxOpeningLikeElement) {
function getJsxReferenceKind(node: JsxOpeningLikeElement): JsxReferenceKind {
function getJsxStatelessElementTypeAt(location: Node): Type | undefined {
function getJsxType(name: __String, location: Node | undefined) {
function getKeyPropertyName(unionType: UnionType): __String | undefined {
function getKnownKeysOfTupleType(type: TupleTypeReference) {
function getLastResult(state: WorkArea) {
function getLateBoundSymbol(symbol: Symbol): Symbol {
function getLeftSideOfImportEqualsOrExportAssignment(nodeOnRightSide: EntityName): ImportEqualsDeclaration | ExportAssignment | undefined {
function getLeftType(state: WorkArea) {
function getLiteralPropertyNameText(name: PropertyName) {
function getLiteralTypeFromProperties(type: Type, include: TypeFlags, includeOrigin: boolean) {
function getLiteralTypeFromProperty(prop: Symbol, include: TypeFlags, includeNonPublic?: boolean) {
function getLiteralTypeFromPropertyName(name: PropertyName) {
function getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol: Symbol): TypeParameter[] | undefined {
function getLongestCandidateIndex(candidates: Signature[], argsCount: number): number {
function getLowerBoundOfKeyType(type: Type): Type {
function getMappedType(type: Type, mapper: TypeMapper): Type {
function getMappedTypeModifiers(type: MappedType): MappedTypeModifiers {
function getMappedTypeOptionality(type: MappedType): number {
function getMapperFromContext<T extends InferenceContext | undefined>(context: T): TypeMapper | T & undefined {
function getMarkerTypeReference(type: GenericType, source: TypeParameter, target: Type) {
function getMatchingUnionConstituentForObjectLiteral(unionType: UnionType, node: ObjectLiteralExpression) {
function getMatchingUnionConstituentForType(unionType: UnionType, type: Type) {
function getMembersOfSymbol(symbol: Symbol) {
function getMergedSymbol(symbol: Symbol | undefined): Symbol | undefined {
function getMergedSymbol(symbol: Symbol | undefined): Symbol | undefined;
function getMergedSymbol(symbol: Symbol): Symbol;
function getMinArgumentCount(signature: Signature, flags?: MinArgumentCountFlags) {
function getMinTypeArgumentCount(typeParameters: readonly TypeParameter[] | undefined): number {
function getModifiedReadonlyState(state: boolean, modifiers: MappedTypeModifiers) {
function getModifiersTypeFromMappedType(type: MappedType) {
function getMutableArrayOrTupleType(type: Type) {
function getNameCandidateWorker(symbol: Symbol, localName: string) {
function getNameForJSDocFunctionParameter(p: ParameterDeclaration, index: number) {
function getNameFromJsxElementAttributesContainer(nameOfAttribPropContainer: __String, jsxNamespace: Symbol): __String | undefined {
function getNameOfSymbolAsWritten(symbol: Symbol, context?: NodeBuilderContext): string {
function getNameOfSymbolFromNameType(symbol: Symbol, context?: NodeBuilderContext) {
function getNameTypeFromMappedType(type: MappedType) {
function getNameableDeclarationAtPosition(signature: Signature, pos: number) {
function getNamedMembers(members: SymbolTable): Symbol[] {
function getNamedOrIndexSignatureMembers(members: SymbolTable): Symbol[] {
function getNamesOfDeclaration(statement: Statement): Identifier[] {
function getNamespaceMembersForSerialization(symbol: Symbol) {
function getNarrowableTypeForReference(type: Type, reference: Node, checkMode?: CheckMode) {
function getNarrowedType(type: Type, candidate: Type, assumeTrue: boolean, isRelated: (source: Type, target: Type) => boolean) {
function getNodeCheckFlags(node: Node): NodeCheckFlags {
function getNodeId(node: Node): number {
function getNodeLinks(node: Node): NodeLinks {
function getNonArrayRestType(signature: Signature) {
function getNonInterhitedProperties(type: InterfaceType, baseTypes: BaseType[], properties: Symbol[]) {
function getNonMissingTypeOfSymbol(symbol: Symbol) {
function getNonNullableType(type: Type): Type {
function getNonNullableTypeIfNeeded(type: Type) {
function getNonSimpleParameters(parameters: readonly ParameterDeclaration[]): readonly ParameterDeclaration[] {
function getNonUndefinedType(type: Type) {
function getNormalizedType(type: Type, writing: boolean): Type {
function getNullableType(type: Type, flags: TypeFlags): Type {
function getNumNonRestParameters(signature: Signature): number {
function getNumberLiteralType(value: number): NumberLiteralType {
function getObjectLiteralIndexInfo(node: ObjectLiteralExpression, offset: number, properties: Symbol[], keyType: Type): IndexInfo {
function getObjectTypeInstantiation(type: AnonymousType | DeferredTypeReference, mapper: TypeMapper, aliasSymbol?: Symbol, aliasTypeArguments?: readonly Type[]) {
function getOptionalCallSignature(signature: Signature, callChainFlags: SignatureFlags): Signature {
function getOptionalExpressionType(exprType: Type, expression: Expression) {
function getOptionalType(type: Type, isProperty = false): Type {
function getOrCreateTypeFromSignature(signature: Signature): ObjectType {
function getOrSetCacheKey() {
function getOuterTypeParameters(node: Node, includeThisTypes?: boolean): TypeParameter[] | undefined {
function getOuterTypeParametersOfClassOrInterface(symbol: Symbol): TypeParameter[] | undefined {
function getParameterCount(signature: Signature) {
function getParameterIdentifierNameAtPosition(signature: Signature, pos: number): [parameterName: __String, isRestParameter: boolean] | undefined {
function getParameterNameAtPosition(signature: Signature, pos: number, overrideRestType?: Type) {
function getParameterTypeNodeForDecoratorCheck(node: ParameterDeclaration): TypeNode | undefined {
function getParentElementAccess(node: BindingElement | PropertyAssignment | ShorthandPropertyAssignment | Expression) {
function getParentOfSymbol(symbol: Symbol): Symbol | undefined {
function getParentSymbolOfTypeParameter(typeParameter: TypeParameter): Symbol | undefined {
function getParentTypeOfClassElement(node: ClassElement) {
function getPartOfForStatementContainingNode(node: Node, container: ForStatement) {
function getPermissiveInstantiation(type: Type) {
function getPotentiallyUnusedIdentifiers(sourceFile: SourceFile): readonly PotentiallyUnusedIdentifier[] {
function getPrivateIdentifierPropertyOfType(leftType: Type, lexicallyScopedIdentifier: Symbol): Symbol | undefined {
function getPromisedTypeOfPromise(type: Type, errorNode?: Node): Type | undefined {
function getPropagatingFlagsOfTypes(types: readonly Type[], excludeKinds: TypeFlags): ObjectFlags {
function getPropertiesOfContainerFunction(node: Declaration): Symbol[] {
function getPropertiesOfContext(context: WideningContext): Symbol[] {
function getPropertiesOfObjectType(type: Type): Symbol[] {
function getPropertiesOfType(type: Type): Symbol[] {
function getPropertiesOfUnionOrIntersectionType(type: UnionOrIntersectionType): Symbol[] {
function getPropertyAccess(expr: Expression) {
function getPropertyNameForKnownSymbolName(symbolName: string): __String {
function getPropertyNameFromIndex(indexType: Type, accessNode: StringLiteral | Identifier | PrivateIdentifier | ObjectBindingPattern | ArrayBindingPattern | ComputedPropertyName | NumericLiteral | IndexedAccessTypeNode | ElementAccessExpression | SyntheticExpression | undefined) {
function getPropertyNameFromType(type: StringLiteralType | NumberLiteralType | UniqueESSymbolType): __String {
function getPropertyNameNodeForSymbol(symbol: Symbol, context: NodeBuilderContext) {
function getPropertyNameNodeForSymbolFromNameType(symbol: Symbol, context: NodeBuilderContext, singleQuote?: boolean) {
function getPropertyOfObjectType(type: Type, name: __String): Symbol | undefined {
function getPropertyOfType(type: Type, name: __String, skipObjectFunctionPropertyAugment?: boolean): Symbol | undefined {
function getPropertyOfUnionOrIntersectionType(type: UnionOrIntersectionType, name: __String, skipObjectFunctionPropertyAugment?: boolean): Symbol | undefined {
function getPropertyOfVariable(symbol: Symbol, name: __String): Symbol | undefined {
function getPropertySymbolOfDestructuringAssignment(location: Identifier) {
function getPropertyTypeForIndexType(originalObjectType: Type, objectType: Type, indexType: Type, fullIndexType: Type, accessNode: ElementAccessExpression | IndexedAccessTypeNode | PropertyName | BindingName | SyntheticExpression | undefined, accessFlags: AccessFlags) {
function getQualifiedLeftMeaning(rightMeaning: SymbolFlags) {
function getQuickTypeOfExpression(node: Expression) {
function getRecursionIdentity(type: Type): object {
function getReducedApparentType(type: Type): Type {
function getReducedType(type: Type): Type {
function getReducedUnionType(unionType: UnionType) {
function getReferenceCandidate(node: Expression): Expression {
function getReferenceRoot(node: Node): Node {
function getReferencedDeclarationWithCollidingName(nodeIn: Identifier): Declaration | undefined {
function getReferencedExportContainer(nodeIn: Identifier, prefixLocals?: boolean): SourceFile | ModuleDeclaration | EnumDeclaration | undefined {
function getReferencedImportDeclaration(nodeIn: Identifier): Declaration | undefined {
function getReferencedValueDeclaration(referenceIn: Identifier): Declaration | undefined {
function getReferencedValueSymbol(reference: Identifier, startInDeclarationContainer?: boolean): Symbol | undefined {
function getRegularTypeOfExpression(expr: Expression): Type {
function getRegularTypeOfLiteralType(type: Type): Type {
function getRegularTypeOfObjectLiteral(type: Type): Type {
function getRelationKey(source: Type, target: Type, intersectionState: IntersectionState, relation: ESMap<string, RelationComparisonResult>) {
function getResolvedApparentTypeOfMappedType(type: MappedType) {
function getResolvedBaseConstraint(type: InstantiableType | UnionOrIntersectionType): Type {
function getResolvedMembersOrExportsOfSymbol(symbol: Symbol, resolutionKind: MembersOrExportsResolutionKind): UnderscoreEscapedMap<Symbol> {
function getResolvedSignature(node: CallLikeExpression, candidatesOutArray?: Signature[] | undefined, checkMode?: CheckMode): Signature {
function getResolvedSignatureWorker(nodeIn: CallLikeExpression, candidatesOutArray: Signature[] | undefined, argumentCount: number | undefined, checkMode: CheckMode): Signature | undefined {
function getResolvedSymbol(node: Identifier): Symbol {
function getResolvedTypeParameterDefault(typeParameter: TypeParameter): Type | undefined {
function getResolvedTypeWithoutAbstractConstructSignatures(type: ResolvedType) {
function getRestArrayTypeOfTupleType(type: TupleTypeReference) {
function getRestType(source: Type, properties: PropertyName[], symbol: Symbol | undefined): Type {
function getRestTypeAtPosition(source: Signature, pos: number): Type {
function getRestTypeElementFlags(node: RestTypeNode | NamedTupleMember) {
function getRestTypeOfSignature(signature: Signature): Type {
function getRestTypeOfTupleType(type: TupleTypeReference) {
function getRestrictiveInstantiation(type: Type) {
function getRestrictiveTypeParameter(tp: TypeParameter) {
function getReturnTypeFromAnnotation(declaration: SignatureDeclaration | JSDocSignature) {
function getReturnTypeFromBody(func: FunctionLikeDeclaration, checkMode?: CheckMode): Type {
function getReturnTypeOfSignature(signature: Signature): Type {
function getReturnTypeOfSingleNonGenericCallSignature(funcType: Type) {
function getReturnTypeOfSingleNonGenericSignatureOfCallChain(expr: CallChain) {
function getReturnTypeOfTypeTag(node: SignatureDeclaration | JSDocSignature) {
function getRootSymbols(symbol: Symbol): readonly Symbol[] {
function getSetAccessorTypeOfSymbol(symbol: Symbol): Type {
function getShorthandAssignmentValueSymbol(location: Node | undefined): Symbol | undefined {
function getSiblingsOfContext(context: WideningContext): Type[] {
function getSignatureApplicabilityError(
function getSignatureFromDeclaration(declaration: SignatureDeclaration | JSDocSignature): Signature {
function getSignatureInstantiation(signature: Signature, typeArguments: Type[] | undefined, isJavascript: boolean, inferredTypeParameters?: readonly TypeParameter[]): Signature {
function getSignatureInstantiationWithoutFillingInTypeArguments(signature: Signature, typeArguments: readonly Type[] | undefined): Signature {
function getSignatureOfTypeTag(node: SignatureDeclaration | JSDocSignature) {
function getSignatureTextRangeLocation(signature: Signature) {
function getSignaturesOfStructuredType(type: Type, kind: SignatureKind): readonly Signature[] {
function getSignaturesOfSymbol(symbol: Symbol | undefined): Signature[] {
function getSignaturesOfType(type: Type, kind: SignatureKind): readonly Signature[] {
function getSimplifiedConditionalType(type: ConditionalType, writing: boolean) {
function getSimplifiedIndexedAccessType(type: IndexedAccessType, writing: boolean): Type {
function getSimplifiedType(type: Type, writing: boolean): Type {
function getSimplifiedTypeOrConstraint(type: Type) {
function getSingleBaseForNonAugmentingSubtype(type: Type) {
function getSingleCallOrConstructSignature(type: Type): Signature | undefined {
function getSingleCallSignature(type: Type): Signature | undefined {
function getSingleSignature(type: Type, kind: SignatureKind, allowMembers: boolean): Signature | undefined {
function getSingleTypeVariableFromIntersectionTypes(types: Type[]) {
function getSourceText(index: number) {
function getSpecialPropertyAssignmentSymbolFromEntityName(entityName: EntityName | PropertyAccessExpression) {
function getSpecifierForModuleSymbol(symbol: Symbol, context: NodeBuilderContext) {
function getSpellingSuggestionForName(name: string, symbols: Symbol[], meaning: SymbolFlags): Symbol | undefined {
function getSpreadArgumentIndex(args: readonly Expression[]): number {
function getSpreadArgumentType(args: readonly Expression[], index: number, argCount: number, restType: Type, context: InferenceContext | undefined, checkMode: CheckMode) {
function getSpreadSymbol(prop: Symbol, readonly: boolean) {
function getSpreadType(left: Type, right: Type, symbol: Symbol | undefined, objectFlags: ObjectFlags, readonly: boolean): Type {
function getStartElementCount(type: TupleType, flags: ElementFlags) {
function getStaticTypeOfReferencedJsxConstructor(context: JsxOpeningLikeElement) {
function getStringLikeTypeForType(type: Type) {
function getStringLiteralType(value: string): StringLiteralType {
function getStringMappingType(symbol: Symbol, type: Type): Type {
function getStringMappingTypeForGenericType(symbol: Symbol, type: Type): Type {
function getSubstitutionType(baseType: Type, substitute: Type) {
function getSuggestedBooleanOperator(operator: SyntaxKind): SyntaxKind | undefined {
function getSuggestedLibForNonExistentName(name: __String | Identifier) {
function getSuggestedLibForNonExistentProperty(missingProperty: string, containingType: Type) {
function getSuggestedSymbolForNonexistentClassMember(name: string, baseType: Type): Symbol | undefined {
function getSuggestedSymbolForNonexistentJSXAttribute(name: Identifier | PrivateIdentifier | string, containingType: Type): Symbol | undefined {
function getSuggestedSymbolForNonexistentModule(name: Identifier, targetModule: Symbol): Symbol | undefined {
function getSuggestedSymbolForNonexistentProperty(name: Identifier | PrivateIdentifier | string, containingType: Type): Symbol | undefined {
function getSuggestedSymbolForNonexistentSymbol(location: Node | undefined, outerName: __String, meaning: SymbolFlags): Symbol | undefined {
function getSuggestionForNonexistentExport(name: Identifier, targetModule: Symbol): string | undefined {
function getSuggestionForNonexistentIndexSignature(objectType: Type, expr: ElementAccessExpression, keyedType: Type): string | undefined {
function getSuggestionForNonexistentProperty(name: Identifier | PrivateIdentifier | string, containingType: Type): string | undefined {
function getSuggestionForNonexistentSymbol(location: Node | undefined, outerName: __String, meaning: SymbolFlags): string | undefined {
function getSuperClass(classType: InterfaceType): Type | undefined {
function getSupertypeOrUnion(types: Type[]): Type {
function getSwitchClauseTypeOfWitnesses(switchStatement: SwitchStatement, retainDefault: boolean): (string | undefined)[] {
function getSwitchClauseTypeOfWitnesses(switchStatement: SwitchStatement, retainDefault: boolean): (string | undefined)[];
function getSwitchClauseTypeOfWitnesses(switchStatement: SwitchStatement, retainDefault: false): string[];
function getSwitchClauseTypes(switchStatement: SwitchStatement): Type[] {
function getSymbol(symbols: SymbolTable, name: __String, meaning: SymbolFlags): Symbol | undefined {
function getSymbolAtLocation(node: Node, ignoreErrors?: boolean): Symbol | undefined {
function getSymbolChain(symbol: Symbol, meaning: SymbolFlags, endOfChain: boolean): Symbol[] | undefined {
function getSymbolForExpression(e: Expression) {
function getSymbolId(symbol: Symbol): SymbolId {
function getSymbolIfSameReference(s Symbol, s Symbol) {
function getSymbolLinks(symbol: Symbol): SymbolLinks {
function getSymbolOfExpando(node: Node, allowDeclaration: boolean): Symbol | undefined {
function getSymbolOfNameOrPropertyAccessExpression(name: EntityName | PrivateIdentifier | PropertyAccessExpression | JSDocMemberName): Symbol | undefined {
function getSymbolOfNode(node: Declaration): Symbol;
function getSymbolOfNode(node: Node): Symbol | undefined {
function getSymbolOfNode(node: Node): Symbol | undefined;
function getSymbolOfPartOfRightHandSideOfImportEquals(entityName: EntityName, dontResolveAlias?: boolean): Symbol | undefined {
function getSymbolsInScope(location: Node, meaning: SymbolFlags): Symbol[] {
function getSymbolsOfParameterPropertyDeclaration(parameter: ParameterDeclaration, parameterName: __String): [Symbol, Symbol] {
function getSyntheticElementAccess(node: BindingElement | PropertyAssignment | ShorthandPropertyAssignment | Expression): ElementAccessExpression | undefined {
function getTargetOfAccessExpression(node: AccessExpression, dontRecursivelyResolve: boolean): Symbol | undefined {
function getTargetOfAliasDeclaration(node: Declaration, dontRecursivelyResolve = false): Symbol | undefined {
function getTargetOfAliasLikeExpression(expression: Expression, dontResolveAlias: boolean) {
function getTargetOfExportAssignment(node: ExportAssignment | BinaryExpression, dontResolveAlias: boolean): Symbol | undefined {
function getTargetOfExportSpecifier(node: ExportSpecifier, meaning: SymbolFlags, dontResolveAlias?: boolean) {
function getTargetOfImportClause(node: ImportClause, dontResolveAlias: boolean): Symbol | undefined {
function getTargetOfImportEqualsDeclaration(node: ImportEqualsDeclaration | VariableDeclaration, dontResolveAlias: boolean): Symbol | undefined {
function getTargetOfImportSpecifier(node: ImportSpecifier | BindingElement, dontResolveAlias: boolean): Symbol | undefined {
function getTargetOfNamespaceExport(node: NamespaceExport, dontResolveAlias: boolean): Symbol | undefined {
function getTargetOfNamespaceExportDeclaration(node: NamespaceExportDeclaration, dontResolveAlias: boolean): Symbol {
function getTargetOfNamespaceImport(node: NamespaceImport, dontResolveAlias: boolean): Symbol | undefined {
function getTargetOfPropertyAssignment(node: PropertyAssignment, dontRecursivelyResolve: boolean): Symbol | undefined {
function getTargetSymbol(s: Symbol) {
function getTargetType(type: Type): Type {
function getTemplateLiteralType(texts: readonly string[], types: readonly Type[]): Type {
function getTemplateStringForType(type: Type) {
function getTemplateTypeFromMappedType(type: MappedType) {
function getThisArgumentOfCall(node: CallLikeExpression): LeftHandSideExpression | undefined {
function getThisArgumentType(thisArgumentNode: LeftHandSideExpression | undefined) {
function getThisParameterFromNodeContext(node: Node) {
function getThisType(node: Node): Type {
function getThisTypeArgument(type: Type): Type | undefined {
function getThisTypeFromContextualType(type: Type): Type | undefined {
function getThisTypeOfDeclaration(declaration: SignatureDeclaration): Type | undefined {
function getThisTypeOfSignature(signature: Signature): Type | undefined {
function getTopmostIndexedAccessType(top: IndexedAccessTypeNode): IndexedAccessTypeNode {
function getTrueTypeFromConditionalType(type: ConditionalType) {
function getTupleBaseType(type: TupleType) {
function getTupleElementFlags(node: TypeNode) {
function getTupleElementLabel(d: ParameterDeclaration | NamedTupleMember) {
function getTupleElementType(type: Type, index: number) {
function getTupleTargetType(elementFlags: readonly ElementFlags[], readonly: boolean, namedMemberDeclarations?: readonly (NamedTupleMember | ParameterDeclaration)[]): GenericType {
function getTypeAliasForTypeLiteral(type: Type): Symbol | undefined {
function getTypeAliasInstantiation(symbol: Symbol, typeArguments: readonly Type[] | undefined, aliasSymbol?: Symbol, aliasTypeArguments?: readonly Type[]): Type {
function getTypeArgumentArityError(node: Node, signatures: readonly Signature[], typeArguments: NodeArray<TypeNode>) {
function getTypeArgumentConstraint(node: TypeNode): Type | undefined {
function getTypeArguments(type: TypeReference): readonly Type[] {
function getTypeArgumentsForAliasSymbol(symbol: Symbol | undefined) {
function getTypeArgumentsFromNodes(typeArgumentNodes: readonly TypeNode[], typeParameters: readonly TypeParameter[], isJs: boolean): readonly Type[] {
function getTypeAtFlowArrayMutation(flow: FlowArrayMutation): FlowType | undefined {
function getTypeAtFlowAssignment(flow: FlowAssignment) {
function getTypeAtFlowBranchLabel(flow: FlowLabel): FlowType {
function getTypeAtFlowCall(flow: FlowCall): FlowType | undefined {
function getTypeAtFlowCondition(flow: FlowCondition): FlowType {
function getTypeAtFlowLoopLabel(flow: FlowLabel): FlowType {
function getTypeAtFlowNode(flow: FlowNode): FlowType {
function getTypeAtPosition(signature: Signature, pos: number): Type {
function getTypeAtSwitchClause(flow: FlowSwitchClause): FlowType {
function getTypeDeclaration(symbol: Symbol): Declaration | undefined {
function getTypeFacts(type: Type, ignoreObjects = false): TypeFacts {
function getTypeForBindingElement(declaration: BindingElement): Type | undefined {
function getTypeForBindingElementParent(node: BindingElementGrandparent) {
function getTypeForDeclarationFromJSDocComment(declaration: Node) {
function getTypeForThisExpressionFromJSDoc(node: Node) {
function getTypeForVariableLikeDeclaration(declaration: ParameterDeclaration | PropertyDeclaration | PropertySignature | VariableDeclaration | BindingElement | JSDocPropertyLikeTag, includeOptionality: boolean): Type | undefined {
function getTypeFromArrayBindingPattern(pattern: BindingPattern, includePatternInType: boolean, reportErrors: boolean): Type {
function getTypeFromArrayOrTupleTypeNode(node: ArrayTypeNode | TupleTypeNode): Type {
function getTypeFromBindingElement(element: BindingElement, includePatternInType?: boolean, reportErrors?: boolean): Type {
function getTypeFromBindingPattern(pattern: BindingPattern, includePatternInType = false, reportErrors = false): Type {
function getTypeFromClassOrInterfaceReference(node: NodeWithTypeArguments, symbol: Symbol): Type {
function getTypeFromConditionalTypeNode(node: ConditionalTypeNode): Type {
function getTypeFromFlowType(flowType: FlowType) {
function getTypeFromImportTypeNode(node: ImportTypeNode): Type {
function getTypeFromIndexedAccessTypeNode(node: IndexedAccessTypeNode) {
function getTypeFromInferTypeNode(node: InferTypeNode): Type {
function getTypeFromInference(inference: InferenceInfo) {
function getTypeFromIntersectionTypeNode(node: IntersectionTypeNode): Type {
function getTypeFromJSDocNullableTypeNode(node: JSDocNullableType) {
function getTypeFromJSDocValueReference(node: NodeWithTypeArguments, symbol: Symbol): Type | undefined {
function getTypeFromJSDocVariadicType(node: JSDocVariadicType): Type {
function getTypeFromLiteralTypeNode(node: LiteralTypeNode): Type {
function getTypeFromMappedTypeNode(node: MappedTypeNode): Type {
function getTypeFromNamedTupleTypeNode(node: NamedTupleMember): Type {
function getTypeFromObjectBindingPattern(pattern: ObjectBindingPattern, includePatternInType: boolean, reportErrors: boolean): Type {
function getTypeFromOptionalTypeNode(node: OptionalTypeNode): Type {
function getTypeFromRestTypeNode(node: RestTypeNode | NamedTupleMember) {
function getTypeFromTemplateTypeNode(node: TemplateLiteralTypeNode) {
function getTypeFromThisTypeNode(node: ThisExpression | ThisTypeNode): Type {
function getTypeFromTypeAliasReference(node: NodeWithTypeArguments, symbol: Symbol): Type {
function getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node: TypeNode): Type {
function getTypeFromTypeNode(node: TypeNode): Type {
function getTypeFromTypeNodeWorker(node: TypeNode): Type {
function getTypeFromTypeOperatorNode(node: TypeOperatorNode): Type {
function getTypeFromTypeQueryNode(node: TypeQueryNode): Type {
function getTypeFromTypeReference(node: TypeReferenceType): Type {
function getTypeFromUnionTypeNode(node: UnionTypeNode): Type {
function getTypeId(type: Type): TypeId {
function getTypeListId(types: readonly Type[] | undefined) {
function getTypeNameForErrorDisplay(type: Type) {
function getTypeNamesForErrorDisplay(left: Type, right: Type): [string, string] {
function getTypeOfAccessors(symbol: Symbol): Type {
function getTypeOfAccessorsWorker(symbol: Symbol, writing = false): Type | undefined {
function getTypeOfAlias(symbol: Symbol): Type {
function getTypeOfAssignmentPattern(expr: AssignmentPattern): Type | undefined {
function getTypeOfDestructuredArrayElement(type: Type, index: number) {
function getTypeOfDestructuredProperty(type: Type, name: PropertyName) {
function getTypeOfDestructuredSpreadExpression(type: Type) {
function getTypeOfDottedName(node: Expression, diagnostic: Diagnostic | undefined): Type | undefined {
function getTypeOfEnumMember(symbol: Symbol): Type {
function getTypeOfExpression(node: Expression) {
function getTypeOfFirstParameterOfSignature(signature: Signature) {
function getTypeOfFirstParameterOfSignatureWithFallback(signature: Signature, fallbackType: Type) {
function getTypeOfFuncClassEnumModule(symbol: Symbol): Type {
function getTypeOfFuncClassEnumModuleWorker(symbol: Symbol): Type {
function getTypeOfGlobalSymbol(symbol: Symbol | undefined, arity: number): ObjectType {
function getTypeOfInitializer(node: Expression) {
function getTypeOfInstantiatedSymbol(symbol: Symbol): Type {
function getTypeOfMappedSymbol(symbol: MappedSymbol) {
function getTypeOfNode(node: Node): Type {
function getTypeOfParameter(symbol: Symbol) {
function getTypeOfPropertyInBaseClass(property: Symbol) {
function getTypeOfPropertyInTypes(types: Type[], name: __String) {
function getTypeOfPropertyOfContextualType(type: Type, name: __String) {
function getTypeOfPropertyOfType(type: Type, name: __String): Type | undefined {
function getTypeOfPropertyOrIndexSignature(type: Type, name: __String): Type {
function getTypeOfPrototypeProperty(prototype: Symbol): Type {
function getTypeOfReverseMappedSymbol(symbol: ReverseMappedSymbol) {
function getTypeOfSetAccessor(symbol: Symbol): Type | undefined {
function getTypeOfSwitchClause(clause: CaseClause | DefaultClause) {
function getTypeOfSymbol(symbol: Symbol): Type {
function getTypeOfSymbolAtLocation(symbol: Symbol, location: Node) {
function getTypeOfSymbolWithDeferredType(symbol: Symbol) {
function getTypeOfVariableOrParameterOrProperty(symbol: Symbol): Type {
function getTypeOfVariableOrParameterOrPropertyWorker(symbol: Symbol): Type {
function getTypeOnlyAliasDeclaration(symbol: Symbol): TypeOnlyCompatibleAliasDeclaration | undefined {
function getTypeParameterFromMappedType(type: MappedType) {
function getTypeParametersForTypeReference(node: TypeReferenceNode | ExpressionWithTypeArguments) {
function getTypeParametersFromDeclaration(declaration: DeclarationWithTypeParameters): TypeParameter[] | undefined {
function getTypeParametersOfClassOrInterface(symbol: Symbol): TypeParameter[] | undefined {
function getTypePredicateArgument(predicate: TypePredicate, callExpression: CallExpression) {
function getTypePredicateOfSignature(signature: Signature): TypePredicate | undefined {
function getTypePredicateParent(node: Node): SignatureDeclaration | undefined {
function getTypeReferenceArity(type: TypeReference): number {
function getTypeReferenceDirectivesForEntityName(node: EntityNameOrEntityNameExpression): string[] | undefined {
function getTypeReferenceDirectivesForSymbol(symbol: Symbol, meaning?: SymbolFlags): string[] | undefined {
function getTypeReferenceId(type: TypeReference, typeParameters: Type[], depth = 0) {
function getTypeReferenceName(node: TypeReferenceType): EntityNameOrEntityNameExpression | undefined {
function getTypeReferenceSerializationKind(typeNameIn: EntityName, location?: Node): TypeReferenceSerializationKind {
function getTypeReferenceType(node: NodeWithTypeArguments, symbol: Symbol): Type {
function getTypeWithDefault(type: Type, defaultExpression: Expression) {
function getTypeWithFacts(type: Type, include: TypeFacts) {
function getTypeWithSyntheticDefaultImportType(type: Type, symbol: Symbol, originalSymbol: Symbol): Type {
function getTypeWithThisArgument(type: Type, thisArgument?: Type, needApparentType?: boolean): Type {
function getTypeWithoutSignatures(type: Type): Type {
function getUnaryResultType(operandType: Type): Type {
function getUndefinedProperty(prop: Symbol) {
function getUndefinedStrippedTargetIfNeeded(source: Type, target: Type) {
function getUninstantiatedJsxSignaturesOfType(elementType: Type, caller: JsxOpeningLikeElement): readonly Signature[] {
function getUnionIndexInfos(types: readonly Type[]): IndexInfo[] {
function getUnionOrEvolvingArrayType(types: Type[], subtypeReduction: UnionReduction) {
function getUnionOrIntersectionProperty(type: UnionOrIntersectionType, name: __String, skipObjectFunctionPropertyAugment?: boolean): Symbol | undefined {
function getUnionOrIntersectionType(types: Type[], kind: TypeFlags | undefined, unionReduction?: UnionReduction) {
function getUnionOrIntersectionTypePredicate(signatures: readonly Signature[], kind: TypeFlags | undefined): TypePredicate | undefined {
function getUnionSignatures(signatureLists: readonly (readonly Signature[])[]): Signature[] {
function getUnionType(types: readonly Type[], unionReduction: UnionReduction = UnionReduction.Literal, aliasSymbol?: Symbol, aliasTypeArguments?: readonly Type[], origin?: Type): Type {
function getUnionTypeFromSortedList(types: Type[], objectFlags: ObjectFlags, aliasSymbol?: Symbol, aliasTypeArguments?: readonly Type[], origin?: Type): Type {
function getUniqueTypeParameterName(typeParameters: readonly TypeParameter[], baseName: __String) {
function getUniqueTypeParameters(context: InferenceContext, typeParameters: readonly TypeParameter[]): readonly TypeParameter[] {
function getUnmatchedProperty(source: Type, target: Type, requireOptionalProperties: boolean, matchDiscriminantProperties: boolean): Symbol | undefined {
function getUnusedName(input: string, symbol?: Symbol): string {
function getVariableDeclarationOfObjectLiteral(symbol: Symbol, meaning: SymbolFlags) {
function getVariances(type: GenericType): VarianceFlags[] {
function getVariancesWorker<TCache extends { variances?: VarianceFlags[] }>(typeParameters: readonly TypeParameter[] = emptyArray, cache: TCache, createMarkerType: (input: TCache, param: TypeParameter, marker: Type) => Type): VarianceFlags[] {
function getWidenedLiteralLikeTypeForContextualIterationTypeIfNeeded(type: Type | undefined, contextualSignatureReturnType: Type | undefined, kind: IterationTypeKind, isAsyncGenerator: boolean) {
function getWidenedLiteralLikeTypeForContextualReturnTypeIfNeeded(type: Type | undefined, contextualSignatureReturnType: Type | undefined, isAsync: boolean) {
function getWidenedLiteralLikeTypeForContextualType(type: Type, contextualType: Type | undefined) {
function getWidenedLiteralType(type: Type): Type {
function getWidenedProperty(prop: Symbol, context: WideningContext | undefined): Symbol {
function getWidenedType(type: Type) {
function getWidenedTypeForAssignmentDeclaration(symbol: Symbol, resolvedSymbol?: Symbol) {
function getWidenedTypeForVariableLikeDeclaration(declaration: ParameterDeclaration | PropertyDeclaration | PropertySignature | VariableDeclaration | BindingElement | JSDocPropertyLikeTag, reportErrors?: boolean): Type {
function getWidenedTypeOfObjectLiteral(type: Type, context: WideningContext | undefined): Type {
function getWidenedTypeWithContext(type: Type, context: WideningContext | undefined): Type {
function getWidenedUniqueESSymbolType(type: Type): Type {
function getYieldedTypeOfYieldExpression(node: YieldExpression, expressionType: Type, sentType: Type, isAsync: boolean): Type | undefined {

// grammar
function grammarErrorAfterFirstToken(node: Node, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any): boolean {
function grammarErrorAtPos(nodeForSourceFile: Node, start: number, length: number, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any): boolean {
function grammarErrorOnFirstToken(node: Node, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any): boolean {
function grammarErrorOnNode(node: Node, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any): boolean {
function grammarErrorOnNodeSkippedOn(key: keyof CompilerOptions, node: Node, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any): boolean {

// has
function hasBaseType(type: Type, checkBase: Type | undefined) {
function hasBindableName(node: Declaration) {
function hasCommonProperties(source: Type, target: Type, isComparingJsxAttributes: boolean) {
function hasContextSensitiveParameters(node: FunctionLikeDeclaration) {
function hasContextSensitiveReturnExpression(node: FunctionLikeDeclaration) {
function hasCorrectArity(node: CallLikeExpression, args: readonly Expression[], signature: Signature, signatureHelpTrailingComma = false) {
function hasCorrectTypeArgumentArity(signature: Signature, typeArguments: NodeArray<TypeNode> | undefined) {
function hasCovariantVoidArgument(typeArguments: readonly Type[], variances: VarianceFlags[]): boolean {
function hasDefaultValue(node: BindingElement | Expression): boolean {
function hasDistributiveNameType(mappedType: MappedType) {
function hasEffectiveRestParameter(signature: Signature) {
function hasExcessProperties(source: FreshObjectLiteralType, target: Type, reportErrors: boolean): boolean {
function hasExportAssignmentSymbol(moduleSymbol: Symbol): boolean {
function hasExportedMembers(moduleSymbol: Symbol) {
function hasExternalModuleSymbol(declaration: Node) {
function hasGlobalName(name: string): boolean {
function hasInferenceCandidates(info: InferenceInfo) {
function hasLateBindableName(node: Declaration): node is LateBoundDeclaration | LateBoundBinaryExpressionDeclaration {
function hasMatchingArgument(expression: CallExpression | NewExpression, reference: Node) {
function hasNonBindingPatternContextualTypeWithNoGenericTypes(node: Node) {
function hasNonCircularBaseConstraint(type: InstantiableType): boolean {
function hasNonCircularTypeParameterDefault(typeParameter: TypeParameter) {
function hasNonGlobalAugmentationExternalModuleSymbol(declaration: Node) {
function hasNumericPropertyNames(type: Type) {
function hasOverlappingInferences(a: InferenceInfo[], b: InferenceInfo[]) {
function hasParentWithAssignmentsMarked(node: Node) {
function hasParseDiagnostics(sourceFile: SourceFile): boolean {
function hasPrimitiveConstraint(type: TypeParameter): boolean {
function hasProp(name: "set" | "get") {
function hasSkipDirectInferenceFlag(node: Node) {
function hasType(target: TypeSystemEntity, propertyName: TypeSystemPropertyName): boolean {
function hasTypeParameterByName(typeParameters: readonly TypeParameter[] | undefined, name: __String) {
function hasTypeParameterDefault(typeParameter: TypeParameter): boolean {
function hasTypePredicateOrNeverReturnType(signature: Signature) {
function hasVisibleDeclarations(symbol: Symbol, shouldComputeAliasToMakeVisible: boolean): SymbolVisibilityResult | undefined {

// import
function importClauseContainsConstEnumUsedAsValue(importClause: ImportClause) {
function importClauseContainsReferencedImport(importClause: ImportClause) {
function importClauseFromImported(decl: ImportedDeclaration): ImportClause {

function inSameLexicalScope(node Node, node Node) {

// include
function includeMixinType(type: Type, types: readonly Type[], mixinFlags: readonly boolean[], index: number): Type {
function includePrivateSymbol(symbol: Symbol) {
function includeUndefinedInIndexSignature(type: Type | undefined): Type | undefined {

// index
function indexInfoRelatedTo(sourceInfo: IndexInfo, targetInfo: IndexInfo, reportErrors: boolean) {
function indexInfoToIndexSignatureDeclarationHelper(indexInfo: IndexInfo, context: NodeBuilderContext, typeNode: TypeNode | undefined): IndexSignatureDeclaration {
function indexSignaturesIdenticalTo(source: Type, target: Type): Ternary {
function indexSignaturesRelatedTo(source: Type, target: Type, sourceIsPrimitive: boolean, reportErrors: boolean, intersectionState: IntersectionState): Ternary {
function indexTypeLessThan(indexType: Type, limit: number) {

// inferer
function inferFromAnnotatedParameters(signature: Signature, context: Signature, inferenceContext: InferenceContext) {
function inferFromContravariantTypes(source: Type, target: Type) {
function inferFromIndexTypes(source: Type, target: Type) {
function inferFromLiteralPartsToTemplateLiteral(sourceTexts: readonly string[], sourceTypes: readonly Type[], target: TemplateLiteralType): Type[] | undefined {
function inferFromMatchingTypes(sources: Type[], targets: Type[], matches: (s: Type, t: Type) => boolean): [Type[], Type[]] {
function inferFromObjectTypes(source: Type, target: Type) {
function inferFromProperties(source: Type, target: Type) {
function inferFromSignature(source: Signature, target: Signature, skipParameters: boolean) {
function inferFromSignatures(source: Type, target: Type, kind: SignatureKind) {
function inferFromTypeArguments(sourceTypes: readonly Type[], targetTypes: readonly Type[], variances: readonly VarianceFlags[]) {
function inferFromTypes(source: Type, target: Type): void {
function inferJsxTypeArguments(node: JsxOpeningLikeElement, signature: Signature, checkMode: CheckMode, context: InferenceContext): Type[] {
function inferReverseMappedType(sourceType: Type, target: MappedType, constraint: IndexType): Type {
function inferSignatureInstantiationForOverloadFailure(node: CallLikeExpression, typeParameters: readonly TypeParameter[], candidate: Signature, args: readonly Expression[]): Signature {
function inferToConditionalType(source: Type, target: ConditionalType) {
function inferToMappedType(source: Type, target: MappedType, constraintType: Type): boolean {
function inferToMultipleTypes(source: Type, targets: Type[], targetFlags: TypeFlags) {
function inferToTemplateLiteralType(source: Type, target: TemplateLiteralType) {
function inferTypeArguments(node: CallLikeExpression, signature: Signature, args: readonly Expression[], checkMode: CheckMode, context: InferenceContext): Type[] {
function inferTypeForHomomorphicMappedType(source: Type, target: MappedType, constraint: IndexType): Type | undefined {
function inferTypes(inferences: InferenceInfo[], originalSource: Type, originalTarget: Type, priority: InferencePriority = 0, contravariant = false) {
function inferTypesFromTemplateLiteralType(source: Type, target: TemplateLiteralType): Type[] | undefined {
function inferWithPriority(source: Type, target: Type, newPriority: InferencePriority) {

function initializeTypeChecker() {

function inlineExportModifiers(statements: Statement[]) {

function insertType(types: Type[], type: Type): boolean {

// instantiate
function instantiateAnonymousType(type: AnonymousType, mapper: TypeMapper, aliasSymbol?: Symbol, aliasTypeArguments?: readonly Type[]): AnonymousType {
function instantiateConditionalType(root: ConditionalRoot, mapper: TypeMapper, aliasSymbol?: Symbol, aliasTypeArguments?: readonly Type[]): Type {
function instantiateContextualType(contextualType: Type | undefined, node: Node, contextFlags?: ContextFlags): Type | undefined {
function instantiateIndexInfo(info: IndexInfo, mapper: TypeMapper) {
function instantiateIndexInfos(indexInfos: readonly IndexInfo[], mapper: TypeMapper): readonly IndexInfo[] {
function instantiateInstantiableTypes(type: Type, mapper: TypeMapper): Type {
function instantiateList<T>(items: readonly T[] | undefined, mapper: TypeMapper, instantiator: (item: T, mapper: TypeMapper) => T): readonly T[] | undefined {
function instantiateList<T>(items: readonly T[] | undefined, mapper: TypeMapper, instantiator: (item: T, mapper: TypeMapper) => T): readonly T[] | undefined;
function instantiateList<T>(items: readonly T[], mapper: TypeMapper, instantiator: (item: T, mapper: TypeMapper) => T): readonly T[];
function instantiateMappedArrayType(arrayType: Type, mappedType: MappedType, mapper: TypeMapper) {
function instantiateMappedGenericTupleType(tupleType: TupleTypeReference, mappedType: MappedType, typeVariable: TypeVariable, mapper: TypeMapper) {
function instantiateMappedTupleType(tupleType: TupleTypeReference, mappedType: MappedType, mapper: TypeMapper) {
function instantiateMappedType(type: MappedType, mapper: TypeMapper, aliasSymbol?: Symbol, aliasTypeArguments?: readonly Type[]): Type {
function instantiateMappedTypeTemplate(type: MappedType, key: Type, isOptional: boolean, mapper: TypeMapper) {
function instantiateReverseMappedType(type: ReverseMappedType, mapper: TypeMapper) {
function instantiateSignature(signature: Signature, mapper: TypeMapper, eraseTypeParameters?: boolean): Signature {
function instantiateSignatureInContextOf(signature: Signature, contextualSignature: Signature, inferenceContext?: InferenceContext, compareTypes?: TypeComparer): Signature {
function instantiateSignatures(signatures: readonly Signature[], mapper: TypeMapper): readonly Signature[] {
function instantiateSymbol(symbol: Symbol, mapper: TypeMapper): Symbol {
function instantiateType(type: Type | undefined, mapper: TypeMapper | undefined): Type | undefined {
function instantiateType(type: Type | undefined, mapper: TypeMapper | undefined): Type | undefined;
function instantiateType(type: Type, mapper: TypeMapper | undefined): Type;
function instantiateTypeAsMappedNameType(nameType: Type, type: MappedType, t: Type) {
function instantiateTypeIfNeeded(type: Type, symbol: Symbol) {
function instantiateTypePredicate(predicate: TypePredicate, mapper: TypeMapper): TypePredicate {
function instantiateTypeWithAlias(type: Type, mapper: TypeMapper, aliasSymbol: Symbol | undefined, aliasTypeArguments: readonly Type[] | undefined): Type {
function instantiateTypeWithSingleGenericCallSignature(node: Expression | MethodDeclaration | QualifiedName, type: Type, checkMode?: CheckMode) {
function instantiateTypeWorker(type: Type, mapper: TypeMapper, aliasSymbol: Symbol | undefined, aliasTypeArguments: readonly Type[] | undefined): Type {
function instantiateTypes(types: readonly Type[] | undefined, mapper: TypeMapper): readonly Type[] | undefined {
function instantiateTypes(types: readonly Type[] | undefined, mapper: TypeMapper): readonly Type[] | undefined;
function instantiateTypes(types: readonly Type[], mapper: TypeMapper): readonly Type[];

// intersect
function intersectTypes(type Type | undefined, type Type | undefined): Type | undefined {
function intersectTypes(type Type | undefined, type Type | undefined): Type | undefined;
function intersectTypes(type Type, type Type): Type;
function intersectUnionsOfPrimitiveTypes(types: Type[]) {

// invocation
function invocationError(errorTarget: Node, apparentType: Type, kind: SignatureKind, relatedInformation?: DiagnosticRelatedInformation) {
function invocationErrorDetails(errorTarget: Node, apparentType: Type, kind: SignatureKind): { messageChain: DiagnosticMessageChain, relatedMessage: DiagnosticMessage | undefined } {
function invocationErrorRecovery(apparentType: Type, kind: SignatureKind, diagnostic: Diagnostic) {

function invokeOnce(source: Type, target: Type, action: (source: Type, target: Type) => void) {

// is
function isAccessible(symbolFromSymbolTable: Symbol, resolvedAliasSymbol?: Symbol, ignoreQualification?: boolean) {
function isAliasResolvedToValue(symbol: Symbol): boolean {
function isAliasSymbolDeclaration(node: Node): boolean {
function isAliasableOrJsExpression(e: Expression) {
function isAnySignature(s: Signature) {
function isAnySymbolAccessible(symbols: Symbol[] | undefined, enclosingDeclaration: Node | undefined, initialSymbol: Symbol, meaning: SymbolFlags, shouldComputeAliasesToMakeVisible: boolean, allowModules: boolean): SymbolAccessibilityResult | undefined {
function isApplicableIndexType(source: Type, target: Type): boolean {
function isArgumentsLocalBinding(nodeIn: Identifier): boolean {
function isAritySmaller(signature: Signature, target: SignatureDeclaration) {
function isArrayLikeType(type: Type): boolean {
function isArrayOrTupleLikeType(type: Type): boolean {
function isArrayType(type: Type): type is TypeReference {
function isAssignedInBodyOfForStatement(node: Identifier, container: ForStatement): boolean {
function isAssignmentDeclaration(kind: AssignmentDeclarationKind) {
function isAssignmentToReadonlyEntity(expr: Expression, symbol: Symbol, assignmentKind: AssignmentKind) {
function isAutoTypedProperty(symbol: Symbol) {
function isBigIntLiteralExpression(expr: Expression) {
function isBindingCapturedByNode(node: Node, decl: VariableDeclaration | BindingElement) {
function isBlockScopedNameDeclaredBeforeUse(declaration: Declaration, usage: Node): boolean {
function isCircularMappedProperty(symbol: Symbol) {
function isClassDerivedFromDeclaringClasses(checkClass: Type, prop: Symbol, writing: boolean) {
function isClassInstanceSide(type: Type) {
function isCoercibleUnderDoubleEquals(source: Type, target: Type): boolean {
function isCommonJsRequire(node: Node): boolean {
function isConditionalTypeAlwaysTrueDisregardingInferTypes(type: ConditionalType) {
function isConflictingPrivateProperty(prop: Symbol) {
function isConstContext(node: Expression): boolean {
function isConstEnumObjectType(type: Type): boolean {
function isConstEnumOrConstEnumOnlyModule(s: Symbol): boolean {
function isConstEnumSymbol(symbol: Symbol): boolean {
function isConstVariable(symbol: Symbol) {
function isConstantMemberAccess(node: Expression): boolean {
function isConstantReference(node: Node): boolean {
function isConstraintPosition(type: Type, node: Node) {
function isConstructedBy(source: Type, target: Type) {
function isConstructorAccessible(node: NewExpression, signature: Signature) {
function isConstructorDeclaredProperty(symbol: Symbol) {
function isConstructorType(type: Type): boolean {
function isContextSensitive(node: Expression | MethodDeclaration | ObjectLiteralElementLike | JsxAttributeLike | JsxChild): boolean {
function isContextSensitiveFunctionLikeDeclaration(node: FunctionLikeDeclaration): boolean {
function isContextSensitiveFunctionOrObjectLiteralMethod(func: Node): func is FunctionExpression | ArrowFunction | MethodDeclaration {
function isDeclarationInConstructor(expression: Expression) {
function isDeclarationNameOrImportPropertyName(name: Node): boolean {
function isDeclarationVisible(node: Node): boolean {
function isDeclarationWithCollidingName(nodeIn: Declaration): boolean {
function isDeclarationWithExplicitTypeAnnotation(declaration: Declaration) {
function isDeeplyNestedType(type: Type, stack: Type[], depth: number): boolean {
function isDefaultBindingContext(location: Node) {
function isDeferredTypeReferenceNode(node: TypeReferenceNode | ArrayTypeNode | TupleTypeNode, hasDefaultTypeArguments?: boolean) {
function isDestructuringAssignmentTarget(parent: Node) {
function isDiscriminantProperty(type: Type | undefined, name: __String) {
function isDiscriminantWithNeverType(prop: Symbol) {
function isDistributive(type: Type): boolean {
function isDuplicatedCommonJSExport(declarations: Declaration[] | undefined) {
function isES2015OrLaterConstructorName(n: __String) {
function isES2015OrLaterIterable(n: __String) {
function isEmptyAnonymousObjectType(type: Type) {
function isEmptyArrayAssignment(node: VariableDeclaration | BindingElement | Expression) {
function isEmptyArrayLiteral(node: Expression) {
function isEmptyArrayLiteralType(type: Type): boolean {
function isEmptyLiteralType(type: Type): boolean {
function isEmptyObjectType(type: Type): boolean {
function isEmptyObjectTypeOrSpreadsIntoEmptyObject(type: Type) {
function isEmptyResolvedType(t: ResolvedType) {
function isEntityNameVisible(entityName: EntityNameOrEntityNameExpression, enclosingDeclaration: Node): SymbolVisibilityResult {
function isEnumTypeRelatedTo(sourceSymbol: Symbol, targetSymbol: Symbol, errorReporter?: ErrorReporter) {
function isEvalNode(node: Expression) {
function isEvolvingArrayOperationTarget(node: Node) {
function isEvolvingArrayTypeList(types: Type[]) {
function isExcessPropertyCheckTarget(type: Type): boolean {
function isExhaustiveSwitchStatement(node: SwitchStatement): boolean {
function isExpandoFunctionDeclaration(node: Declaration): boolean {
function isExportOrExportExpression(location: Node) {
function isExportingScope(enclosingDeclaration: Node) {
function isFalseExpression(expr: Expression): boolean {
function isForInVariableForNumericPropertyNames(expr: Expression) {
function isFreshLiteralType(type: Type) {
function isFromInferenceBlockedSource(type: Type) {
function isFunctionExpressionOrArrowFunction(node: Node): node is FunctionExpression | ArrowFunction {
function isFunctionObjectType(type: ObjectType): boolean {
function isFunctionType(type: Type): boolean {
function isGenericFunctionReturningFunction(signature: Signature) {
function isGenericIndexType(type: Type): boolean {
function isGenericMappedType(type: Type): type is MappedType {
function isGenericObjectType(type: Type): boolean {
function isGenericTupleType(type: Type): type is TupleTypeReference {
function isGenericTypeWithUndefinedConstraint(type: Type) {
function isGenericTypeWithUnionConstraint(type: Type) {
function isGenericTypeWithoutNullableConstraint(type: Type) {
function isGlobalSourceFile(node: Node) {
function isGlobalSymbolConstructor(node: Node) {
function isHeritageClauseElementIdentifier(node: Node): boolean {
function isHyphenatedJsxName(name: string | __String) {
function isIdenticalTo(source: Type, target: Type): Ternary {
function isIdentifierAndNotUndefined(node: Node | undefined): node is Identifier {
function isIdentifierThatStartsWithUnderscore(node: Node) {
function isIgnoredJsxProperty(source: Type, sourceProp: Symbol) {
function isImmediatelyUsedInInitializerOfBlockScopedVariable(declaration: VariableDeclaration, usage: Node): boolean {
function isImplementationCompatibleWithOverload(implementation: Signature, overload: Signature): boolean {
function isImplementationOfOverload(node: SignatureDeclaration) {
function isImportRequiredByAugmentation(node: ImportDeclaration) {
function isImportTypeQualifierPart(node: EntityName): ImportTypeNode | undefined {
function isImportedDeclaration(node: Node): node is ImportedDeclaration {
function isInConstructorArgumentInitializer(node: Node, constructorDecl: Node): boolean {
function isInHeritageClause(node: PropertyAccessEntityNameExpression) {
function isInParameterInitializerBeforeContainingFunction(node: Node) {
function isInPropertyInitializerOrClassStaticBlock(node: Node): boolean {
function isInRightSideOfImportOrExportAssignment(node: EntityName) {
function isInTypeQuery(node: Node): boolean {
function isIncomplete(flowType: FlowType) {
function isInfinityOrNaNString(name: string | __String): boolean {
function isInsideFunctionOrInstancePropertyInitializer(node: Node, threshold: Node): boolean {
function isInstancePropertyWithInitializerOrPrivateIdentifierProperty(n: Node): boolean {
function isInstantiatedModule(node: ModuleDeclaration, preserveConstEnums: boolean) {
function isIntersectionEmpty(type Type, type Type) {
function isIteratorResult(type: Type, kind: IterationTypeKind.Yield | IterationTypeKind.Return) {
function isJSConstructor(node: Node | undefined): node is FunctionDeclaration | FunctionExpression {
function isJSDocOptionalParameter(node: ParameterDeclaration) {
function isJSDocTypeReference(node: Node): node is TypeReferenceNode {
function isJSLiteralType(type: Type): boolean {
function isJsxIntrinsicIdentifier(tagName: JsxTagNameExpression): boolean {
function isKnownProperty(targetType: Type, name: __String, isComparingJsxAttributes: boolean): boolean {
function isLateBindableName(node: DeclarationName): node is LateBoundName {
function isLateBoundName(name: __String): boolean {
function isLegalUsageOfSuperExpression(container: Node): boolean {
function isLiteralConstDeclaration(node: VariableDeclaration | PropertyDeclaration | PropertySignature | ParameterDeclaration): boolean {
function isLiteralEnumMember(member: EnumMember) {
function isLiteralOfContextualType(candidateType: Type, contextualType: Type | undefined): boolean {
function isLiteralType(type: Type): boolean {
function isLocalTypeAlias(symbol: Symbol) {
function isMappedTypeWithKeyofConstraintDeclaration(type: MappedType) {
function isMatchingConstructorReference(expr: Expression) {
function isMatchingReference(source: Node, target: Node): boolean {
function isMatchingSignature(source: Signature, target: Signature, partialMatch: boolean) {
function isMethodAccessForCall(node: Node) {
function isMixinConstructorType(type: Type) {
function isMutableArrayOrTuple(type: Type): boolean {
function isNameOfModuleOrEnumDeclaration(node: Identifier) {
function isNamedUnionType(type: Type) {
function isNamespaceMember(p: Symbol) {
function isNeitherUnitTypeNorNever(type: Type): boolean {
function isNeverReducedProperty(prop: Symbol) {
function isNodeUsedDuringClassInitialization(node: Node) {
function isNodeWithinClass(node: Node, classDeclaration: ClassLikeDeclaration) {
function isNonBindableDynamicName(node: DeclarationName) {
function isNonDeferredTypeReference(type: Type): type is TypeReference {
function isNonGenericObjectType(type: Type) {
function isNonGenericTopLevelType(type: Type) {
function isNonLocalAlias(symbol: Symbol | undefined, excludes = SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace): symbol is Symbol {
function isNotAccessor(declaration: Declaration): boolean {
function isNotOverload(declaration: Declaration): boolean {
function isNullOrUndefined(node: Expression) {
function isNullableType(type: Type) {
function isNumericComputedName(name: ComputedPropertyName): boolean {
function isNumericLiteralName(name: string | __String) {
function isNumericName(name: DeclarationName): boolean {
function isObjectLiteralType(type: Type) {
function isObjectOrArrayLiteralType(type: Type) {
function isObjectTypeWithInferableIndex(type: Type): boolean {
function isOptionalJSDocPropertyLikeTag(node: Node): node is JSDocPropertyLikeTag {
function isOptionalParameter(node: ParameterDeclaration | JSDocParameterTag | JSDocPropertyTag) {
function isOptionalPropertyDeclaration(node: Declaration) {
function isOptionalUninitializedParameter(parameter: ParameterDeclaration) {
function isOptionalUninitializedParameterProperty(parameter: ParameterDeclaration) {
function isOrContainsMatchingReference(source: Node, target: Node) {
function isOrHasGenericConditional(type: Type): boolean {
function isParameterAssigned(symbol: Symbol) {
function isParameterDeclarationWithIdentifierName(symbol: Symbol) {
function isPartialMappedType(type: Type) {
function isPartiallyInferableType(type: Type): boolean {
function isPatternLiteralPlaceholderType(type: Type) {
function isPatternLiteralType(type: Type) {
function isPossiblyAliasedThisProperty(declaration: BinaryExpression, kind = getAssignmentDeclarationKind(declaration)) {
function isPossiblyDiscriminantValue(node: Expression): boolean {
function isPostSuperFlowNode(flow: FlowNode, noCacheCheck: boolean): boolean {
function isPotentiallyUncalledDecorator(decorator: Decorator, signatures: readonly Signature[]) {
function isPrimitiveTypeName(name: __String) {
function isPrivateWithinAmbient(node: Node): boolean {
function isPromiseResolveArityError(node: CallLikeExpression) {
function isPropertyDeclaredInAncestorClass(prop: Symbol): boolean {
function isPropertyIdenticalTo(sourceProp: Symbol, targetProp: Symbol): boolean {
function isPropertyImmediatelyReferencedWithinDeclaration(declaration: PropertyDeclaration | ParameterPropertyDeclaration, usage: Node, stopAtAnyPropertyDeclaration: boolean) {
function isPropertyInClassDerivedFrom(prop: Symbol, baseClass: Type | undefined) {
function isPropertyInitializedInConstructor(propName: Identifier | PrivateIdentifier, propType: Type, constructor: ConstructorDeclaration) {
function isPropertyInitializedInStaticBlocks(propName: Identifier | PrivateIdentifier, propType: Type, staticBlocks: readonly ClassStaticBlockDeclaration[], startPos: number, endPos: number) {
function isPropertyOrMethodDeclarationSymbol(symbol: Symbol) {
function isPropertySymbolTypeRelated(sourceProp: Symbol, targetProp: Symbol, getTypeOfSourceProperty: (sym: Symbol) => Type, reportErrors: boolean, intersectionState: IntersectionState): Ternary {
function isPropertyWithoutInitializer(node: Node) {
function isPrototypeProperty(symbol: Symbol) {
function isReachableFlowNode(flow: FlowNode) {
function isReachableFlowNodeWorker(flow: FlowNode, noCacheCheck: boolean): boolean {
function isReadonlyArrayType(type: Type): boolean {
function isReadonlyAssignmentDeclaration(d: Declaration) {
function isReadonlySymbol(symbol: Symbol): boolean {
function isReadonlyTypeOperator(node: Node) {
function isReferenceToType(type: Type, target: Type) {
function isReferencedAliasDeclaration(node: Node, checkChildren?: boolean): boolean {
function isRelatedTo(originalSource: Type, originalTarget: Type, reportErrors = false, headMessage?: DiagnosticMessage, intersectionState = IntersectionState.None): Ternary {
function isRequiredInitializedParameter(parameter: ParameterDeclaration | JSDocParameterTag): boolean {
function isReservedMemberName(name: __String) {
function isResolvedByTypeAlias(node: Node): boolean {
function isResolvingReturnTypeOfSignature(signature: Signature) {
function isReturnIteratorResult(type: Type) {
function isSameScopeDescendentOf(initial: Node, parent: Node | undefined, stopAt: Node): boolean {
function isSelfReferenceLocation(node: Node): boolean {
function isSelfTypeAccess(name: Expression | QualifiedName, parent: Symbol | undefined) {
function isSideEffectFree(node: Node): boolean {
function isSignatureAssignableTo(source: Signature,
function isSimpleLiteralEnumReference(expr: Expression) {
function isSimpleTypeRelatedTo(source: Type, target: Type, relation: ESMap<string, RelationComparisonResult>, errorReporter?: ErrorReporter) {
function isSingleElementGenericTupleType(type: Type): type is TupleTypeReference {
function isSingleQuotedStringNamed(d: Declaration) {
function isSingletonTupleType(node: TypeNode) {
function isSpreadArgument(arg: Expression | undefined): arg is Expression {
function isSpreadableProperty(prop: Symbol): boolean {
function isStaticPrivateIdentifierProperty(s: Symbol): boolean {
function isStringConcatExpression(expr: Node): boolean {
function isStringIndexSignatureOnlyType(type: Type): boolean {
function isStringNamed(d: Declaration) {
function isStringOrNumberLiteralExpression(expr: Expression) {
function isSymbolAccessible(symbol: Symbol | undefined, enclosingDeclaration: Node | undefined, meaning: SymbolFlags, shouldComputeAliasesToMakeVisible: boolean): SymbolAccessibilityResult {
function isSymbolAccessibleByFlags(typeSymbol: Symbol, enclosingDeclaration: Node | undefined, flags: SymbolFlags): boolean {
function isSymbolAccessibleWorker(symbol: Symbol | undefined, enclosingDeclaration: Node | undefined, meaning: SymbolFlags, shouldComputeAliasesToMakeVisible: boolean, allowModules: boolean): SymbolAccessibilityResult {
function isSymbolFromTypeDeclarationFile(symbol: Symbol): boolean {
function isSymbolOfDeclarationWithCollidingName(symbol: Symbol): boolean {
function isSymbolOfDestructuredElementOfCatchBinding(symbol: Symbol) {
function isSymbolOrSymbolForCall(node: Node) {
function isSymbolUsedInBinaryExpressionChain(node: Node, testedSymbol: Symbol): boolean {
function isSymbolUsedInConditionBody(expr: Expression, body: Statement | Expression, testedNode: Node, testedSymbol: Symbol): boolean {
function isSymbolWithNumericName(symbol: Symbol) {
function isSymbolWithSymbolName(symbol: Symbol) {
function isSyntacticDefault(node: Node) {
function isTemplateLiteralContext(node: Node): boolean {
function isTemplateLiteralContextualType(type: Type): boolean {
function isThenableType(type: Type): boolean {
function isThisPropertyAccessInConstructor(node: ElementAccessExpression | PropertyAccessExpression | QualifiedName, prop: Symbol) {
function isThisTypeParameter(type: Type): boolean {
function isThisless(symbol: Symbol): boolean {
function isThislessFunctionLikeDeclaration(node: FunctionLikeDeclaration): boolean {
function isThislessInterface(symbol: Symbol): boolean {
function isThislessType(node: TypeNode): boolean {
function isThislessTypeParameter(node: TypeParameterDeclaration) {
function isThislessVariableLikeDeclaration(node: VariableLikeDeclaration): boolean {
function isTopLevelInExternalModuleAugmentation(node: Node): boolean {
function isTopLevelValueImportEqualsWithEntityName(nodeIn: ImportEqualsDeclaration): boolean {
function isTupleLikeType(type: Type): boolean {
function isTupleType(type: Type): type is TupleTypeReference {
function isTupleTypeStructureMatching(t TupleTypeReference, t TupleTypeReference) {
function isTypeAny(type: Type | undefined) {
function isTypeAssertion(node: Expression) {
function isTypeAssignableTo(source: Type, target: Type): boolean {
function isTypeAssignableToKind(source: Type, kind: TypeFlags, strict?: boolean): boolean {
function isTypeCloselyMatchedBy(s: Type, t: Type) {
function isTypeComparableTo(source: Type, target: Type): boolean {
function isTypeDeclaration(node: Node): node is TypeParameterDeclaration | ClassDeclaration | InterfaceDeclaration | TypeAliasDeclaration | JSDocTypedefTag | JSDocCallbackTag | JSDocEnumTag | EnumDeclaration | ImportClause | ImportSpecifier | ExportSpecifier {
function isTypeDeclarationName(name: Node): boolean {
function isTypeDerivedFrom(source: Type, target: Type): boolean {
function isTypeEqualityComparableTo(source: Type, target: Type) {
function isTypeIdenticalTo(source: Type, target: Type): boolean {
function isTypeInvalidDueToUnionDiscriminant(contextualType: Type, obj: ObjectLiteralExpression | JsxAttributes): boolean {
function isTypeOnlyNamespace(symbol: Symbol) {
function isTypeOrBaseIdenticalTo(s: Type, t: Type) {
function isTypeParameterAtTopLevel(type: Type, typeParameter: TypeParameter): boolean {
function isTypeParameterPossiblyReferenced(tp: TypeParameter, node: Node) {
function isTypeParameterSymbolDeclaredInContainer(symbol: Symbol, container: Node) {
function isTypeParameterUnused(typeParameter: TypeParameterDeclaration): boolean {
function isTypePresencePossible(type: Type, propName: __String, assumeTrue: boolean) {
function isTypeReferenceIdentifier(node: EntityName): boolean {
function isTypeReferenceWithGenericArguments(type: Type): boolean {
function isTypeRelatedTo(source: Type, target: Type, relation: ESMap<string, RelationComparisonResult>) {
function isTypeRepresentableAsFunctionNamespaceMerge(typeToSerialize: Type, hostSymbol: Symbol) {
function isTypeSubsetOf(source: Type, target: Type) {
function isTypeSubsetOfUnion(source: Type, target: UnionType) {
function isTypeSubtypeOf(source: Type, target: Type): boolean {
function isTypeSymbolAccessible(typeSymbol: Symbol, enclosingDeclaration: Node | undefined): boolean {
function isTypeUsableAsPropertyName(type: Type): type is StringLiteralType | NumberLiteralType | UniqueESSymbolType {
function isTypicalNondistributiveConditional(root: ConditionalRoot) {
function isUnaryTupleTypeNode(node: TypeNode) {
function isUncalledFunctionReference(node: Node, symbol: Symbol) {
function isUncheckedJSSuggestion(node: Node | undefined, suggestion: Symbol | undefined, excludeClasses: boolean): boolean {
function isUnconstrainedTypeParameter(type: Type) {
function isUnitLikeType(type: Type): boolean {
function isUnitType(type: Type): boolean {
function isUntypedFunctionCall(funcType: Type, apparentFuncType: Type, numCallSignatures: number, numConstructSignatures: number): boolean {
function isUnwrappedReturnTypeVoidOrAny(func: SignatureDeclaration, returnType: Type): boolean {
function isUsedInFunctionOrInstanceProperty(usage: Node, declaration: Node): boolean {
function isValidBaseType(type: Type): type is BaseType {
function isValidBigIntString(s: string): boolean {
function isValidConstAssertionArgument(node: Node): boolean {
function isValidDeclarationForTupleLabel(d: Declaration): d is NamedTupleMember | (ParameterDeclaration & { name: Identifier }) {
function isValidIndexKeyType(type: Type): boolean {
function isValidOverrideOf(sourceProp: Symbol, targetProp: Symbol) {
function isValidPropertyAccess(node: PropertyAccessExpression | QualifiedName | ImportTypeNode, propertyName: __String): boolean {
function isValidPropertyAccessForCompletions(node: PropertyAccessExpression | ImportTypeNode | QualifiedName, type: Type, property: Symbol): boolean {
function isValidPropertyAccessWithType(
function isValidSpreadType(type: Type): boolean {
function isValidTypeForTemplateLiteralPlaceholder(source: Type, target: Type): boolean {
function isValidUnusedLocalDeclaration(declaration: Declaration): boolean {
function isValue(s: Symbol): boolean {
function isValueAliasDeclaration(node: Node): boolean {
function isValueSymbolAccessible(typeSymbol: Symbol, enclosingDeclaration: Node | undefined): boolean {
function isWeakType(type: Type): boolean {
function isYieldIteratorResult(type: Type) {
function isZeroBigInt({value}: BigIntLiteralType) {
function issueMemberSpecificError(node: ClassLikeDeclaration, typeWithThis: Type, baseWithThis: Type, broadDiag: DiagnosticMessage) {

function lateBindMember(parent: Symbol, earlySymbols: SymbolTable | undefined, lateSymbols: UnderscoreEscapedMap<TransientSymbol>, decl: LateBoundDeclaration | LateBoundBinaryExpressionDeclaration) {

function literalTypeToNode(type: FreshableType, enclosing: Node, tracker: SymbolTracker): Expression {
function literalTypesWithSameBaseType(types: Type[]): boolean {

// lookup
function lookupOrIssueError(location: Node | undefined, message: DiagnosticMessage, arg0?: string | number, arg1?: string | number, arg2?: string | number, arg3?: string | number): Diagnostic {
function lookupSymbolChain(symbol: Symbol, context: NodeBuilderContext, meaning: SymbolFlags, yieldModuleSymbol?: boolean) {
function lookupSymbolChainWorker(symbol: Symbol, context: NodeBuilderContext, meaning: SymbolFlags, yieldModuleSymbol?: boolean) {
function lookupSymbolForPrivateIdentifierDeclaration(propName: __String, location: Node): Symbol | undefined {
function lookupTypeParameterNodes(chain: Symbol[], index: number, context: NodeBuilderContext) {

// make
function makeArrayTypeMapper(sources: readonly TypeParameter[], targets: readonly Type[] | undefined): TypeMapper {
function makeCompositeTypeMapper(kind: TypeMapKind.Composite | TypeMapKind.Merged, mapper TypeMapper, mapper TypeMapper): TypeMapper {
function makeFunctionTypeMapper(func: (t: Type) => Type): TypeMapper {
function makeSerializePropertySymbol<T extends Node>(createProperty: (
function makeSerializePropertySymbol<T extends Node>(createProperty: (
function makeSerializePropertySymbol<T extends Node>(createProperty: (
function makeUnaryTypeMapper(source: Type, target: Type): TypeMapper {

// map
function mapToInferredType(context: InferenceContext, t: Type, fix: boolean): Type {
function mapToTypeNodes(types: readonly Type[] | undefined, context: NodeBuilderContext, isBareList?: boolean): TypeNode[] | undefined {
function mapType(type: Type, mapper: (t: Type) => Type | undefined, noReductions?: boolean): Type | undefined {
function mapType(type: Type, mapper: (t: Type) => Type | undefined, noReductions?: boolean): Type | undefined;
function mapType(type: Type, mapper: (t: Type) => Type, noReductions?: boolean): Type;
function mapTypeWithAlias(type: Type, mapper: (t: Type) => Type, aliasSymbol: Symbol | undefined, aliasTypeArguments: readonly Type[] | undefined) {
function mapTypesByKeyProperty(types: Type[], name: __String) {
function mappedTypeRelatedTo(source: MappedType, target: MappedType, reportErrors: boolean): Ternary {

// mark
function markAliasReferenced(symbol: Symbol, location: Node) {
function markAliasSymbolAsReferenced(symbol: Symbol) {
function markAsSynthetic(node: Node): VisitResult<Node> {
function markConstEnumAliasAsReferenced(symbol: Symbol) {
function markDecoratorMedataDataTypeNodeAsReferenced(node: TypeNode | undefined): void {
function markEntityNameOrEntityExpressionAsReference(typeName: EntityNameOrEntityNameExpression | undefined) {
function markExportAsReferenced(node: ImportEqualsDeclaration | ExportSpecifier) {
function markParameterAssignments(node: Node) {
function markPropertyAsReferenced(prop: Symbol, nodeForCheckWriteOnly: Node | undefined, isSelfTypeAccess: boolean) {
function markSymbolOfAliasDeclarationIfTypeOnly(
function markSymbolOfAliasDeclarationIfTypeOnlyWorker(aliasDeclarationLinks: SymbolLinks, target: Symbol | undefined, overwriteEmpty: boolean): boolean {
function markTypeNodeAsReferenced(node: TypeNode) {

// may
function mayResolveTypeAlias(node: Node): boolean {
function mayReturnNever(func: FunctionLikeDeclaration): boolean {

// maybe
function maybeAddJsSyntheticRestParameter(declaration: SignatureDeclaration | JSDocSignature, parameters: Symbol[]): boolean {
function maybeAddMissingAwaitInfo(errorNode: Node | undefined, source: Type, target: Type) {
function maybeCheckExpression(state: WorkArea, node: Expression): BinaryExpression | undefined {
function maybeMappedType(node: Node, symbol: Symbol) {
function maybeTypeOfKind(type: Type, kind: TypeFlags): boolean {
function maybeTypeParameterReference(node: Node) {

function membersRelatedToIndexInfo(source: Type, targetInfo: IndexInfo, reportErrors: boolean): Ternary {

// merge
function mergeExportDeclarations(statements: Statement[]) {
function mergeInferences(target: InferenceInfo[], source: InferenceInfo[]) {
function mergeJSSymbols(target: Symbol, source: Symbol | undefined) {
function mergeModuleAugmentation(moduleName: StringLiteral | Identifier): void {
function mergeRedundantStatements(statements: Statement[]) {
function mergeSymbol(target: Symbol, source: Symbol, unidirectional = false): Symbol {
function mergeSymbolTable(target: SymbolTable, source: SymbolTable, unidirectional = false) {
function mergeTypeMappers(mapper TypeMapper | undefined, mapper TypeMapper): TypeMapper {

function moduleExportsSomeValue(moduleReferenceExpression: Expression): boolean {

// narrow
function narrowByInKeyword(type: Type, literal: LiteralExpression, assumeTrue: boolean) {
function narrowBySwitchOnTypeOf(type: Type, switchStatement: SwitchStatement, clauseStart: number, clauseEnd: number): Type {
function narrowType(type: Type, expr: Expression, assumeTrue: boolean): Type {
function narrowTypeByAssertion(type: Type, expr: Expression): Type {
function narrowTypeByBinaryExpression(type: Type, expr: BinaryExpression, assumeTrue: boolean): Type {
function narrowTypeByCallExpression(type: Type, callExpression: CallExpression, assumeTrue: boolean): Type {
function narrowTypeByConstructor(type: Type, operator: SyntaxKind, identifier: Expression, assumeTrue: boolean): Type {
function narrowTypeByDiscriminant(type: Type, access: AccessExpression | BindingElement, narrowType: (t: Type) => Type): Type {
function narrowTypeByDiscriminantProperty(type: Type, access: AccessExpression | BindingElement, operator: SyntaxKind, value: Expression, assumeTrue: boolean) {
function narrowTypeByEquality(type: Type, operator: SyntaxKind, value: Expression, assumeTrue: boolean): Type {
function narrowTypeByInstanceof(type: Type, expr: BinaryExpression, assumeTrue: boolean): Type {
function narrowTypeByOptionalChainContainment(type: Type, operator: SyntaxKind, value: Expression, assumeTrue: boolean): Type {
function narrowTypeByOptionality(type: Type, expr: Expression, assumePresent: boolean): Type {
function narrowTypeBySwitchOnDiscriminant(type: Type, switchStatement: SwitchStatement, clauseStart: number, clauseEnd: number) {
function narrowTypeBySwitchOnDiscriminantProperty(type: Type, access: AccessExpression | BindingElement, switchStatement: SwitchStatement, clauseStart: number, clauseEnd: number) {
function narrowTypeBySwitchOptionalChainContainment(type: Type, switchStatement: SwitchStatement, clauseStart: number, clauseEnd: number, clauseCheck: (type: Type) => boolean) {
function narrowTypeByTruthiness(type: Type, expr: Expression, assumeTrue: boolean): Type {
function narrowTypeByTypePredicate(type: Type, predicate: TypePredicate, callExpression: CallExpression, assumeTrue: boolean): Type {
function narrowTypeByTypeof(type: Type, typeOfExpr: TypeOfExpression, operator: SyntaxKind, literal: LiteralExpression, assumeTrue: boolean): Type {
function narrowUnionMemberByTypeof(candidate: Type) {

// need
function needCollisionCheckForIdentifier(node: Node, identifier: Identifier | undefined, name: string): boolean {
function needsQualification(symbol: Symbol, enclosingDeclaration: Node | undefined, meaning: SymbolFlags) {

function nodeHasAnyModifiersExcept(node: Node, allowedModifier: SyntaxKind): boolean {

// on
function onEnter(node: BinaryExpression, state: WorkArea | undefined, checkMode: CheckMode | undefined) {
function onExit(node: BinaryExpression, state: WorkArea): Type | undefined {
function onLeft(left: Expression, state: WorkArea, _node: BinaryExpression) {
function onOperator(operatorToken: BinaryOperatorToken, state: WorkArea, node: BinaryExpression) {
function onRight(right: Expression, state: WorkArea, _node: BinaryExpression) {

function optionalChainContainsReference(source: Node, target: Node) {

function padTupleType(type: TupleTypeReference, pattern: ArrayBindingPattern) {

function pickLongestCandidateSignature(node: CallLikeExpression, candidates: Signature[], args: readonly Expression[]): Signature {

// pop
function popTypeResolution(): boolean {
function populateSymbols() {

function prependTypeMapping(source: Type, target: Type, mapper: TypeMapper | undefined) {

function preserveCommentsOn<T extends Node>(node: T) {

function propagateOptionalTypeMarker(type: Type, node: OptionalChain, wasOptional: boolean) {

// properties
function propertiesIdenticalTo(source: Type, target: Type, excludedProperties: Set<__String> | undefined): Ternary {
function propertiesRelatedTo(source: Type, target: Type, reportErrors: boolean, excludedProperties: Set<__String> | undefined, intersectionState: IntersectionState): Ternary {
function propertyRelatedTo(source: Type, target: Type, sourceProp: Symbol, targetProp: Symbol, getTypeOfSourceProperty: (sym: Symbol) => Type, reportErrors: boolean, intersectionState: IntersectionState, skipOptional: boolean): Ternary {

function pushTypeResolution(target: TypeSystemEntity, propertyName: TypeSystemPropertyName): boolean {

// record
function recordMergedSymbol(target: Symbol, source: Symbol) {
function recordPotentialCollisionWithReflectInGeneratedCode(node: Node, name: Identifier | undefined): void {
function recordPotentialCollisionWithWeakMapSetInGeneratedCode(node: Node, name: Identifier): void {

function recursiveTypeRelatedTo(source: Type, target: Type, reportErrors: boolean, intersectionState: IntersectionState): Ternary {

function registerForUnusedIdentifiersCheck(node: PotentiallyUnusedIdentifier): void {

function relateVariances(sourceTypeArguments: readonly Type[] | undefined, targetTypeArguments: readonly Type[] | undefined, variances: VarianceFlags[], intersectionState: IntersectionState) {

// remove
function removeDefinitelyFalsyTypes(type: Type): Type {
function removeExportModifier(node: Extract<HasModifiers, Statement>) {
function removeMissingOrUndefinedType(type: Type): Type {
function removeMissingType(type: Type, isOptional: boolean) {
function removeOptionalTypeMarker(type: Type): Type {
function removeOptionalityFromDeclaredType(declaredType: Type, declaration: VariableLikeDeclaration): Type {
function removeRedundantLiteralTypes(types: Type[], includes: TypeFlags, reduceVoidUndefined: boolean) {
function removeRedundantPrimitiveTypes(types: Type[], includes: TypeFlags) {
function removeStringLiteralsMatchedByTemplateLiterals(types: Type[]) {
function removeSubtypes(types: Type[], hasObjectTypes: boolean): Type[] | undefined {
function removeType(type: Type, targetType: Type) {

function reorderCandidates(signatures: readonly Signature[], result: Signature[], callChainFlags: SignatureFlags): void {

// replace
function replaceIndexedAccess(instantiable: Type, type: ReplaceableIndexedAccessType, replacement: Type) {

function replacePrimitivesWithLiterals(typeWithPrimitives: Type, typeWithLiterals: Type) {

// report
function reportCannotInvokePossiblyNullOrUndefinedError(node: Node, flags: TypeFlags) {
function reportCircularBaseType(node: Node, type: Type) {
function reportCircularityError(symbol: Symbol) {
function reportError(message: DiagnosticMessage, arg0?: string | number, arg1?: string | number, arg2?: string | number, arg3?: string | number): void {
function reportErrorResults(source: Type, target: Type, result: Ternary, isComparingJsxAttributes: boolean) {
function reportErrorsFromWidening(declaration: Declaration, type: Type, wideningKind?: WideningKind) {
function reportFlowControlError(node: Node) {
function reportImplementationExpectedError(node: SignatureDeclaration): void {
function reportImplicitAny(declaration: Declaration, type: Type, wideningKind?: WideningKind) {
function reportIncompatibleCallSignatureReturn(siga: Signature, sigb: Signature) {
function reportIncompatibleConstructSignatureReturn(siga: Signature, sigb: Signature) {
function reportIncompatibleError(message: DiagnosticMessage, arg0?: string | number, arg1?: string | number, arg2?: string | number, arg3?: string | number) {
function reportIncompatibleStack() {
function reportInvalidImportEqualsExportMember(node: ImportDeclaration | ExportDeclaration | VariableDeclaration, name: Identifier, declarationName: string, moduleName: string) {
function reportNonDefaultExport(moduleSymbol: Symbol, node: ImportClause) {
function reportNonExportedMember(node: ImportDeclaration | ExportDeclaration | VariableDeclaration, name: Identifier, declarationName: string, moduleSymbol: Symbol, moduleName: string): void {
function reportNonexistentProperty(propNode: Identifier | PrivateIdentifier, containingType: Type, isUncheckedJS: boolean) {
function reportObjectPossiblyNullOrUndefinedError(node: Node, flags: TypeFlags) {
function reportObviousModifierErrors(node: Node): boolean | undefined {
function reportOperatorError(isRelated?: (left: Type, right: Type) => boolean) {
function reportOperatorErrorUnless(typesAreCompatible: (left: Type, right: Type) => boolean): boolean {
function reportRelationError(message: DiagnosticMessage | undefined, source: Type, target: Type) {
function reportTypeNotIterableError(errorNode: Node, type: Type, allowAsyncIterables: boolean): void {
function reportUnmatchedProperty(source: Type, target: Type, unmatchedProperty: Symbol, requireOptionalProperties: boolean) {
function reportUnmeasurableMarkers(p: TypeParameter) {
function reportUnreliableMarkers(p: TypeParameter) {
function reportWideningErrorsInType(type: Type): boolean {

// requires
function requiresScopeChange(node: ParameterDeclaration): boolean {
function requiresScopeChangeWorker(node: Node): boolean {

function resetErrorInfo(saved: ReturnType<typeof captureErrorCalculationState>) {

// resolve
function resolveAlias(symbol: Symbol): Symbol {
function resolveAnonymousTypeMembers(type: AnonymousType) {
function resolveBaseTypesOfClass(type: InterfaceType) {
function resolveBaseTypesOfInterface(type: InterfaceType): void {
function resolveCall(node: CallLikeExpression, signatures: readonly Signature[], candidatesOutArray: Signature[] | undefined, checkMode: CheckMode, callChainFlags: SignatureFlags, fallbackError?: DiagnosticMessage): Signature {
function resolveCallExpression(node: CallExpression, candidatesOutArray: Signature[] | undefined, checkMode: CheckMode): Signature {
function resolveClassOrInterfaceMembers(type: InterfaceType): void {
function resolveDeclaredMembers(type: InterfaceType): InterfaceTypeWithDeclaredMembers {
function resolveDecorator(node: Decorator, candidatesOutArray: Signature[] | undefined, checkMode: CheckMode): Signature {
function resolveESModuleSymbol(moduleSymbol: Symbol | undefined, referencingLocation: Node, dontResolveAlias: boolean, suppressInteropError: boolean): Symbol | undefined {
function resolveEntityName(name: EntityNameOrEntityNameExpression, meaning: SymbolFlags, ignoreErrors?: boolean, dontResolveAlias?: boolean, location?: Node): Symbol | undefined {
function resolveEntityNameFromAssignmentDeclaration(name: Identifier, meaning: SymbolFlags) {
function resolveErrorCall(node: CallLikeExpression): Signature {
function resolveExportByName(moduleSymbol: Symbol, name: __String, sourceNode: TypeOnlyCompatibleAliasDeclaration | undefined, dontResolveAlias: boolean) {
function resolveExternalModule(location: Node, moduleReference: string, moduleNotFoundError: DiagnosticMessage | undefined, errorNode: Node, isForAugmentation = false): Symbol | undefined {
function resolveExternalModuleName(location: Node, moduleReferenceExpression: Expression, ignoreErrors?: boolean): Symbol | undefined {
function resolveExternalModuleNameWorker(location: Node, moduleReferenceExpression: Expression, moduleNotFoundError: DiagnosticMessage | undefined, isForAugmentation = false): Symbol | undefined {
function resolveExternalModuleSymbol(moduleSymbol: Symbol | undefined, dontResolveAlias?: boolean): Symbol | undefined;
function resolveExternalModuleSymbol(moduleSymbol: Symbol, dontResolveAlias?: boolean): Symbol | undefined {
function resolveExternalModuleSymbol(moduleSymbol: Symbol, dontResolveAlias?: boolean): Symbol;
function resolveExternalModuleTypeByLiteral(name: StringLiteral) {
function resolveHelpersModule(node: SourceFile, errorNode: Node) {
function resolveImportSymbolType(node: ImportTypeNode, links: NodeLinks, symbol: Symbol, meaning: SymbolFlags) {
function resolveIntersectionTypeMembers(type: IntersectionType) {
function resolveJSDocMemberName(name: EntityName | JSDocMemberName, container?: Symbol): Symbol | undefined {
function resolveJsxOpeningLikeElement(node: JsxOpeningLikeElement, candidatesOutArray: Signature[] | undefined, checkMode: CheckMode): Signature {
function resolveMappedTypeMembers(type: MappedType) {
function resolveName(
function resolveNameHelper(
function resolveNewExpression(node: NewExpression, candidatesOutArray: Signature[] | undefined, checkMode: CheckMode): Signature {
function resolveObjectTypeMembers(type: ObjectType, source: InterfaceTypeWithDeclaredMembers, typeParameters: readonly TypeParameter[], typeArguments: readonly Type[]) {
function resolveReverseMappedTypeMembers(type: ReverseMappedType) {
function resolveSignature(node: CallLikeExpression, candidatesOutArray: Signature[] | undefined, checkMode: CheckMode): Signature {
function resolveStructuredTypeMembers(type: StructuredType): ResolvedType {
function resolveSymbol(symbol: Symbol | undefined, dontResolveAlias?: boolean): Symbol | undefined {
function resolveSymbol(symbol: Symbol | undefined, dontResolveAlias?: boolean): Symbol | undefined;
function resolveSymbol(symbol: Symbol, dontResolveAlias?: boolean): Symbol;
function resolveTaggedTemplateExpression(node: TaggedTemplateExpression, candidatesOutArray: Signature[] | undefined, checkMode: CheckMode): Signature {
function resolveTypeOfAccessors(symbol: Symbol, writing = false) {
function resolveTypeReferenceMembers(type: TypeReference): void {
function resolveTypeReferenceName(typeReferenceName: EntityNameExpression | EntityName | undefined, meaning: SymbolFlags, ignoreErrors?: boolean) {
function resolveUnionTypeMembers(type: UnionType) {
function resolveUntypedCall(node: CallLikeExpression): Signature {

function rewriteModuleSpecifier(parent: ImportTypeNode, lit: StringLiteral) {

function sanitizeJSDocImplements(clauses: readonly ExpressionWithTypeArguments[]): ExpressionWithTypeArguments[] | undefined {

// serialize
function serializeAsAlias(symbol: Symbol, localName: string, modifierFlags: ModifierFlags) {
function serializeAsClass(symbol: Symbol, localName: string, modifierFlags: ModifierFlags) {
function serializeAsFunctionNamespaceMerge(type: Type, symbol: Symbol, localName: string, modifierFlags: ModifierFlags) {
function serializeAsNamespaceDeclaration(props: readonly Symbol[], localName: string, modifierFlags: ModifierFlags, suppressNewPrivateContext: boolean) {
function serializeBaseType(t: Type, staticType: Type, rootName: string) {
function serializeEnum(symbol: Symbol, symbolName: string, modifierFlags: ModifierFlags) {
function serializeExistingTypeNode(context: NodeBuilderContext, existing: TypeNode, includePrivateSymbol?: (s: Symbol) => void, bundled?: boolean) {
function serializeExportSpecifier(localName: string, targetName: string, specifier?: Expression) {
function serializeImplementedType(t: Type) {
function serializeIndexSignatures(input: Type, baseType: Type | undefined) {
function serializeInterface(symbol: Symbol, symbolName: string, modifierFlags: ModifierFlags) {
function serializeMaybeAliasAssignment(symbol: Symbol): boolean {
function serializeModule(symbol: Symbol, symbolName: string, modifierFlags: ModifierFlags) {
function serializePropertySymbolForInterface(p: Symbol, baseType: Type | undefined) {
function serializeReturnTypeForSignature(context: NodeBuilderContext, type: Type, signature: Signature, includePrivateSymbol?: (s: Symbol) => void, bundled?: boolean) {
function serializeSignatures(kind: SignatureKind, input: Type, baseType: Type | undefined, outputKind: SignatureDeclaration["kind"]) {
function serializeSymbol(symbol: Symbol, isPrivate: boolean, propertyAsAlias: boolean) {
function serializeSymbolWorker(symbol: Symbol, isPrivate: boolean, propertyAsAlias: boolean) {
function serializeTypeAlias(symbol: Symbol, symbolName: string, modifierFlags: ModifierFlags) {
function serializeTypeForDeclaration(context: NodeBuilderContext, type: Type, symbol: Symbol, enclosingDeclaration: Node | undefined, includePrivateSymbol?: (s: Symbol) => void, bundled?: boolean) {

// set
function setCachedIterationTypes(type: Type, cacheKey: MatchingKeys<IterableOrIteratorType, IterationTypes | undefined>, cachedTypes: IterationTypes) {
function setLastResult(state: WorkArea, type: Type | undefined) {
function setLeftType(state: WorkArea, type: Type | undefined) {
function setNodeLinksForPrivateIdentifierScope(node: PropertyDeclaration | PropertySignature | MethodDeclaration | MethodSignature | AccessorDeclaration) {
function setStructuredTypeMembers(type: StructuredType, members: SymbolTable, callSignatures: readonly Signature[], constructSignatures: readonly Signature[], indexInfos: readonly IndexInfo[]): ResolvedType {

// should
function shouldCheckAsExcessProperty(prop: Symbol, container: Symbol) {
function shouldReportBadModifier(node: Node): boolean {
function shouldTreatPropertiesOfExternalModuleAsExports(resolvedExternalModuleType: Type) {
function shouldUsePlaceholderForProperty(propertySymbol: Symbol, context: NodeBuilderContext) {
function shouldWriteTypeOfFunctionSymbol() {

// signature
function signatureHasLiteralTypes(s: Signature) {
function signatureHasRestParameter(s: Signature) {
function signatureRelatedTo(source: Signature, target: Signature, erase: boolean, reportErrors: boolean, incompatibleReporter: (source: Type, target: Type) => void): Ternary {
function signatureToSignatureDeclarationHelper(signature: Signature, kind: SignatureDeclaration["kind"], context: NodeBuilderContext, options?: SignatureToSignatureDeclarationOptions): SignatureDeclaration {
function signatureToString(signature: Signature, enclosingDeclaration?: Node, flags = TypeFormatFlags.None, kind?: SignatureKind, writer?: EmitTextWriter): string {
function signatureToStringWorker(writer: EmitTextWriter) {

// signatures
function signaturesIdenticalTo(source: Type, target: Type, kind: SignatureKind): Ternary {
function signaturesRelatedTo(source: Type, target: Type, kind: SignatureKind, reportErrors: boolean): Ternary {

function skippedGenericFunction(node: Node, checkMode: CheckMode) {

function sliceTupleType(type: TupleTypeReference, index: number, endSkipCount = 0) {

// some
function someType(type: Type, f: (t: Type) => boolean): boolean {
function someTypeRelatedToType(source: UnionOrIntersectionType, target: Type, reportErrors: boolean, intersectionState: IntersectionState): Ternary {

function sortByBestName(a: number, b: number) {

// structued
function structuredTypeRelatedTo(source: Type, target: Type, reportErrors: boolean, intersectionState: IntersectionState): Ternary {
function structuredTypeRelatedToWorker(source: Type, target: Type, reportErrors: boolean, intersectionState: IntersectionState): Ternary {

function substituteIndexedMappedType(objectType: MappedType, index: Type) {

// symbol
function symbolHasNonMethodDeclaration(symbol: Symbol) {
function symbolIsValue(symbol: Symbol): boolean {
function symbolTableToDeclarationStatements(symbolTable: SymbolTable, context: NodeBuilderContext, bundled?: boolean): Statement[] {
function symbolToExpression(symbol: Symbol, context: NodeBuilderContext, meaning: SymbolFlags) {
function symbolToName(symbol: Symbol, context: NodeBuilderContext, meaning: SymbolFlags, expectsIdentifier: boolean): EntityName {
function symbolToName(symbol: Symbol, context: NodeBuilderContext, meaning: SymbolFlags, expectsIdentifier: false): EntityName;
function symbolToName(symbol: Symbol, context: NodeBuilderContext, meaning: SymbolFlags, expectsIdentifier: true): Identifier;
function symbolToParameterDeclaration(parameterSymbol: Symbol, context: NodeBuilderContext, preserveModifierFlags?: boolean, privateSymbolVisitor?: (s: Symbol) => void, bundledImports?: boolean): ParameterDeclaration {
function symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags: SymbolFormatFlags = SymbolFormatFlags.AllowAnyNodeKind, writer?: EmitTextWriter): string {
function symbolToStringWorker(writer: EmitTextWriter) {
function symbolToTypeNode(symbol: Symbol, context: NodeBuilderContext, meaning: SymbolFlags, overrideTypeArguments?: readonly TypeNode[]): TypeNode {
function symbolValueDeclarationIsContextSensitive(symbol: Symbol): boolean {
function symbolsToArray(symbols: SymbolTable): Symbol[] {

function throwIfNonDiagnosticsProducing() {

function toNodeBuilderFlags(flags = TypeFormatFlags.None): NodeBuilderFlags {

// trace
function traceUnionsOrIntersectionsTooLarge(source: Type, target: Type): void {
function trackComputedName(accessExpression: EntityNameOrEntityNameExpression, enclosingDeclaration: Node | undefined, context: NodeBuilderContext) {
function trackExistingEntityName<T extends EntityNameOrEntityNameExpression>(node: T, context: NodeBuilderContext, includePrivateSymbol?: (s: Symbol) => void) {
function transformTypeOfMembers(type: Type, f: (propertyType: Type) => Type) {
function traverse(node: Node): boolean {

// try
function tryElaborateArrayLikeErrors(source: Type, target: Type, reportErrors: boolean): boolean {
function tryElaborateErrorsForPrimitivesAndObjects(source: Type, target: Type) {
function tryFindAmbientModule(moduleName: string, withAugmentations: boolean) {
function tryFindWhenConstTypeReference(node: Expression) {
function tryGetAliasTarget(symbol: Symbol): Symbol | undefined {
function tryGetDeclaredTypeOfSymbol(symbol: Symbol): Type | undefined {
function tryGetMemberInModuleExports(memberName: __String, moduleSymbol: Symbol): Symbol | undefined {
function tryGetMemberInModuleExportsAndProperties(memberName: __String, moduleSymbol: Symbol): Symbol | undefined {
function tryGetPrivateIdentifierPropertyOfType(type: Type, id: PrivateIdentifier) {
function tryGetRestTypeOfSignature(signature: Signature): Type | undefined {
function tryGetRootParameterDeclaration(node: Node): ParameterDeclaration | undefined {
function tryGetThisTypeAt(node: Node, includeGlobalThis = true, container = getThisContainer(node, /*includeArrowFunctions*/ false)): Type | undefined {
function tryGetTypeAtPosition(signature: Signature, pos: number): Type | undefined {
function tryGetTypeFromEffectiveTypeNode(declaration: Declaration) {
function tryGiveBetterPrimaryError(errNode: Node, maybeMissingAwait: boolean, leftStr: string, rightStr: string) {
function tryMergeUnionOfObjectTypeAndEmptyObject(type: Type, readonly: boolean): Type {
function tryResolveAlias(symbol: Symbol): Symbol | undefined {
function trySerializeAsTypeReference(t: Type, flags: SymbolFlags) {
function trySymbolTable(symbols: SymbolTable, ignoreQualification: boolean | undefined, isLocalNameLookup: boolean | undefined): Symbol[] | undefined {

function tupleTypesDefinitelyUnrelated(source: TupleTypeReference, target: TupleTypeReference) {

// type
function typeArgumentsFromTypeReferenceNode(node: NodeWithTypeArguments): Type[] | undefined {
function typeArgumentsRelatedTo(sources: readonly Type[] = emptyArray, targets: readonly Type[] = emptyArray, variances: readonly VarianceFlags[] = emptyArray, reportErrors: boolean, intersectionState: IntersectionState): Ternary {
function typeCouldHaveTopLevelSingletonTypes(type: Type): boolean {
function typeHasCallOrConstructSignatures(type: Type): boolean {
function typeHasProtectedAccessibleBase(target: Symbol, type: InterfaceType): boolean {
function typeHasStaticProperty(propName: __String, containingType: Type): boolean {
function typeMaybeAssignableTo(source: Type, target: Type) {
function typeParameterShadowsNameInScope(escapedName: __String, context: NodeBuilderContext, type: TypeParameter) {
function typeParameterToDeclaration(type: TypeParameter, context: NodeBuilderContext, constraint = getConstraintOfTypeParameter(type)): TypeParameterDeclaration {
function typeParameterToDeclarationWithConstraint(type: TypeParameter, context: NodeBuilderContext, constraintNode: TypeNode | undefined): TypeParameterDeclaration {
function typeParameterToName(type: TypeParameter, context: NodeBuilderContext) {
function typeParametersToTypeParameterDeclarations(symbol: Symbol, context: NodeBuilderContext) {
function typePredicateKindsMatch(a: TypePredicate, b: TypePredicate): boolean {
function typePredicateToString(typePredicate: TypePredicate, enclosingDeclaration?: Node, flags: TypeFormatFlags = TypeFormatFlags.UseAliasDefinedOutsideCurrentScope, writer?: EmitTextWriter): string {
function typePredicateToStringWorker(writer: EmitTextWriter) {
function typeReferenceToTypeNode(type: TypeReference) {
function typeRelatedToDiscriminatedType(source: Type, target: UnionType) {
function typeRelatedToEachType(source: Type, target: IntersectionType, reportErrors: boolean, intersectionState: IntersectionState): Ternary {
function typeRelatedToIndexInfo(source: Type, targetInfo: IndexInfo, reportErrors: boolean, intersectionState: IntersectionState): Ternary {
function typeRelatedToSomeType(source: Type, target: UnionOrIntersectionType, reportErrors: boolean): Ternary {
function typeToString(type: Type, enclosingDeclaration?: Node, flags: TypeFormatFlags = TypeFormatFlags.AllowUniqueESSymbolType | TypeFormatFlags.UseAliasDefinedOutsideCurrentScope, writer: EmitTextWriter = createTextWriter("")): string {
function typeToTypeNodeHelper(type: Type, context: NodeBuilderContext): TypeNode {
function typeToTypeNodeOrCircularityElision(type: Type) {

// types
function typesAreSameReference(a: Type, b: Type): boolean {
function typesDefinitelyUnrelated(source: Type, target: Type) {
function typesPackageExists(packageName: string): boolean {

function unionObjectAndArrayLiteralCandidates(candidates: Type[]): Type[] {

function unusedIsError(kind: UnusedKind, isAmbient: boolean): boolean {

// unwrap
function unwrapNondistributiveConditionalTuple(root: ConditionalRoot, type: Type) {
function unwrapReturnType(returnType: Type, functionFlags: FunctionFlags) {

function usageInTypeDeclaration() {

function useOuterVariableScopeInParameter(result: Symbol, location: Node, lastLocation: Node) {

function visibilityToString(flags: ModifierFlags): string | undefined {

// visit
function visit(node: Node) {
function visit(symbol: Symbol | undefined): SymbolTable | undefined {
function visitAndTransformType<T extends TypeNode>(type: Type, transform: (type: Type) => T) {
function visitExistingNodeTreeSymbols<T extends Node>(node: T): Node {
function visitSymbolTable(symbolTable: SymbolTable, suppressNewPrivateContext?: boolean, propertyAsAlias?: boolean) {

// widen
function widenTypeForVariableLikeDeclaration(type: Type | undefined, declaration: any, reportErrors?: boolean) {
function widenTypeInferredFromInitializer(declaration: HasExpressionInitializer, type: Type) {

function withContext<T>(enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined, tracker: SymbolTracker | undefined, cb: (context: NodeBuilderContext) => T): T | undefined {
function wrapReportedDiagnostic<T extends (...args: any[]) => any>(method: T | undefined): T | undefined {
function wrapSymbolTrackerToReportForContext(context: NodeBuilderContext, tracker: SymbolTracker): SymbolTracker {

Three-words prefix

prefix	count	desc
getTypeOf	34
getTypeFrom	31
getContextualType	21
narrowTypeBy	16
getIterationTypes	14
getTargetOf	12
checkGrammarFor	10
getTypeAt	9
checkAndReport	8
getFlowType	7
getDeclaredType	7
getTypeReference	7
getAssignedType	6
checkNonNull	6
getReturnType	6
getWidenedType	5
getConstraintOf	5
getIndexInfos	5
getThisType	5
getIndexType	5
getPropertiesOf	5
getPropertyName	5
getSuggestedSymbol	5
resolveExternalModule	5
getRestType	5
getTypeFor	5
getWidenedLiteral	4
getSymbolOf	4
getUnionOr	4
getGlobalPromise	4
isTypeParameter	4
getTypeWith	4
getBaseType	4
getJsxElement	4
getApparentType	4
getExportsOf	4
checkObjectLiteral	4
typeRelatedTo	4
checkGrammarJsx	4
getSuggestionFor	4
getGlobalAsync	4
getPropertyOf	4
checkGrammarType	3
getGlobalType	3
getEntityName	3
typeParameterTo	3
getRegularType	3
isEmptyArray	3
isSymbolAccessible	3
checkIndexedAccess	3
getTypeArguments	3
getJsxProps	3
getExternalModule	3
getJsxNamespace	3
getLiteralType	3
getGlobalIterator	3
isGenericType	3
getMappedType	3
isValidProperty	3
isConstEnum	3
grammarErrorOn	3
getApplicableIndex	3
isContextSensitive	3
checkArrayLiteral	3
checkCollisionWith	3
getElementType	3
getSignaturesOf	3
getTypeParameters	3
addDeprecatedSuggestion	3
getInitialType	3
getTypePredicate	3
checkPropertyAccess	3
getConstraintFrom	3
getAnnotatedAccessor	3
getTupleElement	3
getAwaitedType	3
getBaseConstraint	3
signatureToString	2
checkAndAggregate	2
getDeclarationOf	2
getOuterType	2
structuredTypeRelated	2
checkGrammarDecorators	2
checkDeleteExpression	2
getIndexInfo	2
symbolToString	2
hasContextSensitive	2
getIndexSymbol	2
getIndexedAccess	2
addDuplicateDeclaration	2
tryGetMember	2
getInferredType	2
checkGrammarImport	2
tryGetType	2
lookupSymbolChain	2
checkGrammarIndex	2
hasNonCircular	2
checkElementAccess	2
createAnonymousType	2
getIntrinsicAttributes	2
hasTypeParameter	2
checkIndexConstraint	2
getReferencedValue	2
importClauseContains	2
typePredicateTo	2
getBaseTypes	2
typeToType	2
getResolvedSignature	2
checkForIn	2
getResolvedType	2
markSymbolOf	2
getIterationType	2
createCombinedSymbol	2
canConvertImport	2
checkBinaryLike	2
getSignatureInstantiation	2
checkGrammarConstructor	2
combineSignaturesOf	2
isNonGeneric	2
getSimplifiedType	2
findBestType	2
getSingleCall	2
checkFunctionExpression	2
checkTypeAssignable	2
createTypeOf	2
checkFunctionOr	2
createTypePredicate	2
addMemberFor	2
getSpreadArgument	2
addTypeTo	2
checkJsxElement	2
isOptionalUninitialized	2
getConditionalType	2
recordPotentialCollision	2
addTypesTo	2
getStringMapping	2
checkClassExpression	2
instantiateMappedType	2
isPatternLiteral	2
getMatchingUnion	2
getSuggestedLib	2
createInferenceContext	2
instantiateTypeWith	2
getSwitchClause	2
getConstraintDeclaration	2
isPropertyInitialized	2
getFalsyFlags	2
checkTypeParameter	2
isReachableFlow	2
checkTypeParameters	2
getFirstNon	2
getNameOf	2
checkExpressionFor	2
checkClassFor	2
discriminateContextualType	2
reportOperatorError	2
getThisArgument	2
checkTypeRelated	2
createJsxAttributes	2
requiresScopeChange	2
checkJsxSelf	2
resolveBaseTypes	2
getAccessibleSymbol	2
getTypeAlias	2
getTypeArgument	2
resolveEntityName	2
checkGrammarTop	2
getContextualSignature	2
getGlobalIterable	2
getNonNullable	2
eachTypeRelated	2
isSymbolOf	2
resolveTypeReference	2
isSymbolUsed	2
isSymbolWith	2
isTemplateLiteral	2
isDeclarationWith	2
isThislessType	2
isTopLevel	2
isTupleType	2
checkSourceElement	2
isTypeAssignable	2
checkSourceFile	2
isTypeDeclaration	2
checkGrammarVariable	2
isEmptyObject	2
getCrossProduct	2
checkGrammarClass	2
getUnionType	2
isTypeReference	2
isEvolvingArray	2
getUniqueType	2
isTypeSubset	2
checkTagName	1
checkTaggedTemplate	1
checkTemplateExpression	1
checkTemplateLiteral	1
checkTestingKnown	1
checkThisBefore	1
checkThisExpression	1
checkThisIn	1
checkThisType	1
checkThrowStatement	1
checkTruncationLength	1
checkTruthinessExpression	1
checkTruthinessOf	1
checkTryStatement	1
checkTupleType	1
checkTypeAlias	1
checkTypeArgument	1
checkTypeArguments	1
checkTypeComparable	1
checkTypeFor	1
checkTypeLiteral	1
checkTypeName	1
checkTypeOf	1
checkTypeOperator	1
checkTypePredicate	1
checkTypeQuery	1
checkTypeReference	1
checkUnionOr	1
checkUnusedClass	1
checkUnusedIdentifiers	1
checkUnusedInfer	1
checkUnusedLocals	1
checkUnusedType	1
checkVarDeclared	1
checkVariableDeclaration	1
checkVariableLike	1
checkVariableStatement	1
checkVoidExpression	1
checkWeakMap	1
checkWhileStatement	1
checkWithStatement	1
checkYieldExpression	1
classDeclarationExtends	1
clearCachedInferences	1
cloneBindingName	1
cloneInferenceContext	1
cloneInferenceInfo	1
cloneInferredPart	1
cloneNodeBuilder	1
cloneTypeParameter	1
cloneTypeReference	1
collectLinkedAliases	1
combineIntersectionParameters	1
combineIntersectionThis	1
combineIterationTypes	1
combineSymbolTables	1
combineTypeMappers	1
combineUnionParameters	1
combineUnionThis	1
combineValueAnd	1
compareSignaturesIdentical	1
compareSignaturesRelated	1
compareTypeParameters	1
compareTypePredicate	1
compareTypePredicates	1
compareTypesAssignable	1
compareTypesIdentical	1
compareTypesSubtype	1
computeBaseConstraint	1
computeConstantValue	1
computeEnumMember	1
computeExhaustiveSwitch	1
computeMemberValue	1
conditionalTypeTo	1
constructorVisibilitiesAre	1
containerSeemsTo	1
containsArgumentsReference	1
containsGenericType	1
containsMatchingReference	1
containsMissingType	1
containsSameNamed	1
containsTruthyCheck	1
contextuallyCheckFunction	1
convertAutoTo	1
copyLocallyVisible	1
couldContainType	1
countMessageChain	1
createAccessFrom	1
createArrayLiteral	1
createArrayType	1
createBackreferenceMapper	1
createCanonicalSignature	1
createCheckBinary	1
createDeferredType	1
createElidedInformation	1
createEmptyObject	1
createEntityName	1
createErasedSignature	1
createEvolvingArray	1
createExpressionFrom	1
createFinalArray	1
createFlowType	1
createGeneratorReturn	1
createIndexInfo	1
createIndexType	1
createIndexedAccess	1
createInferenceInfo	1
createInstantiatedSymbol	1
createIntersectionType	1
createIntrinsicType	1
createIterableType	1
createIterationTypes	1
createLiteralConst	1
createLiteralType	1
createMappedType	1
createNodeBuilder	1
createNormalizedTuple	1
createNormalizedType	1
createObjectLiteral	1
createObjectType	1
createOptionalCall	1
createOriginIndex	1
createOriginType	1
createOriginUnion	1
createPromiseLike	1
createPromiseReturn	1
createPromiseType	1
createPropertyName	1
createReturnType	1
createReverseMapped	1
createSignatureFor	1
createSignatureInstantiation	1
createSignatureType	1
createStringMapping	1
createSymbolWith	1
createSyntheticExpression	1
createTemplateLiteral	1
createTupleTarget	1
createTupleType	1
createTypeChecker	1
createTypeEraser	1
createTypeFrom	1
createTypeMapper	1
createTypeNode	1
createTypeNodes	1
createTypeParameter	1
createTypeReference	1
createTypedProperty	1
createTypeofType	1
createUnionOf	1
createUnionOr	1
createUnionSignature	1
createWideningContext	1
declarationBelongsTo	1
deepCloneOr	1
determineIfDeclaration	1
discriminateTypeBy	1
distributeIndexOver	1
distributeObjectOver	1
doesAccessorHave	1
eachTypeContained	1
eachUnionContains	1
elaborateArrayLiteral	1
elaborateArrowFunction	1
elaborateDidYou	1
elaborateJsxComponents	1
elaborateNeverIntersection	1
elaborateObjectLiteral	1
elideInitializerAnd	1
errorAndMaybe	1
errorIfWriting	1
errorNextVariable	1
errorOnImplicit	1
errorOrSuggestion	1
errorSkippedOn	1
errorUnusedLocal	1
evaluateEnumMember	1
everyContainedType	1
existingTypeNode	1
expandSignatureParameters	1
extendExportSymbols	1
extractDefinitelyFalsy	1
extractRedundantTemplate	1
extractTypesOf	1
extractUnitType	1
fileSymbolIf	1
fillMissingType	1
filterPrimitivesIf	1
finalizeEvolvingArray	1
findApplicableIndex	1
findConstructorDeclaration	1
findDiscriminantProperties	1
findFirstSuper	1
findIndexInfo	1
findMatchingDiscriminant	1
findMatchingSignature	1
findMatchingSignatures	1
findMatchingType	1
findMostOverlappy	1
findResolutionCycle	1
flattenExportAssigned	1
forEachEnclosing	1
forEachProperty	1
forEachSymbol	1
forEachType	1
formatUnionTypes	1
functionHasImplicit	1
generateInitialError	1
getAccessStack	1
getAccessedProperty	1
getAccessorThis	1
getActualType	1
getAliasFor	1
getAliasId	1
getAliasSymbol	1
getAliasVariances	1
getAllPossible	1
getAlternativeContaining	1
getAmbientModules	1
getAnnotatedType	1
getAnonymousPartial	1
getAnyImport	1
getArgumentArity	1
getArrayElement	1
getArrayOr	1
getAssignedClass	1
getAssignmentDeclaration	1
getAssignmentReduced	1
getAsyncFrom	1
getAugmentedProperties	1
getBaseConstructor	1
getBaseSignature	1
getBestMatch	1
getBestMatching	1
getBigInt	1
getCachedIteration	1
getCandidateFor	1
getCandidateList	1
getCandidateName	1
getCannotFind	1
getCanonicalOverload	1
getCanonicalSignature	1
getClassElement	1
getClassName	1
getClassOr	1
getCombinedMapped	1
getCommonJs	1
getCommonSubtype	1
getCommonSupertype	1
getConditionalFlow	1
getConstantValue	1
getConstituentCount	1
getConstituentType	1
getConstraintType	1
getConstructorDefined	1
getConstructorsFor	1
getContainersOf	1
getContainingObject	1
getContextFree	1
getContextNode	1
getContextualCall	1
getContextualIteration	1
getContextualJsx	1
getContextualReturn	1
getContextualThis	1
getContextuallyTyped	1
getContravariantInference	1
getControlFlow	1
getCovariantInference	1
getDeclarationContainer	1
getDeclarationNode	1
getDeclarationSpaces	1
getDeclarationWith	1
getDeclaringClass	1
getDeclaringConstructor	1
getDecoratorArgument	1
getDefaultConstraint	1
getDefaultConstruct	1
getDefaultFrom	1
getDefaultType	1
getDefinitelyFalsy	1
getDeprecatedSuggestion	1
getDestructuringProperty	1
getDiagnosticFor	1
getDiagnosticHead	1
getDiagnosticSpan	1
getDiagnosticsWorker	1
getDiscriminantProperty	1
getEffectiveCall	1
getEffectiveConstraint	1
getEffectiveDeclaration	1
getEffectiveDecorator	1
getEffectiveDot	1
getEffectiveFirst	1
getEffectiveRest	1
getEffectiveType	1
getEffectsSignature	1
getElaborationElement	1
getEmitResolver	1
getEnclosingIteration	1
getEndElement	1
getEnumKind	1
getEnumLiteral	1
getEnumMember	1
getErasedSignature	1
getEvolvingArray	1
getExcludedSymbol	1
getExpandedParameters	1
getExpandoSymbol	1
getExplicitThis	1
getExplicitType	1
getExportOf	1
getExportSpecifier	1
getExportSymbol	1
getExportsAnd	1
getExtractString	1
getFactsFrom	1
getFalseType	1
getFileSymbol	1
getFinalArray	1
getFlowCache	1
getFlowNode	1
getForIn	1
getFreshType	1
getFullyQualified	1
getGlobalBig	1
getGlobalDiagnostics	1
getGlobalExtract	1
getGlobalGenerator	1
getGlobalImport	1
getGlobalNon	1
getGlobalOmit	1
getGlobalSymbol	1
getGlobalTemplate	1
getGlobalTyped	1
getGlobalValue	1
getHelperName	1
getHomomorphicType	1
getIdentifierChain	1
getIdentifierFrom	1
getImmediateAliased	1
getImmediateBase	1
getImmediateRoot	1
getImplementsTypes	1
getImpliedConstraint	1
getImpliedType	1
getIndexNode	1
getInferType	1
getInferenceContext	1
getInferenceInfo	1
getInferredTrue	1
getInferredTypes	1
getInitialOr	1
getInitializerType	1
getInstantiatedConstructors	1
getIntendedType	1
getInternalSymbol	1
getIntersectedSignatures	1
getIntersectionType	1
getIntrinsicTag	1
getInvalidTextual	1
getIsDeclaration	1
getIsDeferred	1
getIsLate	1
getIteratedType	1
getIterationDiagnostic	1
getJsxFactory	1
getJsxFragment	1
getJsxIntrinsic	1
getJsxLibrary	1
getJsxManaged	1
getJsxReference	1
getJsxStateless	1
getJsxType	1
getKeyProperty	1
getKnownKeys	1
getLastResult	1
getLateBound	1
getLeftSide	1
getLeftType	1
getLiteralProperty	1
getLocalType	1
getLongestCandidate	1
getLowerBound	1
getMapperFrom	1
getMarkerType	1
getMembersOf	1
getMergedSymbol	1
getMinArgument	1
getMinType	1
getModifiedReadonly	1
getModifiersType	1
getMutableArray	1
getNameCandidate	1
getNameFor	1
getNameFrom	1
getNameType	1
getNameableDeclaration	1
getNamedMembers	1
getNamedOr	1
getNamesOf	1
getNamespaceMembers	1
getNarrowableType	1
getNarrowedType	1
getNodeCheck	1
getNodeId	1
getNodeLinks	1
getNonArray	1
getNonInterhited	1
getNonMissing	1
getNonSimple	1
getNonUndefined	1
getNormalizedType	1
getNullableType	1
getNumNon	1
getNumberLiteral	1
getObjectLiteral	1
getObjectType	1
getOptionalCall	1
getOptionalExpression	1
getOptionalType	1
getOrCreate	1
getOrSet	1
getParameterCount	1
getParameterIdentifier	1
getParameterName	1
getParameterType	1
getParentElement	1
getParentOf	1
getParentSymbol	1
getParentType	1
getPartOf	1
getPermissiveInstantiation	1
getPotentiallyUnused	1
getPrivateIdentifier	1
getPromisedType	1
getPropagatingFlags	1
getPropertyAccess	1
getPropertySymbol	1
getPropertyType	1
getQualifiedLeft	1
getQuickType	1
getRecursionIdentity	1
getReducedApparent	1
getReducedType	1
getReducedUnion	1
getReferenceCandidate	1
getReferenceRoot	1
getReferencedDeclaration	1
getReferencedExport	1
getReferencedImport	1
getRelationKey	1
getResolvedApparent	1
getResolvedBase	1
getResolvedMembers	1
getResolvedSymbol	1
getRestArray	1
getRestrictiveInstantiation	1
getRestrictiveType	1
getRootSymbols	1
getSetAccessor	1
getShorthandAssignment	1
getSiblingsOf	1
getSignatureApplicability	1
getSignatureFrom	1
getSignatureOf	1
getSignatureText	1
getSimplifiedConditional	1
getSimplifiedIndexed	1
getSingleBase	1
getSingleSignature	1
getSingleType	1
getSourceText	1
getSpecialProperty	1
getSpecifierFor	1
getSpellingSuggestion	1
getSpreadSymbol	1
getSpreadType	1
getStartElement	1
getStaticType	1
getStringLike	1
getStringLiteral	1
getSubstitutionType	1
getSuggestedBoolean	1
getSuperClass	1
getSupertypeOr	1
getSymbolAt	1
getSymbolChain	1
getSymbolFor	1
getSymbolId	1
getSymbolIf	1
getSymbolLinks	1
getSymbolsIn	1
getSymbolsOf	1
getSyntheticElement	1
getTargetSymbol	1
getTargetType	1
getTemplateLiteral	1
getTemplateString	1
getTemplateType	1
getThisParameter	1
getTopmostIndexed	1
getTrueType	1
getTupleBase	1
getTupleTarget	1
getTypeDeclaration	1
getTypeFacts	1
getTypeId	1
getTypeList	1
getTypeName	1
getTypeNames	1
getTypeOnly	1
getTypeParameter	1
getTypeWithout	1
getUnaryResult	1
getUndefinedProperty	1
getUndefinedStripped	1
getUninstantiatedJsx	1
getUnionIndex	1
getUnionSignatures	1
getUnmatchedProperty	1
getUnusedName	1
getVariableDeclaration	1
getVariancesWorker	1
getWidenedProperty	1
getWidenedUnique	1
getYieldedType	1
grammarErrorAfter	1
grammarErrorAt	1
hasBaseType	1
hasBindableName	1
hasCommonProperties	1
hasCorrectArity	1
hasCorrectType	1
hasCovariantVoid	1
hasDefaultValue	1
hasDistributiveName	1
hasEffectiveRest	1
hasExcessProperties	1
hasExportAssignment	1
hasExportedMembers	1
hasExternalModule	1
hasGlobalName	1
hasInferenceCandidates	1
hasLateBindable	1
hasMatchingArgument	1
hasNonBinding	1
hasNonGlobal	1
hasNumericProperty	1
hasOverlappingInferences	1
hasParentWith	1
hasParseDiagnostics	1
hasPrimitiveConstraint	1
hasSkipDirect	1
hasTypePredicate	1
hasVisibleDeclarations	1
importClauseFrom	1
inSameLexical	1
includeMixinType	1
includePrivateSymbol	1
includeUndefinedIn	1
indexInfoRelated	1
indexInfoTo	1
indexSignaturesIdentical	1
indexSignaturesRelated	1
indexTypeLess	1
inferFromAnnotated	1
inferFromContravariant	1
inferFromIndex	1
inferFromLiteral	1
inferFromMatching	1
inferFromObject	1
inferFromProperties	1
inferFromSignature	1
inferFromSignatures	1
inferFromType	1
inferFromTypes	1
inferJsxType	1
inferReverseMapped	1
inferSignatureInstantiation	1
inferToConditional	1
inferToMapped	1
inferToMultiple	1
inferToTemplate	1
inferTypeArguments	1
inferTypeFor	1
inferTypesFrom	1
inferWithPriority	1
initializeTypeChecker	1
inlineExportModifiers	1
instantiateAnonymousType	1
instantiateConditionalType	1
instantiateContextualType	1
instantiateIndexInfo	1
instantiateIndexInfos	1
instantiateInstantiableTypes	1
instantiateMappedArray	1
instantiateMappedGeneric	1
instantiateMappedTuple	1
instantiateReverseMapped	1
instantiateSignatureIn	1
instantiateTypeAs	1
instantiateTypeIf	1
instantiateTypePredicate	1
instantiateTypeWorker	1
intersectUnionsOf	1
invocationErrorDetails	1
invocationErrorRecovery	1
isAliasResolved	1
isAliasSymbol	1
isAliasableOr	1
isAnySignature	1
isAnySymbol	1
isApplicableIndex	1
isArgumentsLocal	1
isAritySmaller	1
isArrayLike	1
isArrayOr	1
isArrayType	1
isAssignedIn	1
isAssignmentDeclaration	1
isAssignmentTo	1
isAutoTyped	1
isBigInt	1
isBindingCaptured	1
isBlockScoped	1
isCircularMapped	1
isClassDerived	1
isClassInstance	1
isCoercibleUnder	1
isCommonJs	1
isConditionalType	1
isConflictingPrivate	1
isConstContext	1
isConstVariable	1
isConstantMember	1
isConstantReference	1
isConstraintPosition	1
isConstructedBy	1
isConstructorAccessible	1
isConstructorDeclared	1
isConstructorType	1
isDeclarationIn	1
isDeclarationName	1
isDeclarationVisible	1
isDeeplyNested	1
isDefaultBinding	1
isDeferredType	1
isDestructuringAssignment	1
isDiscriminantProperty	1
isDiscriminantWith	1
isDuplicatedCommon	1
isEmptyAnonymous	1
isEmptyLiteral	1
isEmptyResolved	1
isEntityName	1
isEnumType	1
isEvalNode	1
isExcessProperty	1
isExhaustiveSwitch	1
isExpandoFunction	1
isExportOr	1
isExportingScope	1
isFalseExpression	1
isForIn	1
isFreshLiteral	1
isFromInference	1
isFunctionExpression	1
isFunctionObject	1
isFunctionType	1
isGenericFunction	1
isGenericIndex	1
isGenericMapped	1
isGenericObject	1
isGenericTuple	1
isGlobalSource	1
isGlobalSymbol	1
isHeritageClause	1
isHyphenatedJsx	1
isIdenticalTo	1
isIdentifierAnd	1
isIdentifierThat	1
isIgnoredJsx	1
isImmediatelyUsed	1
isImplementationCompatible	1
isImplementationOf	1
isImportRequired	1
isImportType	1
isImportedDeclaration	1
isInConstructor	1
isInHeritage	1
isInParameter	1
isInProperty	1
isInRight	1
isInType	1
isInfinityOr	1
isInsideFunction	1
isInstanceProperty	1
isInstantiatedModule	1
isIntersectionEmpty	1
isIteratorResult	1
isJsxIntrinsic	1
isKnownProperty	1
isLateBindable	1
isLateBound	1
isLegalUsage	1
isLiteralConst	1
isLiteralEnum	1
isLiteralOf	1
isLiteralType	1
isLocalType	1
isMappedType	1
isMatchingConstructor	1
isMatchingReference	1
isMatchingSignature	1
isMethodAccess	1
isMixinConstructor	1
isMutableArray	1
isNameOf	1
isNamedUnion	1
isNamespaceMember	1
isNeitherUnit	1
isNeverReduced	1
isNodeUsed	1
isNodeWithin	1
isNonBindable	1
isNonDeferred	1
isNonLocal	1
isNotAccessor	1
isNotOverload	1
isNullOr	1
isNullableType	1
isNumericComputed	1
isNumericLiteral	1
isNumericName	1
isObjectLiteral	1
isObjectOr	1
isObjectType	1
isOptionalParameter	1
isOptionalProperty	1
isOrContains	1
isOrHas	1
isParameterAssigned	1
isParameterDeclaration	1
isPartialMapped	1
isPartiallyInferable	1
isPossiblyAliased	1
isPossiblyDiscriminant	1
isPostSuper	1
isPotentiallyUncalled	1
isPrimitiveType	1
isPrivateWithin	1
isPromiseResolve	1
isPropertyDeclared	1
isPropertyIdentical	1
isPropertyImmediately	1
isPropertyIn	1
isPropertyOr	1
isPropertySymbol	1
isPropertyWithout	1
isPrototypeProperty	1
isReadonlyArray	1
isReadonlyAssignment	1
isReadonlySymbol	1
isReadonlyType	1
isReferenceTo	1
isReferencedAlias	1
isRelatedTo	1
isRequiredInitialized	1
isReservedMember	1
isResolvedBy	1
isResolvingReturn	1
isReturnIterator	1
isSameScope	1
isSelfReference	1
isSelfType	1
isSideEffect	1
isSignatureAssignable	1
isSimpleLiteral	1
isSimpleType	1
isSingleElement	1
isSingleQuoted	1
isSingletonTuple	1
isSpreadArgument	1
isSpreadableProperty	1
isStaticPrivate	1
isStringConcat	1
isStringIndex	1
isStringNamed	1
isStringOr	1
isSymbolFrom	1
isSymbolOr	1
isSyntacticDefault	1
isThenableType	1
isThisProperty	1
isThisType	1
isThislessFunction	1
isThislessInterface	1
isThislessVariable	1
isTupleLike	1
isTypeAny	1
isTypeAssertion	1
isTypeClosely	1
isTypeComparable	1
isTypeDerived	1
isTypeEquality	1
isTypeIdentical	1
isTypeInvalid	1
isTypeOnly	1
isTypeOr	1
isTypePresence	1
isTypeRelated	1
isTypeRepresentable	1
isTypeSubtype	1
isTypeSymbol	1
isTypeUsable	1
isTypicalNondistributive	1
isUnaryTuple	1
isUncalledFunction	1
isUnconstrainedType	1
isUnitLike	1
isUnitType	1
isUntypedFunction	1
isUnwrappedReturn	1
isUsedIn	1
isValidBase	1
isValidBig	1
isValidConst	1
isValidDeclaration	1
isValidIndex	1
isValidOverride	1
isValidSpread	1
isValidType	1
isValidUnused	1
isValueAlias	1
isValueSymbol	1
isWeakType	1
isYieldIterator	1
isZeroBig	1
issueMemberSpecific	1
lateBindMember	1
literalTypeTo	1
literalTypesWith	1
lookupOrIssue	1
lookupSymbolFor	1
lookupTypeParameter	1
makeArrayType	1
makeCompositeType	1
makeFunctionType	1
makeSerializeProperty	1
makeUnaryType	1
mapToInferred	1
mapToType	1
mapTypeWith	1
mapTypesBy	1
mappedTypeRelated	1
markAliasReferenced	1
markAliasSymbol	1
markAsSynthetic	1
markConstEnum	1
markDecoratorMedata	1
markEntityName	1
markExportAs	1
markParameterAssignments	1
markPropertyAs	1
markTypeNode	1
mayResolveType	1
mayReturnNever	1
maybeAddJs	1
maybeAddMissing	1
maybeCheckExpression	1
maybeMappedType	1
maybeTypeOf	1
maybeTypeParameter	1
membersRelatedTo	1
mergeExportDeclarations	1
mergeModuleAugmentation	1
mergeRedundantStatements	1
mergeSymbolTable	1
mergeTypeMappers	1
moduleExportsSome	1
narrowByIn	1
narrowBySwitch	1
narrowUnionMember	1
needCollisionCheck	1
nodeHasAny	1
optionalChainContains	1
padTupleType	1
pickLongestCandidate	1
popTypeResolution	1
prependTypeMapping	1
preserveCommentsOn	1
propagateOptionalType	1
propertiesIdenticalTo	1
propertiesRelatedTo	1
propertyRelatedTo	1
pushTypeResolution	1
recordMergedSymbol	1
recursiveTypeRelated	1
registerForUnused	1
removeDefinitelyFalsy	1
removeExportModifier	1
removeMissingOr	1
removeMissingType	1
removeOptionalType	1
removeOptionalityFrom	1
removeRedundantLiteral	1
removeRedundantPrimitive	1
removeStringLiterals	1
replaceIndexedAccess	1
replacePrimitivesWith	1
reportCannotInvoke	1
reportCircularBase	1
reportCircularityError	1
reportErrorResults	1
reportErrorsFrom	1
reportFlowControl	1
reportImplementationExpected	1
reportImplicitAny	1
reportIncompatibleCall	1
reportIncompatibleConstruct	1
reportIncompatibleError	1
reportIncompatibleStack	1
reportInvalidImport	1
reportNonDefault	1
reportNonExported	1
reportNonexistentProperty	1
reportObjectPossibly	1
reportObviousModifier	1
reportRelationError	1
reportTypeNot	1
reportUnmatchedProperty	1
reportUnmeasurableMarkers	1
reportUnreliableMarkers	1
reportWideningErrors	1
resetErrorInfo	1
resolveAnonymousType	1
resolveCallExpression	1
resolveClassOr	1
resolveDeclaredMembers	1
resolveErrorCall	1
resolveExportBy	1
resolveHelpersModule	1
resolveImportSymbol	1
resolveIntersectionType	1
resolveJsxOpening	1
resolveMappedType	1
resolveNameHelper	1
resolveNewExpression	1
resolveObjectType	1
resolveReverseMapped	1
resolveStructuredType	1
resolveTaggedTemplate	1
resolveTypeOf	1
resolveUnionType	1
resolveUntypedCall	1
rewriteModuleSpecifier	1
serializeAsAlias	1
serializeAsClass	1
serializeAsFunction	1
serializeAsNamespace	1
serializeBaseType	1
serializeExistingType	1
serializeExportSpecifier	1
serializeImplementedType	1
serializeIndexSignatures	1
serializeMaybeAlias	1
serializePropertySymbol	1
serializeReturnType	1
serializeSymbolWorker	1
serializeTypeAlias	1
serializeTypeFor	1
setCachedIteration	1
setLastResult	1
setLeftType	1
setNodeLinks	1
setStructuredType	1
shouldCheckAs	1
shouldReportBad	1
shouldTreatProperties	1
shouldUsePlaceholder	1
shouldWriteType	1
signatureHasLiteral	1
signatureHasRest	1
signatureRelatedTo	1
signatureToSignature	1
signaturesIdenticalTo	1
signaturesRelatedTo	1
skippedGenericFunction	1
sliceTupleType	1
someTypeRelated	1
sortByBest	1
substituteIndexedMapped	1
symbolHasNon	1
symbolIsValue	1
symbolTableTo	1
symbolToExpression	1
symbolToName	1
symbolToParameter	1
symbolToType	1
symbolValueDeclaration	1
symbolsToArray	1
throwIfNon	1
toNodeBuilder	1
traceUnionsOr	1
trackComputedName	1
trackExistingEntity	1
transformTypeOf	1
tryElaborateArray	1
tryElaborateErrors	1
tryFindAmbient	1
tryFindWhen	1
tryGetAlias	1
tryGetDeclared	1
tryGetPrivate	1
tryGetRest	1
tryGetRoot	1
tryGetThis	1
tryGiveBetter	1
tryMergeUnion	1
tryResolveAlias	1
trySerializeAs	1
trySymbolTable	1
tupleTypesDefinitely	1
typeArgumentsFrom	1
typeArgumentsRelated	1
typeCouldHave	1
typeHasCall	1
typeHasProtected	1
typeHasStatic	1
typeMaybeAssignable	1
typeParameterShadows	1
typeParametersTo	1
typePredicateKinds	1
typeReferenceTo	1
typeToString	1
typesAreSame	1
typesDefinitelyUnrelated	1
typesPackageExists	1
unionObjectAnd	1
unusedIsError	1
unwrapNondistributiveConditional	1
unwrapReturnType	1
usageInType	1
useOuterVariable	1
visibilityToString	1
visitAndTransform	1
visitExistingNode	1
visitSymbolTable	1
widenTypeFor	1
widenTypeInferred	1
wrapReportedDiagnostic	1
generateJsxAttributes	1
wrapSymbolTracker	1
generateJsxChildren	1
generateLimitedTuple	1
generateObjectLiteral	1
acceptsVoidUndefined	1
addDeclarationDiagnostic	1
addDeclarationTo	1
addDuplicateLocations	1
addErrorOr	1
addEvolvingArray	1
addExportModifier	1
addImplementationSuccess	1
addInheritedMembers	1
addNamedUnions	1
addOptionalType	1
addPropertyTo	1
addReferencedFiles	1
addToGroup	1
addToSymbol	1
addVisibleAlias	1
allTypesAssignable	1
allowLetAnd	1
appendIndexInfo	1
appendReferenceTo	1
appendTypeMapping	1
appendTypeParameters	1
applyStringMapping	1
applyToParameter	1
applyToReturn	1
areDeclarationFlags	1
areTypeParameters	1
areTypesComparable	1
assignBindingElement	1
assignContextualParameter	1
assignNonContextual	1
assignParameterType	1
associateRelatedInfo	1
bindingNameText	1
bothAreBig	1
buildVisibleNode	1
callLikeExpression	1
canHaveConstant	1
canHaveExport	1
canHaveSynthetic	1
canQualifySymbol	1
captureErrorCalculation	1
captureLexicalThis	1
checkAccessorDeclaration	1
checkAliasSymbol	1
checkAllCode	1
checkAmbientInitializer	1
checkApplicableSignature	1
checkArithmeticOperand	1
checkArrayType	1
checkAssertionWorker	1
checkAssignmentDeclaration	1
checkAssignmentOperator	1
checkAsyncFunction	1
checkAwaitExpression	1
checkAwaitedType	1
checkBaseType	1
checkBindingElement	1
checkBreakOr	1
checkCallExpression	1
checkClassDeclaration	1
checkClassLike	1
checkClassMember	1
checkClassName	1
checkClassStatic	1
checkCollisionsFor	1
checkComputedProperty	1
checkConditionalExpression	1
checkConditionalType	1
checkConstEnum	1
checkConstructorDeclaration	1
checkCrossProduct	1
checkDeclarationInitializer	1
checkDeferredNode	1
checkDeferredNodes	1
checkDeprecatedSignature	1
checkDestructuringAssignment	1
checkDoStatement	1
checkEnumDeclaration	1
checkEnumMember	1
checkExportAssignment	1
checkExportDeclaration	1
checkExportSpecifier	1
checkExportsOn	1
checkExpressionCached	1
checkExpressionStatement	1
checkExpressionWith	1
checkExpressionWorker	1
checkExternalEmit	1
checkExternalImport	1
checkExternalModule	1
checkFlagAgreement	1
checkForDisallowed	1
checkForOf	1
checkForStatement	1
checkFunctionDeclaration	1
checkGrammarAccessor	1
checkGrammarArguments	1
checkGrammarArrow	1
checkGrammarAsync	1
checkGrammarBig	1
checkGrammarBinding	1
checkGrammarBreak	1
checkGrammarComputed	1
checkGrammarExport	1
checkGrammarExpression	1
checkGrammarFunction	1
checkGrammarHeritage	1
checkGrammarInterface	1
checkGrammarMeta	1
checkGrammarMethod	1
checkGrammarModifiers	1
checkGrammarModule	1
checkGrammarName	1
checkGrammarNullish	1
checkGrammarNumeric	1
checkGrammarObject	1
checkGrammarParameter	1
checkGrammarProperty	1
checkGrammarSource	1
checkGrammarStatement	1
checkGrammarTagged	1
checkIfNew	1
checkIfStatement	1
checkIfThis	1
checkIfType	1
checkImportBinding	1
checkImportCall	1
checkImportDeclaration	1
checkImportEquals	1
checkImportMeta	1
checkImportType	1
checkImportsFor	1
checkInExpression	1
checkIndexConstraints	1
checkInferType	1
checkInheritedProperties	1
checkInstanceOf	1
checkInterfaceDeclaration	1
checkIteratedType	1
checkJsxAttribute	1
checkJsxAttributes	1
checkJsxChildren	1
checkJsxExpression	1
checkJsxFragment	1
checkJsxOpening	1
checkJsxPreconditions	1
checkJsxReturn	1
checkKindsOf	1
checkLabeledStatement	1
checkMappedType	1
checkMembersFor	1
checkMetaProperty	1
checkMethodDeclaration	1
checkMissingDeclaration	1
checkModuleAugmentation	1
checkModuleDeclaration	1
checkNamedTuple	1
checkNestedBlock	1
checkNewTarget	1
checkNoType	1
checkNodeDeferred	1
checkNumericLiteral	1
checkObjectType	1
checkParenthesizedExpression	1
checkPostfixUnary	1
checkPrefixUnary	1
checkPrivateIdentifier	1
checkPropertyAccessibility	1
checkPropertyAssignment	1
checkPropertyDeclaration	1
checkPropertyInitialization	1
checkPropertyNot	1
checkPropertySignature	1
checkQualifiedName	1
checkQuestionToken	1
checkReferenceAssignment	1
checkReferenceExpression	1
checkReflectCollision	1
checkResolvedBlock	1
checkReturnStatement	1
checkRightHand	1
checkSignatureDeclaration	1
checkSpreadExpression	1
checkSpreadProp	1
checkSuperExpression	1
checkSwitchStatement	1
checkSymbolUsage	1
checkSyntheticExpression	1