From a9336ba8a5df106fd40ca8816735b6a98cd7381e Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Thu, 12 Sep 2019 09:15:43 -0700
Subject: [PATCH] Revert "Use declared type for references in unreachable code"

This reverts commit 436339ddef241c3ae9da802ecddb9782e768cdc7.
---
 src/compiler/checker.ts | 16 ++++------------
 1 file changed, 4 insertions(+), 12 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index c7e11e5be6a..d2a106b903d 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -671,7 +671,6 @@ namespace ts {
         const silentNeverType = createIntrinsicType(TypeFlags.Never, "never");
         const nonInferrableType = createIntrinsicType(TypeFlags.Never, "never", ObjectFlags.NonInferrableType);
         const implicitNeverType = createIntrinsicType(TypeFlags.Never, "never");
-        const unreachableNeverType = createIntrinsicType(TypeFlags.Never, "never");
         const nonPrimitiveType = createIntrinsicType(TypeFlags.NonPrimitive, "object");
         const stringNumberSymbolType = getUnionType([stringType, numberType, esSymbolType]);
         const keyofConstraintType = keyofStringsOnly ? stringType : stringNumberSymbolType;
@@ -17009,7 +17008,7 @@ namespace ts {
             // on empty arrays are possible without implicit any errors and new element types can be inferred without
             // type mismatch errors.
             const resultType = getObjectFlags(evolvedType) & ObjectFlags.EvolvingArray && isEvolvingArrayOperationTarget(reference) ? autoArrayType : finalizeEvolvingArrayType(evolvedType);
-            if (resultType === unreachableNeverType || reference.parent && reference.parent.kind === SyntaxKind.NonNullExpression && getTypeWithFacts(resultType, TypeFacts.NEUndefinedOrNull).flags & TypeFlags.Never) {
+            if (reference.parent && reference.parent.kind === SyntaxKind.NonNullExpression && getTypeWithFacts(resultType, TypeFacts.NEUndefinedOrNull).flags & TypeFlags.Never) {
                 return declaredType;
             }
             return resultType;
@@ -17145,11 +17144,8 @@ namespace ts {
                 // Assignments only narrow the computed type if the declared type is a union type. Thus, we
                 // only need to evaluate the assigned type if the declared type is a union type.
                 if (isMatchingReference(reference, node)) {
-                    const flowType = getTypeAtFlowNode(flow.antecedent);
-                    if (flowType === unreachableNeverType) {
-                        return flowType;
-                    }
                     if (getAssignmentTargetKind(node) === AssignmentKind.Compound) {
+                        const flowType = getTypeAtFlowNode(flow.antecedent);
                         return createFlowType(getBaseTypeOfLiteralType(getTypeFromFlowType(flowType)), isIncomplete(flowType));
                     }
                     if (declaredType === autoType || declaredType === autoArrayType) {
@@ -17169,16 +17165,12 @@ namespace ts {
                 // reference 'x.y.z', we may be at an assignment to 'x.y' or 'x'. In that case,
                 // return the declared type.
                 if (containsMatchingReference(reference, node)) {
-                    const flowType = getTypeAtFlowNode(flow.antecedent);
-                    if (flowType === unreachableNeverType) {
-                        return flowType;
-                    }
                     // A matching dotted name might also be an expando property on a function *expression*,
                     // in which case we continue control flow analysis back to the function's declaration
                     if (isVariableDeclaration(node) && (isInJSFile(node) || isVarConst(node))) {
                         const init = getDeclaredExpandoInitializer(node);
                         if (init && (init.kind === SyntaxKind.FunctionExpression || init.kind === SyntaxKind.ArrowFunction)) {
-                            return flowType;
+                            return getTypeAtFlowNode(flow.antecedent);
                         }
                     }
                     return declaredType;
@@ -17217,7 +17209,7 @@ namespace ts {
                         return narrowedType === type ? flowType : createFlowType(narrowedType, isIncomplete(flowType));
                     }
                     if (getReturnTypeOfSignature(signature).flags & TypeFlags.Never) {
-                        return unreachableNeverType;
+                        return neverType;
                     }
                 }
                 return undefined;