Handle case where this access is inside the supercall

Paul van Brenk · Paul van Brenk · commit 163e758e1060 · 2016-10-06T11:44:53.000-07:00
diff --git a/src/harness/fourslash.ts b/src/harness/fourslash.ts
@@ -2041,13 +2041,7 @@ namespace FourSlash {
             }
         }
 
-        public verifyCodeFixAtPosition(expectedText: string, errorCode?: number) {
-
-            const ranges = this.getRanges();
-            if (ranges.length == 0) {
-                this.raiseError("At least one range should be specified in the testfile.");
-            }
-
+        private getCodeFixes(errorCode?: number) {
             const fileName = this.activeFile.fileName;
             const diagnostics = this.getDiagnostics(fileName);
 
@@ -2061,7 +2055,16 @@ namespace FourSlash {
 
             const diagnostic = !errorCode ? diagnostics[0] : ts.find(diagnostics, d => d.code == errorCode);
 
-            const actual = this.languageService.getCodeFixesAtPosition(fileName, diagnostic.start, diagnostic.length, [`TS${diagnostic.code}`]);
+            return this.languageService.getCodeFixesAtPosition(fileName, diagnostic.start, diagnostic.length, [`TS${diagnostic.code}`]);
+        }
+
+        public verifyCodeFixAtPosition(expectedText: string, errorCode?: number) {
+            const ranges = this.getRanges();
+            if (ranges.length == 0) {
+                this.raiseError("At least one range should be specified in the testfile.");
+            }
+
+            const actual = this.getCodeFixes(errorCode);
 
             if (!actual || actual.length == 0) {
                 this.raiseError("No codefixes returned.");
@@ -2350,6 +2353,18 @@ namespace FourSlash {
             }
         }
 
+        public verifyCodeFixAvailable(negative: boolean, errorCode?:number ) {
+            const fixes = this.getCodeFixes(errorCode);
+
+            if (negative && fixes && fixes.length > 0) {
+                this.raiseError(`verifyCodeFixAvailable failed - expected no fixes, actual: ${fixes.length}`);
+            }
+
+            if (!negative && (fixes === undefined || fixes.length === 0)) {
+                this.raiseError(`verifyCodeFixAvailable failed - expected code fixes, actual: 0`);
+            }
+        }
+
         // Get the text of the entire line the caret is currently at
         private getCurrentLineContent() {
             const text = this.getFileContent(this.activeFile.fileName);
@@ -3137,6 +3152,10 @@ namespace FourSlashInterface {
         public isValidBraceCompletionAtPosition(openingBrace: string) {
             this.state.verifyBraceCompletionAtPosition(this.negative, openingBrace);
         }
+
+        public codeFixAvailable(errorCode?: number) {
+            this.state.verifyCodeFixAvailable(this.negative, errorCode);
+        }
     }
 
     export class Verify extends VerifyNegatable {
diff --git a/src/services/codefixes/superFixes.ts b/src/services/codefixes/superFixes.ts
@@ -34,11 +34,22 @@ namespace ts.codefix {
             }
 
             const constructor = getContainingFunction(token);
-            const superCall = findSuperCall((<ConstructorDeclaration>constructor).body);
+            const superCall = <ExpressionStatement>findSuperCall((<ConstructorDeclaration>constructor).body);
             if (!superCall) {
                 return undefined;
             }
 
+            // figure out if the this access is actuall inside the supercall
+            // i.e. super(this.a), since in that case we won't suggest a fix
+            if (superCall.expression && superCall.expression.kind == SyntaxKind.CallExpression) {
+                const arguments = (<CallExpression>superCall.expression).arguments;
+                for (let i = 0; i < arguments.length; i++){
+                    if ((<PropertyAccessExpression>arguments[i]).expression === token) {
+                        return undefined;
+                    }
+                }
+            }
+
             const newPosition = getOpenBraceEnd(<ConstructorDeclaration>constructor, sourceFile);
             const changes = [{
                 fileName: sourceFile.fileName, textChanges: [{
diff --git a/tests/cases/fourslash/fourslash.ts b/tests/cases/fourslash/fourslash.ts
@@ -136,6 +136,7 @@ declare namespace FourSlashInterface {
         typeDefinitionCountIs(expectedCount: number): void;
         implementationListIsEmpty(): void;
         isValidBraceCompletionAtPosition(openingBrace?: string): void;
+        codeFixAvailable(): void;
     }
     class verify extends verifyNegatable {
         assertHasRanges(ranges: Range[]): void;
diff --git a/tests/cases/fourslash/superFix3.ts b/tests/cases/fourslash/superFix3.ts
@@ -0,0 +1,12 @@
+/// <reference path='fourslash.ts' />
+
+////class Base{
+////    constructor(id: number) { }
+////}
+////class C extends Base{
+////    constructor(private a:number) {
+////        super(this.a);
+////    }
+////}
+
+verify.not.codeFixAvailable();

Original file line number	Diff line number	Diff line change
`@@ -136,6 +136,7 @@ declare namespace FourSlashInterface {`
`136`	`136`	`typeDefinitionCountIs(expectedCount: number): void;`
`137`	`137`	`implementationListIsEmpty(): void;`
`138`	`138`	`isValidBraceCompletionAtPosition(openingBrace?: string): void;`
	`139`	`+ codeFixAvailable(): void;`
`139`	`140`	`}`
`140`	`141`	`class verify extends verifyNegatable {`
`141`	`142`	`assertHasRanges(ranges: Range[]): void;`