Directly copy only the index signature in addition to declared properties

Fixes microsoft#56620

Partial revert of microsoft#55252

Author: RyanCavanaugh

src/compiler/checker.ts

@@ -13058,12 +13058,11 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         const baseTypes = getBaseTypes(source);
         if (baseTypes.length) {
             if (source.symbol && members === getMembersOfSymbol(source.symbol)) {
-                const symbolTable = createSymbolTable();
-                // copy all symbols (except type parameters), including the ones with internal names like `InternalSymbolName.Index`
-                for (const symbol of members.values()) {
-                    if (!(symbol.flags & SymbolFlags.TypeParameter)) {
-                        symbolTable.set(symbol.escapedName, symbol);
-                    }
+                const symbolTable = createSymbolTable(source.declaredProperties);
+                // copy index signature symbol as well (for quickinfo)
+                const sourceIndex = getIndexSymbol(source.symbol);
+                if (sourceIndex) {
+                   symbolTable.set(InternalSymbolName.Index, sourceIndex);
                 }
                 members = symbolTable;
             }

tests/baselines/reference/conflictingTypeParameterSymbolTransfer.errors.txt

@@ -0,0 +1,23 @@
+conflictingTypeParameterSymbolTransfer.ts(14,16): error TS2304: Cannot find name 'U'.
+
+
+==== conflictingTypeParameterSymbolTransfer.ts (1 errors) ====
+    // @strict
+    
+    // Via #56620
+    
+    class Base<U> { }
+    export class C2<T> extends Base<unknown> {
+        T: number;
+        constructor(T: number) {
+            super();
+            // Should not error
+            this.T = T;
+    
+            // Should error
+            let a: U = null;
+                   ~
+!!! error TS2304: Cannot find name 'U'.
+        }
+    }
+    

tests/baselines/reference/conflictingTypeParameterSymbolTransfer.js

@@ -0,0 +1,60 @@
+//// [tests/cases/compiler/conflictingTypeParameterSymbolTransfer.ts] ////
+
+//// [conflictingTypeParameterSymbolTransfer.ts]
+// @strict
+
+// Via #56620
+
+class Base<U> { }
+export class C2<T> extends Base<unknown> {
+    T: number;
+    constructor(T: number) {
+        super();
+        // Should not error
+        this.T = T;
+
+        // Should error
+        let a: U = null;
+    }
+}
+
+
+//// [conflictingTypeParameterSymbolTransfer.js]
+"use strict";
+// @strict
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.C2 = void 0;
+// Via #56620
+var Base = /** @class */ (function () {
+    function Base() {
+    }
+    return Base;
+}());
+var C2 = /** @class */ (function (_super) {
+    __extends(C2, _super);
+    function C2(T) {
+        var _this = _super.call(this) || this;
+        // Should not error
+        _this.T = T;
+        // Should error
+        var a = null;
+        return _this;
+    }
+    return C2;
+}(Base));
+exports.C2 = C2;

tests/baselines/reference/conflictingTypeParameterSymbolTransfer.symbols

@@ -0,0 +1,39 @@
+//// [tests/cases/compiler/conflictingTypeParameterSymbolTransfer.ts] ////
+
+=== conflictingTypeParameterSymbolTransfer.ts ===
+// @strict
+
+// Via #56620
+
+class Base<U> { }
+>Base : Symbol(Base, Decl(conflictingTypeParameterSymbolTransfer.ts, 0, 0))
+>U : Symbol(U, Decl(conflictingTypeParameterSymbolTransfer.ts, 4, 11))
+
+export class C2<T> extends Base<unknown> {
+>C2 : Symbol(C2, Decl(conflictingTypeParameterSymbolTransfer.ts, 4, 17))
+>T : Symbol(T, Decl(conflictingTypeParameterSymbolTransfer.ts, 5, 16), Decl(conflictingTypeParameterSymbolTransfer.ts, 5, 42))
+>Base : Symbol(Base, Decl(conflictingTypeParameterSymbolTransfer.ts, 0, 0))
+
+    T: number;
+>T : Symbol(T, Decl(conflictingTypeParameterSymbolTransfer.ts, 5, 16), Decl(conflictingTypeParameterSymbolTransfer.ts, 5, 42))
+
+    constructor(T: number) {
+>T : Symbol(T, Decl(conflictingTypeParameterSymbolTransfer.ts, 7, 16))
+
+        super();
+>super : Symbol(Base, Decl(conflictingTypeParameterSymbolTransfer.ts, 0, 0))
+
+        // Should not error
+        this.T = T;
+>this.T : Symbol(T, Decl(conflictingTypeParameterSymbolTransfer.ts, 5, 16), Decl(conflictingTypeParameterSymbolTransfer.ts, 5, 42))
+>this : Symbol(C2, Decl(conflictingTypeParameterSymbolTransfer.ts, 4, 17))
+>T : Symbol(T, Decl(conflictingTypeParameterSymbolTransfer.ts, 5, 16), Decl(conflictingTypeParameterSymbolTransfer.ts, 5, 42))
+>T : Symbol(T, Decl(conflictingTypeParameterSymbolTransfer.ts, 7, 16))
+
+        // Should error
+        let a: U = null;
+>a : Symbol(a, Decl(conflictingTypeParameterSymbolTransfer.ts, 13, 11))
+>U : Symbol(U)
+    }
+}
+

tests/baselines/reference/conflictingTypeParameterSymbolTransfer.types

@@ -0,0 +1,38 @@
+//// [tests/cases/compiler/conflictingTypeParameterSymbolTransfer.ts] ////
+
+=== conflictingTypeParameterSymbolTransfer.ts ===
+// @strict
+
+// Via #56620
+
+class Base<U> { }
+>Base : Base<U>
+
+export class C2<T> extends Base<unknown> {
+>C2 : C2<T>
+>Base : Base<unknown>
+
+    T: number;
+>T : number
+
+    constructor(T: number) {
+>T : number
+
+        super();
+>super() : void
+>super : typeof Base
+
+        // Should not error
+        this.T = T;
+>this.T = T : number
+>this.T : number
+>this : this
+>T : number
+>T : number
+
+        // Should error
+        let a: U = null;
+>a : U
+    }
+}
+

tests/cases/compiler/conflictingTypeParameterSymbolTransfer.ts

@@ -0,0 +1,16 @@
+// @strict
+
+// Via #56620
+
+class Base<U> { }
+export class C2<T> extends Base<unknown> {
+    T: number;
+    constructor(T: number) {
+        super();
+        // Should not error
+        this.T = T;
+
+        // Should error
+        let a: U = null;
+    }
+}