instantiate generic this param correctly

Arthur Ozga · Arthur Ozga · commit 1c25034a18d7 · 2017-02-22T16:15:16.000-08:00
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -97,6 +97,7 @@ namespace ts {
             getBaseTypes,
             getBaseTypeOfLiteralType,
             getWidenedType,
+            getTypeWithThisArgument,
             getTypeFromTypeNode: node => {
                 node = getParseTreeNode(node, isTypeNode);
                 return node ? getTypeFromTypeNode(node) : unknownType;
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -2411,6 +2411,7 @@
         getIndexTypeOfType(type: Type, kind: IndexKind): Type;
         getBaseTypes(type: InterfaceType): BaseType[];
         getBaseTypeOfLiteralType(type: Type): Type;
+        getTypeWithThisArgument(type: Type, thisArgument?: Type): Type;
         getWidenedType(type: Type): Type;
         getReturnTypeOfSignature(signature: Signature): Type;
         /**
diff --git a/src/services/codefixes/fixClassDoesntImplementInheritedAbstractMember.ts b/src/services/codefixes/fixClassDoesntImplementInheritedAbstractMember.ts
@@ -23,7 +23,7 @@ namespace ts.codefix {
             const startPos = classDecl.members.pos;
 
             const classType = checker.getTypeAtLocation(classDecl) as InterfaceType;
-            const instantiatedExtendsType = checker.getBaseTypes(classType)[0];
+            const instantiatedExtendsType = checker.getTypeWithThisArgument(checker.getBaseTypes(classType)[0], classType.thisType);
 
             // Note that this is ultimately derived from a map indexed by symbol names,
             // so duplicates cannot occur.
diff --git a/src/services/codefixes/fixClassIncorrectlyImplementsInterface.ts b/src/services/codefixes/fixClassIncorrectlyImplementsInterface.ts
@@ -17,15 +17,15 @@ namespace ts.codefix {
         }
 
         const startPos: number = classDecl.members.pos;
-        const classType = checker.getTypeAtLocation(classDecl);
+        const classType = checker.getTypeAtLocation(classDecl) as InterfaceType;
         const implementedTypeNodes = getClassImplementsHeritageClauseElements(classDecl);
 
         const hasNumericIndexSignature = !!checker.getIndexTypeOfType(classType, IndexKind.Number);
         const hasStringIndexSignature = !!checker.getIndexTypeOfType(classType, IndexKind.String);
 
         const result: CodeAction[] = [];
         for (const implementedTypeNode of implementedTypeNodes) {
-            const implementedType = checker.getTypeFromTypeNode(implementedTypeNode) as InterfaceType;
+            const implementedType = checker.getTypeWithThisArgument(checker.getTypeFromTypeNode(implementedTypeNode), classType.thisType) as InterfaceType;
             // Note that this is ultimately derived from a map indexed by symbol names,
             // so duplicates cannot occur.
             const implementedTypeSymbols = checker.getPropertiesOfType(implementedType);
diff --git a/src/services/codefixes/helpers.ts b/src/services/codefixes/helpers.ts
@@ -32,22 +32,14 @@ namespace ts.codefix {
         const name = declaration.name ? declaration.name.getText() : undefined;
         const visibility = getVisibilityPrefixWithSpace(getModifierFlags(declaration));
 
-        const typeAtNewDeclaration = checker.getTypeOfSymbolAtLocation(symbol, enclosingDeclaration);
+        const type = checker.getTypeOfSymbolAtLocation(symbol, enclosingDeclaration);
 
         switch (declaration.kind) {
             case SyntaxKind.GetAccessor:
             case SyntaxKind.SetAccessor:
             case SyntaxKind.PropertySignature:
             case SyntaxKind.PropertyDeclaration:
-                let typeString: string | undefined = undefined;
-                const typeAtOldDeclaration = checker.getTypeAtLocation(declaration);
-                if ((typeAtOldDeclaration as TypeParameter).isThisType) {
-                    typeString = "this";
-                }
-                else {
-                    typeString = checker.typeToString(typeAtNewDeclaration, enclosingDeclaration, TypeFormatFlags.None);
-                }
-
+                const typeString = checker.typeToString(type, enclosingDeclaration, TypeFormatFlags.None);
                 return `${visibility}${name}: ${typeString};${newlineChar}`;
 
             case SyntaxKind.MethodSignature:
@@ -59,7 +51,7 @@ namespace ts.codefix {
                 // If there is more than one overload but no implementation signature
                 // (eg: an abstract method or interface declaration), there is a 1-1
                 // correspondence of declarations and signatures.
-                const signatures = checker.getSignaturesOfType(typeAtNewDeclaration, SignatureKind.Call);
+                const signatures = checker.getSignaturesOfType(type, SignatureKind.Call);
                 if (!(signatures && signatures.length > 0)) {
                     return "";
                 }
diff --git a/tests/cases/fourslash/codeFixClassExtendAbstractMethod.ts b/tests/cases/fourslash/codeFixClassExtendAbstractMethod.ts
@@ -2,6 +2,7 @@
 
 //// abstract class A {
 ////    abstract f(a: number, b: string): boolean;
+////    abstract f(a: number, b: string): this;
 ////    abstract f(a: string, b: number): Function;
 ////    abstract f(a: string): Function;
 //// }
@@ -10,6 +11,7 @@
 
 verify.rangeAfterCodeFix(`
     f(a: number, b: string): boolean;
+    f(a: number, b: string): this;
     f(a: string, b: number): Function;
     f(a: string): Function;
     f(a: any, b?: any) {
diff --git a/tests/cases/fourslash/codeFixClassExtendAbstractMethodThis.ts b/tests/cases/fourslash/codeFixClassExtendAbstractMethodThis.ts
@@ -0,0 +1,13 @@
+/// <reference path='fourslash.ts' />
+
+//// abstract class A {
+////    abstract f(): this;
+//// }
+////
+//// class C extends A {[| |]}
+
+verify.rangeAfterCodeFix(`
+    f(): this {
+        throw new Error('Method not implemented.');
+    }
+`);
diff --git a/tests/cases/fourslash/codeFixClassImplementInterfaceMethodThisAndSelfReference.ts b/tests/cases/fourslash/codeFixClassImplementInterfaceMethodThisAndSelfReference.ts
@@ -1,14 +1,14 @@
 /// <reference path='fourslash.ts' />
 
 //// interface I {
-////     f(x: number, y: string): I
+////     f(x: number, y: this): I
 //// }
 ////
 //// class C implements I {[|
 //// |]}
 
 verify.rangeAfterCodeFix(`
-f(x: number,y: string): I {
+f(x: number,y: this): I {
     throw new Error('Method not implemented.');
 }
 `);
diff --git a/tests/cases/fourslash/quickInfoOnThis5.ts b/tests/cases/fourslash/quickInfoOnThis5.ts
@@ -0,0 +1,35 @@
+/// <reference path='fourslash.ts' />
+
+verify.quickInfos({
+    1: "this: ContextualInterface",
+    2: "(parameter) this: void"
+});
+
+
+
+////interface ContextualInterface {
+////    m: number;
+////    method(this: this, n: number);
+////}
+////let o: ContextualInterface = {
+////    m: 12,
+////    method(n) {
+////        let x = this/*1*/.m;
+////    }
+////}
+////interface ContextualInterface2 {
+////    (this: void, n: number): void;
+////}
+////let contextualInterface2: ContextualInterface2 = function (th/*2*/is, n) { }
+
+class A {
+    x: number
+    myMethod(): this { return this; }
+}
+
+class B extends A {
+    constructor(){
+        super();
+        this.myMethod();
+    }
+}
