Forbid this as constructor parameter type

src/compiler/checker.ts

@@ -4420,12 +4420,19 @@ namespace ts {
             let container = getThisContainer(node, /*includeArrowFunctions*/ false);
             let parent = container && container.parent;
             if (parent && (isClassLike(parent) || parent.kind === SyntaxKind.InterfaceDeclaration)) {
-                if (!(container.flags & NodeFlags.Static)) {
+                if (!(container.flags & NodeFlags.Static) && !isConstructorParameter(node, container)) {
                     return getDeclaredTypeOfClassOrInterface(getSymbolOfNode(parent)).thisType;
                 }
             }
             error(node, Diagnostics.A_this_type_is_available_only_in_a_non_static_member_of_a_class_or_interface);
             return unknownType;
+
+            function isConstructorParameter(node: TypeNode, container: Node) {
+                if (container.kind === SyntaxKind.Constructor) {
+                    let ctor = (<ConstructorDeclaration>container);
+                    return !ctor.body.statements.some(st => st === node.parent);
+                }
+            }
         }
 
         function getTypeFromThisTypeNode(node: TypeNode): Type {

tests/baselines/reference/declarationFiles.errors.txt

@@ -1,15 +1,18 @@
+tests/cases/conformance/types/thisType/declarationFiles.ts(5,20): error TS2526: A 'this' type is available only in a non-static member of a class or interface.
 tests/cases/conformance/types/thisType/declarationFiles.ts(31,5): error TS2527: The inferred type of 'x1' references an inaccessible 'this' type. A type annotation is necessary.
 tests/cases/conformance/types/thisType/declarationFiles.ts(33,5): error TS2527: The inferred type of 'x3' references an inaccessible 'this' type. A type annotation is necessary.
 tests/cases/conformance/types/thisType/declarationFiles.ts(35,5): error TS2527: The inferred type of 'f1' references an inaccessible 'this' type. A type annotation is necessary.
 tests/cases/conformance/types/thisType/declarationFiles.ts(41,5): error TS2527: The inferred type of 'f3' references an inaccessible 'this' type. A type annotation is necessary.
 
 
-==== tests/cases/conformance/types/thisType/declarationFiles.ts (4 errors) ====
+==== tests/cases/conformance/types/thisType/declarationFiles.ts (5 errors) ====
 
     class C1 {
         x: this;
         f(x: this): this { return undefined; }
         constructor(x: this) { }
+                       ~~~~
+!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface.
     }
 
     class C2 {

tests/baselines/reference/thisTypeErrors2.errors.txt

@@ -0,0 +1,22 @@
+tests/cases/conformance/types/thisType/thisTypeErrors2.ts(2,20): error TS2526: A 'this' type is available only in a non-static member of a class or interface.
+tests/cases/conformance/types/thisType/thisTypeErrors2.ts(9,38): error TS2526: A 'this' type is available only in a non-static member of a class or interface.
+
+
+==== tests/cases/conformance/types/thisType/thisTypeErrors2.ts (2 errors) ====
+    class Base {
+        constructor(a: this) {
+                       ~~~~
+!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface.
+        }
+    }
+    class Generic<T> {
+    }
+    class Derived {
+        n: number;
+        constructor(public host: Generic<this>) {
+                                         ~~~~
+!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface.
+            this.n = 12;
+        }
+    }
+

tests/baselines/reference/thisTypeErrors2.js

@@ -0,0 +1,33 @@
+//// [thisTypeErrors2.ts]
+class Base {
+    constructor(a: this) {
+    }
+}
+class Generic<T> {
+}
+class Derived {
+    n: number;
+    constructor(public host: Generic<this>) {
+        this.n = 12;
+    }
+}
+
+
+//// [thisTypeErrors2.js]
+var Base = (function () {
+    function Base(a) {
+    }
+    return Base;
+})();
+var Generic = (function () {
+    function Generic() {
+    }
+    return Generic;
+})();
+var Derived = (function () {
+    function Derived(host) {
+        this.host = host;
+        this.n = 12;
+    }
+    return Derived;
+})();

tests/baselines/reference/thisTypeInClasses.errors.txt

@@ -0,0 +1,57 @@
+tests/cases/conformance/types/thisType/thisTypeInClasses.ts(4,20): error TS2526: A 'this' type is available only in a non-static member of a class or interface.
+
+
+==== tests/cases/conformance/types/thisType/thisTypeInClasses.ts (1 errors) ====
+    class C1 {
+        x: this;
+        f(x: this): this { return undefined; }
+        constructor(x: this) { }
+                       ~~~~
+!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface.
+    }
+
+    class C2 {
+        [x: string]: this;
+    }
+
+    interface Foo<T> {
+        x: T;
+        y: this;
+    }
+
+    class C3 {
+        a: this[];
+        b: [this, this];
+        c: this | Date;
+        d: this & Date;
+        e: (((this)));
+        f: (x: this) => this;
+        g: new (x: this) => this;
+        h: Foo<this>;
+        i: Foo<this | (() => this)>;
+        j: (x: any) => x is this;
+    }
+
+    declare class C4 {
+        x: this;
+        f(x: this): this;
+    }
+
+    class C5 {
+        foo() {
+            let f1 = (x: this): this => this;
+            let f2 = (x: this) => this;
+            let f3 = (x: this) => (y: this) => this;
+            let f4 = (x: this) => {
+                let g = (y: this) => {
+                    return () => this;
+                }
+                return g(this);
+            }
+        }
+        bar() {
+            let x1 = <this>undefined;
+            let x2 = undefined as this;
+        }
+    }
+

tests/cases/conformance/types/thisType/thisTypeErrors2.ts

@@ -0,0 +1,12 @@
+class Base {
+    constructor(a: this) {
+    }
+}
+class Generic<T> {
+}
+class Derived {
+    n: number;
+    constructor(public host: Generic<this>) {
+        this.n = 12;
+    }
+}