check usage before declaration for decorators

src/compiler/checker.ts

@@ -1672,13 +1672,17 @@ namespace ts {
                 return isForInOrOfStatement(grandparent) && isSameScopeDescendentOf(usage, grandparent.expression, declContainer);
             }
 
-            function isUsedInFunctionOrInstanceProperty(usage: Node, declaration: Node): boolean {
+            function isUsedInFunctionOrInstanceProperty(usage: Node, declaration: Node) {
+                return isUsedInFunctionOrInstancePropertyWorker(usage, declaration);
+            }
+
+            function isUsedInFunctionOrInstancePropertyWorker(usage: Node, declaration: Node): boolean {
                 return !!findAncestor(usage, current => {
                     if (current === declContainer) {
                         return "quit";
                     }
                     if (isFunctionLike(current)) {
-                        return true;
+                        return !getImmediatelyInvokedFunctionExpression(current);
                     }
                     if (isClassStaticBlockDeclaration(current)) {
                         return declaration.pos < usage.pos;
@@ -1711,6 +1715,17 @@ namespace ts {
                             }
                         }
                     }
+
+                    const decorator = tryCast(current.parent, isDecorator);
+                    if (decorator && decorator.expression === current) {
+                        if (isParameter(decorator.parent)) {
+                            return isUsedInFunctionOrInstancePropertyWorker(decorator.parent.parent.parent, declaration) ? true : "quit";
+                        }
+                        if (isMethodDeclaration(decorator.parent)) {
+                            return isUsedInFunctionOrInstancePropertyWorker(decorator.parent.parent, declaration) ? true : "quit";
+                        }
+                    }
+
                     return false;
                 });
             }

tests/baselines/reference/blockScopedVariablesUseBeforeDef.errors.txt

@@ -5,9 +5,10 @@ tests/cases/compiler/blockScopedVariablesUseBeforeDef.ts(100,12): error TS2448:
 tests/cases/compiler/blockScopedVariablesUseBeforeDef.ts(111,28): error TS2448: Block-scoped variable 'a' used before its declaration.
 tests/cases/compiler/blockScopedVariablesUseBeforeDef.ts(112,21): error TS2448: Block-scoped variable 'a' used before its declaration.
 tests/cases/compiler/blockScopedVariablesUseBeforeDef.ts(122,22): error TS2448: Block-scoped variable 'a' used before its declaration.
+tests/cases/compiler/blockScopedVariablesUseBeforeDef.ts(126,20): error TS2450: Enum 'Enum' used before its declaration.
 
 
-==== tests/cases/compiler/blockScopedVariablesUseBeforeDef.ts (7 errors) ====
+==== tests/cases/compiler/blockScopedVariablesUseBeforeDef.ts (8 errors) ====
     function foo0() {
         let a = x;
                 ~
@@ -152,4 +153,15 @@ tests/cases/compiler/blockScopedVariablesUseBeforeDef.ts(122,22): error TS2448:
 !!! error TS2448: Block-scoped variable 'a' used before its declaration.
 !!! related TS2728 tests/cases/compiler/blockScopedVariablesUseBeforeDef.ts:122:10: 'a' is declared here.
     }
+
+    function foo17() {
+        let a = (() => Enum.Yes)();
+                       ~~~~
+!!! error TS2450: Enum 'Enum' used before its declaration.
+!!! related TS2728 tests/cases/compiler/blockScopedVariablesUseBeforeDef.ts:127:10: 'Enum' is declared here.
+        enum Enum {
+            No = 0,
+            Yes = 1,
+        }
+    }
 

tests/baselines/reference/blockScopedVariablesUseBeforeDef.js

@@ -122,6 +122,14 @@ function foo15() {
 function foo16() {
     let [a] = (() => a)();
 }
+
+function foo17() {
+    let a = (() => Enum.Yes)();
+    enum Enum {
+        No = 0,
+        Yes = 1,
+    }
+}
 
 
 //// [blockScopedVariablesUseBeforeDef.js]
@@ -254,3 +262,11 @@ function foo15() {
 function foo16() {
     var a = (function () { return a; })()[0];
 }
+function foo17() {
+    var a = (function () { return Enum.Yes; })();
+    var Enum;
+    (function (Enum) {
+        Enum[Enum["No"] = 0] = "No";
+        Enum[Enum["Yes"] = 1] = "Yes";
+    })(Enum || (Enum = {}));
+}

tests/baselines/reference/blockScopedVariablesUseBeforeDef.symbols

@@ -256,3 +256,23 @@ function foo16() {
 >a : Symbol(a, Decl(blockScopedVariablesUseBeforeDef.ts, 121, 9))
 }
 
+function foo17() {
+>foo17 : Symbol(foo17, Decl(blockScopedVariablesUseBeforeDef.ts, 122, 1))
+
+    let a = (() => Enum.Yes)();
+>a : Symbol(a, Decl(blockScopedVariablesUseBeforeDef.ts, 125, 7))
+>Enum.Yes : Symbol(Enum.Yes, Decl(blockScopedVariablesUseBeforeDef.ts, 127, 15))
+>Enum : Symbol(Enum, Decl(blockScopedVariablesUseBeforeDef.ts, 125, 31))
+>Yes : Symbol(Enum.Yes, Decl(blockScopedVariablesUseBeforeDef.ts, 127, 15))
+
+    enum Enum {
+>Enum : Symbol(Enum, Decl(blockScopedVariablesUseBeforeDef.ts, 125, 31))
+
+        No = 0,
+>No : Symbol(Enum.No, Decl(blockScopedVariablesUseBeforeDef.ts, 126, 15))
+
+        Yes = 1,
+>Yes : Symbol(Enum.Yes, Decl(blockScopedVariablesUseBeforeDef.ts, 127, 15))
+    }
+}
+

tests/baselines/reference/blockScopedVariablesUseBeforeDef.types

@@ -287,3 +287,28 @@ function foo16() {
 >a : any
 }
 
+function foo17() {
+>foo17 : () => void
+
+    let a = (() => Enum.Yes)();
+>a : Enum
+>(() => Enum.Yes)() : Enum
+>(() => Enum.Yes) : () => Enum
+>() => Enum.Yes : () => Enum
+>Enum.Yes : Enum.Yes
+>Enum : typeof Enum
+>Yes : Enum.Yes
+
+    enum Enum {
+>Enum : Enum
+
+        No = 0,
+>No : Enum.No
+>0 : 0
+
+        Yes = 1,
+>Yes : Enum.Yes
+>1 : 1
+    }
+}
+

tests/baselines/reference/decoratorUsedBeforeDeclaration.errors.txt

@@ -0,0 +1,132 @@
+tests/cases/compiler/decoratorUsedBeforeDeclaration.ts(1,2): error TS2448: Block-scoped variable 'lambda' used before its declaration.
+tests/cases/compiler/decoratorUsedBeforeDeclaration.ts(1,9): error TS2450: Enum 'Enum' used before its declaration.
+tests/cases/compiler/decoratorUsedBeforeDeclaration.ts(2,7): error TS2450: Enum 'Enum' used before its declaration.
+tests/cases/compiler/decoratorUsedBeforeDeclaration.ts(4,4): error TS2448: Block-scoped variable 'lambda' used before its declaration.
+tests/cases/compiler/decoratorUsedBeforeDeclaration.ts(4,11): error TS2450: Enum 'Enum' used before its declaration.
+tests/cases/compiler/decoratorUsedBeforeDeclaration.ts(5,9): error TS2450: Enum 'Enum' used before its declaration.
+tests/cases/compiler/decoratorUsedBeforeDeclaration.ts(12,4): error TS2448: Block-scoped variable 'lambda' used before its declaration.
+tests/cases/compiler/decoratorUsedBeforeDeclaration.ts(12,11): error TS2450: Enum 'Enum' used before its declaration.
+tests/cases/compiler/decoratorUsedBeforeDeclaration.ts(13,9): error TS2450: Enum 'Enum' used before its declaration.
+tests/cases/compiler/decoratorUsedBeforeDeclaration.ts(18,4): error TS2448: Block-scoped variable 'lambda' used before its declaration.
+tests/cases/compiler/decoratorUsedBeforeDeclaration.ts(24,11): error TS2448: Block-scoped variable 'lambda' used before its declaration.
+tests/cases/compiler/decoratorUsedBeforeDeclaration.ts(24,18): error TS2450: Enum 'Enum' used before its declaration.
+tests/cases/compiler/decoratorUsedBeforeDeclaration.ts(24,33): error TS2450: Enum 'Enum' used before its declaration.
+tests/cases/compiler/decoratorUsedBeforeDeclaration.ts(28,11): error TS2448: Block-scoped variable 'lambda' used before its declaration.
+
+
+==== tests/cases/compiler/decoratorUsedBeforeDeclaration.ts (14 errors) ====
+    @lambda(Enum.No)
+     ~~~~~~
+!!! error TS2448: Block-scoped variable 'lambda' used before its declaration.
+!!! related TS2728 tests/cases/compiler/decoratorUsedBeforeDeclaration.ts:40:7: 'lambda' is declared here.
+            ~~~~
+!!! error TS2450: Enum 'Enum' used before its declaration.
+!!! related TS2728 tests/cases/compiler/decoratorUsedBeforeDeclaration.ts:35:6: 'Enum' is declared here.
+    @deco(Enum.No)
+          ~~~~
+!!! error TS2450: Enum 'Enum' used before its declaration.
+!!! related TS2728 tests/cases/compiler/decoratorUsedBeforeDeclaration.ts:35:6: 'Enum' is declared here.
+    class Greeter {
+      @lambda(Enum.No)
+       ~~~~~~
+!!! error TS2448: Block-scoped variable 'lambda' used before its declaration.
+!!! related TS2728 tests/cases/compiler/decoratorUsedBeforeDeclaration.ts:40:7: 'lambda' is declared here.
+              ~~~~
+!!! error TS2450: Enum 'Enum' used before its declaration.
+!!! related TS2728 tests/cases/compiler/decoratorUsedBeforeDeclaration.ts:35:6: 'Enum' is declared here.
+      @deco(Enum.No)
+            ~~~~
+!!! error TS2450: Enum 'Enum' used before its declaration.
+!!! related TS2728 tests/cases/compiler/decoratorUsedBeforeDeclaration.ts:35:6: 'Enum' is declared here.
+      greeting: string;
+
+      constructor(message: string) {
+        this.greeting = message;
+      }
+
+      @lambda(Enum.No)
+       ~~~~~~
+!!! error TS2448: Block-scoped variable 'lambda' used before its declaration.
+!!! related TS2728 tests/cases/compiler/decoratorUsedBeforeDeclaration.ts:40:7: 'lambda' is declared here.
+              ~~~~
+!!! error TS2450: Enum 'Enum' used before its declaration.
+!!! related TS2728 tests/cases/compiler/decoratorUsedBeforeDeclaration.ts:35:6: 'Enum' is declared here.
+      @deco(Enum.No)
+            ~~~~
+!!! error TS2450: Enum 'Enum' used before its declaration.
+!!! related TS2728 tests/cases/compiler/decoratorUsedBeforeDeclaration.ts:35:6: 'Enum' is declared here.
+      greet() {
+        return "Hello, " + this.greeting;
+      }
+
+      @lambda
+       ~~~~~~
+!!! error TS2448: Block-scoped variable 'lambda' used before its declaration.
+!!! related TS2728 tests/cases/compiler/decoratorUsedBeforeDeclaration.ts:40:7: 'lambda' is declared here.
+      @deco
+      greet1() {
+        return "Hello, " + this.greeting;
+      }
+
+      greet2(@lambda(Enum.No) @deco(Enum.No) param) {
+              ~~~~~~
+!!! error TS2448: Block-scoped variable 'lambda' used before its declaration.
+!!! related TS2728 tests/cases/compiler/decoratorUsedBeforeDeclaration.ts:40:7: 'lambda' is declared here.
+                     ~~~~
+!!! error TS2450: Enum 'Enum' used before its declaration.
+!!! related TS2728 tests/cases/compiler/decoratorUsedBeforeDeclaration.ts:35:6: 'Enum' is declared here.
+                                    ~~~~
+!!! error TS2450: Enum 'Enum' used before its declaration.
+!!! related TS2728 tests/cases/compiler/decoratorUsedBeforeDeclaration.ts:35:6: 'Enum' is declared here.
+        return "Hello, " + this.greeting;
+      }
+
+      greet3(@lambda @deco param) {
+              ~~~~~~
+!!! error TS2448: Block-scoped variable 'lambda' used before its declaration.
+!!! related TS2728 tests/cases/compiler/decoratorUsedBeforeDeclaration.ts:40:7: 'lambda' is declared here.
+        return "Hello, " + this.greeting;
+      }
+    }
+
+    function deco(...args: any[]): any {}
+
+    enum Enum {
+      No = 0,
+      Yes = 1,
+    }
+
+    const lambda = (...args: any[]): any => {};
+
+    @lambda(Enum.No)
+    @deco(Enum.No)
+    class Greeter1 {
+      @lambda(Enum.No)
+      @deco(Enum.No)
+      greeting: string;
+
+      constructor(message: string) {
+        this.greeting = message;
+      }
+
+      @lambda(Enum.No)
+      @deco(Enum.No)
+      greet() {
+        return "Hello, " + this.greeting;
+      }
+
+      @lambda
+      @deco
+      greet1() {
+        return "Hello, " + this.greeting;
+      }
+
+      greet2(@lambda(Enum.No) @deco(Enum.No) param) {
+        return "Hello, " + this.greeting;
+      }
+
+      greet3(@lambda @deco param) {
+        return "Hello, " + this.greeting;
+      }
+    }
+