Total ordering of types

internal/ast/ast.go

@@ -5654,14 +5654,14 @@ type SourceFile struct {
 	IsDeclarationFile           bool
 	IsBound                     bool
 	ModuleReferencesProcessed   bool
+	HasNoDefaultLib             bool
 	UsesUriStyleNodeCoreModules core.Tristate
 	SymbolCount                 int
 	ClassifiableNames           core.Set[string]
 	Imports                     []*LiteralLikeNode // []LiteralLikeNode
 	ModuleAugmentations         []*ModuleName      // []ModuleName
 	PatternAmbientModules       []PatternAmbientModule
 	AmbientModuleNames          []string
-	HasNoDefaultLib             bool
 	jsdocCache                  map[*Node][]*Node
 	Pragmas                     []Pragma
 	ReferencedFiles             []*FileReference

internal/ast/utilities.go

@@ -821,15 +821,13 @@ func WalkUpParenthesizedTypes(node *TypeNode) *Node {
 
 // Walks up the parents of a node to find the containing SourceFile
 func GetSourceFileOfNode(node *Node) *SourceFile {
-	for {
-		if node == nil {
-			return nil
-		}
-		if node.Kind == KindSourceFile {
-			return node.AsSourceFile()
-		}
+	for node.Parent != nil {
 		node = node.Parent
 	}
+	if node.Kind == KindSourceFile {
+		return node.AsSourceFile()
+	}
+	return nil
 }
 
 // Walks up the parents of a node to find the ancestor that matches the callback

internal/compiler/checker.go

@@ -816,7 +816,7 @@ func NewChecker(program *Program) *Checker {
 	c.emptyStringType = c.getStringLiteralType("")
 	c.zeroType = c.getNumberLiteralType(0)
 	c.zeroBigIntType = c.getBigIntLiteralType(PseudoBigInt{negative: false, base10Value: "0"})
-	c.typeofType = c.getUnionType(core.Map(slices.Collect(maps.Keys(typeofNEFacts)), c.getStringLiteralType))
+	c.typeofType = c.getUnionType(core.Map(slices.Sorted(maps.Keys(typeofNEFacts)), c.getStringLiteralType))
 	c.flowLoopCache = make(map[FlowLoopKey]*Type)
 	c.flowNodeReachable = make(map[*ast.FlowNode]bool)
 	c.flowNodePostSuper = make(map[*ast.FlowNode]bool)
@@ -18214,14 +18214,7 @@ func (c *Checker) addTypeToUnion(typeSet []*Type, includes TypeFlags, t *Type) (
 				includes |= TypeFlagsIncludesNonWideningType
 			}
 		} else {
-			var index int
-			var ok bool
-			if len(typeSet) != 0 && t.id > typeSet[len(typeSet)-1].id {
-				index = len(typeSet)
-			} else {
-				index, ok = slices.BinarySearchFunc(typeSet, t, compareTypeIds)
-			}
-			if !ok {
+			if index, ok := slices.BinarySearchFunc(typeSet, t, compareTypes); !ok {
 				typeSet = slices.Insert(typeSet, index, t)
 			}
 		}
@@ -18963,12 +18956,12 @@ func (c *Checker) removeType(t *Type, targetType *Type) *Type {
 }
 
 func containsType(types []*Type, t *Type) bool {
-	_, ok := slices.BinarySearchFunc(types, t, compareTypeIds)
+	_, ok := slices.BinarySearchFunc(types, t, compareTypes)
 	return ok
 }
 
 func insertType(types []*Type, t *Type) ([]*Type, bool) {
-	if i, ok := slices.BinarySearchFunc(types, t, compareTypeIds); !ok {
+	if i, ok := slices.BinarySearchFunc(types, t, compareTypes); !ok {
 		return slices.Insert(types, i, t), true
 	}
 	return types, false

internal/compiler/mapper.go

@@ -2,18 +2,31 @@ package compiler
 
 import "github.com/microsoft/typescript-go/internal/core"
 
+// TypeMapperKind
+
+type TypeMapperKind int32
+
+const (
+	TypeMapperKindUnknown TypeMapperKind = iota
+	TypeMapperKindSimple
+	TypeMapperKindArray
+	TypeMapperKindMerged
+)
+
 // TypeMapper
 
 type TypeMapper struct {
 	data TypeMapperData
 }
 
-func (m *TypeMapper) Map(t *Type) *Type { return m.data.Map(t) }
+func (m *TypeMapper) Map(t *Type) *Type    { return m.data.Map(t) }
+func (m *TypeMapper) Kind() TypeMapperKind { return m.data.Kind() }
 
 // TypeMapperData
 
 type TypeMapperData interface {
 	Map(t *Type) *Type
+	Kind() TypeMapperKind
 }
 
 // Factory functions
@@ -70,10 +83,19 @@ func (c *Checker) newBackreferenceMapper(context *InferenceContext, index int) *
 	return newArrayToSingleTypeMapper(typeParameters, c.unknownType)
 }
 
+// TypeMapperBase
+
+type TypeMapperBase struct {
+	TypeMapper
+}
+
+func (m *TypeMapperBase) Map(t *Type) *Type    { return t }
+func (m *TypeMapperBase) Kind() TypeMapperKind { return TypeMapperKindUnknown }
+
 // SimpleTypeMapper
 
 type SimpleTypeMapper struct {
-	TypeMapper
+	TypeMapperBase
 	source *Type
 	target *Type
 }
@@ -93,10 +115,14 @@ func (m *SimpleTypeMapper) Map(t *Type) *Type {
 	return t
 }
 
+func (m *SimpleTypeMapper) Kind() TypeMapperKind {
+	return TypeMapperKindSimple
+}
+
 // ArrayTypeMapper
 
 type ArrayTypeMapper struct {
-	TypeMapper
+	TypeMapperBase
 	sources []*Type
 	targets []*Type
 }
@@ -118,10 +144,14 @@ func (m *ArrayTypeMapper) Map(t *Type) *Type {
 	return t
 }
 
+func (m *ArrayTypeMapper) Kind() TypeMapperKind {
+	return TypeMapperKindArray
+}
+
 // ArrayToSingleTypeMapper
 
 type ArrayToSingleTypeMapper struct {
-	TypeMapper
+	TypeMapperBase
 	sources []*Type
 	target  *Type
 }
@@ -146,7 +176,7 @@ func (m *ArrayToSingleTypeMapper) Map(t *Type) *Type {
 // DeferredTypeMapper
 
 type DeferredTypeMapper struct {
-	TypeMapper
+	TypeMapperBase
 	sources []*Type
 	targets []func() *Type
 }
@@ -171,7 +201,7 @@ func (m *DeferredTypeMapper) Map(t *Type) *Type {
 // FunctionTypeMapper
 
 type FunctionTypeMapper struct {
-	TypeMapper
+	TypeMapperBase
 	fn func(*Type) *Type
 }
 
@@ -189,7 +219,7 @@ func (m *FunctionTypeMapper) Map(t *Type) *Type {
 // MergedTypeMapper
 
 type MergedTypeMapper struct {
-	TypeMapper
+	TypeMapperBase
 	m1 *TypeMapper
 	m2 *TypeMapper
 }
@@ -206,10 +236,14 @@ func (m *MergedTypeMapper) Map(t *Type) *Type {
 	return m.m2.Map(m.m1.Map(t))
 }
 
+func (m *MergedTypeMapper) Kind() TypeMapperKind {
+	return TypeMapperKindMerged
+}
+
 // CompositeTypeMapper
 
 type CompositeTypeMapper struct {
-	TypeMapper
+	TypeMapperBase
 	c  *Checker
 	m1 *TypeMapper
 	m2 *TypeMapper
@@ -235,7 +269,7 @@ func (m *CompositeTypeMapper) Map(t *Type) *Type {
 // InferenceTypeMapper
 
 type InferenceTypeMapper struct {
-	TypeMapper
+	TypeMapperBase
 	c      *Checker
 	n      *InferenceContext
 	fixing bool

internal/compiler/printer.go

@@ -112,6 +112,7 @@ func (p *Printer) printType(t *Type) {
 }
 
 func (p *Printer) printTypeNoAlias(t *Type) {
+	p.depth++
 	switch {
 	case t.flags&TypeFlagsIntrinsic != 0:
 		p.print(t.AsIntrinsicType().intrinsicName)
@@ -136,14 +137,13 @@ func (p *Printer) printTypeNoAlias(t *Type) {
 	case t.flags&TypeFlagsStringMapping != 0:
 		p.printStringMappingType(t)
 	}
+	p.depth--
 }
 
 func (p *Printer) printRecursive(t *Type, f func(*Printer, *Type)) {
 	if !p.printing.Has(t) && p.depth < 10 {
 		p.printing.Add(t)
-		p.depth++
 		f(p, t)
-		p.depth--
 		p.printing.Delete(t)
 	} else {
 		p.print("???")
@@ -280,22 +280,37 @@ func (p *Printer) printTupleType(t *Type) {
 	tail := false
 	p.print("[")
 	elementInfos := t.TargetTupleType().elementInfos
-	for i, t := range p.c.getTypeArguments(t) {
+	typeArguments := p.c.getTypeArguments(t)
+	for i, info := range elementInfos {
+		t := typeArguments[i]
 		if tail {
 			p.print(", ")
 		}
-		info := elementInfos[i]
 		if info.flags&ElementFlagsVariable != 0 {
 			p.print("...")
 		}
-		if info.flags&ElementFlagsOptional != 0 {
-			p.printTypeEx(t, ast.TypePrecedencePostfix)
-			p.print("?")
-		} else if info.flags&ElementFlagsRest != 0 {
-			p.printTypeEx(t, ast.TypePrecedencePostfix)
-			p.print("[]")
+		if info.labeledDeclaration != nil {
+			p.print(info.labeledDeclaration.Name().Text())
+			if info.flags&ElementFlagsOptional != 0 {
+				p.print("?")
+			}
+			p.print(": ")
+			if info.flags&ElementFlagsRest != 0 {
+				p.printTypeEx(t, ast.TypePrecedencePostfix)
+				p.print("[]")
+			} else {
+				p.printType(t)
+			}
 		} else {
-			p.printType(t)
+			if info.flags&ElementFlagsOptional != 0 {
+				p.printTypeEx(t, ast.TypePrecedencePostfix)
+				p.print("?")
+			} else if info.flags&ElementFlagsRest != 0 {
+				p.printTypeEx(t, ast.TypePrecedencePostfix)
+				p.print("[]")
+			} else {
+				p.printType(t)
+			}
 		}
 		tail = true
 	}

internal/compiler/types.go

@@ -375,21 +375,21 @@ const (
 	TypeFlagsNone            TypeFlags = 0
 	TypeFlagsAny             TypeFlags = 1 << 0
 	TypeFlagsUnknown         TypeFlags = 1 << 1
-	TypeFlagsString          TypeFlags = 1 << 2
-	TypeFlagsNumber          TypeFlags = 1 << 3
-	TypeFlagsBoolean         TypeFlags = 1 << 4
-	TypeFlagsEnum            TypeFlags = 1 << 5 // Numeric computed enum member value
-	TypeFlagsBigInt          TypeFlags = 1 << 6
-	TypeFlagsStringLiteral   TypeFlags = 1 << 7
-	TypeFlagsNumberLiteral   TypeFlags = 1 << 8
-	TypeFlagsBooleanLiteral  TypeFlags = 1 << 9
-	TypeFlagsEnumLiteral     TypeFlags = 1 << 10 // Always combined with StringLiteral, NumberLiteral, or Union
-	TypeFlagsBigIntLiteral   TypeFlags = 1 << 11
-	TypeFlagsESSymbol        TypeFlags = 1 << 12 // Type of symbol primitive introduced in ES6
-	TypeFlagsUniqueESSymbol  TypeFlags = 1 << 13 // unique symbol
-	TypeFlagsVoid            TypeFlags = 1 << 14
-	TypeFlagsUndefined       TypeFlags = 1 << 15
-	TypeFlagsNull            TypeFlags = 1 << 16
+	TypeFlagsUndefined       TypeFlags = 1 << 2
+	TypeFlagsNull            TypeFlags = 1 << 3
+	TypeFlagsVoid            TypeFlags = 1 << 4
+	TypeFlagsString          TypeFlags = 1 << 5
+	TypeFlagsNumber          TypeFlags = 1 << 6
+	TypeFlagsBigInt          TypeFlags = 1 << 7
+	TypeFlagsBoolean         TypeFlags = 1 << 8
+	TypeFlagsESSymbol        TypeFlags = 1 << 9 // Type of symbol primitive introduced in ES6
+	TypeFlagsStringLiteral   TypeFlags = 1 << 10
+	TypeFlagsNumberLiteral   TypeFlags = 1 << 11
+	TypeFlagsBigIntLiteral   TypeFlags = 1 << 12
+	TypeFlagsBooleanLiteral  TypeFlags = 1 << 13
+	TypeFlagsUniqueESSymbol  TypeFlags = 1 << 14 // unique symbol
+	TypeFlagsEnumLiteral     TypeFlags = 1 << 15 // Always combined with StringLiteral, NumberLiteral, or Union
+	TypeFlagsEnum            TypeFlags = 1 << 16 // Numeric computed enum member value (must be right after EnumLiteral, see getSortOrderFlags)
 	TypeFlagsNever           TypeFlags = 1 << 17 // Never type
 	TypeFlagsTypeParameter   TypeFlags = 1 << 18 // Type parameter
 	TypeFlagsObject          TypeFlags = 1 << 19 // Object type
@@ -488,7 +488,7 @@ const (
 	ObjectFlagsPropagatingFlags   = ObjectFlagsContainsWideningType | ObjectFlagsContainsObjectOrArrayLiteral | ObjectFlagsNonInferrableType
 	ObjectFlagsInstantiatedMapped = ObjectFlagsMapped | ObjectFlagsInstantiated
 	// Object flags that uniquely identify the kind of ObjectType
-	ObjectFlagsObjectTypeKindMask = ObjectFlagsClassOrInterface | ObjectFlagsReference | ObjectFlagsTuple | ObjectFlagsAnonymous | ObjectFlagsMapped | ObjectFlagsReverseMapped | ObjectFlagsEvolvingArray
+	ObjectFlagsObjectTypeKindMask = ObjectFlagsClassOrInterface | ObjectFlagsReference | ObjectFlagsTuple | ObjectFlagsAnonymous | ObjectFlagsMapped | ObjectFlagsReverseMapped | ObjectFlagsEvolvingArray | ObjectFlagsInstantiationExpressionType | ObjectFlagsSingleSignatureType
 	// Flags that require TypeFlags.Object
 	ObjectFlagsContainsSpread              = 1 << 22 // Object literal contains spread operation
 	ObjectFlagsObjectRestType              = 1 << 23 // Originates in object rest declaration
@@ -719,17 +719,42 @@ func (t *StructuredType) ConstructSignatures() []*Signature {
 	return slices.Clip(t.signatures[t.callSignatureCount:])
 }
 
-// ObjectType (base of all instantiable object types)
-// Instances of ObjectType or derived types have the following ObjectFlags:
-// ObjectType (ObjectFlagsAnonymous)
-//   TypeReference (ObjectFlagsReference)
-//     InterfaceType (ObjectFlagsReference | (ObjectFlagsClass|ObjectFlagsInterface))
-//       TupleType (ObjectFlagsReference | ObjectFlagsTuple)
-//   SingleSignatureType (ObjectFlagsAnonymous|ObjectFlagsSingleSignatureType)
-//   InstantiationExpressionType (ObjectFlagsAnonymous|ObjectFlagsInstantiationExpressionType)
-//   MappedType (ObjectFlagsAnonymous|ObjectFlagsMapped)
-//   ReverseMapped (ObjectFlagsReverseMapped)
-//   EvolvingArray (ObjectFlagsEvolvingArray)
+// Except for tuple type references and reverse mapped types, all object types have an associated symbol.
+// Possible object type instances are listed in the following.
+
+// InterfaceType:
+// ObjectFlagsClass: Originating non-generic class type
+// ObjectFlagsClass|ObjectFlagsReference: Originating generic class type
+// ObjectFlagsInterface: Originating non-generic interface type
+// ObjectFlagsInterface|ObjectFlagsReference: Originating generic interface type
+
+// TupleType:
+// ObjectFlagsReference|ObjectFlagsTuple: Originating generic tuple type (synthesized)
+
+// TypeReference
+// ObjectFlagsReference: Instantiated generic class, interface, or tuple type
+
+// ObjectType:
+// ObjectFlagsAnonymous: Originating anonymous object type
+// ObjectFlagsAnonymous|ObjectFlagsInstantiated: Instantiated anonymous object type
+
+// MappedType:
+// ObjectFlagsMapped: Originating mapped type
+// ObjectFlagsMapped|ObjectFlagsInstantiated: Instantiated mapped type
+
+// InstantiationExpressionType:
+// ObjectFlagsAnonymous|ObjectFlagsInstantiationExpression: Originating instantiation expression type
+// ObjectFlagsAnonymous|ObjectFlagsInstantiated|ObjectFlagsInstantiationExpression: Instantiated instantiation expression type
+
+// SingleSignatureType:
+// ObjectFlagsAnonymous|ObjectFlagsSingleSignatureType: Originating single signature type
+// ObjectFlagsAnonymous|ObjectFlagsInstantiated|ObjectFlagsSingleSignatureType: Instantiated single signature type
+
+// ReverseMappedType:
+// ObjectFlagsAnonymous|ObjectFlagsReverseMapped: Reverse mapped type
+
+// EvolvingArrayType:
+// ObjectFlagsEvolvingArray: Evolving array type
 
 type ObjectType struct {
 	StructuredType
@@ -873,7 +898,6 @@ type UnionOrIntersectionType struct {
 	propertyCache                               ast.SymbolTable
 	propertyCacheWithoutFunctionPropertyAugment ast.SymbolTable
 	resolvedProperties                          []*ast.Symbol
-	resolvedBaseConstraint                      *Type
 }
 
 func (t *UnionOrIntersectionType) AsUnionOrIntersectionType() *UnionOrIntersectionType { return t }