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 {

prefix	count
get	714
check	306
is	304
create	84
resolve	39
has	35
add	32
report	27
instantiate	25
infer	23
type	23
narrow	20
serialize	20
try	19
find	14
mark	12
remove	11
symbol	10
combine	10
clone	9
compare	9
merge	8
error	8
elaborate	8
contains	8
can	6
maybe	6
signature	6
should	5
compute	5
extract	5
on	5
generate	5
map	5
make	5
lookup	5
grammar	5
append	5
index	5
set	5
for	4
visit	4
each	4
assign	4
types	3
invocation	3
include	3
import	3
discriminate	3
apply	3
are	3
record	3
copy	3
wrap	2
accepts	2
capture	2
count	2
distribute	2
evaluate	2
every	2
filter	2
intersect	2
literal	2
may	2
properties	2
replace	2
requires	2
signatures	2
some	2
structured	2
track	2
unwrap	2
widen	2
initialize	1
insert	1
exclude	1
binding	1
elide	1
invoke	1
does	1
issue	1
late	1
associate	1
diagnostic	1
determine	1
deep	1
mapped	1
declaration	1
union	1
could	1
members	1
convert	1
module	1
contextually	1
need	1
needs	1
node	1
container	1
optional	1
pad	1
pick	1
pop	1
populate	1
prepend	1
preserve	1
propagate	1
unused	1
property	1
push	1
constructor	1
recursive	1
register	1
relate	1
conditional	1
reorder	1
with	1
collect	1
usage	1
reset	1
clear	1
rewrite	1
sanitize	1
cleanup	1
class	1
choose	1
call	1
use	1
skipped	1
slice	1
visibility	1
sort	1
allow	1
substitute	1
build	1
symbols	1
throw	1
to	1
trace	1
all	1
transform	1
traverse	1
both	1
tuple	1
fold	1
format	1
function	1
flatten	1
finalize	1
fill	1
file	1
in	1
extend	1
expand	1
existing	1
inline	1

Two-words prefix

prefix	count	desc
getType	112
checkGrammar	57
getGlobal	30
getContextual	28
isType	28
checkType	20
getJsx	18
getIteration	17
narrowType	17
getIndex	15
getTarget	14
createType	13
checkJsx	12
getProperty	12
isValid	12
getBase	11
getWidened	11
getSymbol	11
inferFrom	11
getConstraint	11
isSymbol	11
checkAnd	10
tryGet	10
getFlow	9
checkProperty	9
checkClass	9
isProperty	9
getEffective	8
getUnion	8
getAssigned	8
isEmpty	8
getResolved	8
getSuggested	8
isGeneric	8
getThis	8
getDeclared	7
checkExpression	7
instantiateType	7
getNon	7
getRest	6
checkNon	6
getName	6
isThisless	6
getReturn	6
isIn	6
getDeclaration	6
checkImport	6
getSignature	6
symbolTo	6
getReferenced	5
getSingle	5
getExports	5
checkUnused	5
checkFor	5
checkObject	5
isDeclaration	5
isConst	5
getProperties	5
checkFunction	5
isNon	5
resolveExternal	5
getTuple	5
instantiateMapped	5
grammarError	5
isOptional	5
inferTo	4
getSpread	4
isReadonly	4
reportIncompatible	4
getString	4
getSuggestion	4
getApparent	4
checkArray	4
getCommon	4
serializeAs	4
getParent	4
getInferred	4
getInitial	4
getParameter	4
checkIf	4
createSignature	4
getLiteral	4
isString	4
findMatching	4
checkSource	4
getAnnotated	4
getDefault	4
typeParameter	4
hasNon	4
forEach	4
typeRelated	4
isLiteral	4
getAlias	4
hasType	4
checkThis	4
getSimplified	4
getExternal	3
checkCollision	3
getSignatures	3
isObject	3
getRegular	3
resolveType	3
getConditional	3
getImmediate	3
isArray	3
compareTypes	3
getTemplate	3
eachType	3
getReduced	3
typeHas	3
checkExport	3
getEntity	3
getOptional	3
typePredicate	3
getCandidate	3
getAwaited	3
typeTo	3
checkVariable	3
checkIndex	3
getDiagnostic	3
compareType	3
createOrigin	3
checkIndexed	3
createPromise	3
getEnum	3
invocationError	3
getNode	3
isMatching	3
getApplicable	3
isTuple	3
getClass	3
lookupSymbol	3
createUnion	3
getExport	3
createInference	3
isValue	3
signatureTo	3
canHave	3
getIs	3
addDuplicate	3
getElement	3
getIntrinsic	3
isNumeric	3
addDeprecated	3
importClause	3
isFunction	3
isContext	3
isConstructor	3
getMapped	3
checkExternal	3
generateJsx	2
getObject	2
getOr	2
isNode	2
isNot	2
getOuter	2
isOr	2
isParameter	2
isPattern	2
isPossibly	2
createSymbol	2
compareSignatures	2
isReachable	2
getReference	2
getArray	2
isSelf	2
isSimple	2
isSingle	2
getRestrictive	2
getAssignment	2
createTuple	2
isTemplate	2
isThis	2
isTop	2
isUnit	2
getBest	2
checkBinary	2
getCanonical	2
getSwitch	2
getSymbols	2
mapTo	2
mapType	2
markAlias	2
checkReference	2
getUndefined	2
getConstituent	2
markSymbol	2
getUnique	2
maybeAdd	2
maybeType	2
getVariances	2
mergeSymbol	2
getContext	2
narrowBy	2
hasContext	2
hasCorrect	2
discriminateContextual	2
checkSpread	2
getCross	2
getDeclaring	2
acceptsVoid	2
addDeclaration	2
getDiagnostics	2
addTo	2
recordPotential	2
checkTemplate	2
removeMissing	2
removeRedundant	2
indexInfo	2
indexSignatures	2
appendType	2
addType	2
checkTruthiness	2
inferType	2
reportError	2
inferTypes	2
checkConditional	2
getExplicit	2
reportNon	2
reportOperator	2
instantiateIndex	2
createAnonymous	2
createArray	2
getFalsy	2
instantiateSignature	2
requiresScope	2
resolveBase	2
resolveCall	2
getFirst	2
applyTo	2
resolveEntity	2
createCombined	2
isAlias	2
isAny	2
addTypes	2
resolveName	2
getIdentifier	2
isAssignment	2
checkAssertion	2
getImplied	2
getIndexed	2
checkAssignment	2
isClass	2
getInference	2
checkModule	2
isConstant	2
checkDeferred	2
checkDelete	2
serializeSymbol	2
serializeType	2
canConvert	2
cloneInference	2
isDiscriminant	2
createIndex	2
signatureHas	2
isEvolving	2
findBest	2
someType	2
checkElement	2
structuredType	2
getLeft	2
cloneType	2
checkEnum	2
isGlobal	2
createJsx	2
isIdentifier	2
tryElaborate	2
tryFind	2
getMatching	2
createLiteral	2
isImplementation	2
isImport	2
combineIntersection	2
typeArguments	2
getMin	2
createNormalized	2
createObject	2
getNamed	2
combineSignatures	2
isLate	2
addMember	2
getAccessible	2
widenType	2
combineUnion	2
getExpanded	1
getExpando	1
getExtract	1
getFacts	1
getFalse	1
getFile	1
getFinal	1
getFor	1
getFresh	1
getFully	1
getHelper	1
getHomomorphic	1
getImplements	1
getInfer	1
getInitializer	1
getInstantiated	1
getIntended	1
getInternal	1
getIntersected	1
getIntersection	1
getInvalid	1
getIterated	1
getKey	1
getKnown	1
getLast	1
getLate	1
getLocal	1
getLongest	1
getLower	1
getMapper	1
getMarker	1
getMembers	1
getMerged	1
getModified	1
getModifiers	1
getMutable	1
getNameable	1
getNames	1
getNamespace	1
getNarrowable	1
getNarrowed	1
getNormalized	1
getNullable	1
getNum	1
getNumber	1
getPart	1
getPermissive	1
getPotentially	1
getPrivate	1
getPromised	1
getPropagating	1
getQualified	1
getQuick	1
getRecursion	1
getRelation	1
getRoot	1
getSet	1
getShorthand	1
getSiblings	1
getSource	1
getSpecial	1
getSpecifier	1
getSpelling	1
getStart	1
getStatic	1
getSubstitution	1
getSuper	1
getSupertype	1
getSynthetic	1
getTopmost	1
getTrue	1
getUnary	1
getUninstantiated	1
getUnmatched	1
getUnused	1
getVariable	1
getYielded	1
hasBase	1
hasBindable	1
hasCommon	1
hasCovariant	1
hasDefault	1
hasDistributive	1
hasEffective	1
hasExcess	1
hasExport	1
hasExported	1
hasExternal	1
hasGlobal	1
hasInference	1
hasLate	1
hasMatching	1
hasNumeric	1
hasOverlapping	1
hasParent	1
hasParse	1
hasPrimitive	1
hasProp	1
hasSkip	1
hasVisible	1
inSame	1
includeMixin	1
includePrivate	1
includeUndefined	1
indexType	1
inferJsx	1
inferReverse	1
inferSignature	1
inferWith	1
initializeType	1
inlineExport	1
insertType	1
instantiateAnonymous	1
instantiateConditional	1
instantiateContextual	1
instantiateInstantiable	1
instantiateList	1
instantiateReverse	1
instantiateSignatures	1
instantiateSymbol	1
instantiateTypes	1
intersectTypes	1
intersectUnions	1
invokeOnce	1
isAccessible	1
isAliasable	1
isApplicable	1
isArguments	1
isArity	1
isAssigned	1
isAuto	1
isBig	1
isBinding	1
isBlock	1
isCircular	1
isCoercible	1
isCommon	1
isConditional	1
isConflicting	1
isConstraint	1
isConstructed	1
isDeeply	1
isDefault	1
isDeferred	1
isDestructuring	1
isDistributive	1
isDuplicated	1
isEntity	1
isEnum	1
isEval	1
isExcess	1
isExhaustive	1
isExpando	1
isExport	1
isExporting	1
isFalse	1
isFor	1
isFresh	1
isFrom	1
isHeritage	1
isHyphenated	1
isIdentical	1
isIgnored	1
isImmediately	1
isImported	1
isIncomplete	1
isInfinity	1
isInside	1
isInstance	1
isInstantiated	1
isIntersection	1
isIterator	1
isJsx	1
isKnown	1
isLegal	1
isLocal	1
isMapped	1
isMethod	1
isMixin	1
isMutable	1
isName	1
isNamed	1
isNamespace	1
isNeither	1
isNever	1
isNull	1
isNullable	1
isPartial	1
isPartially	1
isPost	1
isPotentially	1
isPrimitive	1
isPrivate	1
isPromise	1
isPrototype	1
isReference	1
isReferenced	1
isRelated	1
isRequired	1
isReserved	1
isResolved	1
isResolving	1
isReturn	1
isSame	1
isSide	1
isSignature	1
isSingleton	1
isSpread	1
isSpreadable	1
isStatic	1
isSyntactic	1
isThenable	1
isTypical	1
isUnary	1
isUncalled	1
isUnchecked	1
isUnconstrained	1
isUntyped	1
isUnwrapped	1
isUsed	1
isWeak	1
isYield	1
isZero	1
issueMember	1
lateBind	1
literalType	1
literalTypes	1
lookupOr	1
lookupType	1
makeArray	1
makeComposite	1
makeFunction	1
makeSerialize	1
makeUnary	1
mapTypes	1
mappedType	1
markAs	1
markConst	1
markDecorator	1
markEntity	1
markExport	1
markParameter	1
markProperty	1
markType	1
mayResolve	1
mayReturn	1
maybeCheck	1
maybeMapped	1
membersRelated	1
mergeExport	1
mergeInferences	1
mergeModule	1
mergeRedundant	1
mergeType	1
moduleExports	1
narrowUnion	1
needCollision	1
needsQualification	1
nodeHas	1
onEnter	1
onExit	1
onLeft	1
onOperator	1
onRight	1
optionalChain	1
padTuple	1
pickLongest	1
popType	1
populateSymbols	1
prependType	1
preserveComments	1
propagateOptional	1
propertiesIdentical	1
propertiesRelated	1
propertyRelated	1
pushType	1
recordMerged	1
recursiveType	1
registerFor	1
relateVariances	1
removeDefinitely	1
removeExport	1
removeOptional	1
removeOptionality	1
removeString	1
removeSubtypes	1
removeType	1
reorderCandidates	1
replaceIndexed	1
replacePrimitives	1
reportCannot	1
reportCircular	1
reportCircularity	1
reportErrors	1
reportFlow	1
reportImplementation	1
reportImplicit	1
reportInvalid	1
reportNonexistent	1
reportObject	1
reportObvious	1
reportRelation	1
reportType	1
reportUnmatched	1
reportUnmeasurable	1
reportUnreliable	1
reportWidening	1
resetError	1
resolveAlias	1
resolveAnonymous	1
resolveClass	1
resolveDeclared	1
resolveDecorator	1
resolveError	1
resolveExport	1
resolveHelpers	1
resolveImport	1
resolveIntersection	1
resolveJsx	1
resolveMapped	1
resolveNew	1
resolveObject	1
resolveReverse	1
resolveSignature	1
resolveStructured	1
resolveSymbol	1
resolveTagged	1
resolveUnion	1
resolveUntyped	1
rewriteModule	1
serializeBase	1
serializeEnum	1
serializeExisting	1
serializeExport	1
serializeImplemented	1
serializeIndex	1
serializeInterface	1
serializeMaybe	1
serializeModule	1
serializeProperty	1
serializeReturn	1
serializeSignatures	1
setCached	1
setLast	1
setLeft	1
setNode	1
setStructured	1
shouldCheck	1
shouldReport	1
shouldTreat	1
shouldUse	1
shouldWrite	1
signatureRelated	1
signaturesIdentical	1
signaturesRelated	1
skippedGeneric	1
sliceTuple	1
sortBy	1
substituteIndexed	1
symbolHas	1
symbolIs	1
symbolTable	1
symbolValue	1
symbolsTo	1
throwIf	1
toNode	1
traceUnions	1
trackComputed	1
trackExisting	1
transformType	1
tryGive	1
tryMerge	1
tryResolve	1
trySerialize	1
trySymbol	1
tupleTypes	1
typeCould	1
typeMaybe	1
typeParameters	1
typeReference	1
typesAre	1
typesDefinitely	1
typesPackage	1
unionObject	1
unusedIs	1
unwrapNondistributive	1
unwrapReturn	1
usageIn	1
useOuter	1
visibilityTo	1
visitAnd	1
visitExisting	1
visitSymbol	1
withContext	1
wrapReported	1
wrapSymbol	1
generateLimited	1
generateObject	1
addElement	1
addError	1
addEvolving	1
addExport	1
addImplementation	1
addInherited	1
addMatch	1
addName	1
addNamed	1
addOptional	1
addOptionality	1
addProperty	1
addReferenced	1
addResult	1
addSpans	1
addVisible	1
allTypes	1
allowLet	1
appendIndex	1
appendReference	1
appendSignatures	1
applyString	1
areDeclaration	1
areType	1
areTypes	1
assignBinding	1
assignContextual	1
assignNon	1
assignParameter	1
associateRelated	1
bindingName	1
bothAre	1
buildVisible	1
callLike	1
canQualify	1
captureError	1
captureLexical	1
checkAccessor	1
checkAlias	1
checkAll	1
checkAmbient	1
checkApplicable	1
checkArithmetic	1
checkAsync	1
checkAwait	1
checkAwaited	1
checkBase	1
checkBinding	1
checkBlock	1
checkBreak	1
checkCall	1
checkCollisions	1
checkComputed	1
checkConst	1
checkConstructor	1
checkCross	1
checkDeclaration	1
checkDecorator	1
checkDecorators	1
checkDeprecated	1
checkDestructuring	1
checkDo	1
checkExports	1
checkFlag	1
checkIdentifier	1
checkImports	1
checkIn	1
checkInfer	1
checkInherited	1
checkInstance	1
checkInterface	1
checkIterated	1
checkKinds	1
checkLabeled	1
checkMapped	1
checkMembers	1
checkMeta	1
checkMethod	1
checkMissing	1
checkNamed	1
checkNested	1
checkNew	1
checkNo	1
checkNode	1
checkNumeric	1
checkParameter	1
checkParenthesized	1
checkPostfix	1
checkPrefix	1
checkPrivate	1
checkQualified	1
checkQuestion	1
checkReflect	1
checkResolved	1
checkReturn	1
checkRight	1
checkSignature	1
checkSuper	1
checkSwitch	1
checkSymbol	1
checkSynthetic	1
checkTag	1
checkTagged	1
checkTesting	1
checkThrow	1
checkTruncation	1
checkTry	1
checkTuple	1
checkUnion	1
checkVar	1
checkVoid	1
checkWeak	1
checkWhile	1
checkWith	1
checkYield	1
chooseOverload	1
classDeclaration	1
clearCached	1
cloneBinding	1
cloneInferred	1
cloneNode	1
cloneSignature	1
cloneSymbol	1
collectLinked	1
combineIteration	1
combineSymbol	1
combineType	1
combineValue	1
compareProperties	1
computeBase	1
computeConstant	1
computeEnum	1
computeExhaustive	1
computeMember	1
conditionalType	1
constructorVisibilities	1
containerSeems	1
containsArguments	1
containsGeneric	1
containsMatching	1
containsMissing	1
containsReference	1
containsSame	1
containsTruthy	1
containsType	1
contextuallyCheck	1
convertAuto	1
copyLocally	1
copySymbol	1
copySymbols	1
couldContain	1
countMessage	1
countTypes	1
createAccess	1
createBackreference	1
createCanonical	1
createCheck	1
createDeferred	1
createElided	1
createEmpty	1
createEntity	1
createErased	1
createError	1
createEvolving	1
createExpression	1
createFinal	1
createFlow	1
createGenerator	1
createIndexed	1
createInstantiated	1
createIntersection	1
createIntrinsic	1
createIterable	1
createIteration	1
createMapped	1
createNode	1
createOptional	1
createProperty	1
createResolver	1
createReturn	1
createReverse	1
createString	1
createSynthetic	1
createTemplate	1
createTyped	1
createTypeof	1
createUnique	1
createWidening	1
declarationBelongs	1
deepClone	1
determineIf	1
diagnosticName	1
discriminateType	1
distributeIndex	1
distributeObject	1
doesAccessor	1
eachUnion	1
elaborateArray	1
elaborateArrow	1
elaborateDid	1
elaborateElementwise	1
elaborateError	1
elaborateJsx	1
elaborateNever	1
elaborateObject	1
elideInitializer	1
errorAnd	1
errorIf	1
errorNext	1
errorOn	1
errorOr	1
errorSkipped	1
errorUnused	1
evaluateEnum	1
everyContained	1
everyType	1
excludeProperties	1
existingType	1
expandSignature	1
extendExport	1
extractDefinitely	1
extractIrreducible	1
extractRedundant	1
extractTypes	1
extractUnit	1
fileSymbol	1
fillMissing	1
filterPrimitives	1
filterType	1
finalizeEvolving	1
findApplicable	1
findConstructor	1
findDiscriminant	1
findFirst	1
findIndex	1
findMixins	1
findMost	1
findResolution	1
flattenExport	1
foldState	1
formatUnion	1
functionHas	1
generateInitial	1
getAccess	1
getAccessed	1
getAccessor	1
getActual	1
getAll	1
getAlternative	1
getAmbient	1
getAnonymous	1
getAny	1
getArgument	1
getAsync	1
getAugmented	1
getBig	1
getCached	1
getCannot	1
getCombined	1
getConstant	1
getConstructor	1
getConstructors	1
getContainers	1
getContaining	1
getContextually	1
getContravariant	1
getControl	1
getCovariant	1
getDecorator	1
getDefinitely	1
getDeprecated	1
getDestructuring	1
getDiscriminant	1
getEffects	1
getElaboration	1
getEmit	1
getEnclosing	1
getEnd	1
getErased	1
getEvolving	1
getExcluded	1

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