microsoft
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
@@ -3567,6 +3567,10 @@
         "category": "Error",
         "code": 2845
     },
+    "Type instantiated results in a throw type saying: {0}": {
+        "category": "Error",
+        "code": 2899
+    },
 
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",

diff --git a/src/compiler/factory/nodeFactory.ts b/src/compiler/factory/nodeFactory.ts
@@ -2171,7 +2171,7 @@ namespace ts {
         }
 
         // @api
-        function createTypeOperatorNode(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword, type: TypeNode): TypeOperatorNode {
+        function createTypeOperatorNode(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.ThrowKeyword, type: TypeNode): TypeOperatorNode {
             const node = createBaseNode<TypeOperatorNode>(SyntaxKind.TypeOperator);
             node.operator = operator;
             node.type = operator === SyntaxKind.ReadonlyKeyword ?

diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
@@ -4146,6 +4146,7 @@ namespace ts {
                 case SyntaxKind.ReadonlyKeyword:
                 case SyntaxKind.SymbolKeyword:
                 case SyntaxKind.UniqueKeyword:
+                case SyntaxKind.ThrowKeyword:
                 case SyntaxKind.VoidKeyword:
                 case SyntaxKind.UndefinedKeyword:
                 case SyntaxKind.NullKeyword:
@@ -4228,7 +4229,7 @@ namespace ts {
             return type;
         }
 
-        function parseTypeOperator(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword) {
+        function parseTypeOperator(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.ThrowKeyword) {
             const pos = getNodePos();
             parseExpected(operator);
             return finishNode(factory.createTypeOperatorNode(operator, parseTypeOperatorOrHigher()), pos);
@@ -4263,6 +4264,7 @@ namespace ts {
                 case SyntaxKind.KeyOfKeyword:
                 case SyntaxKind.UniqueKeyword:
                 case SyntaxKind.ReadonlyKeyword:
+                case SyntaxKind.ThrowKeyword:
                     return parseTypeOperator(operator);
                 case SyntaxKind.InferKeyword:
                     return parseInferType();

diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -2045,7 +2045,7 @@ namespace ts {
 
     export interface TypeOperatorNode extends TypeNode {
         readonly kind: SyntaxKind.TypeOperator;
-        readonly operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword;
+        readonly operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.ThrowKeyword;
         readonly type: TypeNode;
     }
 
@@ -5605,6 +5605,7 @@ namespace ts {
         NonPrimitive    = 1 << 26,  // intrinsic object type
         TemplateLiteral = 1 << 27,  // Template literal type
         StringMapping   = 1 << 28,  // Uppercase/Lowercase type
+        ThrowType       = 1 << 29,  // throw T
 
         /* @internal */
         AnyOrUnknown = Any | Unknown,
@@ -5745,6 +5746,10 @@ namespace ts {
     export interface EnumType extends Type {
     }
 
+    export interface ThrowType extends Type {
+        value: Type;
+    }
+
     // Types included in TypeFlags.ObjectFlagsType have an objectFlags property. Some ObjectFlags
     // are specific to certain types and reuse the same bit position. Those ObjectFlags require a check
     // for a certain TypeFlags value to determine their meaning.
@@ -7812,7 +7817,7 @@ namespace ts {
         createParenthesizedType(type: TypeNode): ParenthesizedTypeNode;
         updateParenthesizedType(node: ParenthesizedTypeNode, type: TypeNode): ParenthesizedTypeNode;
         createThisTypeNode(): ThisTypeNode;
-        createTypeOperatorNode(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword, type: TypeNode): TypeOperatorNode;
+        createTypeOperatorNode(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.ThrowKeyword, type: TypeNode): TypeOperatorNode;
         updateTypeOperatorNode(node: TypeOperatorNode, type: TypeNode): TypeOperatorNode;
         createIndexedAccessTypeNode(objectType: TypeNode, indexType: TypeNode): IndexedAccessTypeNode;
         updateIndexedAccessTypeNode(node: IndexedAccessTypeNode, objectType: TypeNode, indexType: TypeNode): IndexedAccessTypeNode;

diff --git a/src/harness/fourslashInterfaceImpl.ts b/src/harness/fourslashInterfaceImpl.ts
@@ -1186,6 +1186,7 @@ namespace FourSlashInterface {
             typeEntry("Lowercase"),
             typeEntry("Capitalize"),
             typeEntry("Uncapitalize"),
+            typeEntry("TypeToString"),
             interfaceEntry("ThisType"),
             varEntry("ArrayBuffer"),
             interfaceEntry("ArrayBufferTypes"),

diff --git a/src/lib/es5.d.ts b/src/lib/es5.d.ts
@@ -1630,6 +1630,11 @@ type Capitalize<S extends string> = intrinsic;
  */
 type Uncapitalize<S extends string> = intrinsic;
 
+/**
+ * Get a string representation of a type
+ */
+type TypeToString<T> = intrinsic;
+
 /**
  * Marker for contextual 'this' type
  */

diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts
@@ -992,7 +992,7 @@ declare namespace ts {
     }
     export interface TypeOperatorNode extends TypeNode {
         readonly kind: SyntaxKind.TypeOperator;
-        readonly operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword;
+        readonly operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.ThrowKeyword;
         readonly type: TypeNode;
     }
     export interface IndexedAccessTypeNode extends TypeNode {
@@ -2665,6 +2665,7 @@ declare namespace ts {
         NonPrimitive = 67108864,
         TemplateLiteral = 134217728,
         StringMapping = 268435456,
+        ThrowType = 536870912,
         Literal = 2944,
         Unit = 109440,
         StringOrNumberLiteral = 384,
@@ -2713,6 +2714,9 @@ declare namespace ts {
     }
     export interface EnumType extends Type {
     }
+    export interface ThrowType extends Type {
+        value: Type;
+    }
     export enum ObjectFlags {
         Class = 1,
         Interface = 2,
@@ -3518,7 +3522,7 @@ declare namespace ts {
         createParenthesizedType(type: TypeNode): ParenthesizedTypeNode;
         updateParenthesizedType(node: ParenthesizedTypeNode, type: TypeNode): ParenthesizedTypeNode;
         createThisTypeNode(): ThisTypeNode;
-        createTypeOperatorNode(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword, type: TypeNode): TypeOperatorNode;
+        createTypeOperatorNode(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.ThrowKeyword, type: TypeNode): TypeOperatorNode;
         updateTypeOperatorNode(node: TypeOperatorNode, type: TypeNode): TypeOperatorNode;
         createIndexedAccessTypeNode(objectType: TypeNode, indexType: TypeNode): IndexedAccessTypeNode;
         updateIndexedAccessTypeNode(node: IndexedAccessTypeNode, objectType: TypeNode, indexType: TypeNode): IndexedAccessTypeNode;

diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts
@@ -992,7 +992,7 @@ declare namespace ts {
     }
     export interface TypeOperatorNode extends TypeNode {
         readonly kind: SyntaxKind.TypeOperator;
-        readonly operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword;
+        readonly operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.ThrowKeyword;
         readonly type: TypeNode;
     }
     export interface IndexedAccessTypeNode extends TypeNode {
@@ -2665,6 +2665,7 @@ declare namespace ts {
         NonPrimitive = 67108864,
         TemplateLiteral = 134217728,
         StringMapping = 268435456,
+        ThrowType = 536870912,
         Literal = 2944,
         Unit = 109440,
         StringOrNumberLiteral = 384,
@@ -2713,6 +2714,9 @@ declare namespace ts {
     }
     export interface EnumType extends Type {
     }
+    export interface ThrowType extends Type {
+        value: Type;
+    }
     export enum ObjectFlags {
         Class = 1,
         Interface = 2,
@@ -3518,7 +3522,7 @@ declare namespace ts {
         createParenthesizedType(type: TypeNode): ParenthesizedTypeNode;
         updateParenthesizedType(node: ParenthesizedTypeNode, type: TypeNode): ParenthesizedTypeNode;
         createThisTypeNode(): ThisTypeNode;
-        createTypeOperatorNode(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword, type: TypeNode): TypeOperatorNode;
+        createTypeOperatorNode(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.ThrowKeyword, type: TypeNode): TypeOperatorNode;
         updateTypeOperatorNode(node: TypeOperatorNode, type: TypeNode): TypeOperatorNode;
         createIndexedAccessTypeNode(objectType: TypeNode, indexType: TypeNode): IndexedAccessTypeNode;
         updateIndexedAccessTypeNode(node: IndexedAccessTypeNode, objectType: TypeNode, indexType: TypeNode): IndexedAccessTypeNode;

diff --git a/tests/baselines/reference/throwType_function_parameter.errors.txt b/tests/baselines/reference/throwType_function_parameter.errors.txt
@@ -0,0 +1,33 @@
+tests/cases/compiler/throwType_function_parameter.ts(4,24): error TS2345: Argument of type 'number' is not assignable to parameter of type 'never'.
+tests/cases/compiler/throwType_function_parameter.ts(4,24): error TS2899: Type instantiated results in a throw type saying: 
+    No zero
+tests/cases/compiler/throwType_function_parameter.ts(13,4): error TS2345: Argument of type 'string' is not assignable to parameter of type 'never'.
+tests/cases/compiler/throwType_function_parameter.ts(13,4): error TS2899: Type instantiated results in a throw type saying: 
+    "found ""str""
+
+
+==== tests/cases/compiler/throwType_function_parameter.ts (4 errors) ====
+    function checkParameterPosition<T extends number>(y: T extends 1234 ? throw 'No zero' : T) {
+        y.toExponential()
+    }
+    checkParameterPosition(1234)
+                           ~~~~
+!!! error TS2345: Argument of type 'number' is not assignable to parameter of type 'never'.
+                           ~~~~
+!!! error TS2899: Type instantiated results in a throw type saying: 
+!!! error TS2899:     No zero
+    checkParameterPosition(12345678)
+
+    type MustNumber<T> = T extends number ? T : throw `"found "${TypeToString<T>}"`
+    type MustNumber2<T> = T extends number ? T : throw `"found "${TypeToString<T>}"`
+    function f2<T>(a: MustNumber<T>, b: MustNumber2<T>) {
+        a = b
+    }
+
+    f2('str', {})
+       ~~~~~
+!!! error TS2345: Argument of type 'string' is not assignable to parameter of type 'never'.
+       ~~~~~
+!!! error TS2899: Type instantiated results in a throw type saying: 
+!!! error TS2899:     "found ""str""
+
diff --git a/tests/baselines/reference/throwType_function_parameter.js b/tests/baselines/reference/throwType_function_parameter.js
@@ -0,0 +1,26 @@
+//// [throwType_function_parameter.ts]
+function checkParameterPosition<T extends number>(y: T extends 1234 ? throw 'No zero' : T) {
+    y.toExponential()
+}
+checkParameterPosition(1234)
+checkParameterPosition(12345678)
+
+type MustNumber<T> = T extends number ? T : throw `"found "${TypeToString<T>}"`
+type MustNumber2<T> = T extends number ? T : throw `"found "${TypeToString<T>}"`
+function f2<T>(a: MustNumber<T>, b: MustNumber2<T>) {
+    a = b
+}
+
+f2('str', {})
+
+
+//// [throwType_function_parameter.js]
+function checkParameterPosition(y) {
+    y.toExponential();
+}
+checkParameterPosition(1234);
+checkParameterPosition(12345678);
+function f2(a, b) {
+    a = b;
+}
+f2('str', {});
diff --git a/tests/baselines/reference/throwType_function_parameter.symbols b/tests/baselines/reference/throwType_function_parameter.symbols
@@ -0,0 +1,53 @@
+=== tests/cases/compiler/throwType_function_parameter.ts ===
+function checkParameterPosition<T extends number>(y: T extends 1234 ? throw 'No zero' : T) {
+>checkParameterPosition : Symbol(checkParameterPosition, Decl(throwType_function_parameter.ts, 0, 0))
+>T : Symbol(T, Decl(throwType_function_parameter.ts, 0, 32))
+>y : Symbol(y, Decl(throwType_function_parameter.ts, 0, 50))
+>T : Symbol(T, Decl(throwType_function_parameter.ts, 0, 32))
+>T : Symbol(T, Decl(throwType_function_parameter.ts, 0, 32))
+
+    y.toExponential()
+>y.toExponential : Symbol(Number.toExponential, Decl(lib.es5.d.ts, --, --))
+>y : Symbol(y, Decl(throwType_function_parameter.ts, 0, 50))
+>toExponential : Symbol(Number.toExponential, Decl(lib.es5.d.ts, --, --))
+}
+checkParameterPosition(1234)
+>checkParameterPosition : Symbol(checkParameterPosition, Decl(throwType_function_parameter.ts, 0, 0))
+
+checkParameterPosition(12345678)
+>checkParameterPosition : Symbol(checkParameterPosition, Decl(throwType_function_parameter.ts, 0, 0))
+
+type MustNumber<T> = T extends number ? T : throw `"found "${TypeToString<T>}"`
+>MustNumber : Symbol(MustNumber, Decl(throwType_function_parameter.ts, 4, 32))
+>T : Symbol(T, Decl(throwType_function_parameter.ts, 6, 16))
+>T : Symbol(T, Decl(throwType_function_parameter.ts, 6, 16))
+>T : Symbol(T, Decl(throwType_function_parameter.ts, 6, 16))
+>TypeToString : Symbol(TypeToString, Decl(lib.es5.d.ts, --, --))
+>T : Symbol(T, Decl(throwType_function_parameter.ts, 6, 16))
+
+type MustNumber2<T> = T extends number ? T : throw `"found "${TypeToString<T>}"`
+>MustNumber2 : Symbol(MustNumber2, Decl(throwType_function_parameter.ts, 6, 79))
+>T : Symbol(T, Decl(throwType_function_parameter.ts, 7, 17))
+>T : Symbol(T, Decl(throwType_function_parameter.ts, 7, 17))
+>T : Symbol(T, Decl(throwType_function_parameter.ts, 7, 17))
+>TypeToString : Symbol(TypeToString, Decl(lib.es5.d.ts, --, --))
+>T : Symbol(T, Decl(throwType_function_parameter.ts, 7, 17))
+
+function f2<T>(a: MustNumber<T>, b: MustNumber2<T>) {
+>f2 : Symbol(f2, Decl(throwType_function_parameter.ts, 7, 80))
+>T : Symbol(T, Decl(throwType_function_parameter.ts, 8, 12))
+>a : Symbol(a, Decl(throwType_function_parameter.ts, 8, 15))
+>MustNumber : Symbol(MustNumber, Decl(throwType_function_parameter.ts, 4, 32))
+>T : Symbol(T, Decl(throwType_function_parameter.ts, 8, 12))
+>b : Symbol(b, Decl(throwType_function_parameter.ts, 8, 32))
+>MustNumber2 : Symbol(MustNumber2, Decl(throwType_function_parameter.ts, 6, 79))
+>T : Symbol(T, Decl(throwType_function_parameter.ts, 8, 12))
+
+    a = b
+>a : Symbol(a, Decl(throwType_function_parameter.ts, 8, 15))
+>b : Symbol(b, Decl(throwType_function_parameter.ts, 8, 32))
+}
+
+f2('str', {})
+>f2 : Symbol(f2, Decl(throwType_function_parameter.ts, 7, 80))
+
diff --git a/tests/baselines/reference/throwType_function_parameter.types b/tests/baselines/reference/throwType_function_parameter.types
@@ -0,0 +1,44 @@
+=== tests/cases/compiler/throwType_function_parameter.ts ===
+function checkParameterPosition<T extends number>(y: T extends 1234 ? throw 'No zero' : T) {
+>checkParameterPosition : <T extends number>(y: T extends 1234 ? throw 'No zero' : T) => void
+>y : T extends 1234 ? never : T
+
+    y.toExponential()
+>y.toExponential() : string
+>y.toExponential : (fractionDigits?: number) => string
+>y : T extends 1234 ? never : T
+>toExponential : (fractionDigits?: number) => string
+}
+checkParameterPosition(1234)
+>checkParameterPosition(1234) : void
+>checkParameterPosition : <T extends number>(y: T extends 1234 ? never : T) => void
+>1234 : 1234
+
+checkParameterPosition(12345678)
+>checkParameterPosition(12345678) : void
+>checkParameterPosition : <T extends number>(y: T extends 1234 ? never : T) => void
+>12345678 : 12345678
+
+type MustNumber<T> = T extends number ? T : throw `"found "${TypeToString<T>}"`
+>MustNumber : MustNumber<T>
+
+type MustNumber2<T> = T extends number ? T : throw `"found "${TypeToString<T>}"`
+>MustNumber2 : MustNumber2<T>
+
+function f2<T>(a: MustNumber<T>, b: MustNumber2<T>) {
+>f2 : <T>(a: MustNumber<T>, b: MustNumber2<T>) => void
+>a : MustNumber<T>
+>b : MustNumber2<T>
+
+    a = b
+>a = b : MustNumber2<T>
+>a : MustNumber<T>
+>b : MustNumber2<T>
+}
+
+f2('str', {})
+>f2('str', {}) : void
+>f2 : <T>(a: MustNumber<T>, b: MustNumber2<T>) => void
+>'str' : "str"
+>{} : {}
+
diff --git a/tests/baselines/reference/throwType_function_return.errors.txt b/tests/baselines/reference/throwType_function_return.errors.txt
@@ -0,0 +1,24 @@
+tests/cases/compiler/throwType_function_return.ts(5,1): error TS2899: Type instantiated results in a throw type saying: 
+    Cannot divided by 0
+tests/cases/compiler/throwType_function_return.ts(10,1): error TS2899: Type instantiated results in a throw type saying: 
+    Wrong
+
+
+==== tests/cases/compiler/throwType_function_return.ts (2 errors) ====
+    function checkedDivide<T extends number>(x: T): T extends 0 ? throw 'Cannot divided by 0' : number {
+        if (x === 0) throw new Error('')
+        return 5 / x
+    }
+    checkedDivide(0)
+    ~~~~~~~~~~~~~~~~
+!!! error TS2899: Type instantiated results in a throw type saying: 
+!!! error TS2899:     Cannot divided by 0
+    checkedDivide(1)
+
+    const theAnswerToEverything = <T>(x: T): T extends 42 ? T : throw "Wrong" => x
+    theAnswerToEverything(42 as const)
+    theAnswerToEverything('')
+    ~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2899: Type instantiated results in a throw type saying: 
+!!! error TS2899:     Wrong
+
diff --git a/tests/baselines/reference/throwType_function_return.js b/tests/baselines/reference/throwType_function_return.js
@@ -0,0 +1,24 @@
+//// [throwType_function_return.ts]
+function checkedDivide<T extends number>(x: T): T extends 0 ? throw 'Cannot divided by 0' : number {
+    if (x === 0) throw new Error('')
+    return 5 / x
+}
+checkedDivide(0)
+checkedDivide(1)
+
+const theAnswerToEverything = <T>(x: T): T extends 42 ? T : throw "Wrong" => x
+theAnswerToEverything(42 as const)
+theAnswerToEverything('')
+
+
+//// [throwType_function_return.js]
+function checkedDivide(x) {
+    if (x === 0)
+        throw new Error('');
+    return 5 / x;
+}
+checkedDivide(0);
+checkedDivide(1);
+var theAnswerToEverything = function (x) { return x; };
+theAnswerToEverything(42);
+theAnswerToEverything('');