Validate member table pairs before indexing by name

The name index and the instantiated fast path both assumed a table
whose properties are found under their own names has no other keys.
A symbol stored under its own name and an alias satisfies every
reverse lookup, so the alias was silently dropped. Checking each
(key, symbol) pair directly keeps such tables on the map path.

Author: jakebailey

tsc/internal/checker/checker.go

@@ -19567,18 +19567,13 @@ func (c *Checker) resolveObjectTypeMembers(t *Type, source *Type, typeParameters
 	} else {
 		instantiated = true
 		mapper = newTypeMapper(typeParameters, typeArguments)
-		properties = c.getNamedMembers(resolved.declaredMembers, t.symbol)
-		for _, symbol := range properties {
-			if resolved.declaredMembers[symbol.Name()] != symbol {
-				members = c.instantiateSymbolTable(resolved.declaredMembers, mapper)
-				properties = nil
-				break
-			}
-		}
-		if members == nil {
+		if symbolTableKeysMatchNames(resolved.declaredMembers) {
+			properties = c.getNamedMembers(resolved.declaredMembers, t.symbol)
 			for i, symbol := range properties {
 				properties[i] = c.instantiateSymbol(symbol, mapper)
 			}
+		} else {
+			members = c.instantiateSymbolTable(resolved.declaredMembers, mapper)
 		}
 		callSignatures = c.instantiateSignatures(resolved.declaredCallSignatures, mapper)
 		constructSignatures = c.instantiateSignatures(resolved.declaredConstructSignatures, mapper)

tsc/internal/checker/types.go

@@ -1177,14 +1177,7 @@ type memberIndex struct {
 // Property order is semantic. Keep it unchanged and index it with pointer-free
 // slots instead of retaining a second map of names and symbol pointers.
 func (c *Checker) newMemberIndex(members ast.SymbolTable, properties []*ast.Symbol, index *memberIndex) *memberIndex {
-	needsFallback := len(members) != len(properties)
-	for _, symbol := range properties {
-		if members[symbol.Name()] != symbol {
-			needsFallback = true
-			break
-		}
-	}
-	if needsFallback {
+	if len(members) != len(properties) || !symbolTableKeysMatchNames(members) {
 		if index == nil {
 			index = c.memberIndexArena.New()
 		}
@@ -1197,6 +1190,18 @@ func (c *Checker) newMemberIndex(members ast.SymbolTable, properties []*ast.Symb
 	return c.newPropertyIndex(properties, index)
 }
 
+// Reports whether every symbol is stored under its own name. Checking the
+// table's pairs, rather than looking each property up by name, also rejects a
+// symbol aliased under a second key, which a name-keyed index would drop.
+func symbolTableKeysMatchNames(members ast.SymbolTable) bool {
+	for name, symbol := range members {
+		if symbol.Name() != name {
+			return false
+		}
+	}
+	return true
+}
+
 func (c *Checker) newPropertyIndex(properties []*ast.Symbol, index *memberIndex) *memberIndex {
 	if len(properties) <= 8 {
 		return nil

tsc/internal/checker/types_test.go

@@ -573,6 +573,16 @@ func TestStructuredMembersLookup(t *testing.T) {
 	member := c.newAnonymousType(nil, ast.SymbolTable{"different": renamed}, nil, nil, nil).AsStructuredType()
 	assert.Equal(t, member.getMember("different"), renamed)
 	assert.Assert(t, member.getMember("original") == nil)
+	aliased := c.newSymbol(ast.SymbolFlagsProperty, "original")
+	aliasedMembers := ast.SymbolTable{"original": aliased, "different": aliased}
+	for i := range 10 {
+		name := "p" + strconv.Itoa(i)
+		aliasedMembers[name] = c.newSymbol(ast.SymbolFlagsProperty, name)
+	}
+	aliasedType := c.newAnonymousType(nil, aliasedMembers, nil, nil, nil).AsStructuredType()
+	for name, symbol := range aliasedMembers {
+		assert.Equal(t, aliasedType.getMember(name), symbol)
+	}
 }
 
 func TestCompactStructuredTypeLayout(t *testing.T) {