checker

package

Go to main page

Versions in this module

v0

v0.0.2

Apr 25, 2026

Changes in this version

+ const ObjectFlagsUnresolvedMembers

+ func FormatTypeFlags(flags TypeFlags) []string

type Checker

+ func (c *Checker) ExpandSymbolForHover(symbol *ast.Symbol, meaning ast.SymbolFlags, vc *VerbosityContext) string

+ func (c *Checker) FillMissingTypeArguments(typeArguments []*Type, typeParameters []*Type, minTypeArgumentCount int, ...) []*Type

+ func (c *Checker) GetDefaultFromTypeParameter(typeParameter *Type) *Type

+ func (c *Checker) GetMinTypeArgumentCount(typeParameters []*Type) int

+ func (c *Checker) GetUnionTypeEx(types []*Type, unionReduction UnionReduction) *Type

+ func (c *Checker) GetWidenedLiteralType(t *Type) *Type

+ func (c *Checker) IsLibSymbolForHoverVerbosity(symbol *ast.Symbol) bool

+ func (c *Checker) IsLibTypeForHoverVerbosity(t *Type) bool

+ func (c *Checker) IsTypeAssignableTo(source *Type, target *Type) bool

+ func (c *Checker) RequiresAddingImplicitUndefined(node *ast.Node) bool

+ func (c *Checker) TypeParameterToStringEx(t *Type, enclosingDeclaration *ast.Node, vc *VerbosityContext) string

+ func (c *Checker) TypeToTypeNodeEx(t *Type, enclosingDeclaration *ast.Node, flags nodebuilder.Flags, ...) *ast.TypeNode

type EmitResolver

+ func (r *EmitResolver) TryJSTypeNodeToTypeNode(emitContext *printer.EmitContext, typeNode *ast.Node, ...) *ast.Node

type NodeBuilder

+ func (b *NodeBuilder) ExpandSymbolForHover(symbol *ast.Symbol, meaning ast.SymbolFlags) []*ast.Node

+ func (b *NodeBuilder) TryJSTypeNodeToTypeNode(node *ast.Node, enclosingDeclaration *ast.Node, flags nodebuilder.Flags, ...) *ast.Node

type NodeCheckFlags

+ const NodeCheckFlagsContainsClassWithPrivateIdentifiers

+ const NodeCheckFlagsContainsSuperPropertyInStaticInitializer

+ type Tracer struct

+ func NewTracer(tr *tracing.Tracing, checkerIndex int) *Tracer

+ func (t *Tracer) Instant(phase tracing.Phase, name string, args map[string]any)

+ func (t *Tracer) Push(phase tracing.Phase, name string, args map[string]any, ...) func()

+ func (t *Tracer) RecordType(typ *Type)

type TypeFlags

+ func (f TypeFlags) String() string

type TypeFormatFlags

+ const TypeFormatFlagsUseInstantiationExpressions

type VarianceFlags

+ func (v VarianceFlags) String() string

+ type VerbosityContext struct

+ CanIncreaseVerbosity bool

+ Level int

+ MaxTruncationLength int

+ Truncated bool

v0.0.1

Apr 11, 2026

Changes in this version

+ const ElementFlagsFixed

+ const ElementFlagsNonRequired

+ const ElementFlagsNonRest

+ const ElementFlagsNone

+ const ElementFlagsOptional

+ const ElementFlagsRequired

+ const ElementFlagsRest

+ const ElementFlagsVariable

+ const ElementFlagsVariadic

+ const IterationUseAllowsAsyncIterablesFlag

+ const IterationUseAllowsStringInputFlag

+ const IterationUseAllowsSyncIterablesFlag

+ const IterationUseAsyncGeneratorReturnType

+ const IterationUseAsyncYieldStar

+ const IterationUseCacheFlags

+ const IterationUseDestructuring

+ const IterationUseDestructuringFlag

+ const IterationUseElement

+ const IterationUseForAwaitOf

+ const IterationUseForOf

+ const IterationUseForOfFlag

+ const IterationUseGeneratorReturnType

+ const IterationUsePossiblyOutOfBounds

+ const IterationUseSpread

+ const IterationUseSpreadFlag

+ const IterationUseYieldStar

+ const IterationUseYieldStarFlag

+ const MAX_REVERSE_MAPPED_NESTING_INSPECTION_DEPTH

+ const ObjectFlagsAnonymous

+ const ObjectFlagsArrayLiteral

+ const ObjectFlagsClass

+ const ObjectFlagsClassOrInterface

+ const ObjectFlagsContainsIntersections

+ const ObjectFlagsContainsObjectOrArrayLiteral

+ const ObjectFlagsContainsSpread

+ const ObjectFlagsContainsWideningType

+ const ObjectFlagsCouldContainTypeVariables

+ const ObjectFlagsCouldContainTypeVariablesComputed

+ const ObjectFlagsEvolvingArray

+ const ObjectFlagsFreshLiteral

+ const ObjectFlagsIdenticalBaseTypeCalculated

+ const ObjectFlagsIdenticalBaseTypeExists

+ const ObjectFlagsInstantiated

+ const ObjectFlagsInstantiatedMapped

+ const ObjectFlagsInstantiationExpressionType

+ const ObjectFlagsInterface

+ const ObjectFlagsIsClassInstanceClone

+ const ObjectFlagsIsConstrainedTypeVariable

+ const ObjectFlagsIsGenericIndexType

+ const ObjectFlagsIsGenericObjectType

+ const ObjectFlagsIsGenericType

+ const ObjectFlagsIsGenericTypeComputed

+ const ObjectFlagsIsNeverIntersection

+ const ObjectFlagsIsNeverIntersectionComputed

+ const ObjectFlagsIsUnknownLikeUnion

+ const ObjectFlagsIsUnknownLikeUnionComputed

+ const ObjectFlagsJSLiteral

+ const ObjectFlagsJsxAttributes

+ const ObjectFlagsMapped

+ const ObjectFlagsMembersResolved

+ const ObjectFlagsNonInferrableType

+ const ObjectFlagsNone

+ const ObjectFlagsObjectLiteral

+ const ObjectFlagsObjectLiteralPatternWithComputedProperties

+ const ObjectFlagsObjectRestType

+ const ObjectFlagsObjectTypeKindMask

+ const ObjectFlagsPrimitiveUnion

+ const ObjectFlagsPropagatingFlags

+ const ObjectFlagsReference

+ const ObjectFlagsRequiresWidening

+ const ObjectFlagsReverseMapped

+ const ObjectFlagsSingleSignatureType

+ const ObjectFlagsTuple

+ const TypeFlagsAny

+ const TypeFlagsAnyOrUnknown

+ const TypeFlagsBigInt

+ const TypeFlagsBigIntLike

+ const TypeFlagsBigIntLiteral

+ const TypeFlagsBoolean

+ const TypeFlagsBooleanLike

+ const TypeFlagsBooleanLiteral

+ const TypeFlagsConditional

+ const TypeFlagsDefinitelyFalsy

+ const TypeFlagsDefinitelyNonNullable

+ const TypeFlagsDisjointDomains

+ const TypeFlagsESSymbol

+ const TypeFlagsESSymbolLike

+ const TypeFlagsEnum

+ const TypeFlagsEnumLike

+ const TypeFlagsEnumLiteral

+ const TypeFlagsFreshable

+ const TypeFlagsIncludesConstrainedTypeVariable

+ const TypeFlagsIncludesEmptyObject

+ const TypeFlagsIncludesError

+ const TypeFlagsIncludesInstantiable

+ const TypeFlagsIncludesMask

+ const TypeFlagsIncludesMissingType

+ const TypeFlagsIncludesNonWideningType

+ const TypeFlagsIncludesWildcard

+ const TypeFlagsIndex

+ const TypeFlagsIndexedAccess

+ const TypeFlagsInstantiable

+ const TypeFlagsInstantiableNonPrimitive

+ const TypeFlagsInstantiablePrimitive

+ const TypeFlagsIntersection

+ const TypeFlagsIntrinsic

+ const TypeFlagsLiteral

+ const TypeFlagsNarrowable

+ const TypeFlagsNever

+ const TypeFlagsNonPrimitive

+ const TypeFlagsNone

+ const TypeFlagsNotPrimitiveUnion

+ const TypeFlagsNull

+ const TypeFlagsNullable

+ const TypeFlagsNumber

+ const TypeFlagsNumberLike

+ const TypeFlagsNumberLiteral

+ const TypeFlagsObject

+ const TypeFlagsObjectFlagsType

+ const TypeFlagsPossiblyFalsy

+ const TypeFlagsPrimitive

+ const TypeFlagsReserved1

+ const TypeFlagsReserved2

+ const TypeFlagsReserved3

+ const TypeFlagsSimplifiable

+ const TypeFlagsSingleton

+ const TypeFlagsString

+ const TypeFlagsStringLike

+ const TypeFlagsStringLiteral

+ const TypeFlagsStringMapping

+ const TypeFlagsStringOrNumberLiteral

+ const TypeFlagsStringOrNumberLiteralOrUnique

+ const TypeFlagsStructuredOrInstantiable

+ const TypeFlagsStructuredType

+ const TypeFlagsSubstitution

+ const TypeFlagsTemplateLiteral

+ const TypeFlagsTypeParameter

+ const TypeFlagsTypeVariable

+ const TypeFlagsUndefined

+ const TypeFlagsUnion

+ const TypeFlagsUnionOrIntersection

+ const TypeFlagsUniqueESSymbol

+ const TypeFlagsUnit

+ const TypeFlagsUnknown

+ const TypeFlagsVoid

+ const TypeFlagsVoidLike

+ const TypeFormatFlagsNodeBuilderFlagsMask

+ var JsxNames = struct{ ... }

+ var LanguageFeatureMinimumTarget = LanguageFeatureMinimumTargetMap

+ var ReactNames = struct{ ... }

+ var SignatureKeyBase = CacheHashKey(xxh3.HashString128("#"))

+ var SignatureKeyCanonical = CacheHashKey(xxh3.HashString128("*"))

+ var SignatureKeyErased = CacheHashKey(xxh3.HashString128("-"))

+ var SignatureKeyInner = CacheHashKey(xxh3.HashString128("<"))

+ var SignatureKeyOuter = CacheHashKey(xxh3.HashString128(">"))

+ func CompareTypes(t1, t2 *Type) int

+ func GetDeclarationModifierFlagsFromSymbol(s *ast.Symbol) ast.ModifierFlags

+ func GetResolvedSignatureForSignatureHelp(node *ast.Node, argumentCount int, c *Checker) (*Signature, []*Signature)

+ func GetSingleVariableOfVariableStatement(node *ast.Node) *ast.Node

+ func IsExternalModuleSymbol(moduleSymbol *ast.Symbol) bool

+ func IsInTypeQuery(node *ast.Node) bool

+ func IsKnownSymbol(symbol *ast.Symbol) bool

+ func IsPrivateIdentifierSymbol(symbol *ast.Symbol) bool

+ func IsTupleType(t *Type) bool

+ func IsTypeAny(t *Type) bool

+ func NewDiagnosticChainForNode(chain *ast.Diagnostic, node *ast.Node, message *diagnostics.Message, ...) *ast.Diagnostic

+ func NewDiagnosticForNode(node *ast.Node, message *diagnostics.Message, args ...any) *ast.Diagnostic

+ func SkipAlias(symbol *ast.Symbol, checker *Checker) *ast.Symbol

+ func TryGetModuleSpecifierFromDeclaration(node *ast.Node) *ast.Node

+ func ValueToString(value any) string

+ type AccessFlags uint32

+ const AccessFlagsAllowMissing

+ const AccessFlagsCacheSymbol

+ const AccessFlagsContextual

+ const AccessFlagsExpressionPosition

+ const AccessFlagsIncludeUndefined

+ const AccessFlagsNoIndexSignatures

+ const AccessFlagsNone

+ const AccessFlagsPersistent

+ const AccessFlagsReportDeprecated

+ const AccessFlagsSuppressNoImplicitAnyError

+ const AccessFlagsWriting

+ type AliasSymbolLinks struct

+ type ArrayLiteralLinks struct

+ type ArrayToSingleTypeMapper struct

+ func (m *ArrayToSingleTypeMapper) Map(t *Type) *Type

+ type ArrayTypeMapper struct

+ func (m *ArrayTypeMapper) Kind() TypeMapperKind

+ func (m *ArrayTypeMapper) Map(t *Type) *Type

+ type AssertionLinks struct

+ type AssignmentKind int32

+ const AssignmentKindCompound

+ const AssignmentKindDefinite

+ const AssignmentKindNone

+ type AssignmentReducedKey struct

+ type AssignmentTarget = ast.Node

+ type CacheHashKey xxh3.Uint128

+ func (k CacheHashKey) IsZero() bool

+ type CachedSignatureKey struct

+ type CachedTypeKey struct

+ type CachedTypeKind int32

+ const CachedTypeKindApparentType

+ const CachedTypeKindArrayLiteralType

+ const CachedTypeKindAwaitedType

+ const CachedTypeKindDecoratorContext

+ const CachedTypeKindDecoratorContextPrivate

+ const CachedTypeKindDecoratorContextPrivateStatic

+ const CachedTypeKindDecoratorContextStatic

+ const CachedTypeKindDefaultOnlyType

+ const CachedTypeKindEquivalentBaseType

+ const CachedTypeKindEvolvingArrayType

+ const CachedTypeKindIndexType

+ const CachedTypeKindIndexedAccessForReading

+ const CachedTypeKindIndexedAccessForWriting

+ const CachedTypeKindLiteralUnionBaseType

+ const CachedTypeKindPermissiveInstantiation

+ const CachedTypeKindPromisedTypeOfPromise

+ const CachedTypeKindRegularObjectLiteral

+ const CachedTypeKindRestrictiveInstantiation

+ const CachedTypeKindRestrictiveTypeParameter

+ const CachedTypeKindStringIndexType

+ const CachedTypeKindSyntheticType

+ const CachedTypeKindWidened

+ type CallState struct

+ type CheckMode uint32

+ const CheckModeContextual

+ const CheckModeForceTuple

+ const CheckModeInferential

+ const CheckModeIsForSignatureHelp

+ const CheckModeNormal

+ const CheckModeRestBindingElement

+ const CheckModeSkipContextSensitive

+ const CheckModeSkipGenericFunctions

+ const CheckModeTypeOnly

+ type Checker struct

+ ReverseMappedSymbolLinks core.LinkStore[*ast.Symbol, ReverseMappedSymbolLinks]

+ SymbolCount uint32

+ TotalInstantiationCount uint32

+ TypeCount uint32

+ func NewChecker(program Program) (*Checker, *sync.Mutex)

+ func (c *Checker) ForEachExportAndPropertyOfModule(moduleSymbol *ast.Symbol, cb func(*ast.Symbol, string))

+ func (c *Checker) GetAccessibleSymbolChain(symbol *ast.Symbol, enclosingDeclaration *ast.Node, meaning ast.SymbolFlags, ...) []*ast.Symbol

+ func (c *Checker) GetAliasedSymbol(symbol *ast.Symbol) *ast.Symbol

+ func (c *Checker) GetAllPossiblePropertiesOfTypes(types []*Type) []*ast.Symbol

+ func (c *Checker) GetAmbientModules() []*ast.Symbol

+ func (c *Checker) GetAnyType() *Type

+ func (c *Checker) GetApparentProperties(t *Type) []*ast.Symbol

+ func (c *Checker) GetApparentType(t *Type) *Type

+ func (c *Checker) GetBaseConstraintOfType(t *Type) *Type

+ func (c *Checker) GetBaseConstructorTypeOfClass(t *Type) *Type

+ func (c *Checker) GetBaseTypeOfLiteralType(t *Type) *Type

+ func (c *Checker) GetBaseTypes(t *Type) []*Type

+ func (c *Checker) GetBigIntType() *Type

+ func (c *Checker) GetBooleanType() *Type

+ func (c *Checker) GetCallSignatures(t *Type) []*Signature

+ func (c *Checker) GetCandidateSignaturesForStringLiteralCompletions(call *ast.CallLikeExpression, editingArgument *ast.Node) []*Signature

+ func (c *Checker) GetConstantValue(node *ast.Node) any

+ func (c *Checker) GetConstraintOfTypeParameter(typeParameter *Type) *Type

+ func (c *Checker) GetConstructSignatures(t *Type) []*Signature

+ func (c *Checker) GetContextualType(node *ast.Expression, contextFlags ContextFlags) *Type

+ func (c *Checker) GetContextualTypeForArgumentAtIndex(node *ast.Node, argIndex int) *Type

+ func (c *Checker) GetContextualTypeForArrayLiteralAtPosition(contextualArrayType *Type, arrayLiteral *ast.Node, position int) *Type

+ func (c *Checker) GetContextualTypeForJsxAttribute(attribute *ast.JsxAttributeLike) *Type

+ func (c *Checker) GetContextualTypeForObjectLiteralElement(element *ast.Node, contextFlags ContextFlags) *Type

+ func (c *Checker) GetDeclaredTypeOfSymbol(symbol *ast.Symbol) *Type

+ func (c *Checker) GetDiagnostics(ctx context.Context, sourceFile *ast.SourceFile) []*ast.Diagnostic

+ func (c *Checker) GetESSymbolType() *Type

+ func (c *Checker) GetEffectiveDeclarationFlags(n *ast.Node, flagsToCheck ast.ModifierFlags) ast.ModifierFlags

+ func (c *Checker) GetElementTypeOfArrayType(t *Type) *Type

+ func (c *Checker) GetEmitResolver() *EmitResolver

+ func (c *Checker) GetErrorType() *Type

+ func (c *Checker) GetExpandedParameters(signature *Signature, skipUnionExpanding bool) [][]*ast.Symbol

+ func (c *Checker) GetExportSpecifierLocalTargetSymbol(node *ast.Node) *ast.Symbol

+ func (c *Checker) GetExportSymbolOfSymbol(symbol *ast.Symbol) *ast.Symbol

+ func (c *Checker) GetExportsAndPropertiesOfModule(moduleSymbol *ast.Symbol) []*ast.Symbol

+ func (c *Checker) GetExportsOfModule(symbol *ast.Symbol) []*ast.Symbol

+ func (c *Checker) GetFirstTypeArgumentFromKnownType(t *Type) *Type

+ func (c *Checker) GetGlobalDiagnostics() []*ast.Diagnostic

+ func (c *Checker) GetGlobalSymbol(name string, meaning ast.SymbolFlags, diagnostic *diagnostics.Message) *ast.Symbol

+ func (c *Checker) GetImmediateAliasedSymbol(symbol *ast.Symbol) *ast.Symbol

+ func (c *Checker) GetIndexInfosOfType(t *Type) []*IndexInfo

+ func (c *Checker) GetIndexSignaturesAtLocation(node *ast.Node) []*ast.Node

+ func (c *Checker) GetJsxFragmentFactory(location *ast.Node) string

+ func (c *Checker) GetJsxIntrinsicTagNamesAt(location *ast.Node) []*ast.Symbol

+ func (c *Checker) GetJsxNamespace(location *ast.Node) string

+ func (c *Checker) GetLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol *ast.Symbol) []*Type

+ func (c *Checker) GetMappedTypeSymbolOfProperty(symbol *ast.Symbol) *ast.Symbol

+ func (c *Checker) GetMergedSymbol(symbol *ast.Symbol) *ast.Symbol

+ func (c *Checker) GetNeverType() *Type

+ func (c *Checker) GetNonNullableType(t *Type) *Type

+ func (c *Checker) GetNonOptionalType(t *Type) *Type

+ func (c *Checker) GetNullType() *Type

+ func (c *Checker) GetNumberIndexType(t *Type) *Type

+ func (c *Checker) GetNumberType() *Type

+ func (c *Checker) GetPromisedTypeOfPromise(t *Type) *Type

+ func (c *Checker) GetPropertiesOfType(t *Type) []*ast.Symbol

+ func (c *Checker) GetPropertyOfType(t *Type, name string) *ast.Symbol

+ func (c *Checker) GetPropertySymbolOfDestructuringAssignment(location *ast.Node) *ast.Symbol

+ func (c *Checker) GetPropertySymbolsFromContextualType(node *ast.Node, contextualType *Type, unionSymbolOk bool) []*ast.Symbol

+ func (c *Checker) GetResolutionModeOverride(node *ast.ImportAttributes, reportErrors bool) core.ResolutionMode

+ func (c *Checker) GetResolvedSignature(node *ast.Node) *Signature

+ func (c *Checker) GetResolvedSymbol(node *ast.Node) *ast.Symbol

+ func (c *Checker) GetRestTypeOfSignature(sig *Signature) *Type

+ func (c *Checker) GetReturnTypeOfSignature(sig *Signature) *Type

+ func (c *Checker) GetRootSymbols(symbol *ast.Symbol) []*ast.Symbol

+ func (c *Checker) GetShorthandAssignmentValueSymbol(location *ast.Node) *ast.Symbol

+ func (c *Checker) GetSignatureFromDeclaration(node *ast.Node) *Signature

+ func (c *Checker) GetSignaturesOfType(t *Type, kind SignatureKind) []*Signature

+ func (c *Checker) GetStringIndexType(t *Type) *Type

+ func (c *Checker) GetStringType() *Type

+ func (c *Checker) GetSuggestionDiagnostics(ctx context.Context, sourceFile *ast.SourceFile) []*ast.Diagnostic

+ func (c *Checker) GetSymbolAtLocation(node *ast.Node) *ast.Symbol

+ func (c *Checker) GetSymbolFlags(symbol *ast.Symbol) ast.SymbolFlags

+ func (c *Checker) GetSymbolsInScope(location *ast.Node, meaning ast.SymbolFlags) []*ast.Symbol

+ func (c *Checker) GetSymbolsOfParameterPropertyDeclaration(parameter *ast.Node, parameterName string) (*ast.Symbol, *ast.Symbol)

+ func (c *Checker) GetTypeAliasTypeParameters(symbol *ast.Symbol) []*Type

+ func (c *Checker) GetTypeArgumentConstraint(node *ast.Node) *Type

+ func (c *Checker) GetTypeArguments(t *Type) []*Type

+ func (c *Checker) GetTypeAtLocation(node *ast.Node) *Type

+ func (c *Checker) GetTypeFromTypeNode(node *ast.Node) *Type

+ func (c *Checker) GetTypeOfPropertyOfContextualType(t *Type, name string) *Type

+ func (c *Checker) GetTypeOfPropertyOfType(t *Type, name string) *Type

+ func (c *Checker) GetTypeOfSymbol(symbol *ast.Symbol) *Type

+ func (c *Checker) GetTypeOfSymbolAtLocation(symbol *ast.Symbol, location *ast.Node) *Type

+ func (c *Checker) GetTypeOnlyAliasDeclaration(symbol *ast.Symbol) *ast.Node

+ func (c *Checker) GetTypeParameterAtPosition(s *Signature, pos int) *Type

+ func (c *Checker) GetTypePredicateOfSignature(sig *Signature) *TypePredicate

+ func (c *Checker) GetUndefinedType() *Type

+ func (c *Checker) GetUnionType(types []*Type) *Type

+ func (c *Checker) GetUnknownSymbol() *ast.Symbol

+ func (c *Checker) GetUnknownType() *Type

+ func (c *Checker) GetVoidType() *Type

+ func (c *Checker) HasEffectiveRestParameter(signature *Signature) bool

+ func (c *Checker) IsAnySymbolAccessible(symbols []*ast.Symbol, enclosingDeclaration *ast.Node, ...) *printer.SymbolAccessibilityResult

+ func (c *Checker) IsArgumentsSymbol(symbol *ast.Symbol) bool

+ func (c *Checker) IsArrayLikeType(t *Type) bool

+ func (c *Checker) IsContextSensitive(node *ast.Node) bool

+ func (c *Checker) IsDeclarationUsed(sourceFile *ast.SourceFile, identifier *ast.Identifier, ...) bool

+ func (c *Checker) IsDeprecatedDeclaration(declaration *ast.Node) bool

+ func (c *Checker) IsEmptyAnonymousObjectType(t *Type) bool

+ func (c *Checker) IsNullableType(t *Type) bool

+ func (c *Checker) IsPropertyAccessible(node *ast.Node, isSuper bool, isWrite bool, containingType *Type, ...) bool

+ func (c *Checker) IsSymbolAccessible(symbol *ast.Symbol, enclosingDeclaration *ast.Node, meaning ast.SymbolFlags, ...) printer.SymbolAccessibilityResult

+ func (c *Checker) IsSymbolAccessibleByFlags(symbol *ast.Symbol, enclosingDeclaration *ast.Node, flags ast.SymbolFlags) bool

+ func (c *Checker) IsSymbolReferencedInFile(sourceFile *ast.SourceFile, definition *ast.Identifier, symbol *ast.Symbol) bool

+ func (c *Checker) IsTypeInvalidDueToUnionDiscriminant(contextualType *Type, obj *ast.Node) bool

+ func (c *Checker) IsTypeSymbolAccessible(typeSymbol *ast.Symbol, enclosingDeclaration *ast.Node) bool

+ func (c *Checker) IsUndefinedSymbol(symbol *ast.Symbol) bool

+ func (c *Checker) IsUnknownSymbol(symbol *ast.Symbol) bool

+ func (c *Checker) IsValidPropertyAccess(node *ast.Node, propertyName string) bool

+ func (c *Checker) IsValidPropertyAccessForCompletions(node *ast.Node, t *Type, property *ast.Symbol) bool

+ func (c *Checker) IsValueSymbolAccessible(symbol *ast.Symbol, enclosingDeclaration *ast.Node) bool

+ func (c *Checker) ResolveAlias(symbol *ast.Symbol) (*ast.Symbol, bool)

+ func (c *Checker) ResolveExternalModuleName(moduleSpecifier *ast.Node) *ast.Symbol

+ func (c *Checker) ResolveExternalModuleSymbol(moduleSymbol *ast.Symbol) *ast.Symbol

+ func (c *Checker) ResolveName(name string, location *ast.Node, meaning ast.SymbolFlags, excludeGlobals bool) *ast.Symbol

+ func (c *Checker) SignatureToStringEx(signature *Signature, enclosingDeclaration *ast.Node, flags TypeFormatFlags) string

+ func (c *Checker) SkipAlias(symbol *ast.Symbol) *ast.Symbol

+ func (c *Checker) SymbolToString(s *ast.Symbol) string

+ func (c *Checker) SymbolToStringEx(symbol *ast.Symbol, enclosingDeclaration *ast.Node, meaning ast.SymbolFlags, ...) string

+ func (c *Checker) TryFindAmbientModule(moduleName string) *ast.Symbol

+ func (c *Checker) TryGetMemberInModuleExports(memberName string, moduleSymbol *ast.Symbol) *ast.Symbol

+ func (c *Checker) TryGetMemberInModuleExportsAndProperties(memberName string, moduleSymbol *ast.Symbol) *ast.Symbol

+ func (c *Checker) TryGetThisTypeAtEx(node *ast.Node, includeGlobalThis bool, container *ast.Node) *Type

+ func (c *Checker) TypeHasCallOrConstructSignatures(t *Type) bool

+ func (c *Checker) TypePredicateToString(t *TypePredicate) string

+ func (c *Checker) TypePredicateToTypePredicateNode(t *TypePredicate, enclosingDeclaration *ast.Node, flags nodebuilder.Flags, ...) *ast.TypePredicateNodeNode

+ func (c *Checker) TypeToString(t *Type) string

+ func (c *Checker) TypeToStringEx(t *Type, enclosingDeclaration *ast.Node, flags TypeFormatFlags) string

+ func (c *Checker) TypeToTypeNode(t *Type, enclosingDeclaration *ast.Node, flags nodebuilder.Flags, ...) *ast.TypeNode

+ func (c *Checker) UnionTypes() iter.Seq[*Type]

+ func (c *Checker) WasCanceled() bool

+ type CompositeSignature struct

+ type CompositeSymbolIdentity struct

+ type CompositeTypeCacheIdentity struct

+ type CompositeTypeMapper struct

+ func (m *CompositeTypeMapper) Map(t *Type) *Type

+ type ConditionalRoot struct

+ type ConditionalType struct

+ func (t *ConditionalType) CheckType() *Type

+ func (t *ConditionalType) ExtendsType() *Type

+ type ConstrainedType struct

+ func (t *ConstrainedType) AsConstrainedType() *ConstrainedType

+ type ContainingSymbolLinks struct

+ type ContextFlags uint32

+ const ContextFlagsIgnoreNodeInferences

+ const ContextFlagsNoConstraints

+ const ContextFlagsNone

+ const ContextFlagsSignature

+ const ContextFlagsSkipBindingPatterns

+ type ContextualInfo struct

+ type DeclarationFileLinks struct

+ type DeclarationLinks struct

+ type DeclarationMeaning uint32

+ const DeclarationMeaningGetAccessor

+ const DeclarationMeaningGetOrSetAccessor

+ const DeclarationMeaningMethod

+ const DeclarationMeaningPrivateStatic

+ const DeclarationMeaningPropertyAssignment

+ const DeclarationMeaningPropertyAssignmentOrMethod

+ const DeclarationMeaningSetAccessor

+ type DeclarationSpaces int32

+ const DeclarationSpacesExportNamespace

+ const DeclarationSpacesExportType

+ const DeclarationSpacesExportValue

+ const DeclarationSpacesNone

+ type DeclaredTypeLinks struct

+ type DeferredSymbolLinks struct

+ type DeferredTypeMapper struct

+ func (m *DeferredTypeMapper) Map(t *Type) *Type

+ type DiagnosticAndArguments struct

+ type DiagnosticDetails struct

+ Args []any

+ Message *diagnostics.Message

+ func CreateModeMismatchDetails(program Program, file *ast.SourceFile) DiagnosticDetails

+ func CreateModuleNotFoundChain(program Program, file *ast.SourceFile, moduleReference string, ...) DiagnosticDetails

+ type DiscriminatedContextualTypeKey struct

+ type Discriminator interface

+ type ElementFlags uint32

+ type EmitResolver struct

+ func (r *EmitResolver) CreateLateBoundIndexSignatures(emitContext *printer.EmitContext, container *ast.Node, ...) []*ast.Node

+ func (r *EmitResolver) CreateLiteralConstValue(emitContext *printer.EmitContext, node *ast.Node, ...) *ast.Node

+ func (r *EmitResolver) CreateReturnTypeOfSignatureDeclaration(emitContext *printer.EmitContext, signatureDeclaration *ast.Node, ...) *ast.Node

+ func (r *EmitResolver) CreateTypeOfDeclaration(emitContext *printer.EmitContext, declaration *ast.Node, ...) *ast.Node

+ func (r *EmitResolver) CreateTypeOfExpression(emitContext *printer.EmitContext, expression *ast.Node, ...) *ast.Node

+ func (r *EmitResolver) CreateTypeParametersOfSignatureDeclaration(emitContext *printer.EmitContext, signatureDeclaration *ast.Node, ...) []*ast.Node

+ func (r *EmitResolver) GetConstantValue(node *ast.Node) any

+ func (r *EmitResolver) GetEffectiveDeclarationFlags(node *ast.Node, flags ast.ModifierFlags) ast.ModifierFlags

+ func (r *EmitResolver) GetElementAccessExpressionName(expression *ast.ElementAccessExpression) string

+ func (r *EmitResolver) GetEnumMemberValue(node *ast.Node) evaluator.Result

+ func (r *EmitResolver) GetExternalModuleFileFromDeclaration(declaration *ast.Node) *ast.SourceFile

+ func (r *EmitResolver) GetJsxFactoryEntity(location *ast.Node) *ast.Node

+ func (r *EmitResolver) GetJsxFragmentFactoryEntity(location *ast.Node) *ast.Node

+ func (r *EmitResolver) GetPropertiesOfContainerFunction(node *ast.Node) []*ast.Symbol

+ func (r *EmitResolver) GetReferencedExportContainer(node *ast.IdentifierNode, prefixLocals bool) *ast.Node

+ func (r *EmitResolver) GetReferencedImportDeclaration(node *ast.IdentifierNode) *ast.Declaration

+ func (r *EmitResolver) GetReferencedValueDeclaration(node *ast.IdentifierNode) *ast.Declaration

+ func (r *EmitResolver) GetReferencedValueDeclarations(node *ast.IdentifierNode) []*ast.Declaration

+ func (r *EmitResolver) GetResolutionModeOverride(node *ast.Node) core.ResolutionMode

+ func (r *EmitResolver) GetTypeReferenceSerializationKind(typeName *ast.Node, location *ast.Node) printer.TypeReferenceSerializationKind

+ func (r *EmitResolver) IsDeclarationVisible(node *ast.Node) bool

+ func (r *EmitResolver) IsDefinitelyReferenceToGlobalSymbolObject(node *ast.Node) bool

+ func (r *EmitResolver) IsEntityNameVisible(entityName *ast.Node, enclosingDeclaration *ast.Node) printer.SymbolAccessibilityResult

+ func (r *EmitResolver) IsExpandoFunctionDeclaration(node *ast.Node) bool

+ func (r *EmitResolver) IsExpandoFunctionDeclarationUnsafe(node *ast.Node) bool

+ func (r *EmitResolver) IsImplementationOfOverload(node *ast.SignatureDeclaration) bool

+ func (r *EmitResolver) IsImportRequiredByAugmentation(decl *ast.ImportDeclaration) bool

+ func (r *EmitResolver) IsLateBound(node *ast.Node) bool

+ func (r *EmitResolver) IsLiteralConstDeclaration(node *ast.Node) bool

+ func (r *EmitResolver) IsOptionalParameter(node *ast.Node) bool

+ func (r *EmitResolver) IsReferencedAliasDeclaration(node *ast.Node) bool

+ func (r *EmitResolver) IsSymbolAccessible(symbol *ast.Symbol, enclosingDeclaration *ast.Node, meaning ast.SymbolFlags, ...) printer.SymbolAccessibilityResult

+ func (r *EmitResolver) IsTopLevelValueImportEqualsWithEntityName(node *ast.Node) bool

+ func (r *EmitResolver) IsValueAliasDeclaration(node *ast.Node) bool

+ func (r *EmitResolver) MarkLinkedReferencesRecursively(file *ast.SourceFile)

+ func (r *EmitResolver) PrecalculateDeclarationEmitVisibility(file *ast.SourceFile)

+ func (r *EmitResolver) RequiresAddingImplicitUndefined(declaration *ast.Node, symbol *ast.Symbol, enclosingDeclaration *ast.Node) bool

+ func (r *EmitResolver) RequiresAddingImplicitUndefinedUnsafe(declaration *ast.Node, symbol *ast.Symbol, enclosingDeclaration *ast.Node) bool

+ func (r *EmitResolver) SetReferencedImportDeclaration(node *ast.IdentifierNode, ref *ast.Declaration)

+ type EnumLiteralKey struct

+ type EnumMemberLinks struct

+ type EnumRelationKey struct

+ type ErrorChain struct

+ type ErrorOutputContainer struct

+ type ErrorReporter func(message *diagnostics.Message, args ...any)

+ type EvolvingArrayType struct

+ type ExhaustiveState byte

+ const ExhaustiveStateComputing

+ const ExhaustiveStateFalse

+ const ExhaustiveStateTrue

+ const ExhaustiveStateUnknown

+ type ExpandingFlags uint8

+ const ExpandingFlagsBoth

+ const ExpandingFlagsNone

+ const ExpandingFlagsSource

+ const ExpandingFlagsTarget

+ type ExportCollision struct

+ type ExportCollisionTable = map[string]*ExportCollision

+ type ExportTypeLinks struct

+ type FeatureMapEntry struct

+ type FlowLoopInfo struct

+ type FlowLoopKey struct

+ type FlowState struct

+ type FlowType struct

+ type FunctionTypeMapper struct

+ func (m *FunctionTypeMapper) Map(t *Type) *Type

+ type Host interface

+ type IndexFlags uint32

+ const IndexFlagsNoIndexSignatures

+ const IndexFlagsNoReducibleCheck

+ const IndexFlagsNone

+ const IndexFlagsStringsOnly

+ type IndexInfo struct

+ func (info *IndexInfo) IsReadonly() bool

+ func (info *IndexInfo) KeyType() *Type

+ func (info *IndexInfo) ValueType() *Type

+ type IndexType struct

+ func (t *IndexType) Target() *Type

+ type IndexedAccessType struct

+ func (t *IndexedAccessType) IndexType() *Type

+ func (t *IndexedAccessType) ObjectType() *Type

+ type InferenceContext struct

+ type InferenceContextInfo struct

+ type InferenceFlags uint32

+ const InferenceFlagsAnyDefault

+ const InferenceFlagsNoDefault

+ const InferenceFlagsNone

+ const InferenceFlagsSkippedGenericFunction

+ type InferenceInfo struct

+ type InferenceKey struct

+ type InferencePriority int32

+ const InferencePriorityAlwaysStrict

+ const InferencePriorityCircularity

+ const InferencePriorityContravariantConditional

+ const InferencePriorityHomomorphicMappedType

+ const InferencePriorityLiteralKeyof

+ const InferencePriorityMappedTypeConstraint

+ const InferencePriorityMaxValue

+ const InferencePriorityNakedTypeVariable

+ const InferencePriorityNoConstraints

+ const InferencePriorityNone

+ const InferencePriorityPartialHomomorphicMappedType

+ const InferencePriorityPriorityImpliesCombination

+ const InferencePriorityReturnType

+ const InferencePrioritySpeculativeTuple

+ const InferencePrioritySubstituteSource

+ type InferenceState struct

+ type InferenceTypeMapper struct

+ func (m *InferenceTypeMapper) Map(t *Type) *Type

+ type InheritanceInfo struct

+ type InstantiationExpressionKey struct

+ type InstantiationExpressionType struct

+ type InterfaceType struct

+ func (t *InterfaceType) AsInterfaceType() *InterfaceType

+ func (t *InterfaceType) LocalTypeParameters() []*Type

+ func (t *InterfaceType) OuterTypeParameters() []*Type

+ func (t *InterfaceType) TypeParameters() []*Type

+ type IntersectionFlags uint32

+ const IntersectionFlagsNoConstraintReduction

+ const IntersectionFlagsNoSupertypeReduction

+ const IntersectionFlagsNone

+ type IntersectionState uint32

+ const IntersectionStateNone

+ const IntersectionStateSource

+ const IntersectionStateTarget

+ type IntersectionType struct

+ type IntraExpressionInferenceSite struct

+ type IntrinsicType struct

+ func (t *IntrinsicType) IntrinsicName() string

+ type IntrinsicTypeKind int32

+ const IntrinsicTypeKindCapitalize

+ const IntrinsicTypeKindLowercase

+ const IntrinsicTypeKindNoInfer

+ const IntrinsicTypeKindUncapitalize

+ const IntrinsicTypeKindUnknown

+ const IntrinsicTypeKindUppercase

+ type IterationTypeKind int32

+ const IterationTypeKindNext

+ const IterationTypeKindReturn

+ const IterationTypeKindYield

+ type IterationTypes struct

+ type IterationTypesKey struct

+ type IterationTypesResolver struct

+ type IterationUse uint32

+ type JSXLinks struct

+ type JsxElaborationElement struct

+ type JsxElementLinks struct

+ type JsxFlags uint32

+ const JsxFlagsIntrinsicElement

+ const JsxFlagsIntrinsicIndexedElement

+ const JsxFlagsIntrinsicNamedElement

+ const JsxFlagsNone

+ type JsxReferenceKind int32

+ const JsxReferenceKindComponent

+ const JsxReferenceKindFunction

+ const JsxReferenceKindMixed

+ type LanguageFeatureMinimumTargetMap struct

+ AsyncFunctions core.ScriptTarget

+ AsyncGenerators core.ScriptTarget

+ AsyncIteration core.ScriptTarget

+ BigInt core.ScriptTarget

+ BindinglessCatch core.ScriptTarget

+ ClassAndClassElementDecorators core.ScriptTarget

+ ClassFields core.ScriptTarget

+ Exponentiation core.ScriptTarget

+ ForAwaitOf core.ScriptTarget

+ LogicalAssignment core.ScriptTarget

+ NullishCoalesce core.ScriptTarget

+ ObjectSpreadRest core.ScriptTarget

+ OptionalChaining core.ScriptTarget

+ PrivateNamesAndClassStaticBlocks core.ScriptTarget

+ RegularExpressionFlagsDotAll core.ScriptTarget

+ RegularExpressionFlagsHasIndices core.ScriptTarget

+ RegularExpressionFlagsUnicodeSets core.ScriptTarget

+ ShebangComments core.ScriptTarget

+ TopLevelAwait core.ScriptTarget

+ UsingAndAwaitUsing core.ScriptTarget

+ type LateBoundLinks struct

+ type LiteralType struct

+ func (t *LiteralType) String() string

+ func (t *LiteralType) Value() any

+ type MappedSymbolLinks struct

+ type MappedType struct

+ type MappedTypeModifiers uint32

+ const MappedTypeModifiersExcludeOptional

+ const MappedTypeModifiersExcludeReadonly

+ const MappedTypeModifiersIncludeOptional

+ const MappedTypeModifiersIncludeReadonly

+ type MappedTypeNameTypeKind int32

+ const MappedTypeNameTypeKindFiltering

+ const MappedTypeNameTypeKindNone

+ const MappedTypeNameTypeKindRemapping

+ type MarkedAssignmentSymbolLinks struct

+ type MembersAndExportsLinks [2]ast.SymbolTable

+ type MembersOrExportsResolutionKind int

+ const MembersOrExportsResolutionKindResolvedExports

+ const MembersOrExportsResolutionKindResolvedMembers

+ type MergedTypeMapper struct

+ func (m *MergedTypeMapper) Kind() TypeMapperKind

+ func (m *MergedTypeMapper) Map(t *Type) *Type

+ type MinArgumentCountFlags uint32

+ const MinArgumentCountFlagsNone

+ const MinArgumentCountFlagsStrongArityForUntypedJS

+ const MinArgumentCountFlagsVoidIsNonOptional

+ type ModuleSymbolLinks struct

+ type NarrowedTypeKey struct

+ type NodeBuilder struct

+ func NewNodeBuilder(ch *Checker, e *printer.EmitContext) *NodeBuilder

+ func NewNodeBuilderEx(ch *Checker, e *printer.EmitContext, ...) *NodeBuilder

+ func (b *NodeBuilder) EmitContext() *printer.EmitContext

+ func (b *NodeBuilder) IndexInfoToIndexSignatureDeclaration(info *IndexInfo, enclosingDeclaration *ast.Node, flags nodebuilder.Flags, ...) *ast.Node

+ func (b *NodeBuilder) SerializeReturnTypeForSignature(signatureDeclaration *ast.Node, enclosingDeclaration *ast.Node, ...) *ast.Node

+ func (b *NodeBuilder) SerializeTypeForDeclaration(declaration *ast.Node, symbol *ast.Symbol, enclosingDeclaration *ast.Node, ...) *ast.Node

+ func (b *NodeBuilder) SerializeTypeForExpression(expr *ast.Node, enclosingDeclaration *ast.Node, flags nodebuilder.Flags, ...) *ast.Node

+ func (b *NodeBuilder) SerializeTypeParametersForSignature(signatureDeclaration *ast.Node, enclosingDeclaration *ast.Node, ...) []*ast.Node

+ func (b *NodeBuilder) SignatureToSignatureDeclaration(signature *Signature, kind ast.Kind, enclosingDeclaration *ast.Node, ...) *ast.Node

+ func (b *NodeBuilder) SymbolTableToDeclarationStatements(symbolTable *ast.SymbolTable, enclosingDeclaration *ast.Node, ...) []*ast.Node

+ func (b *NodeBuilder) SymbolToEntityName(symbol *ast.Symbol, meaning ast.SymbolFlags, enclosingDeclaration *ast.Node, ...) *ast.Node

+ func (b *NodeBuilder) SymbolToExpression(symbol *ast.Symbol, meaning ast.SymbolFlags, enclosingDeclaration *ast.Node, ...) *ast.Node

+ func (b *NodeBuilder) SymbolToNode(symbol *ast.Symbol, meaning ast.SymbolFlags, enclosingDeclaration *ast.Node, ...) *ast.Node

+ func (b *NodeBuilder) SymbolToTypeParameterDeclarations(symbol *ast.Symbol, enclosingDeclaration *ast.Node, flags nodebuilder.Flags, ...) []*ast.Node

+ func (b *NodeBuilder) TypeParameterToDeclaration(parameter *Type, enclosingDeclaration *ast.Node, flags nodebuilder.Flags, ...) *ast.Node

+ func (b *NodeBuilder) TypePredicateToTypePredicateNode(predicate *TypePredicate, enclosingDeclaration *ast.Node, ...) *ast.Node

+ func (b *NodeBuilder) TypeToTypeNode(typ *Type, enclosingDeclaration *ast.Node, flags nodebuilder.Flags, ...) *ast.Node

+ func (b NodeBuilder) SymbolToParameterDeclaration(symbol *ast.Symbol, enclosingDeclaration *ast.Node, flags nodebuilder.Flags, ...) *ast.Node

+ type NodeBuilderContext struct

+ type NodeBuilderImpl struct

+ type NodeBuilderLinks struct

+ type NodeBuilderSymbolLinks struct

+ type NodeCheckFlags uint32

+ const NodeCheckFlagsAssignmentsMarked

+ const NodeCheckFlagsContextChecked

+ const NodeCheckFlagsEnumValuesComputed

+ const NodeCheckFlagsInCheckIdentifier

+ const NodeCheckFlagsInitializerIsUndefined

+ const NodeCheckFlagsInitializerIsUndefinedComputed

+ const NodeCheckFlagsNone

+ const NodeCheckFlagsTypeChecked

+ type NodeLinks struct

+ type NonExistentPropertyKey struct

+ type ObjectFlags uint32

+ type ObjectLiteralDiscriminator struct

+ type ObjectType struct

+ func (t *ObjectType) AsObjectType() *ObjectType

+ type ParseFlags uint32

+ const ParseFlagsAwait

+ const ParseFlagsIgnoreMissingOpenBrace

+ const ParseFlagsJSDoc

+ const ParseFlagsNone

+ const ParseFlagsType

+ const ParseFlagsYield

+ type PredicateSemantics uint32

+ const PredicateSemanticsAlways

+ const PredicateSemanticsNever

+ const PredicateSemanticsNone

+ const PredicateSemanticsSometimes

+ type Program interface

+ BindSourceFiles func()

+ CommonSourceDirectory func() string

+ FileExists func(fileName string) bool

+ GetEmitModuleFormatOfFile func(sourceFile ast.HasFileName) core.ModuleKind

+ GetEmitSyntaxForUsageLocation func(sourceFile ast.HasFileName, usageLocation *ast.StringLiteralLike) core.ResolutionMode

+ GetImpliedNodeFormatForEmit func(sourceFile ast.HasFileName) core.ModuleKind

+ GetImportHelpersImportSpecifier func(path tspath.Path) *ast.Node

+ GetJSXRuntimeImportSpecifier func(path tspath.Path) (moduleReference string, specifier *ast.Node)

+ GetPackagesMap func() map[string]bool

+ GetProjectReferenceFromOutputDts func(path tspath.Path) *tsoptions.SourceOutputAndProjectReference

+ GetRedirectForResolution func(file ast.HasFileName) *tsoptions.ParsedCommandLine

+ GetResolvedModule func(currentSourceFile ast.HasFileName, moduleReference string, ...) *module.ResolvedModule

+ GetResolvedModules func() map[tspath.Path]module.ModeAwareCache[*module.ResolvedModule]

+ GetSourceFile func(fileName string) *ast.SourceFile

+ GetSourceFileForResolvedModule func(fileName string) *ast.SourceFile

+ GetSourceFileMetaData func(path tspath.Path) ast.SourceFileMetaData

+ IsSourceFileDefaultLibrary func(path tspath.Path) bool

+ Options func() *core.CompilerOptions

+ SourceFileMayBeEmitted func(sourceFile *ast.SourceFile, forceDtsEmit bool) bool

+ SourceFiles func() []*ast.SourceFile

+ type PropertiesTypesKey struct

+ type RecursionFlags uint32

+ const RecursionFlagsBoth

+ const RecursionFlagsNone

+ const RecursionFlagsSource

+ const RecursionFlagsTarget

+ type RecursionId struct

+ type ReferenceHint int32

+ const ReferenceHintDecorator

+ const ReferenceHintExportAssignment

+ const ReferenceHintExportImportEquals

+ const ReferenceHintExportSpecifier

+ const ReferenceHintIdentifier

+ const ReferenceHintJsx

+ const ReferenceHintProperty

+ const ReferenceHintUnspecified

+ type Relater struct

+ type Relation struct

+ type RelationComparisonResult uint32

+ const RelationComparisonResultComplexityOverflow

+ const RelationComparisonResultFailed

+ const RelationComparisonResultNone

+ const RelationComparisonResultOverflow

+ const RelationComparisonResultReportsMask

+ const RelationComparisonResultReportsUnmeasurable

+ const RelationComparisonResultReportsUnreliable

+ const RelationComparisonResultStackDepthOverflow

+ const RelationComparisonResultSucceeded

+ type ReverseMappedSymbolLinks struct

+ type ReverseMappedType struct

+ type ReverseMappedTypeKey struct

+ type SerializedTypeEntry struct

+ type SharedFlow struct

+ type Signature struct

+ func (s *Signature) Declaration() *ast.Node

+ func (s *Signature) Flags() SignatureFlags

+ func (s *Signature) HasRestParameter() bool

+ func (s *Signature) Parameters() []*ast.Symbol

+ func (s *Signature) Target() *Signature

+ func (s *Signature) ThisParameter() *ast.Symbol

+ func (s *Signature) TypeParameters() []*Type

+ type SignatureCheckMode uint32

+ const SignatureCheckModeBivariantCallback

+ const SignatureCheckModeCallback

+ const SignatureCheckModeIgnoreReturnTypes

+ const SignatureCheckModeNone

+ const SignatureCheckModeStrictArity

+ const SignatureCheckModeStrictCallback

+ const SignatureCheckModeStrictTopSignature

+ type SignatureFlags uint32

+ const SignatureFlagsAbstract

+ const SignatureFlagsCallChainFlags

+ const SignatureFlagsConstruct

+ const SignatureFlagsHasLiteralTypes

+ const SignatureFlagsHasRestParameter

+ const SignatureFlagsIsInnerCallChain

+ const SignatureFlagsIsNonInferrable

+ const SignatureFlagsIsOuterCallChain

+ const SignatureFlagsIsSignatureCandidateForOverloadFailure

+ const SignatureFlagsIsUntypedSignatureInJSFile

+ const SignatureFlagsNone

+ const SignatureFlagsPropagatingFlags

+ type SignatureKind int32

+ const SignatureKindCall

+ const SignatureKindConstruct

+ func (i SignatureKind) String() string

+ type SignatureLinks struct

+ type SignatureToSignatureDeclarationOptions struct

+ type SimpleTypeMapper struct

+ func (m *SimpleTypeMapper) Kind() TypeMapperKind

+ func (m *SimpleTypeMapper) Map(t *Type) *Type

+ type SourceFileLinks struct

+ type SpreadLinks struct

+ type StringLiteralType = Type

+ type StringMappingKey struct

+ type StringMappingType struct

+ func (t *StringMappingType) Target() *Type

+ type StructuredType struct

+ func (t *StructuredType) AsStructuredType() *StructuredType

+ func (t *StructuredType) CallSignatures() []*Signature

+ func (t *StructuredType) ConstructSignatures() []*Signature

+ func (t *StructuredType) Properties() []*ast.Symbol

+ type SubstitutionType struct

+ func (t *SubstitutionType) BaseType() *Type

+ func (t *SubstitutionType) SubstConstraint() *Type

+ type SubstitutionTypeKey struct

+ type SwitchStatementLinks struct

+ type SymbolFormatFlags uint32

+ const SymbolFormatFlagsAllowAnyNodeKind

+ const SymbolFormatFlagsDoNotIncludeSymbolChain

+ const SymbolFormatFlagsNone

+ const SymbolFormatFlagsUseAliasDefinedOutsideCurrentScope

+ const SymbolFormatFlagsUseOnlyExternalAliasing

+ const SymbolFormatFlagsWriteComputedProps

+ const SymbolFormatFlagsWriteTypeParametersOrArguments

+ type SymbolNodeLinks struct

+ type SymbolReferenceLinks struct

+ type SymbolTrackerImpl struct

+ DisableTrackSymbol bool

+ func NewSymbolTrackerImpl(context *NodeBuilderContext, tracker nodebuilder.SymbolTracker) *SymbolTrackerImpl

+ func (this *SymbolTrackerImpl) PopErrorFallbackNode()

+ func (this *SymbolTrackerImpl) PushErrorFallbackNode(node *ast.Node)

+ func (this *SymbolTrackerImpl) ReportCyclicStructureError()

+ func (this *SymbolTrackerImpl) ReportInaccessibleThisError()

+ func (this *SymbolTrackerImpl) ReportInaccessibleUniqueSymbolError()

+ func (this *SymbolTrackerImpl) ReportInferenceFallback(node *ast.Node)

+ func (this *SymbolTrackerImpl) ReportLikelyUnsafeImportRequiredError(specifier string, symbolName string)

+ func (this *SymbolTrackerImpl) ReportNonSerializableProperty(propertyName string)

+ func (this *SymbolTrackerImpl) ReportNonlocalAugmentation(containingFile *ast.SourceFile, parentSymbol *ast.Symbol, ...)

+ func (this *SymbolTrackerImpl) ReportPrivateInBaseOfClassExpression(propertyName string)

+ func (this *SymbolTrackerImpl) ReportTruncationError()

+ func (this *SymbolTrackerImpl) TrackSymbol(symbol *ast.Symbol, enclosingDeclaration *ast.Node, meaning ast.SymbolFlags) bool

+ type TemplateLiteralType struct

+ func (t *TemplateLiteralType) Texts() []string

+ func (t *TemplateLiteralType) Types() []*Type

+ type Ternary int8

+ const TernaryFalse

+ const TernaryMaybe

+ const TernaryTrue

+ const TernaryUnknown

+ type TrackedSymbolArgs struct

+ type TupleElementInfo struct

+ func (t *TupleElementInfo) LabeledDeclaration() *ast.Node

+ func (t *TupleElementInfo) TupleElementFlags() ElementFlags

+ type TupleNormalizer struct

+ type TupleType struct

+ func (t *TupleType) ElementFlags() []ElementFlags

+ func (t *TupleType) ElementInfos() []TupleElementInfo

+ func (t *TupleType) FixedLength() int

+ func (t *TupleType) IsReadonly() bool

+ type Type struct

+ func (t *Type) AsConditionalType() *ConditionalType

+ func (t *Type) AsConstrainedType() *ConstrainedType

+ func (t *Type) AsEvolvingArrayType() *EvolvingArrayType

+ func (t *Type) AsIndexType() *IndexType

+ func (t *Type) AsIndexedAccessType() *IndexedAccessType

+ func (t *Type) AsInstantiationExpressionType() *InstantiationExpressionType

+ func (t *Type) AsInterfaceType() *InterfaceType

+ func (t *Type) AsIntersectionType() *IntersectionType

+ func (t *Type) AsIntrinsicType() *IntrinsicType

+ func (t *Type) AsLiteralType() *LiteralType

+ func (t *Type) AsMappedType() *MappedType

+ func (t *Type) AsObjectType() *ObjectType

+ func (t *Type) AsReverseMappedType() *ReverseMappedType

+ func (t *Type) AsStringMappingType() *StringMappingType

+ func (t *Type) AsStructuredType() *StructuredType

+ func (t *Type) AsSubstitutionType() *SubstitutionType

+ func (t *Type) AsTemplateLiteralType() *TemplateLiteralType

+ func (t *Type) AsTupleType() *TupleType

+ func (t *Type) AsTypeParameter() *TypeParameter

+ func (t *Type) AsTypeReference() *TypeReference

+ func (t *Type) AsUnionOrIntersectionType() *UnionOrIntersectionType

+ func (t *Type) AsUnionType() *UnionType

+ func (t *Type) AsUniqueESSymbolType() *UniqueESSymbolType

+ func (t *Type) Distributed() []*Type

+ func (t *Type) Flags() TypeFlags

+ func (t *Type) Id() TypeId

+ func (t *Type) IsBigIntLiteral() bool

+ func (t *Type) IsBooleanLike() bool

+ func (t *Type) IsClass() bool

+ func (t *Type) IsEnumLiteral() bool

+ func (t *Type) IsIndex() bool

+ func (t *Type) IsIntersection() bool

+ func (t *Type) IsNumberLiteral() bool

+ func (t *Type) IsString() bool

+ func (t *Type) IsStringLike() bool

+ func (t *Type) IsStringLiteral() bool

+ func (t *Type) IsTupleType() bool

+ func (t *Type) IsTypeParameter() bool

+ func (t *Type) IsUnion() bool

+ func (t *Type) Mapper() *TypeMapper

+ func (t *Type) ObjectFlags() ObjectFlags

+ func (t *Type) Symbol() *ast.Symbol

+ func (t *Type) Target() *Type

+ func (t *Type) TargetInterfaceType() *InterfaceType

+ func (t *Type) TargetTupleType() *TupleType

+ func (t *Type) Types() []*Type

+ type TypeAlias struct

+ func (a *TypeAlias) Symbol() *ast.Symbol

+ func (a *TypeAlias) TypeArguments() []*Type

+ func (t *TypeAlias) ToTypeReferenceNode(b *NodeBuilderImpl) *ast.Node

+ type TypeAliasLinks struct

+ type TypeBase struct

+ func (t *TypeBase) AsConstrainedType() *ConstrainedType

+ func (t *TypeBase) AsInterfaceType() *InterfaceType

+ func (t *TypeBase) AsObjectType() *ObjectType

+ func (t *TypeBase) AsStructuredType() *StructuredType

+ func (t *TypeBase) AsType() *Type

+ func (t *TypeBase) AsTypeReference() *TypeReference

+ func (t *TypeBase) AsUnionOrIntersectionType() *UnionOrIntersectionType

+ type TypeComparer func(s *Type, t *Type, reportErrors bool) Ternary

+ type TypeData interface

+ AsConstrainedType func() *ConstrainedType

+ AsInterfaceType func() *InterfaceType

+ AsObjectType func() *ObjectType

+ AsStructuredType func() *StructuredType

+ AsType func() *Type

+ AsTypeReference func() *TypeReference

+ AsUnionOrIntersectionType func() *UnionOrIntersectionType

+ type TypeDiscriminator struct

+ type TypeFacts uint32

+ const TypeFactsAll

+ const TypeFactsAllTypeofNE

+ const TypeFactsAndFactsMask

+ const TypeFactsBaseBigIntFacts

+ const TypeFactsBaseBigIntStrictFacts

+ const TypeFactsBaseBooleanFacts

+ const TypeFactsBaseBooleanStrictFacts

+ const TypeFactsBaseNumberFacts

+ const TypeFactsBaseNumberStrictFacts

+ const TypeFactsBaseStringFacts

+ const TypeFactsBaseStringStrictFacts

+ const TypeFactsBigIntFacts

+ const TypeFactsBigIntStrictFacts

+ const TypeFactsBooleanFacts

+ const TypeFactsBooleanStrictFacts

+ const TypeFactsEQNull

+ const TypeFactsEQUndefined

+ const TypeFactsEQUndefinedOrNull

+ const TypeFactsEmptyObjectFacts

+ const TypeFactsEmptyObjectStrictFacts

+ const TypeFactsEmptyStringFacts

+ const TypeFactsEmptyStringStrictFacts

+ const TypeFactsFalseFacts

+ const TypeFactsFalseStrictFacts

+ const TypeFactsFalsy

+ const TypeFactsFunctionFacts

+ const TypeFactsFunctionStrictFacts

+ const TypeFactsIsNull

+ const TypeFactsIsUndefined

+ const TypeFactsIsUndefinedOrNull

+ const TypeFactsNENull

+ const TypeFactsNEUndefined

+ const TypeFactsNEUndefinedOrNull

+ const TypeFactsNonEmptyStringFacts

+ const TypeFactsNonEmptyStringStrictFacts

+ const TypeFactsNonZeroBigIntFacts

+ const TypeFactsNonZeroBigIntStrictFacts

+ const TypeFactsNonZeroNumberFacts

+ const TypeFactsNonZeroNumberStrictFacts

+ const TypeFactsNone

+ const TypeFactsNullFacts

+ const TypeFactsNumberFacts

+ const TypeFactsNumberStrictFacts

+ const TypeFactsObjectFacts

+ const TypeFactsObjectStrictFacts

+ const TypeFactsOrFactsMask

+ const TypeFactsStringFacts

+ const TypeFactsStringStrictFacts

+ const TypeFactsSymbolFacts

+ const TypeFactsSymbolStrictFacts

+ const TypeFactsTrueFacts

+ const TypeFactsTrueStrictFacts

+ const TypeFactsTruthy

+ const TypeFactsTypeofEQBigInt

+ const TypeFactsTypeofEQBoolean

+ const TypeFactsTypeofEQFunction

+ const TypeFactsTypeofEQHostObject

+ const TypeFactsTypeofEQNumber

+ const TypeFactsTypeofEQObject

+ const TypeFactsTypeofEQString

+ const TypeFactsTypeofEQSymbol

+ const TypeFactsTypeofNEBigInt

+ const TypeFactsTypeofNEBoolean

+ const TypeFactsTypeofNEFunction

+ const TypeFactsTypeofNEHostObject

+ const TypeFactsTypeofNENumber

+ const TypeFactsTypeofNEObject

+ const TypeFactsTypeofNEString

+ const TypeFactsTypeofNESymbol

+ const TypeFactsUndefinedFacts

+ const TypeFactsUnknownFacts

+ const TypeFactsVoidFacts

+ const TypeFactsZeroBigIntFacts

+ const TypeFactsZeroBigIntStrictFacts

+ const TypeFactsZeroNumberFacts

+ const TypeFactsZeroNumberStrictFacts

+ type TypeFlags uint32

+ type TypeFormatFlags uint32

+ const TypeFormatFlagsAddUndefined

+ const TypeFormatFlagsAllowUniqueESSymbolType

+ const TypeFormatFlagsGenerateNamesForShadowedTypeParams

+ const TypeFormatFlagsInArrayType

+ const TypeFormatFlagsInElementType

+ const TypeFormatFlagsInFirstTypeArgument

+ const TypeFormatFlagsInTypeAlias

+ const TypeFormatFlagsMultilineObjectLiterals

+ const TypeFormatFlagsNoTruncation

+ const TypeFormatFlagsNoTypeReduction

+ const TypeFormatFlagsNone

+ const TypeFormatFlagsOmitParameterModifiers

+ const TypeFormatFlagsOmitThisParameter

+ const TypeFormatFlagsSuppressAnyReturnType

+ const TypeFormatFlagsUseAliasDefinedOutsideCurrentScope

+ const TypeFormatFlagsUseFullyQualifiedType

+ const TypeFormatFlagsUseSingleQuotesForStringLiteralType

+ const TypeFormatFlagsUseStructuralFallback

+ const TypeFormatFlagsUseTypeOfFunction

+ const TypeFormatFlagsWriteArrayAsGenericType

+ const TypeFormatFlagsWriteArrowStyleSignature

+ const TypeFormatFlagsWriteCallStyleSignature

+ const TypeFormatFlagsWriteClassExpressionAsTypeLiteral

+ const TypeFormatFlagsWriteTypeArgumentsOfSignature

+ type TypeId uint32

+ type TypeMapper struct

+ func (m *TypeMapper) Kind() TypeMapperKind

+ func (m *TypeMapper) Map(t *Type) *Type

+ type TypeMapperBase struct

+ func (m *TypeMapperBase) Kind() TypeMapperKind

+ func (m *TypeMapperBase) Map(t *Type) *Type

+ type TypeMapperData interface

+ Kind func() TypeMapperKind

+ Map func(t *Type) *Type

+ type TypeMapperKind int32

+ const TypeMapperKindArray

+ const TypeMapperKindMerged

+ const TypeMapperKindSimple

+ const TypeMapperKindUnknown

+ type TypeNodeLinks struct

+ type TypeParameter struct

+ func (t *TypeParameter) IsThisType() bool

+ type TypePredicate struct

+ func (typePredicate *TypePredicate) Kind() TypePredicateKind

+ func (typePredicate *TypePredicate) ParameterIndex() int32

+ func (typePredicate *TypePredicate) ParameterName() string

+ func (typePredicate *TypePredicate) Type() *Type

+ type TypePredicateKind int32

+ const TypePredicateKindAssertsIdentifier

+ const TypePredicateKindAssertsThis

+ const TypePredicateKindIdentifier

+ const TypePredicateKindThis

+ type TypeReference struct

+ func (t *TypeReference) AsTypeReference() *TypeReference

+ type TypeResolution struct

+ type TypeSystemEntity any

+ type TypeSystemPropertyName int32

+ const TypeSystemPropertyNameAliasTarget

+ const TypeSystemPropertyNameDeclaredType

+ const TypeSystemPropertyNameInitializerIsUndefined

+ const TypeSystemPropertyNameResolvedBaseConstraint

+ const TypeSystemPropertyNameResolvedBaseConstructorType

+ const TypeSystemPropertyNameResolvedBaseTypes

+ const TypeSystemPropertyNameResolvedReturnType

+ const TypeSystemPropertyNameResolvedTypeArguments

+ const TypeSystemPropertyNameType

+ const TypeSystemPropertyNameWriteType

+ type UnionOfUnionKey struct

+ type UnionOrIntersectionType struct

+ func (t *UnionOrIntersectionType) AsUnionOrIntersectionType() *UnionOrIntersectionType

+ func (t *UnionOrIntersectionType) Types() []*Type

+ type UnionReduction int32

+ const UnionReductionLiteral

+ const UnionReductionNone

+ const UnionReductionSubtype

+ type UnionType struct

+ type UniqueESSymbolType struct

+ type UnusedKind int32

+ const UnusedKindLocal

+ const UnusedKindParameter

+ type ValueSymbolLinks struct

+ type VarianceFlags uint32

+ const VarianceFlagsAllowsStructuralFallback

+ const VarianceFlagsBivariant

+ const VarianceFlagsContravariant

+ const VarianceFlagsCovariant

+ const VarianceFlagsIndependent

+ const VarianceFlagsInvariant

+ const VarianceFlagsUnmeasurable

+ const VarianceFlagsUnreliable

+ const VarianceFlagsVarianceMask

+ type VarianceLinks struct

+ type WideningContext struct

+ type WideningKind int32

+ const WideningKindFunctionReturn

+ const WideningKindGeneratorNext

+ const WideningKindGeneratorYield

+ const WideningKindNormal

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL