Respond to PR comments

andy-ms · andy-ms · commit d7709475b349 · 2017-08-18T17:18:04.000-07:00
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -14674,34 +14674,31 @@ namespace ts {
             }
         }
 
+        /**
+         * It's possible that "prop.valueDeclaration" is a local declaration, but the property was also declared in a superclass.
+         * In that case we won't consider it used before its declaration, because it gets its value from the superclass' declaration.
+         */
         function isPropertyDeclaredInAncestorClass(prop: Symbol): boolean {
-            // It's possible that "prop.valueDeclaration" is a local declaration, but the property was also declared in a superclass.
-            // In that case we won't consider it used before its declaration, because it gets its value from the superclass' declaration.
-            let classSymbol = prop.parent;
+            let classType = getTypeOfSymbol(prop.parent) as InterfaceType;
             while (true) {
-                classSymbol = getSuperClass(classSymbol);
-                if (!classSymbol) {
+                classType = getSuperClass(classType);
+                if (!classType) {
                     return false;
                 }
-                const superProperty = classSymbol.members.get(prop.escapedName);
+                const superProperty = getPropertyOfType(classType, prop.escapedName);
                 if (superProperty && superProperty.valueDeclaration) {
                     return true;
                 }
             }
         }
 
-        // TODO: there must be a better way of doing this
-        function getSuperClass(classSymbol: Symbol): Symbol | undefined {
-            const classDecl = classSymbol.valueDeclaration;
-            if (!isClassLike(classDecl)) {
-                return undefined;
-            }
-            const superClassExpression = getClassExtendsHeritageClauseElement(classDecl);
-            if (!superClassExpression) {
+        function getSuperClass(classType: InterfaceType): InterfaceType | undefined {
+            const x = getBaseTypes(classType);
+            if (x.length === 0) {
                 return undefined;
             }
-            const superClassSymbol = getSymbolAtLocation(superClassExpression.expression);
-            return superClassSymbol.flags & SymbolFlags.Class ? superClassSymbol : undefined;
+            Debug.assert(x.length === 1);
+            return x[0] as InterfaceType;
         }
 
         function reportNonexistentProperty(propNode: Identifier, containingType: Type) {
diff --git a/tests/baselines/reference/useBeforeDeclaration_superClass.errors.txt b/tests/baselines/reference/useBeforeDeclaration_superClass.errors.txt
@@ -0,0 +1,34 @@
+tests/cases/compiler/useBeforeDeclaration_superClass.ts(25,18): error TS2448: Block-scoped variable 'x' used before its declaration.
+
+
+==== tests/cases/compiler/useBeforeDeclaration_superClass.ts (1 errors) ====
+    class C {
+        x = 0;
+    }
+    class D extends C {
+        // Not an error -- this will access the parent's initialized value for `x`, not the one on the child.
+        old_x = this.x;
+        x = 1;
+    }
+    
+    // Test that it works on chains of classes
+    class X {
+        x = 0;
+    }
+    class Y extends X {}
+    class Z extends Y {
+        old_x = this.x;
+        x = 1;
+    }
+    
+    // Interface doesn't count
+    interface I {
+        x: number;
+    }
+    class J implements I {
+        old_x = this.x;
+                     ~
+!!! error TS2448: Block-scoped variable 'x' used before its declaration.
+        x = 1;
+    }
+    
diff --git a/tests/baselines/reference/useBeforeDeclaration_superClass.js b/tests/baselines/reference/useBeforeDeclaration_superClass.js
@@ -17,6 +17,15 @@ class Z extends Y {
     old_x = this.x;
     x = 1;
 }
+
+// Interface doesn't count
+interface I {
+    x: number;
+}
+class J implements I {
+    old_x = this.x;
+    x = 1;
+}
 
 
 //// [useBeforeDeclaration_superClass.js]
@@ -71,3 +80,10 @@ var Z = /** @class */ (function (_super) {
     }
     return Z;
 }(Y));
+var J = /** @class */ (function () {
+    function J() {
+        this.old_x = this.x;
+        this.x = 1;
+    }
+    return J;
+}());
diff --git a/tests/baselines/reference/useBeforeDeclaration_superClass.symbols b/tests/baselines/reference/useBeforeDeclaration_superClass.symbols
diff --git a/tests/baselines/reference/useBeforeDeclaration_superClass.types b/tests/baselines/reference/useBeforeDeclaration_superClass.types
diff --git a/tests/cases/compiler/useBeforeDeclaration_superClass.ts b/tests/cases/compiler/useBeforeDeclaration_superClass.ts
@@ -16,3 +16,12 @@ class Z extends Y {
     old_x = this.x;
     x = 1;
 }
+
+// Interface doesn't count
+interface I {
+    x: number;
+}
+class J implements I {
+    old_x = this.x;
+    x = 1;
+}
