From bc02341e9932411e01b36134f611d511f00d1cc8 Mon Sep 17 00:00:00 2001
From: Vladimir Matveev <vladima@microsoft.com>
Date: Tue, 13 Oct 2015 10:15:39 -0700
Subject: [PATCH] addressed PR feedback, updated tests to suppress reachability
 errors where they are not needed

---
 src/compiler/binder.ts                        |  103 +-
 src/compiler/types.ts                         |    4 +-
 .../bestCommonTypeReturnStatement.errors.txt  |   18 -
 .../bestCommonTypeReturnStatement.js          |    1 +
 .../bestCommonTypeReturnStatement.symbols     |   35 +
 .../bestCommonTypeReturnStatement.types       |   40 +
 .../reference/breakTarget3.errors.txt         |   11 -
 tests/baselines/reference/breakTarget3.js     |    1 +
 .../baselines/reference/breakTarget3.symbols  |    8 +
 tests/baselines/reference/breakTarget3.types  |   14 +
 .../reference/breakTarget4.errors.txt         |   11 -
 tests/baselines/reference/breakTarget4.js     |    1 +
 .../baselines/reference/breakTarget4.symbols  |    8 +
 tests/baselines/reference/breakTarget4.types  |   14 +
 .../reference/breakTarget5.errors.txt         |    8 +-
 tests/baselines/reference/breakTarget5.js     |    1 +
 ...utReturnTypeAnnotationInference.errors.txt |  126 -
 ...ureWithoutReturnTypeAnnotationInference.js |    1 +
 ...thoutReturnTypeAnnotationInference.symbols |  256 ++
 ...WithoutReturnTypeAnnotationInference.types |  297 ++
 .../reference/commentEmitAtEndOfFile1.js      |    1 +
 .../reference/commentEmitAtEndOfFile1.symbols |    9 +-
 .../reference/commentEmitAtEndOfFile1.types   |    1 +
 .../compoundAssignmentLHSIsValue.errors.txt   |  122 +-
 .../reference/compoundAssignmentLHSIsValue.js |    1 +
 .../conditionalExpressions2.errors.txt        |   15 -
 .../reference/conditionalExpressions2.js      |    1 +
 .../reference/conditionalExpressions2.symbols |   34 +
 .../reference/conditionalExpressions2.types   |   69 +
 ...nstDeclarations-invalidContexts.errors.txt |    8 +-
 ...constDeclarations-validContexts.errors.txt |    8 +-
 ...torWithIncompleteTypeAnnotation.errors.txt |  171 +-
 ...constructorWithIncompleteTypeAnnotation.js |    1 +
 ...ontinueNotInIterationStatement4.errors.txt |    8 +-
 .../continueNotInIterationStatement4.js       |    1 +
 .../reference/continueTarget3.errors.txt      |   11 -
 tests/baselines/reference/continueTarget3.js  |    1 +
 .../reference/continueTarget3.symbols         |    8 +
 .../baselines/reference/continueTarget3.types |   14 +
 .../reference/continueTarget4.errors.txt      |   11 -
 tests/baselines/reference/continueTarget4.js  |    1 +
 .../reference/continueTarget4.symbols         |    8 +
 .../baselines/reference/continueTarget4.types |   14 +
 .../reference/continueTarget5.errors.txt      |    8 +-
 tests/baselines/reference/continueTarget5.js  |    1 +
 .../doWhileBreakStatements.errors.txt         |   50 -
 .../reference/doWhileBreakStatements.js       |    1 +
 .../reference/doWhileBreakStatements.symbols  |   42 +
 .../reference/doWhileBreakStatements.types    |   81 +
 .../doWhileContinueStatements.errors.txt      |   44 -
 .../reference/doWhileContinueStatements.js    |    1 +
 .../doWhileContinueStatements.symbols         |   42 +
 .../reference/doWhileContinueStatements.types |   81 +
 .../reference/downlevelLetConst16.errors.txt  |   21 +-
 .../reference/downlevelLetConst16.js          |    1 +
 .../reference/downlevelLetConst17.errors.txt  |   73 -
 .../reference/downlevelLetConst17.symbols     |  134 +
 .../reference/downlevelLetConst17.types       |  169 +
 .../reference/downlevelLetConst18.errors.txt  |   24 +-
 .../reference/downlevelLetConst18.js          |    1 +
 .../reference/duplicateLabel1.errors.txt      |    8 +-
 tests/baselines/reference/duplicateLabel1.js  |    1 +
 .../reference/duplicateLabel2.errors.txt      |    8 +-
 tests/baselines/reference/duplicateLabel2.js  |    1 +
 .../reference/duplicateLabel3.errors.txt      |   17 -
 tests/baselines/reference/duplicateLabel3.js  |    1 +
 .../reference/duplicateLabel3.symbols         |   12 +
 .../baselines/reference/duplicateLabel3.types |   19 +
 .../reference/duplicateLabel4.errors.txt      |   16 -
 tests/baselines/reference/duplicateLabel4.js  |    1 +
 .../reference/duplicateLabel4.symbols         |   10 +
 .../baselines/reference/duplicateLabel4.types |   15 +
 .../duplicateLocalVariable1.errors.txt        |   24 +-
 .../reference/duplicateLocalVariable1.js      |    6 +-
 .../duplicateVariablesByScope.errors.txt      |   37 -
 .../reference/duplicateVariablesByScope.js    |    1 +
 .../duplicateVariablesByScope.symbols         |   57 +
 .../reference/duplicateVariablesByScope.types |   73 +
 .../es6ClassSuperCodegenBug.errors.txt        |   19 -
 .../reference/es6ClassSuperCodegenBug.js      |    1 +
 .../reference/es6ClassSuperCodegenBug.symbols |   25 +
 .../reference/es6ClassSuperCodegenBug.types   |   33 +
 .../reference/escapedIdentifiers.errors.txt   |  146 -
 .../baselines/reference/escapedIdentifiers.js |    1 +
 .../reference/escapedIdentifiers.symbols      |  261 ++
 .../reference/escapedIdentifiers.types        |  352 ++
 tests/baselines/reference/for.errors.txt      |    8 +-
 tests/baselines/reference/for.js              |    1 +
 .../reference/forBreakStatements.errors.txt   |   49 -
 .../baselines/reference/forBreakStatements.js |    1 +
 .../reference/forBreakStatements.symbols      |   41 +
 .../reference/forBreakStatements.types        |   64 +
 .../forContinueStatements.errors.txt          |   43 -
 .../reference/forContinueStatements.js        |    1 +
 .../reference/forContinueStatements.symbols   |   41 +
 .../reference/forContinueStatements.types     |   64 +
 .../reference/forInBreakStatements.errors.txt |   46 -
 .../reference/forInBreakStatements.js         |    1 +
 .../reference/forInBreakStatements.symbols    |   59 +
 .../reference/forInBreakStatements.types      |   93 +
 .../forInContinueStatements.errors.txt        |   46 -
 .../reference/forInContinueStatements.js      |    1 +
 .../reference/forInContinueStatements.symbols |   59 +
 .../reference/forInContinueStatements.types   |   93 +
 .../reference/forStatements.errors.txt        |   52 -
 tests/baselines/reference/forStatements.js    |    1 +
 .../baselines/reference/forStatements.symbols |  146 +
 tests/baselines/reference/forStatements.types |  165 +
 ...orStatementsMultipleInvalidDecl.errors.txt |   30 +-
 .../forStatementsMultipleInvalidDecl.js       |    1 +
 .../forStatementsMultipleValidDecl.errors.txt |   39 -
 .../forStatementsMultipleValidDecl.js         |    1 +
 .../forStatementsMultipleValidDecl.symbols    |  111 +
 .../forStatementsMultipleValidDecl.types      |  141 +
 .../functionImplementationErrors.errors.txt   |   62 +-
 .../reference/functionImplementationErrors.js |    1 +
 .../functionImplementations.errors.txt        |  183 -
 .../reference/functionImplementations.js      |    1 +
 .../reference/functionImplementations.symbols |  345 ++
 .../reference/functionImplementations.types   |  417 ++
 .../reference/functionOverloads12.errors.txt  |   10 -
 .../reference/functionOverloads12.js          |    1 +
 .../reference/functionOverloads12.symbols     |   11 +
 .../reference/functionOverloads12.types       |   14 +
 .../reference/functionReturn.errors.txt       |   23 -
 tests/baselines/reference/functionReturn.js   |    1 +
 .../reference/functionReturn.symbols          |   31 +
 .../baselines/reference/functionReturn.types  |   36 +
 ...ionWithMultipleReturnStatements.errors.txt |   36 +-
 .../functionWithMultipleReturnStatements.js   |    1 +
 ...onWithMultipleReturnStatements2.errors.txt |   31 +-
 .../functionWithMultipleReturnStatements2.js  |    1 +
 .../functionWithNoBestCommonType1.errors.txt  |    8 +-
 .../functionWithNoBestCommonType1.js          |    1 +
 .../functionWithNoBestCommonType2.errors.txt  |    8 +-
 .../functionWithNoBestCommonType2.js          |    1 +
 ...gReturnStatementsAndExpressions.errors.txt |   18 +-
 ...nsMissingReturnStatementsAndExpressions.js |    1 +
 .../generatedContextualTyping.errors.txt      |  393 --
 .../reference/generatedContextualTyping.js    |    1 +
 .../generatedContextualTyping.symbols         | 2832 +++++++++++++
 .../reference/generatedContextualTyping.types | 3769 +++++++++++++++++
 .../reference/ifDoWhileStatements.errors.txt  |  168 -
 .../reference/ifDoWhileStatements.js          |    1 +
 .../reference/ifDoWhileStatements.symbols     |  337 ++
 .../reference/ifDoWhileStatements.types       |  434 ++
 .../ifElseWithStatements1.errors.txt          |   13 +-
 .../reference/ifElseWithStatements1.js        |    1 +
 ...edFunctionReturnTypeIsEmptyType.errors.txt |    8 +-
 .../inferredFunctionReturnTypeIsEmptyType.js  |    1 +
 ...taticPropertyOverridingAccessor.errors.txt |   10 +-
 ...ritanceStaticPropertyOverridingAccessor.js |    1 +
 .../interfaceExtendingClass2.errors.txt       |   14 +-
 .../reference/interfaceExtendingClass2.js     |    1 +
 .../interfaceWithPrivateMember.errors.txt     |   16 +-
 .../reference/interfaceWithPrivateMember.js   |    1 +
 .../invalidDoWhileBreakStatements.errors.txt  |   21 +-
 .../invalidDoWhileBreakStatements.js          |    1 +
 ...nvalidDoWhileContinueStatements.errors.txt |   21 +-
 .../invalidDoWhileContinueStatements.js       |    1 +
 .../invalidForBreakStatements.errors.txt      |   21 +-
 .../reference/invalidForBreakStatements.js    |    1 +
 .../invalidForContinueStatements.errors.txt   |   21 +-
 .../reference/invalidForContinueStatements.js |    1 +
 .../invalidForInBreakStatements.errors.txt    |   30 +-
 .../reference/invalidForInBreakStatements.js  |    1 +
 .../invalidForInContinueStatements.errors.txt |   30 +-
 .../invalidForInContinueStatements.js         |    1 +
 .../invalidThrowStatement.errors.txt          |   10 +-
 .../reference/invalidThrowStatement.js        |    1 +
 .../invalidWhileContinueStatements.errors.txt |   21 +-
 .../invalidWhileContinueStatements.js         |    1 +
 .../letAndVarRedeclaration.errors.txt         |   42 +-
 .../reference/letAndVarRedeclaration.js       |    1 +
 ...letDeclarations-invalidContexts.errors.txt |   27 +-
 .../letDeclarations-invalidContexts.js        |    1 +
 .../letDeclarations-scopes.errors.txt         |   14 +-
 .../reference/letDeclarations-scopes.js       |    1 +
 .../letDeclarations-validContexts.errors.txt  |   23 +-
 .../letDeclarations-validContexts.js          |    1 +
 .../reference/localTypes4.errors.txt          |   14 +-
 tests/baselines/reference/localTypes4.js      |    1 +
 tests/baselines/reference/null.errors.txt     |   30 -
 tests/baselines/reference/null.js             |    1 +
 tests/baselines/reference/null.symbols        |   45 +
 tests/baselines/reference/null.types          |   60 +
 ...overloadOnConstAsTypeAnnotation.errors.txt |   12 +-
 .../overloadOnConstAsTypeAnnotation.js        |    1 +
 .../reference/parser10.1.1-8gs.errors.txt     |   10 +-
 tests/baselines/reference/parser10.1.1-8gs.js |    1 +
 .../reference/parser768531.errors.txt         |    8 -
 tests/baselines/reference/parser768531.js     |    1 +
 .../baselines/reference/parser768531.symbols  |    5 +
 tests/baselines/reference/parser768531.types  |    9 +
 .../reference/whileBreakStatements.errors.txt |   54 -
 .../reference/whileBreakStatements.js         |    1 +
 .../reference/whileBreakStatements.symbols    |   46 +
 .../reference/whileBreakStatements.types      |   90 +
 .../compiler/bestCommonTypeReturnStatement.ts |    2 +
 tests/cases/compiler/breakTarget3.ts          |    2 +
 tests/cases/compiler/breakTarget4.ts          |    2 +
 tests/cases/compiler/breakTarget5.ts          |    2 +
 .../cases/compiler/commentEmitAtEndOfFile1.ts |    2 +
 .../cases/compiler/conditionalExpressions2.ts |    2 +
 .../constDeclarations-invalidContexts.ts      |    1 +
 .../constDeclarations-validContexts.ts        |    1 +
 ...constructorWithIncompleteTypeAnnotation.ts |    2 +
 .../continueNotInIterationStatement4.ts       |    2 +
 tests/cases/compiler/continueTarget3.ts       |    2 +
 tests/cases/compiler/continueTarget4.ts       |    2 +
 tests/cases/compiler/continueTarget5.ts       |    2 +
 tests/cases/compiler/downlevelLetConst16.ts   |    2 +
 tests/cases/compiler/downlevelLetConst17.ts   |    1 +
 tests/cases/compiler/downlevelLetConst18.ts   |    2 +
 tests/cases/compiler/duplicateLabel1.ts       |    2 +
 tests/cases/compiler/duplicateLabel2.ts       |    2 +
 tests/cases/compiler/duplicateLabel3.ts       |    2 +
 tests/cases/compiler/duplicateLabel4.ts       |    3 +
 .../cases/compiler/duplicateLocalVariable1.ts |    4 +-
 .../compiler/duplicateVariablesByScope.ts     |    2 +
 .../cases/compiler/es6ClassSuperCodegenBug.ts |    2 +
 tests/cases/compiler/escapedIdentifiers.ts    |    3 +
 tests/cases/compiler/for.ts                   |    2 +
 tests/cases/compiler/functionOverloads12.ts   |    2 +
 tests/cases/compiler/functionReturn.ts        |    2 +
 .../compiler/functionWithNoBestCommonType1.ts |    2 +
 .../compiler/functionWithNoBestCommonType2.ts |    2 +
 ...nsMissingReturnStatementsAndExpressions.ts |    2 +
 tests/cases/compiler/ifElseWithStatements1.ts |    2 +
 .../inferredFunctionReturnTypeIsEmptyType.ts  |    2 +
 ...ritanceStaticPropertyOverridingAccessor.ts |    2 +
 .../cases/compiler/letAndVarRedeclaration.ts  |    2 +
 .../letDeclarations-invalidContexts.ts        |    2 +
 .../cases/compiler/letDeclarations-scopes.ts  |    3 +
 .../compiler/letDeclarations-validContexts.ts |    3 +
 tests/cases/compiler/null.ts                  |    2 +
 .../overloadOnConstAsTypeAnnotation.ts        |    2 +
 .../compoundAssignmentLHSIsValue.ts           |    2 +
 .../generatedContextualTyping.ts              |    2 +
 .../functions/functionImplementationErrors.ts |    2 +
 .../functions/functionImplementations.ts      |    2 +
 .../interfaceExtendingClass2.ts               |    2 +
 .../parser/ecmascript5/Fuzz/parser768531.ts   |    2 +
 .../parser/ecmascript5/parser10.1.1-8gs.ts    |    2 +
 .../breakStatements/doWhileBreakStatements.ts |    3 +
 .../breakStatements/forBreakStatements.ts     |    3 +
 .../breakStatements/forInBreakStatements.ts   |    2 +
 .../invalidDoWhileBreakStatements.ts          |    3 +
 .../invalidForBreakStatements.ts              |    3 +
 .../invalidForInBreakStatements.ts            |    3 +
 .../breakStatements/whileBreakStatements.ts   |    3 +
 .../doWhileContinueStatements.ts              |    2 +
 .../forContinueStatements.ts                  |    2 +
 .../forInContinueStatements.ts                |    2 +
 .../invalidDoWhileContinueStatements.ts       |    3 +
 .../invalidForContinueStatements.ts           |    3 +
 .../invalidForInContinueStatements.ts         |    3 +
 .../invalidWhileContinueStatements.ts         |    3 +
 .../statements/forStatements/forStatements.ts |    2 +
 .../forStatementsMultipleInvalidDecl.ts       |    2 +
 .../forStatementsMultipleValidDecl.ts         |    2 +
 .../ifDoWhileStatements.ts                    |    2 +
 .../throwStatements/invalidThrowStatement.ts  |    2 +
 .../types/localTypes/localTypes4.ts           |    2 +
 .../namedTypes/interfaceWithPrivateMember.ts  |    2 +
 ...ureWithoutReturnTypeAnnotationInference.ts |    2 +
 .../functionWithMultipleReturnStatements.ts   |    2 +
 .../functionWithMultipleReturnStatements2.ts  |    2 +
 268 files changed, 12446 insertions(+), 2425 deletions(-)
 delete mode 100644 tests/baselines/reference/bestCommonTypeReturnStatement.errors.txt
 create mode 100644 tests/baselines/reference/bestCommonTypeReturnStatement.symbols
 create mode 100644 tests/baselines/reference/bestCommonTypeReturnStatement.types
 delete mode 100644 tests/baselines/reference/breakTarget3.errors.txt
 create mode 100644 tests/baselines/reference/breakTarget3.symbols
 create mode 100644 tests/baselines/reference/breakTarget3.types
 delete mode 100644 tests/baselines/reference/breakTarget4.errors.txt
 create mode 100644 tests/baselines/reference/breakTarget4.symbols
 create mode 100644 tests/baselines/reference/breakTarget4.types
 delete mode 100644 tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.errors.txt
 create mode 100644 tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.symbols
 create mode 100644 tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.types
 delete mode 100644 tests/baselines/reference/conditionalExpressions2.errors.txt
 create mode 100644 tests/baselines/reference/conditionalExpressions2.symbols
 create mode 100644 tests/baselines/reference/conditionalExpressions2.types
 delete mode 100644 tests/baselines/reference/continueTarget3.errors.txt
 create mode 100644 tests/baselines/reference/continueTarget3.symbols
 create mode 100644 tests/baselines/reference/continueTarget3.types
 delete mode 100644 tests/baselines/reference/continueTarget4.errors.txt
 create mode 100644 tests/baselines/reference/continueTarget4.symbols
 create mode 100644 tests/baselines/reference/continueTarget4.types
 delete mode 100644 tests/baselines/reference/doWhileBreakStatements.errors.txt
 create mode 100644 tests/baselines/reference/doWhileBreakStatements.symbols
 create mode 100644 tests/baselines/reference/doWhileBreakStatements.types
 delete mode 100644 tests/baselines/reference/doWhileContinueStatements.errors.txt
 create mode 100644 tests/baselines/reference/doWhileContinueStatements.symbols
 create mode 100644 tests/baselines/reference/doWhileContinueStatements.types
 delete mode 100644 tests/baselines/reference/downlevelLetConst17.errors.txt
 create mode 100644 tests/baselines/reference/downlevelLetConst17.symbols
 create mode 100644 tests/baselines/reference/downlevelLetConst17.types
 delete mode 100644 tests/baselines/reference/duplicateLabel3.errors.txt
 create mode 100644 tests/baselines/reference/duplicateLabel3.symbols
 create mode 100644 tests/baselines/reference/duplicateLabel3.types
 delete mode 100644 tests/baselines/reference/duplicateLabel4.errors.txt
 create mode 100644 tests/baselines/reference/duplicateLabel4.symbols
 create mode 100644 tests/baselines/reference/duplicateLabel4.types
 delete mode 100644 tests/baselines/reference/duplicateVariablesByScope.errors.txt
 create mode 100644 tests/baselines/reference/duplicateVariablesByScope.symbols
 create mode 100644 tests/baselines/reference/duplicateVariablesByScope.types
 delete mode 100644 tests/baselines/reference/es6ClassSuperCodegenBug.errors.txt
 create mode 100644 tests/baselines/reference/es6ClassSuperCodegenBug.symbols
 create mode 100644 tests/baselines/reference/es6ClassSuperCodegenBug.types
 delete mode 100644 tests/baselines/reference/escapedIdentifiers.errors.txt
 create mode 100644 tests/baselines/reference/escapedIdentifiers.symbols
 create mode 100644 tests/baselines/reference/escapedIdentifiers.types
 delete mode 100644 tests/baselines/reference/forBreakStatements.errors.txt
 create mode 100644 tests/baselines/reference/forBreakStatements.symbols
 create mode 100644 tests/baselines/reference/forBreakStatements.types
 delete mode 100644 tests/baselines/reference/forContinueStatements.errors.txt
 create mode 100644 tests/baselines/reference/forContinueStatements.symbols
 create mode 100644 tests/baselines/reference/forContinueStatements.types
 delete mode 100644 tests/baselines/reference/forInBreakStatements.errors.txt
 create mode 100644 tests/baselines/reference/forInBreakStatements.symbols
 create mode 100644 tests/baselines/reference/forInBreakStatements.types
 delete mode 100644 tests/baselines/reference/forInContinueStatements.errors.txt
 create mode 100644 tests/baselines/reference/forInContinueStatements.symbols
 create mode 100644 tests/baselines/reference/forInContinueStatements.types
 delete mode 100644 tests/baselines/reference/forStatements.errors.txt
 create mode 100644 tests/baselines/reference/forStatements.symbols
 create mode 100644 tests/baselines/reference/forStatements.types
 delete mode 100644 tests/baselines/reference/forStatementsMultipleValidDecl.errors.txt
 create mode 100644 tests/baselines/reference/forStatementsMultipleValidDecl.symbols
 create mode 100644 tests/baselines/reference/forStatementsMultipleValidDecl.types
 delete mode 100644 tests/baselines/reference/functionImplementations.errors.txt
 create mode 100644 tests/baselines/reference/functionImplementations.symbols
 create mode 100644 tests/baselines/reference/functionImplementations.types
 delete mode 100644 tests/baselines/reference/functionOverloads12.errors.txt
 create mode 100644 tests/baselines/reference/functionOverloads12.symbols
 create mode 100644 tests/baselines/reference/functionOverloads12.types
 delete mode 100644 tests/baselines/reference/functionReturn.errors.txt
 create mode 100644 tests/baselines/reference/functionReturn.symbols
 create mode 100644 tests/baselines/reference/functionReturn.types
 delete mode 100644 tests/baselines/reference/generatedContextualTyping.errors.txt
 create mode 100644 tests/baselines/reference/generatedContextualTyping.symbols
 create mode 100644 tests/baselines/reference/generatedContextualTyping.types
 delete mode 100644 tests/baselines/reference/ifDoWhileStatements.errors.txt
 create mode 100644 tests/baselines/reference/ifDoWhileStatements.symbols
 create mode 100644 tests/baselines/reference/ifDoWhileStatements.types
 delete mode 100644 tests/baselines/reference/null.errors.txt
 create mode 100644 tests/baselines/reference/null.symbols
 create mode 100644 tests/baselines/reference/null.types
 delete mode 100644 tests/baselines/reference/parser768531.errors.txt
 create mode 100644 tests/baselines/reference/parser768531.symbols
 create mode 100644 tests/baselines/reference/parser768531.types
 delete mode 100644 tests/baselines/reference/whileBreakStatements.errors.txt
 create mode 100644 tests/baselines/reference/whileBreakStatements.symbols
 create mode 100644 tests/baselines/reference/whileBreakStatements.types

diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts
index a520e3cd58a..8e764947ee8 100644
--- a/src/compiler/binder.ts
+++ b/src/compiler/binder.ts
@@ -374,10 +374,6 @@ namespace ts {
             blockScopeContainer = savedBlockScopeContainer;
         }
 
-        function shouldSaveReachabilityState(n: Node): boolean {
-            return n.kind === SyntaxKind.SourceFile || n.kind === SyntaxKind.ModuleBlock || isFunctionLike(n);
-        }
-
         function bindWithReachabilityChecks(node: Node): void {
             let savedReachabilityState: Reachability;
             let savedLabelStack: Reachability[];
@@ -385,7 +381,10 @@ namespace ts {
             let savedImplicitLabels: number[];
             let savedHasExplicitReturn: boolean;
 
-            let saveState = shouldSaveReachabilityState(node);
+            // reset all reachability check related flags on node (for incremental scenarios)
+            node.flags &= ~NodeFlags.ReachabilityCheckFlags;
+
+            let saveState = node.kind === SyntaxKind.SourceFile || node.kind === SyntaxKind.ModuleBlock || isFunctionLike(node);
             if (saveState) {
                 savedReachabilityState = currentReachabilityState;
                 savedLabelStack = labelStack;
@@ -398,9 +397,7 @@ namespace ts {
                 labelStack = labelIndexMap = implicitLabels = undefined;
             }
 
-            if (!bindReachableStatement(node)) {
-                forEachChild(node, bind);
-            }
+            bindReachableStatement(node);
 
             if (currentReachabilityState === Reachability.Reachable && isFunctionLike(node) && nodeIsPresent((<FunctionLikeDeclaration>node).body)) {
                 node.flags |= NodeFlags.HasImplicitReturn;
@@ -422,43 +419,56 @@ namespace ts {
          * Returns true if node and its subnodes were successfully traversed.
          * Returning false means that node was not examined and caller needs to dive into the node himself. 
          */
-        function bindReachableStatement(node: Node): boolean {
+        function bindReachableStatement(node: Node): void {
             if (checkUnreachable(node)) {
-                return false;
+                forEachChild(node, bind);
+                return;
             }
 
             switch (node.kind) {
                 case SyntaxKind.WhileStatement:
-                    return bindWhileStatement(<WhileStatement>node);
+                    bindWhileStatement(<WhileStatement>node);
+                    break;
                 case SyntaxKind.DoStatement:
-                    return bindDoStatement(<DoStatement>node);
+                    bindDoStatement(<DoStatement>node);
+                    break;
                 case SyntaxKind.ForStatement:
-                    return bindForStatement(<ForStatement>node);
+                    bindForStatement(<ForStatement>node);
+                    break;
                 case SyntaxKind.ForInStatement:
                 case SyntaxKind.ForOfStatement:
-                    return bindForInOrForOfStatement(<ForInStatement | ForOfStatement>node);
+                    bindForInOrForOfStatement(<ForInStatement | ForOfStatement>node);
+                    break;
                 case SyntaxKind.IfStatement:
-                    return bindIfStatement(<IfStatement>node);
+                    bindIfStatement(<IfStatement>node);
+                    break;
                 case SyntaxKind.ReturnStatement:
                 case SyntaxKind.ThrowStatement:
-                    return bindReturnOrThrow(<ReturnStatement | ThrowStatement>node);
+                    bindReturnOrThrow(<ReturnStatement | ThrowStatement>node);
+                    break;
                 case SyntaxKind.BreakStatement:
                 case SyntaxKind.ContinueStatement:
-                    return bindBreakOrContinueStatement(<BreakOrContinueStatement>node);
+                    bindBreakOrContinueStatement(<BreakOrContinueStatement>node);
+                    break;
                 case SyntaxKind.TryStatement:
-                    return bindTryStatement(<TryStatement>node);
+                    bindTryStatement(<TryStatement>node);
+                    break;
                 case SyntaxKind.SwitchStatement:
-                    return bindSwitchStatement(<SwitchStatement>node);
+                    bindSwitchStatement(<SwitchStatement>node);
+                    break;
                 case SyntaxKind.CaseBlock:
-                    return bindCaseBlock(<CaseBlock>node);
+                    bindCaseBlock(<CaseBlock>node);
+                    break;
                 case SyntaxKind.LabeledStatement:
-                    return bindLabeledStatement(<LabeledStatement>node);
+                    bindLabeledStatement(<LabeledStatement>node);
+                    break;
                 default:
-                    return false;
+                    forEachChild(node, bind);
+                    break;
             }
         }
 
-        function bindWhileStatement(n: WhileStatement): boolean {
+        function bindWhileStatement(n: WhileStatement): void {
             const preWhileState =
                 n.expression.kind === SyntaxKind.FalseKeyword ? Reachability.Unreachable : currentReachabilityState;
             const postWhileState =
@@ -471,11 +481,9 @@ namespace ts {
             const postWhileLabel = pushImplicitLabel();
             bind(n.statement);
             popImplicitLabel(postWhileLabel, postWhileState);
-
-            return true;
         }
 
-        function bindDoStatement(n: DoStatement): boolean {
+        function bindDoStatement(n: DoStatement): void {
             const preDoState = currentReachabilityState;
 
             const postDoLabel = pushImplicitLabel();
@@ -485,11 +493,9 @@ namespace ts {
 
             // bind expressions (don't affect reachability)
             bind(n.expression);
-
-            return true;
         }
 
-        function bindForStatement(n: ForStatement): boolean {
+        function bindForStatement(n: ForStatement): void {
             const preForState = currentReachabilityState;
             const postForLabel = pushImplicitLabel();
 
@@ -506,11 +512,9 @@ namespace ts {
             const isInfiniteLoop = (!n.condition || n.condition.kind === SyntaxKind.TrueKeyword);
             const postForState = isInfiniteLoop ? Reachability.Unreachable : preForState;
             popImplicitLabel(postForLabel, postForState);
-
-            return true;
         }
 
-        function bindForInOrForOfStatement(n: ForInStatement | ForOfStatement): boolean {
+        function bindForInOrForOfStatement(n: ForInStatement | ForOfStatement): void {
             const preStatementState = currentReachabilityState;
             const postStatementLabel = pushImplicitLabel();
 
@@ -520,11 +524,9 @@ namespace ts {
 
             bind(n.statement);
             popImplicitLabel(postStatementLabel, preStatementState);
-
-            return true;
         }
 
-        function bindIfStatement(n: IfStatement): boolean {
+        function bindIfStatement(n: IfStatement): void {
             // denotes reachability state when entering 'thenStatement' part of the if statement: 
             // i.e. if condition is false then thenStatement is unreachable
             const ifTrueState = n.expression.kind === SyntaxKind.FalseKeyword ? Reachability.Unreachable : currentReachabilityState;
@@ -547,22 +549,18 @@ namespace ts {
             else {
                 currentReachabilityState = or(currentReachabilityState, ifFalseState);
             }
-
-            return true;
         }
 
-        function bindReturnOrThrow(n: ReturnStatement | ThrowStatement): boolean {
+        function bindReturnOrThrow(n: ReturnStatement | ThrowStatement): void {
             // bind expression (don't affect reachability)
             bind(n.expression);
             if (n.kind === SyntaxKind.ReturnStatement) {
                 hasExplicitReturn = true;
             }
             currentReachabilityState = Reachability.Unreachable;
-
-            return true;
         }
 
-        function bindBreakOrContinueStatement(n: BreakOrContinueStatement): boolean {
+        function bindBreakOrContinueStatement(n: BreakOrContinueStatement): void {
             // call bind on label (don't affect reachability)
             bind(n.label);
             // for continue case touch label so it will be marked a used
@@ -570,10 +568,9 @@ namespace ts {
             if (isValidJump) {
                 currentReachabilityState = Reachability.Unreachable;
             }
-            return true;
         }
 
-        function bindTryStatement(n: TryStatement): boolean {
+        function bindTryStatement(n: TryStatement): void {
             // catch\finally blocks has the same reachability as try block
             const preTryState = currentReachabilityState;
             bind(n.tryBlock);
@@ -590,11 +587,9 @@ namespace ts {
             // - post try state is reachable - control flow can fall out of try block
             // - post catch state is reachable - control flow can fall out of catch block
             currentReachabilityState = or(postTryState, postCatchState);
-
-            return true;
         }
 
-        function bindSwitchStatement(n: SwitchStatement): boolean {
+        function bindSwitchStatement(n: SwitchStatement): void {
             const preSwitchState = currentReachabilityState;
             const postSwitchLabel = pushImplicitLabel();
 
@@ -609,11 +604,9 @@ namespace ts {
             const postSwitchState = hasDefault && currentReachabilityState !== Reachability.Reachable ? Reachability.Unreachable : preSwitchState;
 
             popImplicitLabel(postSwitchLabel, postSwitchState);
-
-            return true;
         }
 
-        function bindCaseBlock(n: CaseBlock): boolean {
+        function bindCaseBlock(n: CaseBlock): void {
             const startState = currentReachabilityState;
 
             for (let clause of n.clauses) {
@@ -623,11 +616,9 @@ namespace ts {
                     errorOnFirstToken(clause, Diagnostics.Fallthrough_case_in_switch);
                 }
             }
-
-            return true;
         }
 
-        function bindLabeledStatement(n: LabeledStatement): boolean {
+        function bindLabeledStatement(n: LabeledStatement): void {
             // call bind on label (don't affect reachability)
             bind(n.label);
 
@@ -636,8 +627,6 @@ namespace ts {
             if (ok) {
                 popNamedLabel(n.label, currentReachabilityState);
             }
-
-            return true;
         }
 
         function getContainerFlags(node: Node): ContainerFlags {
@@ -1387,8 +1376,6 @@ namespace ts {
         }
 
         function popNamedLabel(label: Identifier, outerState: Reachability): void {
-            initializeReachabilityStateIfNecessary();
-
             let index = labelIndexMap[label.text];
             Debug.assert(index !== undefined);
             Debug.assert(labelStack.length == index + 1);
@@ -1399,8 +1386,6 @@ namespace ts {
         }
 
         function popImplicitLabel(implicitLabelIndex: number, outerState: Reachability): void {
-            initializeReachabilityStateIfNecessary();
-
             Debug.assert(labelStack.length === implicitLabelIndex + 1, `Label stack: ${labelStack.length}, index:${implicitLabelIndex}`);
             let i = implicitLabels.pop();
             Debug.assert(implicitLabelIndex === i, `i: ${i}, index: ${implicitLabelIndex}`);
@@ -1408,8 +1393,6 @@ namespace ts {
         }
 
         function setCurrentStateAtLabel(innerMergedState: Reachability, outerState: Reachability, label: Identifier): void {
-            initializeReachabilityStateIfNecessary();
-
             if (innerMergedState === Reachability.Unintialized) {
                 if (label && !options.allowUnusedLabels) {
                     file.bindDiagnostics.push(createDiagnosticForNode(label, Diagnostics.Unused_label));
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index c3afe56a2e9..fef3f071125 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -384,7 +384,9 @@ namespace ts {
 
         Modifier = Export | Ambient | Public | Private | Protected | Static | Abstract | Default | Async,
         AccessibilityModifier = Public | Private | Protected,
-        BlockScoped = Let | Const
+        BlockScoped = Let | Const,
+
+        ReachabilityCheckFlags = HasImplicitReturn | HasExplicitReturn
     }
 
     /* @internal */
diff --git a/tests/baselines/reference/bestCommonTypeReturnStatement.errors.txt b/tests/baselines/reference/bestCommonTypeReturnStatement.errors.txt
deleted file mode 100644
index af83d53a722..00000000000
--- a/tests/baselines/reference/bestCommonTypeReturnStatement.errors.txt
+++ /dev/null
@@ -1,18 +0,0 @@
-tests/cases/compiler/bestCommonTypeReturnStatement.ts(7,5): error TS7027: Unreachable code detected.
-
-
-==== tests/cases/compiler/bestCommonTypeReturnStatement.ts (1 errors) ====
-    interface IPromise<T> {
-        then(successCallback: (promiseValue: T) => any, errorCallback?: (reason: any) => any): IPromise<any>;
-    }
-    
-    function f() {
-        if (true) return b();
-        return d();
-        ~~~~~~
-!!! error TS7027: Unreachable code detected.
-    }
-    
-    
-    function b(): IPromise<void> { return null; }
-    function d(): IPromise<any> { return null; }
\ No newline at end of file
diff --git a/tests/baselines/reference/bestCommonTypeReturnStatement.js b/tests/baselines/reference/bestCommonTypeReturnStatement.js
index f4ab98ed1c6..6d6f73bc0cf 100644
--- a/tests/baselines/reference/bestCommonTypeReturnStatement.js
+++ b/tests/baselines/reference/bestCommonTypeReturnStatement.js
@@ -1,4 +1,5 @@
 //// [bestCommonTypeReturnStatement.ts]
+
 interface IPromise<T> {
     then(successCallback: (promiseValue: T) => any, errorCallback?: (reason: any) => any): IPromise<any>;
 }
diff --git a/tests/baselines/reference/bestCommonTypeReturnStatement.symbols b/tests/baselines/reference/bestCommonTypeReturnStatement.symbols
new file mode 100644
index 00000000000..14e770ae255
--- /dev/null
+++ b/tests/baselines/reference/bestCommonTypeReturnStatement.symbols
@@ -0,0 +1,35 @@
+=== tests/cases/compiler/bestCommonTypeReturnStatement.ts ===
+
+interface IPromise<T> {
+>IPromise : Symbol(IPromise, Decl(bestCommonTypeReturnStatement.ts, 0, 0))
+>T : Symbol(T, Decl(bestCommonTypeReturnStatement.ts, 1, 19))
+
+    then(successCallback: (promiseValue: T) => any, errorCallback?: (reason: any) => any): IPromise<any>;
+>then : Symbol(then, Decl(bestCommonTypeReturnStatement.ts, 1, 23))
+>successCallback : Symbol(successCallback, Decl(bestCommonTypeReturnStatement.ts, 2, 9))
+>promiseValue : Symbol(promiseValue, Decl(bestCommonTypeReturnStatement.ts, 2, 27))
+>T : Symbol(T, Decl(bestCommonTypeReturnStatement.ts, 1, 19))
+>errorCallback : Symbol(errorCallback, Decl(bestCommonTypeReturnStatement.ts, 2, 51))
+>reason : Symbol(reason, Decl(bestCommonTypeReturnStatement.ts, 2, 69))
+>IPromise : Symbol(IPromise, Decl(bestCommonTypeReturnStatement.ts, 0, 0))
+}
+
+function f() {
+>f : Symbol(f, Decl(bestCommonTypeReturnStatement.ts, 3, 1))
+
+    if (true) return b();
+>b : Symbol(b, Decl(bestCommonTypeReturnStatement.ts, 8, 1))
+
+    return d();
+>d : Symbol(d, Decl(bestCommonTypeReturnStatement.ts, 11, 45))
+}
+
+
+function b(): IPromise<void> { return null; }
+>b : Symbol(b, Decl(bestCommonTypeReturnStatement.ts, 8, 1))
+>IPromise : Symbol(IPromise, Decl(bestCommonTypeReturnStatement.ts, 0, 0))
+
+function d(): IPromise<any> { return null; }
+>d : Symbol(d, Decl(bestCommonTypeReturnStatement.ts, 11, 45))
+>IPromise : Symbol(IPromise, Decl(bestCommonTypeReturnStatement.ts, 0, 0))
+
diff --git a/tests/baselines/reference/bestCommonTypeReturnStatement.types b/tests/baselines/reference/bestCommonTypeReturnStatement.types
new file mode 100644
index 00000000000..31f72ab93b4
--- /dev/null
+++ b/tests/baselines/reference/bestCommonTypeReturnStatement.types
@@ -0,0 +1,40 @@
+=== tests/cases/compiler/bestCommonTypeReturnStatement.ts ===
+
+interface IPromise<T> {
+>IPromise : IPromise<T>
+>T : T
+
+    then(successCallback: (promiseValue: T) => any, errorCallback?: (reason: any) => any): IPromise<any>;
+>then : (successCallback: (promiseValue: T) => any, errorCallback?: (reason: any) => any) => IPromise<any>
+>successCallback : (promiseValue: T) => any
+>promiseValue : T
+>T : T
+>errorCallback : (reason: any) => any
+>reason : any
+>IPromise : IPromise<T>
+}
+
+function f() {
+>f : () => IPromise<void>
+
+    if (true) return b();
+>true : boolean
+>b() : IPromise<void>
+>b : () => IPromise<void>
+
+    return d();
+>d() : IPromise<any>
+>d : () => IPromise<any>
+}
+
+
+function b(): IPromise<void> { return null; }
+>b : () => IPromise<void>
+>IPromise : IPromise<T>
+>null : null
+
+function d(): IPromise<any> { return null; }
+>d : () => IPromise<any>
+>IPromise : IPromise<T>
+>null : null
+
diff --git a/tests/baselines/reference/breakTarget3.errors.txt b/tests/baselines/reference/breakTarget3.errors.txt
deleted file mode 100644
index aff8887c15e..00000000000
--- a/tests/baselines/reference/breakTarget3.errors.txt
+++ /dev/null
@@ -1,11 +0,0 @@
-tests/cases/compiler/breakTarget3.ts(2,1): error TS7028: Unused label.
-
-
-==== tests/cases/compiler/breakTarget3.ts (1 errors) ====
-    target1:
-    target2:
-    ~~~~~~~
-!!! error TS7028: Unused label.
-    while (true) {
-      break target1;
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/breakTarget3.js b/tests/baselines/reference/breakTarget3.js
index 0fa6cd2d298..b36eeb3902b 100644
--- a/tests/baselines/reference/breakTarget3.js
+++ b/tests/baselines/reference/breakTarget3.js
@@ -1,4 +1,5 @@
 //// [breakTarget3.ts]
+
 target1:
 target2:
 while (true) {
diff --git a/tests/baselines/reference/breakTarget3.symbols b/tests/baselines/reference/breakTarget3.symbols
new file mode 100644
index 00000000000..a0b17435504
--- /dev/null
+++ b/tests/baselines/reference/breakTarget3.symbols
@@ -0,0 +1,8 @@
+=== tests/cases/compiler/breakTarget3.ts ===
+
+No type information for this code.target1:
+No type information for this code.target2:
+No type information for this code.while (true) {
+No type information for this code.  break target1;
+No type information for this code.}
+No type information for this code.
\ No newline at end of file
diff --git a/tests/baselines/reference/breakTarget3.types b/tests/baselines/reference/breakTarget3.types
new file mode 100644
index 00000000000..e4b5f8a1c61
--- /dev/null
+++ b/tests/baselines/reference/breakTarget3.types
@@ -0,0 +1,14 @@
+=== tests/cases/compiler/breakTarget3.ts ===
+
+target1:
+>target1 : any
+
+target2:
+>target2 : any
+
+while (true) {
+>true : boolean
+
+  break target1;
+>target1 : any
+}
diff --git a/tests/baselines/reference/breakTarget4.errors.txt b/tests/baselines/reference/breakTarget4.errors.txt
deleted file mode 100644
index d1283de2fa0..00000000000
--- a/tests/baselines/reference/breakTarget4.errors.txt
+++ /dev/null
@@ -1,11 +0,0 @@
-tests/cases/compiler/breakTarget4.ts(1,1): error TS7028: Unused label.
-
-
-==== tests/cases/compiler/breakTarget4.ts (1 errors) ====
-    target1:
-    ~~~~~~~
-!!! error TS7028: Unused label.
-    target2:
-    while (true) {
-      break target2;
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/breakTarget4.js b/tests/baselines/reference/breakTarget4.js
index 4586301d71b..0c91e44ecbd 100644
--- a/tests/baselines/reference/breakTarget4.js
+++ b/tests/baselines/reference/breakTarget4.js
@@ -1,4 +1,5 @@
 //// [breakTarget4.ts]
+
 target1:
 target2:
 while (true) {
diff --git a/tests/baselines/reference/breakTarget4.symbols b/tests/baselines/reference/breakTarget4.symbols
new file mode 100644
index 00000000000..d4edcb17e1a
--- /dev/null
+++ b/tests/baselines/reference/breakTarget4.symbols
@@ -0,0 +1,8 @@
+=== tests/cases/compiler/breakTarget4.ts ===
+
+No type information for this code.target1:
+No type information for this code.target2:
+No type information for this code.while (true) {
+No type information for this code.  break target2;
+No type information for this code.}
+No type information for this code.
\ No newline at end of file
diff --git a/tests/baselines/reference/breakTarget4.types b/tests/baselines/reference/breakTarget4.types
new file mode 100644
index 00000000000..8b6ccf600ad
--- /dev/null
+++ b/tests/baselines/reference/breakTarget4.types
@@ -0,0 +1,14 @@
+=== tests/cases/compiler/breakTarget4.ts ===
+
+target1:
+>target1 : any
+
+target2:
+>target2 : any
+
+while (true) {
+>true : boolean
+
+  break target2;
+>target2 : any
+}
diff --git a/tests/baselines/reference/breakTarget5.errors.txt b/tests/baselines/reference/breakTarget5.errors.txt
index 55a454ee68b..d92f29d67ee 100644
--- a/tests/baselines/reference/breakTarget5.errors.txt
+++ b/tests/baselines/reference/breakTarget5.errors.txt
@@ -1,11 +1,9 @@
-tests/cases/compiler/breakTarget5.ts(1,1): error TS7028: Unused label.
-tests/cases/compiler/breakTarget5.ts(5,7): error TS1107: Jump target cannot cross function boundary.
+tests/cases/compiler/breakTarget5.ts(6,7): error TS1107: Jump target cannot cross function boundary.
 
 
-==== tests/cases/compiler/breakTarget5.ts (2 errors) ====
+==== tests/cases/compiler/breakTarget5.ts (1 errors) ====
+    
     target:
-    ~~~~~~
-!!! error TS7028: Unused label.
     while (true) {
       function f() {
         while (true) {
diff --git a/tests/baselines/reference/breakTarget5.js b/tests/baselines/reference/breakTarget5.js
index 197e4e147bd..9f6b063a8c4 100644
--- a/tests/baselines/reference/breakTarget5.js
+++ b/tests/baselines/reference/breakTarget5.js
@@ -1,4 +1,5 @@
 //// [breakTarget5.ts]
+
 target:
 while (true) {
   function f() {
diff --git a/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.errors.txt b/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.errors.txt
deleted file mode 100644
index 06eca28b512..00000000000
--- a/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.errors.txt
+++ /dev/null
@@ -1,126 +0,0 @@
-tests/cases/conformance/types/objectTypeLiteral/callSignatures/callSignatureWithoutReturnTypeAnnotationInference.ts(28,9): error TS7027: Unreachable code detected.
-
-
-==== tests/cases/conformance/types/objectTypeLiteral/callSignatures/callSignatureWithoutReturnTypeAnnotationInference.ts (1 errors) ====
-    // Call signatures without a return type should infer one from the function body (if present)
-    
-    // Simple types
-    function foo(x) {
-        return 1;
-    }
-    var r = foo(1);
-    
-    function foo2(x) {
-        return foo(x);
-    }
-    var r2 = foo2(1);
-    
-    function foo3() {
-        return foo3();
-    }
-    var r3 = foo3();
-    
-    function foo4<T>(x: T) {
-        return x;
-    }
-    var r4 = foo4(1);
-    
-    function foo5(x) {
-        if (true) {
-            return 1;
-        } else {
-            return 2;
-            ~~~~~~
-!!! error TS7027: Unreachable code detected.
-        }
-    }
-    var r5 = foo5(1);
-    
-    function foo6(x) {
-        try {
-        }
-        catch (e) {
-            return [];
-        }
-        finally {
-            return [];
-        }
-    }
-    var r6 = foo6(1);
-    
-    function foo7(x) {
-        return typeof x;
-    }
-    var r7 = foo7(1);
-    
-    // object types
-    function foo8(x: number) {
-        return { x: x };
-    }
-    var r8 = foo8(1);
-    
-    interface I {
-        foo: string;
-    }
-    function foo9(x: number) {
-        var i: I;
-        return i;    
-    }
-    var r9 = foo9(1);
-    
-    class C {
-        foo: string;
-    }
-    function foo10(x: number) {
-        var c: C;
-        return c;
-    }
-    var r10 = foo10(1);
-    
-    module M {
-        export var x = 1;
-        export class C { foo: string }
-    }
-    function foo11() {
-        return M;
-    }
-    var r11 = foo11();
-    
-    // merged declarations
-    interface I2 {
-        x: number;
-    }
-    interface I2 {
-        y: number;
-    }
-    function foo12() {
-        var i2: I2;
-        return i2;
-    }
-    var r12 = foo12();
-    
-    function m1() { return 1; }
-    module m1 { export var y = 2; }
-    function foo13() {
-        return m1;
-    }
-    var r13 = foo13();
-    
-    class c1 {
-        foo: string;
-        constructor(x) { }
-    }
-    module c1 {
-        export var x = 1;
-    }
-    function foo14() {
-        return c1;
-    }
-    var r14 = foo14();
-    
-    enum e1 { A }
-    module e1 { export var y = 1; }
-    function foo15() {
-        return e1;
-    }
-    var r15 = foo15();
\ No newline at end of file
diff --git a/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.js b/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.js
index 0e78aac2b1b..73270c240cb 100644
--- a/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.js
+++ b/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.js
@@ -1,4 +1,5 @@
 //// [callSignatureWithoutReturnTypeAnnotationInference.ts]
+
 // Call signatures without a return type should infer one from the function body (if present)
 
 // Simple types
diff --git a/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.symbols b/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.symbols
new file mode 100644
index 00000000000..faba4e427ec
--- /dev/null
+++ b/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.symbols
@@ -0,0 +1,256 @@
+=== tests/cases/conformance/types/objectTypeLiteral/callSignatures/callSignatureWithoutReturnTypeAnnotationInference.ts ===
+
+// Call signatures without a return type should infer one from the function body (if present)
+
+// Simple types
+function foo(x) {
+>foo : Symbol(foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 0, 0))
+>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 4, 13))
+
+    return 1;
+}
+var r = foo(1);
+>r : Symbol(r, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 7, 3))
+>foo : Symbol(foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 0, 0))
+
+function foo2(x) {
+>foo2 : Symbol(foo2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 7, 15))
+>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 9, 14))
+
+    return foo(x);
+>foo : Symbol(foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 0, 0))
+>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 9, 14))
+}
+var r2 = foo2(1);
+>r2 : Symbol(r2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 12, 3))
+>foo2 : Symbol(foo2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 7, 15))
+
+function foo3() {
+>foo3 : Symbol(foo3, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 12, 17))
+
+    return foo3();
+>foo3 : Symbol(foo3, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 12, 17))
+}
+var r3 = foo3();
+>r3 : Symbol(r3, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 17, 3))
+>foo3 : Symbol(foo3, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 12, 17))
+
+function foo4<T>(x: T) {
+>foo4 : Symbol(foo4, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 17, 16))
+>T : Symbol(T, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 19, 14))
+>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 19, 17))
+>T : Symbol(T, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 19, 14))
+
+    return x;
+>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 19, 17))
+}
+var r4 = foo4(1);
+>r4 : Symbol(r4, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 22, 3))
+>foo4 : Symbol(foo4, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 17, 16))
+
+function foo5(x) {
+>foo5 : Symbol(foo5, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 22, 17))
+>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 24, 14))
+
+    if (true) {
+        return 1;
+    } else {
+        return 2;
+    }
+}
+var r5 = foo5(1);
+>r5 : Symbol(r5, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 31, 3))
+>foo5 : Symbol(foo5, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 22, 17))
+
+function foo6(x) {
+>foo6 : Symbol(foo6, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 31, 17))
+>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 33, 14))
+
+    try {
+    }
+    catch (e) {
+>e : Symbol(e, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 36, 11))
+
+        return [];
+    }
+    finally {
+        return [];
+    }
+}
+var r6 = foo6(1);
+>r6 : Symbol(r6, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 43, 3))
+>foo6 : Symbol(foo6, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 31, 17))
+
+function foo7(x) {
+>foo7 : Symbol(foo7, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 43, 17))
+>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 45, 14))
+
+    return typeof x;
+>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 45, 14))
+}
+var r7 = foo7(1);
+>r7 : Symbol(r7, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 48, 3))
+>foo7 : Symbol(foo7, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 43, 17))
+
+// object types
+function foo8(x: number) {
+>foo8 : Symbol(foo8, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 48, 17))
+>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 51, 14))
+
+    return { x: x };
+>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 52, 12))
+>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 51, 14))
+}
+var r8 = foo8(1);
+>r8 : Symbol(r8, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 54, 3))
+>foo8 : Symbol(foo8, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 48, 17))
+
+interface I {
+>I : Symbol(I, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 54, 17))
+
+    foo: string;
+>foo : Symbol(foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 56, 13))
+}
+function foo9(x: number) {
+>foo9 : Symbol(foo9, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 58, 1))
+>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 59, 14))
+
+    var i: I;
+>i : Symbol(i, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 60, 7))
+>I : Symbol(I, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 54, 17))
+
+    return i;    
+>i : Symbol(i, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 60, 7))
+}
+var r9 = foo9(1);
+>r9 : Symbol(r9, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 63, 3))
+>foo9 : Symbol(foo9, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 58, 1))
+
+class C {
+>C : Symbol(C, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 63, 17))
+
+    foo: string;
+>foo : Symbol(foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 65, 9))
+}
+function foo10(x: number) {
+>foo10 : Symbol(foo10, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 67, 1))
+>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 68, 15))
+
+    var c: C;
+>c : Symbol(c, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 69, 7))
+>C : Symbol(C, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 63, 17))
+
+    return c;
+>c : Symbol(c, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 69, 7))
+}
+var r10 = foo10(1);
+>r10 : Symbol(r10, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 72, 3))
+>foo10 : Symbol(foo10, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 67, 1))
+
+module M {
+>M : Symbol(M, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 72, 19))
+
+    export var x = 1;
+>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 75, 14))
+
+    export class C { foo: string }
+>C : Symbol(C, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 75, 21))
+>foo : Symbol(foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 76, 20))
+}
+function foo11() {
+>foo11 : Symbol(foo11, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 77, 1))
+
+    return M;
+>M : Symbol(M, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 72, 19))
+}
+var r11 = foo11();
+>r11 : Symbol(r11, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 81, 3))
+>foo11 : Symbol(foo11, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 77, 1))
+
+// merged declarations
+interface I2 {
+>I2 : Symbol(I2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 81, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 86, 1))
+
+    x: number;
+>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 84, 14))
+}
+interface I2 {
+>I2 : Symbol(I2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 81, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 86, 1))
+
+    y: number;
+>y : Symbol(y, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 87, 14))
+}
+function foo12() {
+>foo12 : Symbol(foo12, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 89, 1))
+
+    var i2: I2;
+>i2 : Symbol(i2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 91, 7))
+>I2 : Symbol(I2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 81, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 86, 1))
+
+    return i2;
+>i2 : Symbol(i2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 91, 7))
+}
+var r12 = foo12();
+>r12 : Symbol(r12, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 94, 3))
+>foo12 : Symbol(foo12, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 89, 1))
+
+function m1() { return 1; }
+>m1 : Symbol(m1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 94, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 96, 27))
+
+module m1 { export var y = 2; }
+>m1 : Symbol(m1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 94, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 96, 27))
+>y : Symbol(y, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 97, 22))
+
+function foo13() {
+>foo13 : Symbol(foo13, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 97, 31))
+
+    return m1;
+>m1 : Symbol(m1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 94, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 96, 27))
+}
+var r13 = foo13();
+>r13 : Symbol(r13, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 101, 3))
+>foo13 : Symbol(foo13, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 97, 31))
+
+class c1 {
+>c1 : Symbol(c1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 101, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 106, 1))
+
+    foo: string;
+>foo : Symbol(foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 103, 10))
+
+    constructor(x) { }
+>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 105, 16))
+}
+module c1 {
+>c1 : Symbol(c1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 101, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 106, 1))
+
+    export var x = 1;
+>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 108, 14))
+}
+function foo14() {
+>foo14 : Symbol(foo14, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 109, 1))
+
+    return c1;
+>c1 : Symbol(c1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 101, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 106, 1))
+}
+var r14 = foo14();
+>r14 : Symbol(r14, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 113, 3))
+>foo14 : Symbol(foo14, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 109, 1))
+
+enum e1 { A }
+>e1 : Symbol(e1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 113, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 115, 13))
+>A : Symbol(e1.A, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 115, 9))
+
+module e1 { export var y = 1; }
+>e1 : Symbol(e1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 113, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 115, 13))
+>y : Symbol(y, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 116, 22))
+
+function foo15() {
+>foo15 : Symbol(foo15, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 116, 31))
+
+    return e1;
+>e1 : Symbol(e1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 113, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 115, 13))
+}
+var r15 = foo15();
+>r15 : Symbol(r15, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 120, 3))
+>foo15 : Symbol(foo15, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 116, 31))
+
diff --git a/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.types b/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.types
new file mode 100644
index 00000000000..689ac62c35b
--- /dev/null
+++ b/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.types
@@ -0,0 +1,297 @@
+=== tests/cases/conformance/types/objectTypeLiteral/callSignatures/callSignatureWithoutReturnTypeAnnotationInference.ts ===
+
+// Call signatures without a return type should infer one from the function body (if present)
+
+// Simple types
+function foo(x) {
+>foo : (x: any) => number
+>x : any
+
+    return 1;
+>1 : number
+}
+var r = foo(1);
+>r : number
+>foo(1) : number
+>foo : (x: any) => number
+>1 : number
+
+function foo2(x) {
+>foo2 : (x: any) => number
+>x : any
+
+    return foo(x);
+>foo(x) : number
+>foo : (x: any) => number
+>x : any
+}
+var r2 = foo2(1);
+>r2 : number
+>foo2(1) : number
+>foo2 : (x: any) => number
+>1 : number
+
+function foo3() {
+>foo3 : () => any
+
+    return foo3();
+>foo3() : any
+>foo3 : () => any
+}
+var r3 = foo3();
+>r3 : any
+>foo3() : any
+>foo3 : () => any
+
+function foo4<T>(x: T) {
+>foo4 : <T>(x: T) => T
+>T : T
+>x : T
+>T : T
+
+    return x;
+>x : T
+}
+var r4 = foo4(1);
+>r4 : number
+>foo4(1) : number
+>foo4 : <T>(x: T) => T
+>1 : number
+
+function foo5(x) {
+>foo5 : (x: any) => number
+>x : any
+
+    if (true) {
+>true : boolean
+
+        return 1;
+>1 : number
+
+    } else {
+        return 2;
+>2 : number
+    }
+}
+var r5 = foo5(1);
+>r5 : number
+>foo5(1) : number
+>foo5 : (x: any) => number
+>1 : number
+
+function foo6(x) {
+>foo6 : (x: any) => any[]
+>x : any
+
+    try {
+    }
+    catch (e) {
+>e : any
+
+        return [];
+>[] : undefined[]
+    }
+    finally {
+        return [];
+>[] : undefined[]
+    }
+}
+var r6 = foo6(1);
+>r6 : any[]
+>foo6(1) : any[]
+>foo6 : (x: any) => any[]
+>1 : number
+
+function foo7(x) {
+>foo7 : (x: any) => string
+>x : any
+
+    return typeof x;
+>typeof x : string
+>x : any
+}
+var r7 = foo7(1);
+>r7 : string
+>foo7(1) : string
+>foo7 : (x: any) => string
+>1 : number
+
+// object types
+function foo8(x: number) {
+>foo8 : (x: number) => { x: number; }
+>x : number
+
+    return { x: x };
+>{ x: x } : { x: number; }
+>x : number
+>x : number
+}
+var r8 = foo8(1);
+>r8 : { x: number; }
+>foo8(1) : { x: number; }
+>foo8 : (x: number) => { x: number; }
+>1 : number
+
+interface I {
+>I : I
+
+    foo: string;
+>foo : string
+}
+function foo9(x: number) {
+>foo9 : (x: number) => I
+>x : number
+
+    var i: I;
+>i : I
+>I : I
+
+    return i;    
+>i : I
+}
+var r9 = foo9(1);
+>r9 : I
+>foo9(1) : I
+>foo9 : (x: number) => I
+>1 : number
+
+class C {
+>C : C
+
+    foo: string;
+>foo : string
+}
+function foo10(x: number) {
+>foo10 : (x: number) => C
+>x : number
+
+    var c: C;
+>c : C
+>C : C
+
+    return c;
+>c : C
+}
+var r10 = foo10(1);
+>r10 : C
+>foo10(1) : C
+>foo10 : (x: number) => C
+>1 : number
+
+module M {
+>M : typeof M
+
+    export var x = 1;
+>x : number
+>1 : number
+
+    export class C { foo: string }
+>C : C
+>foo : string
+}
+function foo11() {
+>foo11 : () => typeof M
+
+    return M;
+>M : typeof M
+}
+var r11 = foo11();
+>r11 : typeof M
+>foo11() : typeof M
+>foo11 : () => typeof M
+
+// merged declarations
+interface I2 {
+>I2 : I2
+
+    x: number;
+>x : number
+}
+interface I2 {
+>I2 : I2
+
+    y: number;
+>y : number
+}
+function foo12() {
+>foo12 : () => I2
+
+    var i2: I2;
+>i2 : I2
+>I2 : I2
+
+    return i2;
+>i2 : I2
+}
+var r12 = foo12();
+>r12 : I2
+>foo12() : I2
+>foo12 : () => I2
+
+function m1() { return 1; }
+>m1 : typeof m1
+>1 : number
+
+module m1 { export var y = 2; }
+>m1 : typeof m1
+>y : number
+>2 : number
+
+function foo13() {
+>foo13 : () => typeof m1
+
+    return m1;
+>m1 : typeof m1
+}
+var r13 = foo13();
+>r13 : typeof m1
+>foo13() : typeof m1
+>foo13 : () => typeof m1
+
+class c1 {
+>c1 : c1
+
+    foo: string;
+>foo : string
+
+    constructor(x) { }
+>x : any
+}
+module c1 {
+>c1 : typeof c1
+
+    export var x = 1;
+>x : number
+>1 : number
+}
+function foo14() {
+>foo14 : () => typeof c1
+
+    return c1;
+>c1 : typeof c1
+}
+var r14 = foo14();
+>r14 : typeof c1
+>foo14() : typeof c1
+>foo14 : () => typeof c1
+
+enum e1 { A }
+>e1 : e1
+>A : e1
+
+module e1 { export var y = 1; }
+>e1 : typeof e1
+>y : number
+>1 : number
+
+function foo15() {
+>foo15 : () => typeof e1
+
+    return e1;
+>e1 : typeof e1
+}
+var r15 = foo15();
+>r15 : typeof e1
+>foo15() : typeof e1
+>foo15 : () => typeof e1
+
diff --git a/tests/baselines/reference/commentEmitAtEndOfFile1.js b/tests/baselines/reference/commentEmitAtEndOfFile1.js
index 1be031fa84a..cada7754002 100644
--- a/tests/baselines/reference/commentEmitAtEndOfFile1.js
+++ b/tests/baselines/reference/commentEmitAtEndOfFile1.js
@@ -1,4 +1,5 @@
 //// [commentEmitAtEndOfFile1.ts]
+
 // test
 var f = ''
 // test #2
diff --git a/tests/baselines/reference/commentEmitAtEndOfFile1.symbols b/tests/baselines/reference/commentEmitAtEndOfFile1.symbols
index 1fc0ad09553..cb06d088307 100644
--- a/tests/baselines/reference/commentEmitAtEndOfFile1.symbols
+++ b/tests/baselines/reference/commentEmitAtEndOfFile1.symbols
@@ -1,17 +1,18 @@
 === tests/cases/compiler/commentEmitAtEndOfFile1.ts ===
+
 // test
 var f = ''
->f : Symbol(f, Decl(commentEmitAtEndOfFile1.ts, 1, 3))
+>f : Symbol(f, Decl(commentEmitAtEndOfFile1.ts, 2, 3))
 
 // test #2
 module foo {
->foo : Symbol(foo, Decl(commentEmitAtEndOfFile1.ts, 1, 10))
+>foo : Symbol(foo, Decl(commentEmitAtEndOfFile1.ts, 2, 10))
 
         function bar() { }
->bar : Symbol(bar, Decl(commentEmitAtEndOfFile1.ts, 3, 12))
+>bar : Symbol(bar, Decl(commentEmitAtEndOfFile1.ts, 4, 12))
 }
 // test #3
 module empty {
->empty : Symbol(empty, Decl(commentEmitAtEndOfFile1.ts, 5, 1))
+>empty : Symbol(empty, Decl(commentEmitAtEndOfFile1.ts, 6, 1))
 }
 // test #4
diff --git a/tests/baselines/reference/commentEmitAtEndOfFile1.types b/tests/baselines/reference/commentEmitAtEndOfFile1.types
index d88d7ffa5fc..f96a1069a06 100644
--- a/tests/baselines/reference/commentEmitAtEndOfFile1.types
+++ b/tests/baselines/reference/commentEmitAtEndOfFile1.types
@@ -1,4 +1,5 @@
 === tests/cases/compiler/commentEmitAtEndOfFile1.ts ===
+
 // test
 var f = ''
 >f : string
diff --git a/tests/baselines/reference/compoundAssignmentLHSIsValue.errors.txt b/tests/baselines/reference/compoundAssignmentLHSIsValue.errors.txt
index 645e34bcfa7..392e1781dd5 100644
--- a/tests/baselines/reference/compoundAssignmentLHSIsValue.errors.txt
+++ b/tests/baselines/reference/compoundAssignmentLHSIsValue.errors.txt
@@ -1,81 +1,81 @@
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(7,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(8,9): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(11,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(12,9): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(15,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(16,9): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(21,5): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(8,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(9,9): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(12,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(13,9): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(16,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(17,9): error TS2364: Invalid left-hand side of assignment expression.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(22,5): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(25,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(23,5): error TS2364: Invalid left-hand side of assignment expression.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(26,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(30,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(31,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(33,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(34,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(37,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(38,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(40,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(41,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(44,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(27,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(31,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(32,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(34,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(35,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(38,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(39,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(41,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(42,1): error TS2364: Invalid left-hand side of assignment expression.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(45,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(46,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(47,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(48,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(49,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(46,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(47,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(48,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(49,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(50,1): error TS2364: Invalid left-hand side of assignment expression.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(51,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(52,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(53,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(54,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(55,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(58,3): error TS7028: Unused label.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(58,9): error TS1128: Declaration or statement expected.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(52,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(53,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(54,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(55,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(56,1): error TS2364: Invalid left-hand side of assignment expression.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(59,9): error TS1128: Declaration or statement expected.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(62,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(63,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(69,15): error TS1034: 'super' must be followed by an argument list or member access.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(60,9): error TS1128: Declaration or statement expected.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(63,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(64,1): error TS2364: Invalid left-hand side of assignment expression.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(70,15): error TS1034: 'super' must be followed by an argument list or member access.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(74,15): error TS1034: 'super' must be followed by an argument list or member access.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(71,15): error TS1034: 'super' must be followed by an argument list or member access.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(75,15): error TS1034: 'super' must be followed by an argument list or member access.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(79,15): error TS1034: 'super' must be followed by an argument list or member access.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(76,15): error TS1034: 'super' must be followed by an argument list or member access.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(80,15): error TS1034: 'super' must be followed by an argument list or member access.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(85,21): error TS1128: Declaration or statement expected.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(81,15): error TS1034: 'super' must be followed by an argument list or member access.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(86,21): error TS1128: Declaration or statement expected.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(87,11): error TS1005: ';' expected.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(87,21): error TS1128: Declaration or statement expected.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(88,11): error TS1005: ';' expected.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(91,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(92,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(95,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(89,11): error TS1005: ';' expected.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(92,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(93,1): error TS2364: Invalid left-hand side of assignment expression.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(96,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(97,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(98,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(99,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(100,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(101,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(102,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(103,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(104,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(97,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(98,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(99,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(100,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(101,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(102,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(103,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(104,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(105,1): error TS2364: Invalid left-hand side of assignment expression.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(106,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(107,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(108,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(107,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(108,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(109,1): error TS2364: Invalid left-hand side of assignment expression.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(110,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(111,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(112,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(113,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(114,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(115,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(116,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(117,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(118,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(119,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(120,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(121,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(122,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(111,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(112,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(113,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(114,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(115,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(116,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(117,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(118,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(119,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(120,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(121,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(122,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(123,1): error TS2364: Invalid left-hand side of assignment expression.
 
 
-==== tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts (75 errors) ====
+==== tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts (74 errors) ====
+    
     // expected error for all the LHS of compound assignments (arithmetic and addition)
     var value;
     
@@ -194,8 +194,6 @@ tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsVa
     
     // object literals
     { a: 0} *= value;
-      ~
-!!! error TS7028: Unused label.
             ~~
 !!! error TS1128: Declaration or statement expected.
     { a: 0} += value;
diff --git a/tests/baselines/reference/compoundAssignmentLHSIsValue.js b/tests/baselines/reference/compoundAssignmentLHSIsValue.js
index 833c1e1ea7c..bf66183b70a 100644
--- a/tests/baselines/reference/compoundAssignmentLHSIsValue.js
+++ b/tests/baselines/reference/compoundAssignmentLHSIsValue.js
@@ -1,4 +1,5 @@
 //// [compoundAssignmentLHSIsValue.ts]
+
 // expected error for all the LHS of compound assignments (arithmetic and addition)
 var value;
 
diff --git a/tests/baselines/reference/conditionalExpressions2.errors.txt b/tests/baselines/reference/conditionalExpressions2.errors.txt
deleted file mode 100644
index 3fb44a840b3..00000000000
--- a/tests/baselines/reference/conditionalExpressions2.errors.txt
+++ /dev/null
@@ -1,15 +0,0 @@
-tests/cases/compiler/conditionalExpressions2.ts(9,54): error TS7027: Unreachable code detected.
-
-
-==== tests/cases/compiler/conditionalExpressions2.ts (1 errors) ====
-    var a = false ? 1 : null;
-    var b = false ? undefined : 0;
-    var c = false ? 1 : 0;
-    var d = false ? false : true;
-    var e = false ? "foo" : "bar";
-    var f = false ? null : undefined;
-    var g = true ? {g:5} : null;
-    var h = [{h:5}, null];
-    function i() { if (true) { return { x: 5 }; } else { return null; } }
-                                                         ~~~~~~
-!!! error TS7027: Unreachable code detected.
\ No newline at end of file
diff --git a/tests/baselines/reference/conditionalExpressions2.js b/tests/baselines/reference/conditionalExpressions2.js
index 6749a2c0ac0..8ac7df12cfa 100644
--- a/tests/baselines/reference/conditionalExpressions2.js
+++ b/tests/baselines/reference/conditionalExpressions2.js
@@ -1,4 +1,5 @@
 //// [conditionalExpressions2.ts]
+
 var a = false ? 1 : null;
 var b = false ? undefined : 0;
 var c = false ? 1 : 0;
diff --git a/tests/baselines/reference/conditionalExpressions2.symbols b/tests/baselines/reference/conditionalExpressions2.symbols
new file mode 100644
index 00000000000..e6edd635b40
--- /dev/null
+++ b/tests/baselines/reference/conditionalExpressions2.symbols
@@ -0,0 +1,34 @@
+=== tests/cases/compiler/conditionalExpressions2.ts ===
+
+var a = false ? 1 : null;
+>a : Symbol(a, Decl(conditionalExpressions2.ts, 1, 3))
+
+var b = false ? undefined : 0;
+>b : Symbol(b, Decl(conditionalExpressions2.ts, 2, 3))
+>undefined : Symbol(undefined)
+
+var c = false ? 1 : 0;
+>c : Symbol(c, Decl(conditionalExpressions2.ts, 3, 3))
+
+var d = false ? false : true;
+>d : Symbol(d, Decl(conditionalExpressions2.ts, 4, 3))
+
+var e = false ? "foo" : "bar";
+>e : Symbol(e, Decl(conditionalExpressions2.ts, 5, 3))
+
+var f = false ? null : undefined;
+>f : Symbol(f, Decl(conditionalExpressions2.ts, 6, 3))
+>undefined : Symbol(undefined)
+
+var g = true ? {g:5} : null;
+>g : Symbol(g, Decl(conditionalExpressions2.ts, 7, 3))
+>g : Symbol(g, Decl(conditionalExpressions2.ts, 7, 16))
+
+var h = [{h:5}, null];
+>h : Symbol(h, Decl(conditionalExpressions2.ts, 8, 3))
+>h : Symbol(h, Decl(conditionalExpressions2.ts, 8, 10))
+
+function i() { if (true) { return { x: 5 }; } else { return null; } }
+>i : Symbol(i, Decl(conditionalExpressions2.ts, 8, 22))
+>x : Symbol(x, Decl(conditionalExpressions2.ts, 9, 35))
+
diff --git a/tests/baselines/reference/conditionalExpressions2.types b/tests/baselines/reference/conditionalExpressions2.types
new file mode 100644
index 00000000000..77714e664fb
--- /dev/null
+++ b/tests/baselines/reference/conditionalExpressions2.types
@@ -0,0 +1,69 @@
+=== tests/cases/compiler/conditionalExpressions2.ts ===
+
+var a = false ? 1 : null;
+>a : number
+>false ? 1 : null : number
+>false : boolean
+>1 : number
+>null : null
+
+var b = false ? undefined : 0;
+>b : number
+>false ? undefined : 0 : number
+>false : boolean
+>undefined : undefined
+>0 : number
+
+var c = false ? 1 : 0;
+>c : number
+>false ? 1 : 0 : number
+>false : boolean
+>1 : number
+>0 : number
+
+var d = false ? false : true;
+>d : boolean
+>false ? false : true : boolean
+>false : boolean
+>false : boolean
+>true : boolean
+
+var e = false ? "foo" : "bar";
+>e : string
+>false ? "foo" : "bar" : string
+>false : boolean
+>"foo" : string
+>"bar" : string
+
+var f = false ? null : undefined;
+>f : any
+>false ? null : undefined : null
+>false : boolean
+>null : null
+>undefined : undefined
+
+var g = true ? {g:5} : null;
+>g : { g: number; }
+>true ? {g:5} : null : { g: number; }
+>true : boolean
+>{g:5} : { g: number; }
+>g : number
+>5 : number
+>null : null
+
+var h = [{h:5}, null];
+>h : { h: number; }[]
+>[{h:5}, null] : { h: number; }[]
+>{h:5} : { h: number; }
+>h : number
+>5 : number
+>null : null
+
+function i() { if (true) { return { x: 5 }; } else { return null; } }
+>i : () => { x: number; }
+>true : boolean
+>{ x: 5 } : { x: number; }
+>x : number
+>5 : number
+>null : null
+
diff --git a/tests/baselines/reference/constDeclarations-invalidContexts.errors.txt b/tests/baselines/reference/constDeclarations-invalidContexts.errors.txt
index 56273924ac1..20ec5b0c25b 100644
--- a/tests/baselines/reference/constDeclarations-invalidContexts.errors.txt
+++ b/tests/baselines/reference/constDeclarations-invalidContexts.errors.txt
@@ -1,8 +1,6 @@
 tests/cases/compiler/constDeclarations-invalidContexts.ts(4,5): error TS1156: 'const' declarations can only be declared inside a block.
-tests/cases/compiler/constDeclarations-invalidContexts.ts(6,5): error TS7027: Unreachable code detected.
 tests/cases/compiler/constDeclarations-invalidContexts.ts(6,5): error TS1156: 'const' declarations can only be declared inside a block.
 tests/cases/compiler/constDeclarations-invalidContexts.ts(9,5): error TS1156: 'const' declarations can only be declared inside a block.
-tests/cases/compiler/constDeclarations-invalidContexts.ts(11,1): error TS7027: Unreachable code detected.
 tests/cases/compiler/constDeclarations-invalidContexts.ts(12,5): error TS1156: 'const' declarations can only be declared inside a block.
 tests/cases/compiler/constDeclarations-invalidContexts.ts(16,7): error TS2410: All symbols within a 'with' block will be resolved to 'any'.
 tests/cases/compiler/constDeclarations-invalidContexts.ts(20,5): error TS1156: 'const' declarations can only be declared inside a block.
@@ -11,7 +9,7 @@ tests/cases/compiler/constDeclarations-invalidContexts.ts(26,12): error TS1156:
 tests/cases/compiler/constDeclarations-invalidContexts.ts(29,29): error TS1156: 'const' declarations can only be declared inside a block.
 
 
-==== tests/cases/compiler/constDeclarations-invalidContexts.ts (11 errors) ====
+==== tests/cases/compiler/constDeclarations-invalidContexts.ts (9 errors) ====
     
     // Errors, const must be defined inside a block
     if (true) 
@@ -20,8 +18,6 @@ tests/cases/compiler/constDeclarations-invalidContexts.ts(29,29): error TS1156:
 !!! error TS1156: 'const' declarations can only be declared inside a block.
     else 
         const c2 = 0;
-        ~~~~~
-!!! error TS7027: Unreachable code detected.
         ~~~~~~~~~~~~~
 !!! error TS1156: 'const' declarations can only be declared inside a block.
     
@@ -31,8 +27,6 @@ tests/cases/compiler/constDeclarations-invalidContexts.ts(29,29): error TS1156:
 !!! error TS1156: 'const' declarations can only be declared inside a block.
     
     do 
-    ~~
-!!! error TS7027: Unreachable code detected.
         const c4 = 0;
         ~~~~~~~~~~~~~
 !!! error TS1156: 'const' declarations can only be declared inside a block.
diff --git a/tests/baselines/reference/constDeclarations-validContexts.errors.txt b/tests/baselines/reference/constDeclarations-validContexts.errors.txt
index e55e5f578ba..7af16a53cbe 100644
--- a/tests/baselines/reference/constDeclarations-validContexts.errors.txt
+++ b/tests/baselines/reference/constDeclarations-validContexts.errors.txt
@@ -1,9 +1,7 @@
-tests/cases/compiler/constDeclarations-validContexts.ts(8,5): error TS7027: Unreachable code detected.
-tests/cases/compiler/constDeclarations-validContexts.ts(15,1): error TS7027: Unreachable code detected.
 tests/cases/compiler/constDeclarations-validContexts.ts(20,7): error TS2410: All symbols within a 'with' block will be resolved to 'any'.
 
 
-==== tests/cases/compiler/constDeclarations-validContexts.ts (3 errors) ====
+==== tests/cases/compiler/constDeclarations-validContexts.ts (1 errors) ====
     
     
     // Control flow statements with blocks
@@ -12,8 +10,6 @@ tests/cases/compiler/constDeclarations-validContexts.ts(20,7): error TS2410: All
     }
     else { 
         const c2 = 0;
-        ~~~~~
-!!! error TS7027: Unreachable code detected.
     }
     
     while (true) { 
@@ -21,8 +17,6 @@ tests/cases/compiler/constDeclarations-validContexts.ts(20,7): error TS2410: All
     }
     
     do { 
-    ~~
-!!! error TS7027: Unreachable code detected.
         const c4 = 0;
     } while (true);
     
diff --git a/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.errors.txt b/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.errors.txt
index 56213610b83..b9804b1b6db 100644
--- a/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.errors.txt
+++ b/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.errors.txt
@@ -1,91 +1,90 @@
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(11,13): error TS2304: Cannot find name 'module'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(11,13): error TS2503: Cannot find namespace 'module'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(11,19): error TS1005: ';' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(22,35): error TS1005: ')' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(22,39): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(24,28): error TS1005: ':' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(24,29): error TS1005: ',' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(27,18): error TS1128: Declaration or statement expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(27,26): error TS2304: Cannot find name 'bfs'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(28,30): error TS1005: '=' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(31,18): error TS1109: Expression expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(31,18): error TS7027: Unreachable code detected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(34,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(34,26): error TS1005: ';' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(34,28): error TS2304: Cannot find name 'bfs'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(35,21): error TS2365: Operator '!=' cannot be applied to types 'boolean' and 'number'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(38,17): error TS1109: Expression expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(40,28): error TS2304: Cannot find name 'bfs'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(40,41): error TS1005: ';' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(40,45): error TS1002: Unterminated string literal.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(41,21): error TS2365: Operator '!=' cannot be applied to types 'boolean' and 'number'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(47,17): error TS2304: Cannot find name 'console'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(49,13): error TS1068: Unexpected token. A constructor, method, accessor, or property was expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(53,13): error TS2304: Cannot find name 'console'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(58,5): error TS1128: Declaration or statement expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(69,13): error TS1109: Expression expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(72,37): error TS1127: Invalid character.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(81,13): error TS1109: Expression expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(89,23): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(90,13): error TS1109: Expression expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(105,29): error TS1109: Expression expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(106,13): error TS1109: Expression expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(108,24): error TS2365: Operator '+' cannot be applied to types 'number' and 'boolean'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(138,13): error TS1109: Expression expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(141,32): error TS1005: '{' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(143,13): error TS1005: 'try' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(159,24): error TS1109: Expression expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(159,30): error TS1005: '(' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(159,31): error TS2304: Cannot find name 'Property'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(166,13): error TS2365: Operator '+=' cannot be applied to types 'number' and 'void'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(180,40): error TS2447: The '^' operator is not allowed for boolean types. Consider using '!==' instead.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(205,28): error TS1109: Expression expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(213,16): error TS2304: Cannot find name 'bool'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(218,10): error TS1068: Unexpected token. A constructor, method, accessor, or property was expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(223,23): error TS2304: Cannot find name 'bool'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(227,13): error TS1109: Expression expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(234,14): error TS1005: '{' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(235,9): error TS1128: Declaration or statement expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(235,16): error TS2304: Cannot find name 'method1'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(235,24): error TS2304: Cannot find name 'val'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(235,27): error TS1005: ',' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(235,28): error TS2304: Cannot find name 'number'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(235,36): error TS1005: ';' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(238,9): error TS1128: Declaration or statement expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(238,16): error TS2304: Cannot find name 'method2'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(238,16): error TS7027: Unreachable code detected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(238,26): error TS1005: ';' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(241,5): error TS1128: Declaration or statement expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(246,25): error TS2339: Property 'method1' does not exist on type 'B'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(254,9): error TS2390: Constructor implementation is missing.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(254,21): error TS2369: A parameter property is only allowed in a constructor implementation.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(254,44): error TS2369: A parameter property is only allowed in a constructor implementation.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(254,69): error TS1110: Type expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(256,9): error TS1128: Declaration or statement expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(256,16): error TS2304: Cannot find name 'Overloads'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(256,26): error TS2304: Cannot find name 'value'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(256,31): error TS1005: ',' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(256,33): error TS2304: Cannot find name 'string'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(12,13): error TS2304: Cannot find name 'module'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(12,13): error TS2503: Cannot find namespace 'module'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(12,19): error TS1005: ';' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(23,35): error TS1005: ')' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(23,39): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(25,28): error TS1005: ':' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(25,29): error TS1005: ',' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(28,18): error TS1128: Declaration or statement expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(28,26): error TS2304: Cannot find name 'bfs'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(29,30): error TS1005: '=' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(32,18): error TS1109: Expression expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(35,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(35,26): error TS1005: ';' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(35,28): error TS2304: Cannot find name 'bfs'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(36,21): error TS2365: Operator '!=' cannot be applied to types 'boolean' and 'number'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(39,17): error TS1109: Expression expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(41,28): error TS2304: Cannot find name 'bfs'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(41,41): error TS1005: ';' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(41,45): error TS1002: Unterminated string literal.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(42,21): error TS2365: Operator '!=' cannot be applied to types 'boolean' and 'number'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(48,17): error TS2304: Cannot find name 'console'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(50,13): error TS1068: Unexpected token. A constructor, method, accessor, or property was expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(54,13): error TS2304: Cannot find name 'console'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(59,5): error TS1128: Declaration or statement expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(70,13): error TS1109: Expression expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(73,37): error TS1127: Invalid character.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(82,13): error TS1109: Expression expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(90,23): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(91,13): error TS1109: Expression expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(106,29): error TS1109: Expression expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(107,13): error TS1109: Expression expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(109,24): error TS2365: Operator '+' cannot be applied to types 'number' and 'boolean'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(139,13): error TS1109: Expression expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(142,32): error TS1005: '{' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(144,13): error TS1005: 'try' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(160,24): error TS1109: Expression expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(160,30): error TS1005: '(' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(160,31): error TS2304: Cannot find name 'Property'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(167,13): error TS2365: Operator '+=' cannot be applied to types 'number' and 'void'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(181,40): error TS2447: The '^' operator is not allowed for boolean types. Consider using '!==' instead.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(206,28): error TS1109: Expression expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(214,16): error TS2304: Cannot find name 'bool'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(219,10): error TS1068: Unexpected token. A constructor, method, accessor, or property was expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(224,23): error TS2304: Cannot find name 'bool'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(228,13): error TS1109: Expression expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(235,14): error TS1005: '{' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(236,9): error TS1128: Declaration or statement expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(236,16): error TS2304: Cannot find name 'method1'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(236,24): error TS2304: Cannot find name 'val'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(236,27): error TS1005: ',' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(236,28): error TS2304: Cannot find name 'number'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(236,36): error TS1005: ';' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(239,9): error TS1128: Declaration or statement expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(239,16): error TS2304: Cannot find name 'method2'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(239,26): error TS1005: ';' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(242,5): error TS1128: Declaration or statement expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(247,25): error TS2339: Property 'method1' does not exist on type 'B'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(255,9): error TS2390: Constructor implementation is missing.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(255,21): error TS2369: A parameter property is only allowed in a constructor implementation.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(255,44): error TS2369: A parameter property is only allowed in a constructor implementation.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(255,69): error TS1110: Type expected.
 tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,9): error TS1128: Declaration or statement expected.
 tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,16): error TS2304: Cannot find name 'Overloads'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,27): error TS1135: Argument expression expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,33): error TS1005: '(' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,35): error TS2304: Cannot find name 'string'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,43): error TS1109: Expression expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,52): error TS2304: Cannot find name 'string'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,60): error TS1005: ';' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,65): error TS1109: Expression expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(259,9): error TS2304: Cannot find name 'public'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(259,16): error TS1005: ';' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(259,16): error TS2304: Cannot find name 'DefaultValue'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(259,29): error TS2304: Cannot find name 'value'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(259,35): error TS1109: Expression expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(259,37): error TS2304: Cannot find name 'string'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(259,55): error TS1005: ';' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(261,1): error TS1128: Declaration or statement expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,26): error TS2304: Cannot find name 'value'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,31): error TS1005: ',' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,33): error TS2304: Cannot find name 'string'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,9): error TS1128: Declaration or statement expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,16): error TS2304: Cannot find name 'Overloads'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,27): error TS1135: Argument expression expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,33): error TS1005: '(' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,35): error TS2304: Cannot find name 'string'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,43): error TS1109: Expression expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,52): error TS2304: Cannot find name 'string'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,60): error TS1005: ';' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,65): error TS1109: Expression expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(260,9): error TS2304: Cannot find name 'public'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(260,16): error TS1005: ';' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(260,16): error TS2304: Cannot find name 'DefaultValue'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(260,29): error TS2304: Cannot find name 'value'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(260,35): error TS1109: Expression expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(260,37): error TS2304: Cannot find name 'string'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(260,55): error TS1005: ';' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(262,1): error TS1128: Declaration or statement expected.
 
 
-==== tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts (85 errors) ====
+==== tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts (83 errors) ====
+    
     declare module "fs" {
         export class File {
             constructor(filename: string);
@@ -142,8 +141,6 @@ tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(261,1): error TS
                      ^ 
                      ~
 !!! error TS1109: Expression expected.
-                     ~
-!!! error TS7027: Unreachable code detected.
     
     
                     retValue = bfs.TYPES();
@@ -437,8 +434,6 @@ tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(261,1): error TS
 !!! error TS1128: Declaration or statement expected.
                    ~~~~~~~
 !!! error TS2304: Cannot find name 'method2'.
-                   ~~~~~~~
-!!! error TS7027: Unreachable code detected.
                              ~
 !!! error TS1005: ';' expected.
                 return 2 * this.method1(2);
diff --git a/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.js b/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.js
index 5a61d4d5d7e..4765d1de283 100644
--- a/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.js
+++ b/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.js
@@ -1,4 +1,5 @@
 //// [constructorWithIncompleteTypeAnnotation.ts]
+
 declare module "fs" {
     export class File {
         constructor(filename: string);
diff --git a/tests/baselines/reference/continueNotInIterationStatement4.errors.txt b/tests/baselines/reference/continueNotInIterationStatement4.errors.txt
index 3f0d57ac45d..dec899c7218 100644
--- a/tests/baselines/reference/continueNotInIterationStatement4.errors.txt
+++ b/tests/baselines/reference/continueNotInIterationStatement4.errors.txt
@@ -1,11 +1,9 @@
-tests/cases/compiler/continueNotInIterationStatement4.ts(1,1): error TS7028: Unused label.
-tests/cases/compiler/continueNotInIterationStatement4.ts(4,5): error TS1107: Jump target cannot cross function boundary.
+tests/cases/compiler/continueNotInIterationStatement4.ts(5,5): error TS1107: Jump target cannot cross function boundary.
 
 
-==== tests/cases/compiler/continueNotInIterationStatement4.ts (2 errors) ====
+==== tests/cases/compiler/continueNotInIterationStatement4.ts (1 errors) ====
+    
     TWO:
-    ~~~
-!!! error TS7028: Unused label.
     while (true){
       var x = () => {
         continue TWO;
diff --git a/tests/baselines/reference/continueNotInIterationStatement4.js b/tests/baselines/reference/continueNotInIterationStatement4.js
index f3f52ecb48c..50261be23b1 100644
--- a/tests/baselines/reference/continueNotInIterationStatement4.js
+++ b/tests/baselines/reference/continueNotInIterationStatement4.js
@@ -1,4 +1,5 @@
 //// [continueNotInIterationStatement4.ts]
+
 TWO:
 while (true){
   var x = () => {
diff --git a/tests/baselines/reference/continueTarget3.errors.txt b/tests/baselines/reference/continueTarget3.errors.txt
deleted file mode 100644
index a3f6b64e7c6..00000000000
--- a/tests/baselines/reference/continueTarget3.errors.txt
+++ /dev/null
@@ -1,11 +0,0 @@
-tests/cases/compiler/continueTarget3.ts(2,1): error TS7028: Unused label.
-
-
-==== tests/cases/compiler/continueTarget3.ts (1 errors) ====
-    target1:
-    target2:
-    ~~~~~~~
-!!! error TS7028: Unused label.
-    while (true) {
-      continue target1;
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/continueTarget3.js b/tests/baselines/reference/continueTarget3.js
index 052b7b593c3..70c2d2590e5 100644
--- a/tests/baselines/reference/continueTarget3.js
+++ b/tests/baselines/reference/continueTarget3.js
@@ -1,4 +1,5 @@
 //// [continueTarget3.ts]
+
 target1:
 target2:
 while (true) {
diff --git a/tests/baselines/reference/continueTarget3.symbols b/tests/baselines/reference/continueTarget3.symbols
new file mode 100644
index 00000000000..a5decfe16d1
--- /dev/null
+++ b/tests/baselines/reference/continueTarget3.symbols
@@ -0,0 +1,8 @@
+=== tests/cases/compiler/continueTarget3.ts ===
+
+No type information for this code.target1:
+No type information for this code.target2:
+No type information for this code.while (true) {
+No type information for this code.  continue target1;
+No type information for this code.}
+No type information for this code.
\ No newline at end of file
diff --git a/tests/baselines/reference/continueTarget3.types b/tests/baselines/reference/continueTarget3.types
new file mode 100644
index 00000000000..d55f1c3f6d2
--- /dev/null
+++ b/tests/baselines/reference/continueTarget3.types
@@ -0,0 +1,14 @@
+=== tests/cases/compiler/continueTarget3.ts ===
+
+target1:
+>target1 : any
+
+target2:
+>target2 : any
+
+while (true) {
+>true : boolean
+
+  continue target1;
+>target1 : any
+}
diff --git a/tests/baselines/reference/continueTarget4.errors.txt b/tests/baselines/reference/continueTarget4.errors.txt
deleted file mode 100644
index d8f3cc12892..00000000000
--- a/tests/baselines/reference/continueTarget4.errors.txt
+++ /dev/null
@@ -1,11 +0,0 @@
-tests/cases/compiler/continueTarget4.ts(1,1): error TS7028: Unused label.
-
-
-==== tests/cases/compiler/continueTarget4.ts (1 errors) ====
-    target1:
-    ~~~~~~~
-!!! error TS7028: Unused label.
-    target2:
-    while (true) {
-      continue target2;
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/continueTarget4.js b/tests/baselines/reference/continueTarget4.js
index 0f6211f9202..23c20a03260 100644
--- a/tests/baselines/reference/continueTarget4.js
+++ b/tests/baselines/reference/continueTarget4.js
@@ -1,4 +1,5 @@
 //// [continueTarget4.ts]
+
 target1:
 target2:
 while (true) {
diff --git a/tests/baselines/reference/continueTarget4.symbols b/tests/baselines/reference/continueTarget4.symbols
new file mode 100644
index 00000000000..fc69a881a60
--- /dev/null
+++ b/tests/baselines/reference/continueTarget4.symbols
@@ -0,0 +1,8 @@
+=== tests/cases/compiler/continueTarget4.ts ===
+
+No type information for this code.target1:
+No type information for this code.target2:
+No type information for this code.while (true) {
+No type information for this code.  continue target2;
+No type information for this code.}
+No type information for this code.
\ No newline at end of file
diff --git a/tests/baselines/reference/continueTarget4.types b/tests/baselines/reference/continueTarget4.types
new file mode 100644
index 00000000000..e3e3ae82dfe
--- /dev/null
+++ b/tests/baselines/reference/continueTarget4.types
@@ -0,0 +1,14 @@
+=== tests/cases/compiler/continueTarget4.ts ===
+
+target1:
+>target1 : any
+
+target2:
+>target2 : any
+
+while (true) {
+>true : boolean
+
+  continue target2;
+>target2 : any
+}
diff --git a/tests/baselines/reference/continueTarget5.errors.txt b/tests/baselines/reference/continueTarget5.errors.txt
index 6f0d3a2f6bf..854f57017b6 100644
--- a/tests/baselines/reference/continueTarget5.errors.txt
+++ b/tests/baselines/reference/continueTarget5.errors.txt
@@ -1,11 +1,9 @@
-tests/cases/compiler/continueTarget5.ts(1,1): error TS7028: Unused label.
-tests/cases/compiler/continueTarget5.ts(5,7): error TS1107: Jump target cannot cross function boundary.
+tests/cases/compiler/continueTarget5.ts(6,7): error TS1107: Jump target cannot cross function boundary.
 
 
-==== tests/cases/compiler/continueTarget5.ts (2 errors) ====
+==== tests/cases/compiler/continueTarget5.ts (1 errors) ====
+    
     target:
-    ~~~~~~
-!!! error TS7028: Unused label.
     while (true) {
       function f() {
         while (true) {
diff --git a/tests/baselines/reference/continueTarget5.js b/tests/baselines/reference/continueTarget5.js
index 5bf309d2690..030a1c2589c 100644
--- a/tests/baselines/reference/continueTarget5.js
+++ b/tests/baselines/reference/continueTarget5.js
@@ -1,4 +1,5 @@
 //// [continueTarget5.ts]
+
 target:
 while (true) {
   function f() {
diff --git a/tests/baselines/reference/doWhileBreakStatements.errors.txt b/tests/baselines/reference/doWhileBreakStatements.errors.txt
deleted file mode 100644
index e31109858cf..00000000000
--- a/tests/baselines/reference/doWhileBreakStatements.errors.txt
+++ /dev/null
@@ -1,50 +0,0 @@
-tests/cases/conformance/statements/breakStatements/doWhileBreakStatements.ts(11,1): error TS7028: Unused label.
-tests/cases/conformance/statements/breakStatements/doWhileBreakStatements.ts(19,5): error TS7028: Unused label.
-tests/cases/conformance/statements/breakStatements/doWhileBreakStatements.ts(30,1): error TS7027: Unreachable code detected.
-
-
-==== tests/cases/conformance/statements/breakStatements/doWhileBreakStatements.ts (3 errors) ====
-    do {
-        break;
-    } while(true)
-    
-    ONE:
-    do {
-        break ONE;
-    }
-    while (true)
-    
-    TWO:
-    ~~~
-!!! error TS7028: Unused label.
-    THREE:
-    do {
-        break THREE;
-    }while (true)
-    
-    FOUR:
-    do {
-        FIVE:
-        ~~~~
-!!! error TS7028: Unused label.
-        do {
-            break FOUR;
-        }while (true)
-    }while (true)
-    
-    do {
-        SIX:
-        do break SIX; while(true)
-    }while (true)
-    
-    SEVEN:
-    ~~~~~
-!!! error TS7027: Unreachable code detected.
-    do do do break SEVEN; while (true) while (true)  while (true)
-    
-    EIGHT:
-    do{
-        var fn = function () { }
-        break EIGHT;
-    }while(true)
-    
\ No newline at end of file
diff --git a/tests/baselines/reference/doWhileBreakStatements.js b/tests/baselines/reference/doWhileBreakStatements.js
index a2bc0d3c549..8e272ceed0a 100644
--- a/tests/baselines/reference/doWhileBreakStatements.js
+++ b/tests/baselines/reference/doWhileBreakStatements.js
@@ -1,4 +1,5 @@
 //// [doWhileBreakStatements.ts]
+
 do {
     break;
 } while(true)
diff --git a/tests/baselines/reference/doWhileBreakStatements.symbols b/tests/baselines/reference/doWhileBreakStatements.symbols
new file mode 100644
index 00000000000..14db540598d
--- /dev/null
+++ b/tests/baselines/reference/doWhileBreakStatements.symbols
@@ -0,0 +1,42 @@
+=== tests/cases/conformance/statements/breakStatements/doWhileBreakStatements.ts ===
+
+do {
+    break;
+} while(true)
+
+ONE:
+do {
+    break ONE;
+}
+while (true)
+
+TWO:
+THREE:
+do {
+    break THREE;
+}while (true)
+
+FOUR:
+do {
+    FIVE:
+    do {
+        break FOUR;
+    }while (true)
+}while (true)
+
+do {
+    SIX:
+    do break SIX; while(true)
+}while (true)
+
+SEVEN:
+do do do break SEVEN; while (true) while (true)  while (true)
+
+EIGHT:
+do{
+    var fn = function () { }
+>fn : Symbol(fn, Decl(doWhileBreakStatements.ts, 35, 7))
+
+    break EIGHT;
+}while(true)
+
diff --git a/tests/baselines/reference/doWhileBreakStatements.types b/tests/baselines/reference/doWhileBreakStatements.types
new file mode 100644
index 00000000000..f143cb17d08
--- /dev/null
+++ b/tests/baselines/reference/doWhileBreakStatements.types
@@ -0,0 +1,81 @@
+=== tests/cases/conformance/statements/breakStatements/doWhileBreakStatements.ts ===
+
+do {
+    break;
+} while(true)
+>true : boolean
+
+ONE:
+>ONE : any
+
+do {
+    break ONE;
+>ONE : any
+}
+while (true)
+>true : boolean
+
+TWO:
+>TWO : any
+
+THREE:
+>THREE : any
+
+do {
+    break THREE;
+>THREE : any
+
+}while (true)
+>true : boolean
+
+FOUR:
+>FOUR : any
+
+do {
+    FIVE:
+>FIVE : any
+
+    do {
+        break FOUR;
+>FOUR : any
+
+    }while (true)
+>true : boolean
+
+}while (true)
+>true : boolean
+
+do {
+    SIX:
+>SIX : any
+
+    do break SIX; while(true)
+>SIX : any
+>true : boolean
+
+}while (true)
+>true : boolean
+
+SEVEN:
+>SEVEN : any
+
+do do do break SEVEN; while (true) while (true)  while (true)
+>SEVEN : any
+>true : boolean
+>true : boolean
+>true : boolean
+
+EIGHT:
+>EIGHT : any
+
+do{
+    var fn = function () { }
+>fn : () => void
+>function () { } : () => void
+
+    break EIGHT;
+>EIGHT : any
+
+}while(true)
+>true : boolean
+
diff --git a/tests/baselines/reference/doWhileContinueStatements.errors.txt b/tests/baselines/reference/doWhileContinueStatements.errors.txt
deleted file mode 100644
index 491e1242e2f..00000000000
--- a/tests/baselines/reference/doWhileContinueStatements.errors.txt
+++ /dev/null
@@ -1,44 +0,0 @@
-tests/cases/conformance/statements/continueStatements/doWhileContinueStatements.ts(5,1): error TS7027: Unreachable code detected.
-
-
-==== tests/cases/conformance/statements/continueStatements/doWhileContinueStatements.ts (1 errors) ====
-    do {
-        continue;
-    } while(true)
-    
-    ONE:
-    ~~~
-!!! error TS7027: Unreachable code detected.
-    do {
-        continue ONE;
-    }
-    while (true)
-    
-    TWO:
-    THREE:
-    do {
-        continue THREE;
-    }while (true)
-    
-    FOUR:
-    do {
-        FIVE:
-        do {
-            continue FOUR;
-        }while (true)
-    }while (true)
-    
-    do {
-        SIX:
-        do continue SIX; while(true)
-    }while (true)
-    
-    SEVEN:
-    do do do continue SEVEN; while (true) while (true)  while (true)
-    
-    EIGHT:
-    do{
-        var fn = function () { }
-        continue EIGHT;
-    }while(true)
-    
\ No newline at end of file
diff --git a/tests/baselines/reference/doWhileContinueStatements.js b/tests/baselines/reference/doWhileContinueStatements.js
index 7f73157fd99..51bac3c4e09 100644
--- a/tests/baselines/reference/doWhileContinueStatements.js
+++ b/tests/baselines/reference/doWhileContinueStatements.js
@@ -1,4 +1,5 @@
 //// [doWhileContinueStatements.ts]
+
 do {
     continue;
 } while(true)
diff --git a/tests/baselines/reference/doWhileContinueStatements.symbols b/tests/baselines/reference/doWhileContinueStatements.symbols
new file mode 100644
index 00000000000..36ca2dde764
--- /dev/null
+++ b/tests/baselines/reference/doWhileContinueStatements.symbols
@@ -0,0 +1,42 @@
+=== tests/cases/conformance/statements/continueStatements/doWhileContinueStatements.ts ===
+
+do {
+    continue;
+} while(true)
+
+ONE:
+do {
+    continue ONE;
+}
+while (true)
+
+TWO:
+THREE:
+do {
+    continue THREE;
+}while (true)
+
+FOUR:
+do {
+    FIVE:
+    do {
+        continue FOUR;
+    }while (true)
+}while (true)
+
+do {
+    SIX:
+    do continue SIX; while(true)
+}while (true)
+
+SEVEN:
+do do do continue SEVEN; while (true) while (true)  while (true)
+
+EIGHT:
+do{
+    var fn = function () { }
+>fn : Symbol(fn, Decl(doWhileContinueStatements.ts, 35, 7))
+
+    continue EIGHT;
+}while(true)
+
diff --git a/tests/baselines/reference/doWhileContinueStatements.types b/tests/baselines/reference/doWhileContinueStatements.types
new file mode 100644
index 00000000000..e4d3191d040
--- /dev/null
+++ b/tests/baselines/reference/doWhileContinueStatements.types
@@ -0,0 +1,81 @@
+=== tests/cases/conformance/statements/continueStatements/doWhileContinueStatements.ts ===
+
+do {
+    continue;
+} while(true)
+>true : boolean
+
+ONE:
+>ONE : any
+
+do {
+    continue ONE;
+>ONE : any
+}
+while (true)
+>true : boolean
+
+TWO:
+>TWO : any
+
+THREE:
+>THREE : any
+
+do {
+    continue THREE;
+>THREE : any
+
+}while (true)
+>true : boolean
+
+FOUR:
+>FOUR : any
+
+do {
+    FIVE:
+>FIVE : any
+
+    do {
+        continue FOUR;
+>FOUR : any
+
+    }while (true)
+>true : boolean
+
+}while (true)
+>true : boolean
+
+do {
+    SIX:
+>SIX : any
+
+    do continue SIX; while(true)
+>SIX : any
+>true : boolean
+
+}while (true)
+>true : boolean
+
+SEVEN:
+>SEVEN : any
+
+do do do continue SEVEN; while (true) while (true)  while (true)
+>SEVEN : any
+>true : boolean
+>true : boolean
+>true : boolean
+
+EIGHT:
+>EIGHT : any
+
+do{
+    var fn = function () { }
+>fn : () => void
+>function () { } : () => void
+
+    continue EIGHT;
+>EIGHT : any
+
+}while(true)
+>true : boolean
+
diff --git a/tests/baselines/reference/downlevelLetConst16.errors.txt b/tests/baselines/reference/downlevelLetConst16.errors.txt
index a6651574b9e..a6ada633016 100644
--- a/tests/baselines/reference/downlevelLetConst16.errors.txt
+++ b/tests/baselines/reference/downlevelLetConst16.errors.txt
@@ -1,14 +1,13 @@
-tests/cases/compiler/downlevelLetConst16.ts(151,5): error TS7027: Unreachable code detected.
-tests/cases/compiler/downlevelLetConst16.ts(151,15): error TS2525: Initializer provides no value for this binding element and the binding element has no default value.
-tests/cases/compiler/downlevelLetConst16.ts(164,5): error TS7027: Unreachable code detected.
-tests/cases/compiler/downlevelLetConst16.ts(164,17): error TS2525: Initializer provides no value for this binding element and the binding element has no default value.
-tests/cases/compiler/downlevelLetConst16.ts(195,14): error TS2461: Type 'undefined' is not an array type.
-tests/cases/compiler/downlevelLetConst16.ts(202,15): error TS2459: Type 'undefined' has no property 'a' and no string index signature.
-tests/cases/compiler/downlevelLetConst16.ts(216,16): error TS2461: Type 'undefined' is not an array type.
-tests/cases/compiler/downlevelLetConst16.ts(223,17): error TS2459: Type 'undefined' has no property 'a' and no string index signature.
+tests/cases/compiler/downlevelLetConst16.ts(152,15): error TS2525: Initializer provides no value for this binding element and the binding element has no default value.
+tests/cases/compiler/downlevelLetConst16.ts(165,17): error TS2525: Initializer provides no value for this binding element and the binding element has no default value.
+tests/cases/compiler/downlevelLetConst16.ts(196,14): error TS2461: Type 'undefined' is not an array type.
+tests/cases/compiler/downlevelLetConst16.ts(203,15): error TS2459: Type 'undefined' has no property 'a' and no string index signature.
+tests/cases/compiler/downlevelLetConst16.ts(217,16): error TS2461: Type 'undefined' is not an array type.
+tests/cases/compiler/downlevelLetConst16.ts(224,17): error TS2459: Type 'undefined' has no property 'a' and no string index signature.
 
 
-==== tests/cases/compiler/downlevelLetConst16.ts (8 errors) ====
+==== tests/cases/compiler/downlevelLetConst16.ts (6 errors) ====
+    
     'use strict'
     
     declare function use(a: any);
@@ -160,8 +159,6 @@ tests/cases/compiler/downlevelLetConst16.ts(223,17): error TS2459: Type 'undefin
             use(x);
         }
         for (let [y] = []; ;) {
-        ~~~
-!!! error TS7027: Unreachable code detected.
                   ~
 !!! error TS2525: Initializer provides no value for this binding element and the binding element has no default value.
             use(y);
@@ -177,8 +174,6 @@ tests/cases/compiler/downlevelLetConst16.ts(223,17): error TS2459: Type 'undefin
             use(x);
         }
         for (const [y] = []; ;) {
-        ~~~
-!!! error TS7027: Unreachable code detected.
                     ~
 !!! error TS2525: Initializer provides no value for this binding element and the binding element has no default value.
             use(y);
diff --git a/tests/baselines/reference/downlevelLetConst16.js b/tests/baselines/reference/downlevelLetConst16.js
index 874fc121191..d6f05f7584a 100644
--- a/tests/baselines/reference/downlevelLetConst16.js
+++ b/tests/baselines/reference/downlevelLetConst16.js
@@ -1,4 +1,5 @@
 //// [downlevelLetConst16.ts]
+
 'use strict'
 
 declare function use(a: any);
diff --git a/tests/baselines/reference/downlevelLetConst17.errors.txt b/tests/baselines/reference/downlevelLetConst17.errors.txt
deleted file mode 100644
index 0365b638449..00000000000
--- a/tests/baselines/reference/downlevelLetConst17.errors.txt
+++ /dev/null
@@ -1,73 +0,0 @@
-tests/cases/compiler/downlevelLetConst17.ts(9,1): error TS7027: Unreachable code detected.
-
-
-==== tests/cases/compiler/downlevelLetConst17.ts (1 errors) ====
-    'use strict'
-    
-    declare function use(a: any);
-    
-    var x;
-    for (let x = 10; ;) {
-        use(x);
-    }
-    use(x);
-    ~~~
-!!! error TS7027: Unreachable code detected.
-    
-    for (const x = 10; ;) {
-        use(x);
-    }
-    
-    for (; ;) {
-        let x = 10;
-        use(x);
-        x = 1;
-    }
-    
-    for (; ;) {
-        const x = 10;
-        use(x);
-    }
-    
-    for (let x; ;) {
-        use(x);
-        x = 1;
-    }
-    
-    for (; ;) {
-        let x;
-        use(x);
-        x = 1;
-    }
-    
-    while (true) {
-        let x;
-        use(x);
-    }
-    
-    while (true) {
-        const x = true;
-        use(x);
-    }
-    
-    do {
-        let x;
-        use(x);
-    } while (true);
-    
-    do {
-        let x;
-        use(x);
-    } while (true);
-    
-    for (let x in []) {
-        use(x);
-    }
-    
-    for (const x in []) {
-        use(x);
-    }
-    
-    for (const x of []) {
-        use(x);
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/downlevelLetConst17.symbols b/tests/baselines/reference/downlevelLetConst17.symbols
new file mode 100644
index 00000000000..809a835774c
--- /dev/null
+++ b/tests/baselines/reference/downlevelLetConst17.symbols
@@ -0,0 +1,134 @@
+=== tests/cases/compiler/downlevelLetConst17.ts ===
+'use strict'
+
+declare function use(a: any);
+>use : Symbol(use, Decl(downlevelLetConst17.ts, 0, 12))
+>a : Symbol(a, Decl(downlevelLetConst17.ts, 2, 21))
+
+var x;
+>x : Symbol(x, Decl(downlevelLetConst17.ts, 4, 3))
+
+for (let x = 10; ;) {
+>x : Symbol(x, Decl(downlevelLetConst17.ts, 5, 8))
+
+    use(x);
+>use : Symbol(use, Decl(downlevelLetConst17.ts, 0, 12))
+>x : Symbol(x, Decl(downlevelLetConst17.ts, 5, 8))
+}
+use(x);
+>use : Symbol(use, Decl(downlevelLetConst17.ts, 0, 12))
+>x : Symbol(x, Decl(downlevelLetConst17.ts, 4, 3))
+
+for (const x = 10; ;) {
+>x : Symbol(x, Decl(downlevelLetConst17.ts, 10, 10))
+
+    use(x);
+>use : Symbol(use, Decl(downlevelLetConst17.ts, 0, 12))
+>x : Symbol(x, Decl(downlevelLetConst17.ts, 10, 10))
+}
+
+for (; ;) {
+    let x = 10;
+>x : Symbol(x, Decl(downlevelLetConst17.ts, 15, 7))
+
+    use(x);
+>use : Symbol(use, Decl(downlevelLetConst17.ts, 0, 12))
+>x : Symbol(x, Decl(downlevelLetConst17.ts, 15, 7))
+
+    x = 1;
+>x : Symbol(x, Decl(downlevelLetConst17.ts, 15, 7))
+}
+
+for (; ;) {
+    const x = 10;
+>x : Symbol(x, Decl(downlevelLetConst17.ts, 21, 9))
+
+    use(x);
+>use : Symbol(use, Decl(downlevelLetConst17.ts, 0, 12))
+>x : Symbol(x, Decl(downlevelLetConst17.ts, 21, 9))
+}
+
+for (let x; ;) {
+>x : Symbol(x, Decl(downlevelLetConst17.ts, 25, 8))
+
+    use(x);
+>use : Symbol(use, Decl(downlevelLetConst17.ts, 0, 12))
+>x : Symbol(x, Decl(downlevelLetConst17.ts, 25, 8))
+
+    x = 1;
+>x : Symbol(x, Decl(downlevelLetConst17.ts, 25, 8))
+}
+
+for (; ;) {
+    let x;
+>x : Symbol(x, Decl(downlevelLetConst17.ts, 31, 7))
+
+    use(x);
+>use : Symbol(use, Decl(downlevelLetConst17.ts, 0, 12))
+>x : Symbol(x, Decl(downlevelLetConst17.ts, 31, 7))
+
+    x = 1;
+>x : Symbol(x, Decl(downlevelLetConst17.ts, 31, 7))
+}
+
+while (true) {
+    let x;
+>x : Symbol(x, Decl(downlevelLetConst17.ts, 37, 7))
+
+    use(x);
+>use : Symbol(use, Decl(downlevelLetConst17.ts, 0, 12))
+>x : Symbol(x, Decl(downlevelLetConst17.ts, 37, 7))
+}
+
+while (true) {
+    const x = true;
+>x : Symbol(x, Decl(downlevelLetConst17.ts, 42, 9))
+
+    use(x);
+>use : Symbol(use, Decl(downlevelLetConst17.ts, 0, 12))
+>x : Symbol(x, Decl(downlevelLetConst17.ts, 42, 9))
+}
+
+do {
+    let x;
+>x : Symbol(x, Decl(downlevelLetConst17.ts, 47, 7))
+
+    use(x);
+>use : Symbol(use, Decl(downlevelLetConst17.ts, 0, 12))
+>x : Symbol(x, Decl(downlevelLetConst17.ts, 47, 7))
+
+} while (true);
+
+do {
+    let x;
+>x : Symbol(x, Decl(downlevelLetConst17.ts, 52, 7))
+
+    use(x);
+>use : Symbol(use, Decl(downlevelLetConst17.ts, 0, 12))
+>x : Symbol(x, Decl(downlevelLetConst17.ts, 52, 7))
+
+} while (true);
+
+for (let x in []) {
+>x : Symbol(x, Decl(downlevelLetConst17.ts, 56, 8))
+
+    use(x);
+>use : Symbol(use, Decl(downlevelLetConst17.ts, 0, 12))
+>x : Symbol(x, Decl(downlevelLetConst17.ts, 56, 8))
+}
+
+for (const x in []) {
+>x : Symbol(x, Decl(downlevelLetConst17.ts, 60, 10))
+
+    use(x);
+>use : Symbol(use, Decl(downlevelLetConst17.ts, 0, 12))
+>x : Symbol(x, Decl(downlevelLetConst17.ts, 60, 10))
+}
+
+for (const x of []) {
+>x : Symbol(x, Decl(downlevelLetConst17.ts, 64, 10))
+
+    use(x);
+>use : Symbol(use, Decl(downlevelLetConst17.ts, 0, 12))
+>x : Symbol(x, Decl(downlevelLetConst17.ts, 64, 10))
+}
diff --git a/tests/baselines/reference/downlevelLetConst17.types b/tests/baselines/reference/downlevelLetConst17.types
new file mode 100644
index 00000000000..824abcc76be
--- /dev/null
+++ b/tests/baselines/reference/downlevelLetConst17.types
@@ -0,0 +1,169 @@
+=== tests/cases/compiler/downlevelLetConst17.ts ===
+'use strict'
+>'use strict' : string
+
+declare function use(a: any);
+>use : (a: any) => any
+>a : any
+
+var x;
+>x : any
+
+for (let x = 10; ;) {
+>x : number
+>10 : number
+
+    use(x);
+>use(x) : any
+>use : (a: any) => any
+>x : number
+}
+use(x);
+>use(x) : any
+>use : (a: any) => any
+>x : any
+
+for (const x = 10; ;) {
+>x : number
+>10 : number
+
+    use(x);
+>use(x) : any
+>use : (a: any) => any
+>x : number
+}
+
+for (; ;) {
+    let x = 10;
+>x : number
+>10 : number
+
+    use(x);
+>use(x) : any
+>use : (a: any) => any
+>x : number
+
+    x = 1;
+>x = 1 : number
+>x : number
+>1 : number
+}
+
+for (; ;) {
+    const x = 10;
+>x : number
+>10 : number
+
+    use(x);
+>use(x) : any
+>use : (a: any) => any
+>x : number
+}
+
+for (let x; ;) {
+>x : any
+
+    use(x);
+>use(x) : any
+>use : (a: any) => any
+>x : any
+
+    x = 1;
+>x = 1 : number
+>x : any
+>1 : number
+}
+
+for (; ;) {
+    let x;
+>x : any
+
+    use(x);
+>use(x) : any
+>use : (a: any) => any
+>x : any
+
+    x = 1;
+>x = 1 : number
+>x : any
+>1 : number
+}
+
+while (true) {
+>true : boolean
+
+    let x;
+>x : any
+
+    use(x);
+>use(x) : any
+>use : (a: any) => any
+>x : any
+}
+
+while (true) {
+>true : boolean
+
+    const x = true;
+>x : boolean
+>true : boolean
+
+    use(x);
+>use(x) : any
+>use : (a: any) => any
+>x : boolean
+}
+
+do {
+    let x;
+>x : any
+
+    use(x);
+>use(x) : any
+>use : (a: any) => any
+>x : any
+
+} while (true);
+>true : boolean
+
+do {
+    let x;
+>x : any
+
+    use(x);
+>use(x) : any
+>use : (a: any) => any
+>x : any
+
+} while (true);
+>true : boolean
+
+for (let x in []) {
+>x : any
+>[] : undefined[]
+
+    use(x);
+>use(x) : any
+>use : (a: any) => any
+>x : any
+}
+
+for (const x in []) {
+>x : any
+>[] : undefined[]
+
+    use(x);
+>use(x) : any
+>use : (a: any) => any
+>x : any
+}
+
+for (const x of []) {
+>x : any
+>[] : undefined[]
+
+    use(x);
+>use(x) : any
+>use : (a: any) => any
+>x : any
+}
diff --git a/tests/baselines/reference/downlevelLetConst18.errors.txt b/tests/baselines/reference/downlevelLetConst18.errors.txt
index 5d9d24a4d6d..9f9700dbb7e 100644
--- a/tests/baselines/reference/downlevelLetConst18.errors.txt
+++ b/tests/baselines/reference/downlevelLetConst18.errors.txt
@@ -1,16 +1,16 @@
-tests/cases/compiler/downlevelLetConst18.ts(3,1): error TS4091: Loop contains block-scoped variable 'x' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher.
-tests/cases/compiler/downlevelLetConst18.ts(4,14): error TS2393: Duplicate function implementation.
-tests/cases/compiler/downlevelLetConst18.ts(7,1): error TS4091: Loop contains block-scoped variable 'x' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher.
-tests/cases/compiler/downlevelLetConst18.ts(7,1): error TS7027: Unreachable code detected.
-tests/cases/compiler/downlevelLetConst18.ts(8,14): error TS2393: Duplicate function implementation.
-tests/cases/compiler/downlevelLetConst18.ts(11,1): error TS4091: Loop contains block-scoped variable 'x' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher.
-tests/cases/compiler/downlevelLetConst18.ts(15,1): error TS4091: Loop contains block-scoped variable 'x' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher.
-tests/cases/compiler/downlevelLetConst18.ts(19,1): error TS4091: Loop contains block-scoped variable 'x' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher.
-tests/cases/compiler/downlevelLetConst18.ts(23,1): error TS4091: Loop contains block-scoped variable 'x' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher.
-tests/cases/compiler/downlevelLetConst18.ts(27,1): error TS4091: Loop contains block-scoped variable 'x' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher.
+tests/cases/compiler/downlevelLetConst18.ts(4,1): error TS4091: Loop contains block-scoped variable 'x' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher.
+tests/cases/compiler/downlevelLetConst18.ts(5,14): error TS2393: Duplicate function implementation.
+tests/cases/compiler/downlevelLetConst18.ts(8,1): error TS4091: Loop contains block-scoped variable 'x' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher.
+tests/cases/compiler/downlevelLetConst18.ts(9,14): error TS2393: Duplicate function implementation.
+tests/cases/compiler/downlevelLetConst18.ts(12,1): error TS4091: Loop contains block-scoped variable 'x' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher.
+tests/cases/compiler/downlevelLetConst18.ts(16,1): error TS4091: Loop contains block-scoped variable 'x' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher.
+tests/cases/compiler/downlevelLetConst18.ts(20,1): error TS4091: Loop contains block-scoped variable 'x' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher.
+tests/cases/compiler/downlevelLetConst18.ts(24,1): error TS4091: Loop contains block-scoped variable 'x' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher.
+tests/cases/compiler/downlevelLetConst18.ts(28,1): error TS4091: Loop contains block-scoped variable 'x' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher.
 
 
-==== tests/cases/compiler/downlevelLetConst18.ts (10 errors) ====
+==== tests/cases/compiler/downlevelLetConst18.ts (9 errors) ====
+    
     'use strict'
     
     for (let x; ;) {
@@ -24,8 +24,6 @@ tests/cases/compiler/downlevelLetConst18.ts(27,1): error TS4091: Loop contains b
     for (let x; ;) {
     ~~~
 !!! error TS4091: Loop contains block-scoped variable 'x' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher.
-    ~~~
-!!! error TS7027: Unreachable code detected.
         function foo() { x };
                  ~~~
 !!! error TS2393: Duplicate function implementation.
diff --git a/tests/baselines/reference/downlevelLetConst18.js b/tests/baselines/reference/downlevelLetConst18.js
index 70b8cb9e346..0674929d225 100644
--- a/tests/baselines/reference/downlevelLetConst18.js
+++ b/tests/baselines/reference/downlevelLetConst18.js
@@ -1,4 +1,5 @@
 //// [downlevelLetConst18.ts]
+
 'use strict'
 
 for (let x; ;) {
diff --git a/tests/baselines/reference/duplicateLabel1.errors.txt b/tests/baselines/reference/duplicateLabel1.errors.txt
index 2f89b400e21..cf116f656fc 100644
--- a/tests/baselines/reference/duplicateLabel1.errors.txt
+++ b/tests/baselines/reference/duplicateLabel1.errors.txt
@@ -1,11 +1,9 @@
-tests/cases/compiler/duplicateLabel1.ts(1,1): error TS7028: Unused label.
-tests/cases/compiler/duplicateLabel1.ts(2,1): error TS1114: Duplicate label 'target'
+tests/cases/compiler/duplicateLabel1.ts(3,1): error TS1114: Duplicate label 'target'
 
 
-==== tests/cases/compiler/duplicateLabel1.ts (2 errors) ====
+==== tests/cases/compiler/duplicateLabel1.ts (1 errors) ====
+    
     target:
-    ~~~~~~
-!!! error TS7028: Unused label.
     target:
     ~~~~~~
 !!! error TS1114: Duplicate label 'target'
diff --git a/tests/baselines/reference/duplicateLabel1.js b/tests/baselines/reference/duplicateLabel1.js
index e7976895c94..5251cec3e36 100644
--- a/tests/baselines/reference/duplicateLabel1.js
+++ b/tests/baselines/reference/duplicateLabel1.js
@@ -1,4 +1,5 @@
 //// [duplicateLabel1.ts]
+
 target:
 target:
 while (true) {
diff --git a/tests/baselines/reference/duplicateLabel2.errors.txt b/tests/baselines/reference/duplicateLabel2.errors.txt
index f150879c010..2a87ed96648 100644
--- a/tests/baselines/reference/duplicateLabel2.errors.txt
+++ b/tests/baselines/reference/duplicateLabel2.errors.txt
@@ -1,11 +1,9 @@
-tests/cases/compiler/duplicateLabel2.ts(1,1): error TS7028: Unused label.
-tests/cases/compiler/duplicateLabel2.ts(3,3): error TS1114: Duplicate label 'target'
+tests/cases/compiler/duplicateLabel2.ts(4,3): error TS1114: Duplicate label 'target'
 
 
-==== tests/cases/compiler/duplicateLabel2.ts (2 errors) ====
+==== tests/cases/compiler/duplicateLabel2.ts (1 errors) ====
+    
     target:
-    ~~~~~~
-!!! error TS7028: Unused label.
     while (true) {
       target:
       ~~~~~~
diff --git a/tests/baselines/reference/duplicateLabel2.js b/tests/baselines/reference/duplicateLabel2.js
index 9ee9671d59d..40a5ee4595e 100644
--- a/tests/baselines/reference/duplicateLabel2.js
+++ b/tests/baselines/reference/duplicateLabel2.js
@@ -1,4 +1,5 @@
 //// [duplicateLabel2.ts]
+
 target:
 while (true) {
   target:
diff --git a/tests/baselines/reference/duplicateLabel3.errors.txt b/tests/baselines/reference/duplicateLabel3.errors.txt
deleted file mode 100644
index f256176f1e0..00000000000
--- a/tests/baselines/reference/duplicateLabel3.errors.txt
+++ /dev/null
@@ -1,17 +0,0 @@
-tests/cases/compiler/duplicateLabel3.ts(1,1): error TS7028: Unused label.
-tests/cases/compiler/duplicateLabel3.ts(4,5): error TS7028: Unused label.
-
-
-==== tests/cases/compiler/duplicateLabel3.ts (2 errors) ====
-    target:
-    ~~~~~~
-!!! error TS7028: Unused label.
-    while (true) {
-      function f() {
-        target:
-        ~~~~~~
-!!! error TS7028: Unused label.
-        while (true) {
-        }
-      }
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/duplicateLabel3.js b/tests/baselines/reference/duplicateLabel3.js
index 37e9619e8f6..a1d33e46fc1 100644
--- a/tests/baselines/reference/duplicateLabel3.js
+++ b/tests/baselines/reference/duplicateLabel3.js
@@ -1,4 +1,5 @@
 //// [duplicateLabel3.ts]
+
 target:
 while (true) {
   function f() {
diff --git a/tests/baselines/reference/duplicateLabel3.symbols b/tests/baselines/reference/duplicateLabel3.symbols
new file mode 100644
index 00000000000..89f2d5ee48a
--- /dev/null
+++ b/tests/baselines/reference/duplicateLabel3.symbols
@@ -0,0 +1,12 @@
+=== tests/cases/compiler/duplicateLabel3.ts ===
+
+target:
+while (true) {
+  function f() {
+>f : Symbol(f, Decl(duplicateLabel3.ts, 2, 14))
+
+    target:
+    while (true) {
+    }
+  }
+}
diff --git a/tests/baselines/reference/duplicateLabel3.types b/tests/baselines/reference/duplicateLabel3.types
new file mode 100644
index 00000000000..920a077aa9e
--- /dev/null
+++ b/tests/baselines/reference/duplicateLabel3.types
@@ -0,0 +1,19 @@
+=== tests/cases/compiler/duplicateLabel3.ts ===
+
+target:
+>target : any
+
+while (true) {
+>true : boolean
+
+  function f() {
+>f : () => void
+
+    target:
+>target : any
+
+    while (true) {
+>true : boolean
+    }
+  }
+}
diff --git a/tests/baselines/reference/duplicateLabel4.errors.txt b/tests/baselines/reference/duplicateLabel4.errors.txt
deleted file mode 100644
index 516a4b2324b..00000000000
--- a/tests/baselines/reference/duplicateLabel4.errors.txt
+++ /dev/null
@@ -1,16 +0,0 @@
-tests/cases/compiler/duplicateLabel4.ts(1,1): error TS7028: Unused label.
-tests/cases/compiler/duplicateLabel4.ts(5,1): error TS7027: Unreachable code detected.
-
-
-==== tests/cases/compiler/duplicateLabel4.ts (2 errors) ====
-    target:
-    ~~~~~~
-!!! error TS7028: Unused label.
-    while (true) {
-    }
-    
-    target: 
-    ~~~~~~
-!!! error TS7027: Unreachable code detected.
-    while (true) {
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/duplicateLabel4.js b/tests/baselines/reference/duplicateLabel4.js
index 22d072d38d7..d5b81b1e5bb 100644
--- a/tests/baselines/reference/duplicateLabel4.js
+++ b/tests/baselines/reference/duplicateLabel4.js
@@ -1,4 +1,5 @@
 //// [duplicateLabel4.ts]
+
 target:
 while (true) {
 }
diff --git a/tests/baselines/reference/duplicateLabel4.symbols b/tests/baselines/reference/duplicateLabel4.symbols
new file mode 100644
index 00000000000..5660782e2ec
--- /dev/null
+++ b/tests/baselines/reference/duplicateLabel4.symbols
@@ -0,0 +1,10 @@
+=== tests/cases/compiler/duplicateLabel4.ts ===
+
+No type information for this code.target:
+No type information for this code.while (true) {
+No type information for this code.}
+No type information for this code.
+No type information for this code.target: 
+No type information for this code.while (true) {
+No type information for this code.}
+No type information for this code.
\ No newline at end of file
diff --git a/tests/baselines/reference/duplicateLabel4.types b/tests/baselines/reference/duplicateLabel4.types
new file mode 100644
index 00000000000..a10a06fe7a2
--- /dev/null
+++ b/tests/baselines/reference/duplicateLabel4.types
@@ -0,0 +1,15 @@
+=== tests/cases/compiler/duplicateLabel4.ts ===
+
+target:
+>target : any
+
+while (true) {
+>true : boolean
+}
+
+target: 
+>target : any
+
+while (true) {
+>true : boolean
+}
diff --git a/tests/baselines/reference/duplicateLocalVariable1.errors.txt b/tests/baselines/reference/duplicateLocalVariable1.errors.txt
index 890470f6c11..bd6d535d88e 100644
--- a/tests/baselines/reference/duplicateLocalVariable1.errors.txt
+++ b/tests/baselines/reference/duplicateLocalVariable1.errors.txt
@@ -1,9 +1,19 @@
-tests/cases/compiler/duplicateLocalVariable1.ts(64,92): error TS7027: Unreachable code detected.
-tests/cases/compiler/duplicateLocalVariable1.ts(65,122): error TS7027: Unreachable code detected.
-tests/cases/compiler/duplicateLocalVariable1.ts(185,22): error TS2403: Subsequent variable declarations must have the same type.  Variable 'i' must be of type 'any', but here has type 'number'.
+tests/cases/compiler/duplicateLocalVariable1.ts(2,4): error TS1005: ';' expected.
+tests/cases/compiler/duplicateLocalVariable1.ts(2,11): error TS1146: Declaration expected.
+tests/cases/compiler/duplicateLocalVariable1.ts(2,13): error TS2304: Cannot find name 'commonjs'.
+tests/cases/compiler/duplicateLocalVariable1.ts(12,14): error TS1148: Cannot compile modules unless the '--module' flag is provided.
+tests/cases/compiler/duplicateLocalVariable1.ts(187,22): error TS2403: Subsequent variable declarations must have the same type.  Variable 'i' must be of type 'any', but here has type 'number'.
 
 
-==== tests/cases/compiler/duplicateLocalVariable1.ts (3 errors) ====
+==== tests/cases/compiler/duplicateLocalVariable1.ts (5 errors) ====
+    
+    / /@module: commonjs
+       ~
+!!! error TS1005: ';' expected.
+              
+!!! error TS1146: Declaration expected.
+                ~~~~~~~~
+!!! error TS2304: Cannot find name 'commonjs'.
     
     //import FileManager = require('filemanager');
     //import App = require('app');
@@ -14,6 +24,8 @@ tests/cases/compiler/duplicateLocalVariable1.ts(185,22): error TS2403: Subsequen
     var TestFileDir = ".\\TempTestFiles";
     
     export class TestCase {
+                 ~~~~~~~~
+!!! error TS1148: Cannot compile modules unless the '--module' flag is provided.
         constructor (public name: string, public test: ()=>boolean, public errorMessageRegEx?: string) {
         }
     }
@@ -68,11 +80,7 @@ tests/cases/compiler/duplicateLocalVariable1.ts(185,22): error TS2403: Subsequen
         // First 3 are for simple harness validation
         testRunner.addTest(new TestCase("Basic test", function () { return true; }));
         testRunner.addTest(new TestCase("Test for any error", function () { throw new Error(); return false; }, ""));
-                                                                                               ~~~~~~
-!!! error TS7027: Unreachable code detected.
         testRunner.addTest(new TestCase("Test RegEx error message match", function () { throw new Error("Should also pass"); return false; }, "Should [also]+ pass"));
-                                                                                                                             ~~~~~~
-!!! error TS7027: Unreachable code detected.
         testRunner.addTest(new TestCase("Test array compare true", function () { return TestRunner.arrayCompare([1, 2, 3], [1, 2, 3]); }));
         testRunner.addTest(new TestCase("Test array compare false", function () { return !TestRunner.arrayCompare([3, 2, 3], [1, 2, 3]); }));
     
diff --git a/tests/baselines/reference/duplicateLocalVariable1.js b/tests/baselines/reference/duplicateLocalVariable1.js
index 62e291f28c0..ecde1ff2407 100644
--- a/tests/baselines/reference/duplicateLocalVariable1.js
+++ b/tests/baselines/reference/duplicateLocalVariable1.js
@@ -1,5 +1,7 @@
 //// [duplicateLocalVariable1.ts]
 
+/ /@module: commonjs
+
 //import FileManager = require('filemanager');
 //import App = require('app');
 
@@ -344,8 +346,8 @@ export var tests: TestRunner = (function () {
 })();
 
 //// [duplicateLocalVariable1.js]
-//import FileManager = require('filemanager');
-//import App = require('app');
+/ /;
+commonjs;
 var TestFileDir = ".\\TempTestFiles";
 var TestCase = (function () {
     function TestCase(name, test, errorMessageRegEx) {
diff --git a/tests/baselines/reference/duplicateVariablesByScope.errors.txt b/tests/baselines/reference/duplicateVariablesByScope.errors.txt
deleted file mode 100644
index e101b2b0e0d..00000000000
--- a/tests/baselines/reference/duplicateVariablesByScope.errors.txt
+++ /dev/null
@@ -1,37 +0,0 @@
-tests/cases/compiler/duplicateVariablesByScope.ts(18,9): error TS7027: Unreachable code detected.
-
-
-==== tests/cases/compiler/duplicateVariablesByScope.ts (1 errors) ====
-    // duplicate local variables are only reported at global scope
-    
-    module M {
-        for (var j = 0; j < 10; j++) {
-        }
-    
-        for (var j = 0; j < 10; j++) {
-        }
-    }
-    
-    function foo() {
-        var x = 2;
-        var x = 1;
-        if (true) {
-            var result = 1;
-        }
-        else {
-            var result = 2;
-            ~~~
-!!! error TS7027: Unreachable code detected.
-        }
-    }
-    
-    class C {
-        foo() {
-            try {
-                var x = 1;
-            }
-            catch (e) {
-                var x = 2;
-            }
-        }
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/duplicateVariablesByScope.js b/tests/baselines/reference/duplicateVariablesByScope.js
index d87fd966f32..43b6e89d412 100644
--- a/tests/baselines/reference/duplicateVariablesByScope.js
+++ b/tests/baselines/reference/duplicateVariablesByScope.js
@@ -1,4 +1,5 @@
 //// [duplicateVariablesByScope.ts]
+
 // duplicate local variables are only reported at global scope
 
 module M {
diff --git a/tests/baselines/reference/duplicateVariablesByScope.symbols b/tests/baselines/reference/duplicateVariablesByScope.symbols
new file mode 100644
index 00000000000..9dd280d2756
--- /dev/null
+++ b/tests/baselines/reference/duplicateVariablesByScope.symbols
@@ -0,0 +1,57 @@
+=== tests/cases/compiler/duplicateVariablesByScope.ts ===
+
+// duplicate local variables are only reported at global scope
+
+module M {
+>M : Symbol(M, Decl(duplicateVariablesByScope.ts, 0, 0))
+
+    for (var j = 0; j < 10; j++) {
+>j : Symbol(j, Decl(duplicateVariablesByScope.ts, 4, 12), Decl(duplicateVariablesByScope.ts, 7, 12))
+>j : Symbol(j, Decl(duplicateVariablesByScope.ts, 4, 12), Decl(duplicateVariablesByScope.ts, 7, 12))
+>j : Symbol(j, Decl(duplicateVariablesByScope.ts, 4, 12), Decl(duplicateVariablesByScope.ts, 7, 12))
+    }
+
+    for (var j = 0; j < 10; j++) {
+>j : Symbol(j, Decl(duplicateVariablesByScope.ts, 4, 12), Decl(duplicateVariablesByScope.ts, 7, 12))
+>j : Symbol(j, Decl(duplicateVariablesByScope.ts, 4, 12), Decl(duplicateVariablesByScope.ts, 7, 12))
+>j : Symbol(j, Decl(duplicateVariablesByScope.ts, 4, 12), Decl(duplicateVariablesByScope.ts, 7, 12))
+    }
+}
+
+function foo() {
+>foo : Symbol(foo, Decl(duplicateVariablesByScope.ts, 9, 1))
+
+    var x = 2;
+>x : Symbol(x, Decl(duplicateVariablesByScope.ts, 12, 7), Decl(duplicateVariablesByScope.ts, 13, 7))
+
+    var x = 1;
+>x : Symbol(x, Decl(duplicateVariablesByScope.ts, 12, 7), Decl(duplicateVariablesByScope.ts, 13, 7))
+
+    if (true) {
+        var result = 1;
+>result : Symbol(result, Decl(duplicateVariablesByScope.ts, 15, 11), Decl(duplicateVariablesByScope.ts, 18, 11))
+    }
+    else {
+        var result = 2;
+>result : Symbol(result, Decl(duplicateVariablesByScope.ts, 15, 11), Decl(duplicateVariablesByScope.ts, 18, 11))
+    }
+}
+
+class C {
+>C : Symbol(C, Decl(duplicateVariablesByScope.ts, 20, 1))
+
+    foo() {
+>foo : Symbol(foo, Decl(duplicateVariablesByScope.ts, 22, 9))
+
+        try {
+            var x = 1;
+>x : Symbol(x, Decl(duplicateVariablesByScope.ts, 25, 15), Decl(duplicateVariablesByScope.ts, 28, 15))
+        }
+        catch (e) {
+>e : Symbol(e, Decl(duplicateVariablesByScope.ts, 27, 15))
+
+            var x = 2;
+>x : Symbol(x, Decl(duplicateVariablesByScope.ts, 25, 15), Decl(duplicateVariablesByScope.ts, 28, 15))
+        }
+    }
+}
diff --git a/tests/baselines/reference/duplicateVariablesByScope.types b/tests/baselines/reference/duplicateVariablesByScope.types
new file mode 100644
index 00000000000..30e68d921ca
--- /dev/null
+++ b/tests/baselines/reference/duplicateVariablesByScope.types
@@ -0,0 +1,73 @@
+=== tests/cases/compiler/duplicateVariablesByScope.ts ===
+
+// duplicate local variables are only reported at global scope
+
+module M {
+>M : typeof M
+
+    for (var j = 0; j < 10; j++) {
+>j : number
+>0 : number
+>j < 10 : boolean
+>j : number
+>10 : number
+>j++ : number
+>j : number
+    }
+
+    for (var j = 0; j < 10; j++) {
+>j : number
+>0 : number
+>j < 10 : boolean
+>j : number
+>10 : number
+>j++ : number
+>j : number
+    }
+}
+
+function foo() {
+>foo : () => void
+
+    var x = 2;
+>x : number
+>2 : number
+
+    var x = 1;
+>x : number
+>1 : number
+
+    if (true) {
+>true : boolean
+
+        var result = 1;
+>result : number
+>1 : number
+    }
+    else {
+        var result = 2;
+>result : number
+>2 : number
+    }
+}
+
+class C {
+>C : C
+
+    foo() {
+>foo : () => void
+
+        try {
+            var x = 1;
+>x : number
+>1 : number
+        }
+        catch (e) {
+>e : any
+
+            var x = 2;
+>x : number
+>2 : number
+        }
+    }
+}
diff --git a/tests/baselines/reference/es6ClassSuperCodegenBug.errors.txt b/tests/baselines/reference/es6ClassSuperCodegenBug.errors.txt
deleted file mode 100644
index f30719a2792..00000000000
--- a/tests/baselines/reference/es6ClassSuperCodegenBug.errors.txt
+++ /dev/null
@@ -1,19 +0,0 @@
-tests/cases/compiler/es6ClassSuperCodegenBug.ts(9,10): error TS7027: Unreachable code detected.
-
-
-==== tests/cases/compiler/es6ClassSuperCodegenBug.ts (1 errors) ====
-    class A {
-    	constructor(str1:string, str2:string) {}
-    }
-    class B extends A {
-        constructor() {
-    	    if (true) {
-    	        super('a1', 'b1');
-    	    } else {
-    	        super('a2', 'b2');
-    	        ~~~~~
-!!! error TS7027: Unreachable code detected.
-    	    }
-        }
-    }
-    
\ No newline at end of file
diff --git a/tests/baselines/reference/es6ClassSuperCodegenBug.js b/tests/baselines/reference/es6ClassSuperCodegenBug.js
index 62c96f6260d..9f15af96be8 100644
--- a/tests/baselines/reference/es6ClassSuperCodegenBug.js
+++ b/tests/baselines/reference/es6ClassSuperCodegenBug.js
@@ -1,4 +1,5 @@
 //// [es6ClassSuperCodegenBug.ts]
+
 class A {
 	constructor(str1:string, str2:string) {}
 }
diff --git a/tests/baselines/reference/es6ClassSuperCodegenBug.symbols b/tests/baselines/reference/es6ClassSuperCodegenBug.symbols
new file mode 100644
index 00000000000..bb500a1d2c2
--- /dev/null
+++ b/tests/baselines/reference/es6ClassSuperCodegenBug.symbols
@@ -0,0 +1,25 @@
+=== tests/cases/compiler/es6ClassSuperCodegenBug.ts ===
+
+class A {
+>A : Symbol(A, Decl(es6ClassSuperCodegenBug.ts, 0, 0))
+
+	constructor(str1:string, str2:string) {}
+>str1 : Symbol(str1, Decl(es6ClassSuperCodegenBug.ts, 2, 13))
+>str2 : Symbol(str2, Decl(es6ClassSuperCodegenBug.ts, 2, 25))
+}
+class B extends A {
+>B : Symbol(B, Decl(es6ClassSuperCodegenBug.ts, 3, 1))
+>A : Symbol(A, Decl(es6ClassSuperCodegenBug.ts, 0, 0))
+
+    constructor() {
+	    if (true) {
+	        super('a1', 'b1');
+>super : Symbol(A, Decl(es6ClassSuperCodegenBug.ts, 0, 0))
+
+	    } else {
+	        super('a2', 'b2');
+>super : Symbol(A, Decl(es6ClassSuperCodegenBug.ts, 0, 0))
+	    }
+    }
+}
+
diff --git a/tests/baselines/reference/es6ClassSuperCodegenBug.types b/tests/baselines/reference/es6ClassSuperCodegenBug.types
new file mode 100644
index 00000000000..65269c99997
--- /dev/null
+++ b/tests/baselines/reference/es6ClassSuperCodegenBug.types
@@ -0,0 +1,33 @@
+=== tests/cases/compiler/es6ClassSuperCodegenBug.ts ===
+
+class A {
+>A : A
+
+	constructor(str1:string, str2:string) {}
+>str1 : string
+>str2 : string
+}
+class B extends A {
+>B : B
+>A : A
+
+    constructor() {
+	    if (true) {
+>true : boolean
+
+	        super('a1', 'b1');
+>super('a1', 'b1') : void
+>super : typeof A
+>'a1' : string
+>'b1' : string
+
+	    } else {
+	        super('a2', 'b2');
+>super('a2', 'b2') : void
+>super : typeof A
+>'a2' : string
+>'b2' : string
+	    }
+    }
+}
+
diff --git a/tests/baselines/reference/escapedIdentifiers.errors.txt b/tests/baselines/reference/escapedIdentifiers.errors.txt
deleted file mode 100644
index 8f7d735ceed..00000000000
--- a/tests/baselines/reference/escapedIdentifiers.errors.txt
+++ /dev/null
@@ -1,146 +0,0 @@
-tests/cases/compiler/escapedIdentifiers.ts(93,1): error TS7028: Unused label.
-tests/cases/compiler/escapedIdentifiers.ts(96,8): error TS7027: Unreachable code detected.
-tests/cases/compiler/escapedIdentifiers.ts(100,1): error TS7028: Unused label.
-tests/cases/compiler/escapedIdentifiers.ts(103,8): error TS7027: Unreachable code detected.
-tests/cases/compiler/escapedIdentifiers.ts(107,1): error TS7028: Unused label.
-tests/cases/compiler/escapedIdentifiers.ts(110,8): error TS7027: Unreachable code detected.
-tests/cases/compiler/escapedIdentifiers.ts(114,1): error TS7028: Unused label.
-tests/cases/compiler/escapedIdentifiers.ts(117,8): error TS7027: Unreachable code detected.
-
-
-==== tests/cases/compiler/escapedIdentifiers.ts (8 errors) ====
-    /*
-        0 .. \u0030
-        9 .. \u0039
-    
-        A .. \u0041
-        Z .. \u005a
-    
-        a .. \u0061
-        z .. \u00za
-    */
-    
-    // var decl
-    var \u0061 = 1;
-    a ++;
-    \u0061 ++;
-    
-    var b = 1;
-    b ++;
-    \u0062 ++;
-    
-    // modules
-    module moduleType1 { 
-        export var baz1: number;
-    }
-    module moduleType\u0032 { 
-        export var baz2: number;
-    }
-    
-    moduleType1.baz1 = 3;
-    moduleType\u0031.baz1 = 3;
-    moduleType2.baz2 = 3;
-    moduleType\u0032.baz2 = 3;
-    
-    // classes
-    
-    class classType1 { 
-        public foo1: number;
-    }
-    class classType\u0032 { 
-        public foo2: number;
-    }
-    
-    var classType1Object1 = new classType1();
-    classType1Object1.foo1 = 2;
-    var classType1Object2 = new classType\u0031();
-    classType1Object2.foo1 = 2;
-    var classType2Object1 = new classType2();
-    classType2Object1.foo2 = 2;
-    var classType2Object2 = new classType\u0032();
-    classType2Object2.foo2 = 2;
-    
-    // interfaces
-    interface interfaceType1 { 
-        bar1: number;
-    }
-    interface interfaceType\u0032 { 
-        bar2: number;
-    }
-    
-    var interfaceType1Object1 = <interfaceType1>{ bar1: 0 };
-    interfaceType1Object1.bar1 = 2;
-    var interfaceType1Object2 = <interfaceType\u0031>{ bar1: 0 };
-    interfaceType1Object2.bar1 = 2;
-    var interfaceType2Object1 = <interfaceType2>{ bar2: 0 };
-    interfaceType2Object1.bar2 = 2;
-    var interfaceType2Object2 = <interfaceType\u0032>{ bar2: 0 };
-    interfaceType2Object2.bar2 = 2;
-    
-    
-    // arguments
-    class testClass { 
-        public func(arg1: number, arg\u0032: string, arg\u0033: boolean, arg4: number) { 
-            arg\u0031 = 1;
-            arg2 = 'string';
-            arg\u0033 = true;
-            arg4 = 2;
-        }
-    }
-    
-    // constructors
-    class constructorTestClass { 
-        constructor (public arg1: number,public arg\u0032: string,public arg\u0033: boolean,public arg4: number) { 
-        }
-    }
-    var constructorTestObject = new constructorTestClass(1, 'string', true, 2);
-    constructorTestObject.arg\u0031 = 1;
-    constructorTestObject.arg2 = 'string';
-    constructorTestObject.arg\u0033 = true;
-    constructorTestObject.arg4 = 2;
-    
-    // Lables
-    
-    l\u0061bel1: 
-    ~~~~~~~~~~~
-!!! error TS7028: Unused label.
-        while (false)
-        {  
-           while(false)
-           ~~~~~
-!!! error TS7027: Unreachable code detected.
-               continue label1;  // it will go to next iteration of outer loop 
-        } 
-    
-    label2: 
-    ~~~~~~
-!!! error TS7028: Unused label.
-        while (false)
-        {  
-           while(false)
-           ~~~~~
-!!! error TS7027: Unreachable code detected.
-               continue l\u0061bel2;  // it will go to next iteration of outer loop 
-        } 
-    
-    label3: 
-    ~~~~~~
-!!! error TS7028: Unused label.
-        while (false)
-        {  
-           while(false)
-           ~~~~~
-!!! error TS7027: Unreachable code detected.
-               continue label3;  // it will go to next iteration of outer loop 
-        } 
-    
-    l\u0061bel4: 
-    ~~~~~~~~~~~
-!!! error TS7028: Unused label.
-        while (false)
-        {  
-           while(false)
-           ~~~~~
-!!! error TS7027: Unreachable code detected.
-               continue l\u0061bel4;  // it will go to next iteration of outer loop 
-        } 
\ No newline at end of file
diff --git a/tests/baselines/reference/escapedIdentifiers.js b/tests/baselines/reference/escapedIdentifiers.js
index 5ab7dcc5a5a..64eaaa5784f 100644
--- a/tests/baselines/reference/escapedIdentifiers.js
+++ b/tests/baselines/reference/escapedIdentifiers.js
@@ -1,4 +1,5 @@
 //// [escapedIdentifiers.ts]
+
 /*
     0 .. \u0030
     9 .. \u0039
diff --git a/tests/baselines/reference/escapedIdentifiers.symbols b/tests/baselines/reference/escapedIdentifiers.symbols
new file mode 100644
index 00000000000..a99e067b898
--- /dev/null
+++ b/tests/baselines/reference/escapedIdentifiers.symbols
@@ -0,0 +1,261 @@
+=== tests/cases/compiler/escapedIdentifiers.ts ===
+
+/*
+    0 .. \u0030
+    9 .. \u0039
+
+    A .. \u0041
+    Z .. \u005a
+
+    a .. \u0061
+    z .. \u00za
+*/
+
+// var decl
+var \u0061 = 1;
+>\u0061 : Symbol(\u0061, Decl(escapedIdentifiers.ts, 13, 3))
+
+a ++;
+>a : Symbol(\u0061, Decl(escapedIdentifiers.ts, 13, 3))
+
+\u0061 ++;
+>\u0061 : Symbol(\u0061, Decl(escapedIdentifiers.ts, 13, 3))
+
+var b = 1;
+>b : Symbol(b, Decl(escapedIdentifiers.ts, 17, 3))
+
+b ++;
+>b : Symbol(b, Decl(escapedIdentifiers.ts, 17, 3))
+
+\u0062 ++;
+>\u0062 : Symbol(b, Decl(escapedIdentifiers.ts, 17, 3))
+
+// modules
+module moduleType1 { 
+>moduleType1 : Symbol(moduleType1, Decl(escapedIdentifiers.ts, 19, 10))
+
+    export var baz1: number;
+>baz1 : Symbol(baz1, Decl(escapedIdentifiers.ts, 23, 14))
+}
+module moduleType\u0032 { 
+>moduleType\u0032 : Symbol(moduleType\u0032, Decl(escapedIdentifiers.ts, 24, 1))
+
+    export var baz2: number;
+>baz2 : Symbol(baz2, Decl(escapedIdentifiers.ts, 26, 14))
+}
+
+moduleType1.baz1 = 3;
+>moduleType1.baz1 : Symbol(moduleType1.baz1, Decl(escapedIdentifiers.ts, 23, 14))
+>moduleType1 : Symbol(moduleType1, Decl(escapedIdentifiers.ts, 19, 10))
+>baz1 : Symbol(moduleType1.baz1, Decl(escapedIdentifiers.ts, 23, 14))
+
+moduleType\u0031.baz1 = 3;
+>moduleType\u0031.baz1 : Symbol(moduleType1.baz1, Decl(escapedIdentifiers.ts, 23, 14))
+>moduleType\u0031 : Symbol(moduleType1, Decl(escapedIdentifiers.ts, 19, 10))
+>baz1 : Symbol(moduleType1.baz1, Decl(escapedIdentifiers.ts, 23, 14))
+
+moduleType2.baz2 = 3;
+>moduleType2.baz2 : Symbol(moduleType\u0032.baz2, Decl(escapedIdentifiers.ts, 26, 14))
+>moduleType2 : Symbol(moduleType\u0032, Decl(escapedIdentifiers.ts, 24, 1))
+>baz2 : Symbol(moduleType\u0032.baz2, Decl(escapedIdentifiers.ts, 26, 14))
+
+moduleType\u0032.baz2 = 3;
+>moduleType\u0032.baz2 : Symbol(moduleType\u0032.baz2, Decl(escapedIdentifiers.ts, 26, 14))
+>moduleType\u0032 : Symbol(moduleType\u0032, Decl(escapedIdentifiers.ts, 24, 1))
+>baz2 : Symbol(moduleType\u0032.baz2, Decl(escapedIdentifiers.ts, 26, 14))
+
+// classes
+
+class classType1 { 
+>classType1 : Symbol(classType1, Decl(escapedIdentifiers.ts, 32, 26))
+
+    public foo1: number;
+>foo1 : Symbol(foo1, Decl(escapedIdentifiers.ts, 36, 18))
+}
+class classType\u0032 { 
+>classType\u0032 : Symbol(classType\u0032, Decl(escapedIdentifiers.ts, 38, 1))
+
+    public foo2: number;
+>foo2 : Symbol(foo2, Decl(escapedIdentifiers.ts, 39, 23))
+}
+
+var classType1Object1 = new classType1();
+>classType1Object1 : Symbol(classType1Object1, Decl(escapedIdentifiers.ts, 43, 3))
+>classType1 : Symbol(classType1, Decl(escapedIdentifiers.ts, 32, 26))
+
+classType1Object1.foo1 = 2;
+>classType1Object1.foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 36, 18))
+>classType1Object1 : Symbol(classType1Object1, Decl(escapedIdentifiers.ts, 43, 3))
+>foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 36, 18))
+
+var classType1Object2 = new classType\u0031();
+>classType1Object2 : Symbol(classType1Object2, Decl(escapedIdentifiers.ts, 45, 3))
+>classType\u0031 : Symbol(classType1, Decl(escapedIdentifiers.ts, 32, 26))
+
+classType1Object2.foo1 = 2;
+>classType1Object2.foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 36, 18))
+>classType1Object2 : Symbol(classType1Object2, Decl(escapedIdentifiers.ts, 45, 3))
+>foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 36, 18))
+
+var classType2Object1 = new classType2();
+>classType2Object1 : Symbol(classType2Object1, Decl(escapedIdentifiers.ts, 47, 3))
+>classType2 : Symbol(classType\u0032, Decl(escapedIdentifiers.ts, 38, 1))
+
+classType2Object1.foo2 = 2;
+>classType2Object1.foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 39, 23))
+>classType2Object1 : Symbol(classType2Object1, Decl(escapedIdentifiers.ts, 47, 3))
+>foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 39, 23))
+
+var classType2Object2 = new classType\u0032();
+>classType2Object2 : Symbol(classType2Object2, Decl(escapedIdentifiers.ts, 49, 3))
+>classType\u0032 : Symbol(classType\u0032, Decl(escapedIdentifiers.ts, 38, 1))
+
+classType2Object2.foo2 = 2;
+>classType2Object2.foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 39, 23))
+>classType2Object2 : Symbol(classType2Object2, Decl(escapedIdentifiers.ts, 49, 3))
+>foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 39, 23))
+
+// interfaces
+interface interfaceType1 { 
+>interfaceType1 : Symbol(interfaceType1, Decl(escapedIdentifiers.ts, 50, 27))
+
+    bar1: number;
+>bar1 : Symbol(bar1, Decl(escapedIdentifiers.ts, 53, 26))
+}
+interface interfaceType\u0032 { 
+>interfaceType\u0032 : Symbol(interfaceType\u0032, Decl(escapedIdentifiers.ts, 55, 1))
+
+    bar2: number;
+>bar2 : Symbol(bar2, Decl(escapedIdentifiers.ts, 56, 31))
+}
+
+var interfaceType1Object1 = <interfaceType1>{ bar1: 0 };
+>interfaceType1Object1 : Symbol(interfaceType1Object1, Decl(escapedIdentifiers.ts, 60, 3))
+>interfaceType1 : Symbol(interfaceType1, Decl(escapedIdentifiers.ts, 50, 27))
+>bar1 : Symbol(bar1, Decl(escapedIdentifiers.ts, 60, 45))
+
+interfaceType1Object1.bar1 = 2;
+>interfaceType1Object1.bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 53, 26))
+>interfaceType1Object1 : Symbol(interfaceType1Object1, Decl(escapedIdentifiers.ts, 60, 3))
+>bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 53, 26))
+
+var interfaceType1Object2 = <interfaceType\u0031>{ bar1: 0 };
+>interfaceType1Object2 : Symbol(interfaceType1Object2, Decl(escapedIdentifiers.ts, 62, 3))
+>interfaceType\u0031 : Symbol(interfaceType1, Decl(escapedIdentifiers.ts, 50, 27))
+>bar1 : Symbol(bar1, Decl(escapedIdentifiers.ts, 62, 50))
+
+interfaceType1Object2.bar1 = 2;
+>interfaceType1Object2.bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 53, 26))
+>interfaceType1Object2 : Symbol(interfaceType1Object2, Decl(escapedIdentifiers.ts, 62, 3))
+>bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 53, 26))
+
+var interfaceType2Object1 = <interfaceType2>{ bar2: 0 };
+>interfaceType2Object1 : Symbol(interfaceType2Object1, Decl(escapedIdentifiers.ts, 64, 3))
+>interfaceType2 : Symbol(interfaceType\u0032, Decl(escapedIdentifiers.ts, 55, 1))
+>bar2 : Symbol(bar2, Decl(escapedIdentifiers.ts, 64, 45))
+
+interfaceType2Object1.bar2 = 2;
+>interfaceType2Object1.bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 56, 31))
+>interfaceType2Object1 : Symbol(interfaceType2Object1, Decl(escapedIdentifiers.ts, 64, 3))
+>bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 56, 31))
+
+var interfaceType2Object2 = <interfaceType\u0032>{ bar2: 0 };
+>interfaceType2Object2 : Symbol(interfaceType2Object2, Decl(escapedIdentifiers.ts, 66, 3))
+>interfaceType\u0032 : Symbol(interfaceType\u0032, Decl(escapedIdentifiers.ts, 55, 1))
+>bar2 : Symbol(bar2, Decl(escapedIdentifiers.ts, 66, 50))
+
+interfaceType2Object2.bar2 = 2;
+>interfaceType2Object2.bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 56, 31))
+>interfaceType2Object2 : Symbol(interfaceType2Object2, Decl(escapedIdentifiers.ts, 66, 3))
+>bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 56, 31))
+
+
+// arguments
+class testClass { 
+>testClass : Symbol(testClass, Decl(escapedIdentifiers.ts, 67, 31))
+
+    public func(arg1: number, arg\u0032: string, arg\u0033: boolean, arg4: number) { 
+>func : Symbol(func, Decl(escapedIdentifiers.ts, 71, 17))
+>arg1 : Symbol(arg1, Decl(escapedIdentifiers.ts, 72, 16))
+>arg\u0032 : Symbol(arg\u0032, Decl(escapedIdentifiers.ts, 72, 29))
+>arg\u0033 : Symbol(arg\u0033, Decl(escapedIdentifiers.ts, 72, 48))
+>arg4 : Symbol(arg4, Decl(escapedIdentifiers.ts, 72, 68))
+
+        arg\u0031 = 1;
+>arg\u0031 : Symbol(arg1, Decl(escapedIdentifiers.ts, 72, 16))
+
+        arg2 = 'string';
+>arg2 : Symbol(arg\u0032, Decl(escapedIdentifiers.ts, 72, 29))
+
+        arg\u0033 = true;
+>arg\u0033 : Symbol(arg\u0033, Decl(escapedIdentifiers.ts, 72, 48))
+
+        arg4 = 2;
+>arg4 : Symbol(arg4, Decl(escapedIdentifiers.ts, 72, 68))
+    }
+}
+
+// constructors
+class constructorTestClass { 
+>constructorTestClass : Symbol(constructorTestClass, Decl(escapedIdentifiers.ts, 78, 1))
+
+    constructor (public arg1: number,public arg\u0032: string,public arg\u0033: boolean,public arg4: number) { 
+>arg1 : Symbol(arg1, Decl(escapedIdentifiers.ts, 82, 17))
+>arg\u0032 : Symbol(arg\u0032, Decl(escapedIdentifiers.ts, 82, 37))
+>arg\u0033 : Symbol(arg\u0033, Decl(escapedIdentifiers.ts, 82, 62))
+>arg4 : Symbol(arg4, Decl(escapedIdentifiers.ts, 82, 88))
+    }
+}
+var constructorTestObject = new constructorTestClass(1, 'string', true, 2);
+>constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 85, 3))
+>constructorTestClass : Symbol(constructorTestClass, Decl(escapedIdentifiers.ts, 78, 1))
+
+constructorTestObject.arg\u0031 = 1;
+>constructorTestObject.arg\u0031 : Symbol(constructorTestClass.arg1, Decl(escapedIdentifiers.ts, 82, 17))
+>constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 85, 3))
+>arg\u0031 : Symbol(constructorTestClass.arg1, Decl(escapedIdentifiers.ts, 82, 17))
+
+constructorTestObject.arg2 = 'string';
+>constructorTestObject.arg2 : Symbol(constructorTestClass.arg\u0032, Decl(escapedIdentifiers.ts, 82, 37))
+>constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 85, 3))
+>arg2 : Symbol(constructorTestClass.arg\u0032, Decl(escapedIdentifiers.ts, 82, 37))
+
+constructorTestObject.arg\u0033 = true;
+>constructorTestObject.arg\u0033 : Symbol(constructorTestClass.arg\u0033, Decl(escapedIdentifiers.ts, 82, 62))
+>constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 85, 3))
+>arg\u0033 : Symbol(constructorTestClass.arg\u0033, Decl(escapedIdentifiers.ts, 82, 62))
+
+constructorTestObject.arg4 = 2;
+>constructorTestObject.arg4 : Symbol(constructorTestClass.arg4, Decl(escapedIdentifiers.ts, 82, 88))
+>constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 85, 3))
+>arg4 : Symbol(constructorTestClass.arg4, Decl(escapedIdentifiers.ts, 82, 88))
+
+// Lables
+
+l\u0061bel1: 
+    while (false)
+    {  
+       while(false)
+           continue label1;  // it will go to next iteration of outer loop 
+    } 
+
+label2: 
+    while (false)
+    {  
+       while(false)
+           continue l\u0061bel2;  // it will go to next iteration of outer loop 
+    } 
+
+label3: 
+    while (false)
+    {  
+       while(false)
+           continue label3;  // it will go to next iteration of outer loop 
+    } 
+
+l\u0061bel4: 
+    while (false)
+    {  
+       while(false)
+           continue l\u0061bel4;  // it will go to next iteration of outer loop 
+    } 
diff --git a/tests/baselines/reference/escapedIdentifiers.types b/tests/baselines/reference/escapedIdentifiers.types
new file mode 100644
index 00000000000..67713976bd6
--- /dev/null
+++ b/tests/baselines/reference/escapedIdentifiers.types
@@ -0,0 +1,352 @@
+=== tests/cases/compiler/escapedIdentifiers.ts ===
+
+/*
+    0 .. \u0030
+    9 .. \u0039
+
+    A .. \u0041
+    Z .. \u005a
+
+    a .. \u0061
+    z .. \u00za
+*/
+
+// var decl
+var \u0061 = 1;
+>\u0061 : number
+>1 : number
+
+a ++;
+>a ++ : number
+>a : number
+
+\u0061 ++;
+>\u0061 ++ : number
+>\u0061 : number
+
+var b = 1;
+>b : number
+>1 : number
+
+b ++;
+>b ++ : number
+>b : number
+
+\u0062 ++;
+>\u0062 ++ : number
+>\u0062 : number
+
+// modules
+module moduleType1 { 
+>moduleType1 : typeof moduleType1
+
+    export var baz1: number;
+>baz1 : number
+}
+module moduleType\u0032 { 
+>moduleType\u0032 : typeof moduleType\u0032
+
+    export var baz2: number;
+>baz2 : number
+}
+
+moduleType1.baz1 = 3;
+>moduleType1.baz1 = 3 : number
+>moduleType1.baz1 : number
+>moduleType1 : typeof moduleType1
+>baz1 : number
+>3 : number
+
+moduleType\u0031.baz1 = 3;
+>moduleType\u0031.baz1 = 3 : number
+>moduleType\u0031.baz1 : number
+>moduleType\u0031 : typeof moduleType1
+>baz1 : number
+>3 : number
+
+moduleType2.baz2 = 3;
+>moduleType2.baz2 = 3 : number
+>moduleType2.baz2 : number
+>moduleType2 : typeof moduleType\u0032
+>baz2 : number
+>3 : number
+
+moduleType\u0032.baz2 = 3;
+>moduleType\u0032.baz2 = 3 : number
+>moduleType\u0032.baz2 : number
+>moduleType\u0032 : typeof moduleType\u0032
+>baz2 : number
+>3 : number
+
+// classes
+
+class classType1 { 
+>classType1 : classType1
+
+    public foo1: number;
+>foo1 : number
+}
+class classType\u0032 { 
+>classType\u0032 : classType\u0032
+
+    public foo2: number;
+>foo2 : number
+}
+
+var classType1Object1 = new classType1();
+>classType1Object1 : classType1
+>new classType1() : classType1
+>classType1 : typeof classType1
+
+classType1Object1.foo1 = 2;
+>classType1Object1.foo1 = 2 : number
+>classType1Object1.foo1 : number
+>classType1Object1 : classType1
+>foo1 : number
+>2 : number
+
+var classType1Object2 = new classType\u0031();
+>classType1Object2 : classType1
+>new classType\u0031() : classType1
+>classType\u0031 : typeof classType1
+
+classType1Object2.foo1 = 2;
+>classType1Object2.foo1 = 2 : number
+>classType1Object2.foo1 : number
+>classType1Object2 : classType1
+>foo1 : number
+>2 : number
+
+var classType2Object1 = new classType2();
+>classType2Object1 : classType\u0032
+>new classType2() : classType\u0032
+>classType2 : typeof classType\u0032
+
+classType2Object1.foo2 = 2;
+>classType2Object1.foo2 = 2 : number
+>classType2Object1.foo2 : number
+>classType2Object1 : classType\u0032
+>foo2 : number
+>2 : number
+
+var classType2Object2 = new classType\u0032();
+>classType2Object2 : classType\u0032
+>new classType\u0032() : classType\u0032
+>classType\u0032 : typeof classType\u0032
+
+classType2Object2.foo2 = 2;
+>classType2Object2.foo2 = 2 : number
+>classType2Object2.foo2 : number
+>classType2Object2 : classType\u0032
+>foo2 : number
+>2 : number
+
+// interfaces
+interface interfaceType1 { 
+>interfaceType1 : interfaceType1
+
+    bar1: number;
+>bar1 : number
+}
+interface interfaceType\u0032 { 
+>interfaceType\u0032 : interfaceType\u0032
+
+    bar2: number;
+>bar2 : number
+}
+
+var interfaceType1Object1 = <interfaceType1>{ bar1: 0 };
+>interfaceType1Object1 : interfaceType1
+><interfaceType1>{ bar1: 0 } : interfaceType1
+>interfaceType1 : interfaceType1
+>{ bar1: 0 } : { bar1: number; }
+>bar1 : number
+>0 : number
+
+interfaceType1Object1.bar1 = 2;
+>interfaceType1Object1.bar1 = 2 : number
+>interfaceType1Object1.bar1 : number
+>interfaceType1Object1 : interfaceType1
+>bar1 : number
+>2 : number
+
+var interfaceType1Object2 = <interfaceType\u0031>{ bar1: 0 };
+>interfaceType1Object2 : interfaceType1
+><interfaceType\u0031>{ bar1: 0 } : interfaceType1
+>interfaceType\u0031 : interfaceType1
+>{ bar1: 0 } : { bar1: number; }
+>bar1 : number
+>0 : number
+
+interfaceType1Object2.bar1 = 2;
+>interfaceType1Object2.bar1 = 2 : number
+>interfaceType1Object2.bar1 : number
+>interfaceType1Object2 : interfaceType1
+>bar1 : number
+>2 : number
+
+var interfaceType2Object1 = <interfaceType2>{ bar2: 0 };
+>interfaceType2Object1 : interfaceType\u0032
+><interfaceType2>{ bar2: 0 } : interfaceType\u0032
+>interfaceType2 : interfaceType\u0032
+>{ bar2: 0 } : { bar2: number; }
+>bar2 : number
+>0 : number
+
+interfaceType2Object1.bar2 = 2;
+>interfaceType2Object1.bar2 = 2 : number
+>interfaceType2Object1.bar2 : number
+>interfaceType2Object1 : interfaceType\u0032
+>bar2 : number
+>2 : number
+
+var interfaceType2Object2 = <interfaceType\u0032>{ bar2: 0 };
+>interfaceType2Object2 : interfaceType\u0032
+><interfaceType\u0032>{ bar2: 0 } : interfaceType\u0032
+>interfaceType\u0032 : interfaceType\u0032
+>{ bar2: 0 } : { bar2: number; }
+>bar2 : number
+>0 : number
+
+interfaceType2Object2.bar2 = 2;
+>interfaceType2Object2.bar2 = 2 : number
+>interfaceType2Object2.bar2 : number
+>interfaceType2Object2 : interfaceType\u0032
+>bar2 : number
+>2 : number
+
+
+// arguments
+class testClass { 
+>testClass : testClass
+
+    public func(arg1: number, arg\u0032: string, arg\u0033: boolean, arg4: number) { 
+>func : (arg1: number, arg\u0032: string, arg\u0033: boolean, arg4: number) => void
+>arg1 : number
+>arg\u0032 : string
+>arg\u0033 : boolean
+>arg4 : number
+
+        arg\u0031 = 1;
+>arg\u0031 = 1 : number
+>arg\u0031 : number
+>1 : number
+
+        arg2 = 'string';
+>arg2 = 'string' : string
+>arg2 : string
+>'string' : string
+
+        arg\u0033 = true;
+>arg\u0033 = true : boolean
+>arg\u0033 : boolean
+>true : boolean
+
+        arg4 = 2;
+>arg4 = 2 : number
+>arg4 : number
+>2 : number
+    }
+}
+
+// constructors
+class constructorTestClass { 
+>constructorTestClass : constructorTestClass
+
+    constructor (public arg1: number,public arg\u0032: string,public arg\u0033: boolean,public arg4: number) { 
+>arg1 : number
+>arg\u0032 : string
+>arg\u0033 : boolean
+>arg4 : number
+    }
+}
+var constructorTestObject = new constructorTestClass(1, 'string', true, 2);
+>constructorTestObject : constructorTestClass
+>new constructorTestClass(1, 'string', true, 2) : constructorTestClass
+>constructorTestClass : typeof constructorTestClass
+>1 : number
+>'string' : string
+>true : boolean
+>2 : number
+
+constructorTestObject.arg\u0031 = 1;
+>constructorTestObject.arg\u0031 = 1 : number
+>constructorTestObject.arg\u0031 : number
+>constructorTestObject : constructorTestClass
+>arg\u0031 : number
+>1 : number
+
+constructorTestObject.arg2 = 'string';
+>constructorTestObject.arg2 = 'string' : string
+>constructorTestObject.arg2 : string
+>constructorTestObject : constructorTestClass
+>arg2 : string
+>'string' : string
+
+constructorTestObject.arg\u0033 = true;
+>constructorTestObject.arg\u0033 = true : boolean
+>constructorTestObject.arg\u0033 : boolean
+>constructorTestObject : constructorTestClass
+>arg\u0033 : boolean
+>true : boolean
+
+constructorTestObject.arg4 = 2;
+>constructorTestObject.arg4 = 2 : number
+>constructorTestObject.arg4 : number
+>constructorTestObject : constructorTestClass
+>arg4 : number
+>2 : number
+
+// Lables
+
+l\u0061bel1: 
+>l\u0061bel1 : any
+
+    while (false)
+>false : boolean
+    {  
+       while(false)
+>false : boolean
+
+           continue label1;  // it will go to next iteration of outer loop 
+>label1 : any
+    } 
+
+label2: 
+>label2 : any
+
+    while (false)
+>false : boolean
+    {  
+       while(false)
+>false : boolean
+
+           continue l\u0061bel2;  // it will go to next iteration of outer loop 
+>l\u0061bel2 : any
+    } 
+
+label3: 
+>label3 : any
+
+    while (false)
+>false : boolean
+    {  
+       while(false)
+>false : boolean
+
+           continue label3;  // it will go to next iteration of outer loop 
+>label3 : any
+    } 
+
+l\u0061bel4: 
+>l\u0061bel4 : any
+
+    while (false)
+>false : boolean
+    {  
+       while(false)
+>false : boolean
+
+           continue l\u0061bel4;  // it will go to next iteration of outer loop 
+>l\u0061bel4 : any
+    } 
diff --git a/tests/baselines/reference/for.errors.txt b/tests/baselines/reference/for.errors.txt
index 34de6a4b114..d2caefbcdae 100644
--- a/tests/baselines/reference/for.errors.txt
+++ b/tests/baselines/reference/for.errors.txt
@@ -1,8 +1,8 @@
-tests/cases/compiler/for.ts(29,1): error TS7027: Unreachable code detected.
-tests/cases/compiler/for.ts(29,6): error TS1109: Expression expected.
+tests/cases/compiler/for.ts(30,6): error TS1109: Expression expected.
 
 
-==== tests/cases/compiler/for.ts (2 errors) ====
+==== tests/cases/compiler/for.ts (1 errors) ====
+    
     for (var i = 0; i < 10; i++) { // ok
         var x1 = i;
     }
@@ -32,8 +32,6 @@ tests/cases/compiler/for.ts(29,6): error TS1109: Expression expected.
     }
     
     for () { // error
-    ~~~
-!!! error TS7027: Unreachable code detected.
          ~
 !!! error TS1109: Expression expected.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/for.js b/tests/baselines/reference/for.js
index a77b68d8b6e..857d42bafdb 100644
--- a/tests/baselines/reference/for.js
+++ b/tests/baselines/reference/for.js
@@ -1,4 +1,5 @@
 //// [for.ts]
+
 for (var i = 0; i < 10; i++) { // ok
     var x1 = i;
 }
diff --git a/tests/baselines/reference/forBreakStatements.errors.txt b/tests/baselines/reference/forBreakStatements.errors.txt
deleted file mode 100644
index 2b42afc9be2..00000000000
--- a/tests/baselines/reference/forBreakStatements.errors.txt
+++ /dev/null
@@ -1,49 +0,0 @@
-tests/cases/conformance/statements/breakStatements/forBreakStatements.ts(10,1): error TS7028: Unused label.
-tests/cases/conformance/statements/breakStatements/forBreakStatements.ts(18,5): error TS7028: Unused label.
-tests/cases/conformance/statements/breakStatements/forBreakStatements.ts(29,1): error TS7027: Unreachable code detected.
-
-
-==== tests/cases/conformance/statements/breakStatements/forBreakStatements.ts (3 errors) ====
-    for (; ;) {
-        break;
-    }
-    
-    ONE:
-    for (; ;) {
-        break ONE;
-    }
-    
-    TWO:
-    ~~~
-!!! error TS7028: Unused label.
-    THREE:
-    for (; ;) {
-        break THREE;
-    }
-    
-    FOUR:
-    for (; ;) {
-        FIVE:
-        ~~~~
-!!! error TS7028: Unused label.
-        for (; ;) {
-            break FOUR;
-        }
-    }
-    
-    for (; ;) {
-        SIX:
-        for (; ;) break SIX;
-    }
-    
-    SEVEN:
-    ~~~~~
-!!! error TS7027: Unreachable code detected.
-    for (; ;) for (; ;) for (; ;) break SEVEN;
-    
-    EIGHT:
-    for (; ;) {
-        var fn = function () { }
-        break EIGHT;
-    }
-    
\ No newline at end of file
diff --git a/tests/baselines/reference/forBreakStatements.js b/tests/baselines/reference/forBreakStatements.js
index 9ed65627c9c..da4fccdfd2a 100644
--- a/tests/baselines/reference/forBreakStatements.js
+++ b/tests/baselines/reference/forBreakStatements.js
@@ -1,4 +1,5 @@
 //// [forBreakStatements.ts]
+
 for (; ;) {
     break;
 }
diff --git a/tests/baselines/reference/forBreakStatements.symbols b/tests/baselines/reference/forBreakStatements.symbols
new file mode 100644
index 00000000000..6d869b45934
--- /dev/null
+++ b/tests/baselines/reference/forBreakStatements.symbols
@@ -0,0 +1,41 @@
+=== tests/cases/conformance/statements/breakStatements/forBreakStatements.ts ===
+
+for (; ;) {
+    break;
+}
+
+ONE:
+for (; ;) {
+    break ONE;
+}
+
+TWO:
+THREE:
+for (; ;) {
+    break THREE;
+}
+
+FOUR:
+for (; ;) {
+    FIVE:
+    for (; ;) {
+        break FOUR;
+    }
+}
+
+for (; ;) {
+    SIX:
+    for (; ;) break SIX;
+}
+
+SEVEN:
+for (; ;) for (; ;) for (; ;) break SEVEN;
+
+EIGHT:
+for (; ;) {
+    var fn = function () { }
+>fn : Symbol(fn, Decl(forBreakStatements.ts, 34, 7))
+
+    break EIGHT;
+}
+
diff --git a/tests/baselines/reference/forBreakStatements.types b/tests/baselines/reference/forBreakStatements.types
new file mode 100644
index 00000000000..c494f6be30a
--- /dev/null
+++ b/tests/baselines/reference/forBreakStatements.types
@@ -0,0 +1,64 @@
+=== tests/cases/conformance/statements/breakStatements/forBreakStatements.ts ===
+
+for (; ;) {
+    break;
+}
+
+ONE:
+>ONE : any
+
+for (; ;) {
+    break ONE;
+>ONE : any
+}
+
+TWO:
+>TWO : any
+
+THREE:
+>THREE : any
+
+for (; ;) {
+    break THREE;
+>THREE : any
+}
+
+FOUR:
+>FOUR : any
+
+for (; ;) {
+    FIVE:
+>FIVE : any
+
+    for (; ;) {
+        break FOUR;
+>FOUR : any
+    }
+}
+
+for (; ;) {
+    SIX:
+>SIX : any
+
+    for (; ;) break SIX;
+>SIX : any
+}
+
+SEVEN:
+>SEVEN : any
+
+for (; ;) for (; ;) for (; ;) break SEVEN;
+>SEVEN : any
+
+EIGHT:
+>EIGHT : any
+
+for (; ;) {
+    var fn = function () { }
+>fn : () => void
+>function () { } : () => void
+
+    break EIGHT;
+>EIGHT : any
+}
+
diff --git a/tests/baselines/reference/forContinueStatements.errors.txt b/tests/baselines/reference/forContinueStatements.errors.txt
deleted file mode 100644
index b7a4cc35546..00000000000
--- a/tests/baselines/reference/forContinueStatements.errors.txt
+++ /dev/null
@@ -1,43 +0,0 @@
-tests/cases/conformance/statements/continueStatements/forContinueStatements.ts(5,1): error TS7027: Unreachable code detected.
-
-
-==== tests/cases/conformance/statements/continueStatements/forContinueStatements.ts (1 errors) ====
-    for (; ;) {
-        continue;
-    }
-    
-    ONE:
-    ~~~
-!!! error TS7027: Unreachable code detected.
-    for (; ;) {
-        continue ONE;
-    }
-    
-    TWO:
-    THREE:
-    for (; ;) {
-        continue THREE;
-    }
-    
-    FOUR:
-    for (; ;) {
-        FIVE:
-        for (; ;) {
-            continue FOUR;
-        }
-    }
-    
-    for (; ;) {
-        SIX:
-        for (; ;) continue SIX;
-    }
-    
-    SEVEN:
-    for (; ;) for (; ;) for (; ;) continue SEVEN;
-    
-    EIGHT:
-    for (; ;) {
-        var fn = function () { }
-        continue EIGHT;
-    }
-    
\ No newline at end of file
diff --git a/tests/baselines/reference/forContinueStatements.js b/tests/baselines/reference/forContinueStatements.js
index 34f70bb1fc1..fc5aa0434b3 100644
--- a/tests/baselines/reference/forContinueStatements.js
+++ b/tests/baselines/reference/forContinueStatements.js
@@ -1,4 +1,5 @@
 //// [forContinueStatements.ts]
+
 for (; ;) {
     continue;
 }
diff --git a/tests/baselines/reference/forContinueStatements.symbols b/tests/baselines/reference/forContinueStatements.symbols
new file mode 100644
index 00000000000..9e0c396acfb
--- /dev/null
+++ b/tests/baselines/reference/forContinueStatements.symbols
@@ -0,0 +1,41 @@
+=== tests/cases/conformance/statements/continueStatements/forContinueStatements.ts ===
+
+for (; ;) {
+    continue;
+}
+
+ONE:
+for (; ;) {
+    continue ONE;
+}
+
+TWO:
+THREE:
+for (; ;) {
+    continue THREE;
+}
+
+FOUR:
+for (; ;) {
+    FIVE:
+    for (; ;) {
+        continue FOUR;
+    }
+}
+
+for (; ;) {
+    SIX:
+    for (; ;) continue SIX;
+}
+
+SEVEN:
+for (; ;) for (; ;) for (; ;) continue SEVEN;
+
+EIGHT:
+for (; ;) {
+    var fn = function () { }
+>fn : Symbol(fn, Decl(forContinueStatements.ts, 34, 7))
+
+    continue EIGHT;
+}
+
diff --git a/tests/baselines/reference/forContinueStatements.types b/tests/baselines/reference/forContinueStatements.types
new file mode 100644
index 00000000000..0b52bdd5d47
--- /dev/null
+++ b/tests/baselines/reference/forContinueStatements.types
@@ -0,0 +1,64 @@
+=== tests/cases/conformance/statements/continueStatements/forContinueStatements.ts ===
+
+for (; ;) {
+    continue;
+}
+
+ONE:
+>ONE : any
+
+for (; ;) {
+    continue ONE;
+>ONE : any
+}
+
+TWO:
+>TWO : any
+
+THREE:
+>THREE : any
+
+for (; ;) {
+    continue THREE;
+>THREE : any
+}
+
+FOUR:
+>FOUR : any
+
+for (; ;) {
+    FIVE:
+>FIVE : any
+
+    for (; ;) {
+        continue FOUR;
+>FOUR : any
+    }
+}
+
+for (; ;) {
+    SIX:
+>SIX : any
+
+    for (; ;) continue SIX;
+>SIX : any
+}
+
+SEVEN:
+>SEVEN : any
+
+for (; ;) for (; ;) for (; ;) continue SEVEN;
+>SEVEN : any
+
+EIGHT:
+>EIGHT : any
+
+for (; ;) {
+    var fn = function () { }
+>fn : () => void
+>function () { } : () => void
+
+    continue EIGHT;
+>EIGHT : any
+}
+
diff --git a/tests/baselines/reference/forInBreakStatements.errors.txt b/tests/baselines/reference/forInBreakStatements.errors.txt
deleted file mode 100644
index 8bbbf2d38ee..00000000000
--- a/tests/baselines/reference/forInBreakStatements.errors.txt
+++ /dev/null
@@ -1,46 +0,0 @@
-tests/cases/conformance/statements/breakStatements/forInBreakStatements.ts(10,1): error TS7028: Unused label.
-tests/cases/conformance/statements/breakStatements/forInBreakStatements.ts(18,5): error TS7028: Unused label.
-
-
-==== tests/cases/conformance/statements/breakStatements/forInBreakStatements.ts (2 errors) ====
-    for(var x in {}) {
-        break;
-    }
-    
-    ONE:
-    for(var x in {}) {
-        break ONE;
-    }
-    
-    TWO:
-    ~~~
-!!! error TS7028: Unused label.
-    THREE:
-    for(var x in {}) {
-        break THREE;
-    }
-    
-    FOUR:
-    for(var x in {}) {
-        FIVE:
-        ~~~~
-!!! error TS7028: Unused label.
-        for(var x in {}) {
-            break FOUR;
-        }
-    }
-    
-    for(var x in {}) {
-        SIX:
-        for(var x in {}) break SIX;
-    }
-    
-    SEVEN:
-    for (var x in {}) for (var x in {}) for (var x in {}) break SEVEN;
-    
-    EIGHT:
-    for (var x in {}){
-        var fn = function () { }
-        break EIGHT;
-    }
-    
\ No newline at end of file
diff --git a/tests/baselines/reference/forInBreakStatements.js b/tests/baselines/reference/forInBreakStatements.js
index 24b7cc57b8d..ebbadb31277 100644
--- a/tests/baselines/reference/forInBreakStatements.js
+++ b/tests/baselines/reference/forInBreakStatements.js
@@ -1,4 +1,5 @@
 //// [forInBreakStatements.ts]
+
 for(var x in {}) {
     break;
 }
diff --git a/tests/baselines/reference/forInBreakStatements.symbols b/tests/baselines/reference/forInBreakStatements.symbols
new file mode 100644
index 00000000000..5f48e110835
--- /dev/null
+++ b/tests/baselines/reference/forInBreakStatements.symbols
@@ -0,0 +1,59 @@
+=== tests/cases/conformance/statements/breakStatements/forInBreakStatements.ts ===
+
+for(var x in {}) {
+>x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8))
+
+    break;
+}
+
+ONE:
+for(var x in {}) {
+>x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8))
+
+    break ONE;
+}
+
+TWO:
+THREE:
+for(var x in {}) {
+>x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8))
+
+    break THREE;
+}
+
+FOUR:
+for(var x in {}) {
+>x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8))
+
+    FIVE:
+    for(var x in {}) {
+>x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8))
+
+        break FOUR;
+    }
+}
+
+for(var x in {}) {
+>x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8))
+
+    SIX:
+    for(var x in {}) break SIX;
+>x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8))
+}
+
+SEVEN:
+for (var x in {}) for (var x in {}) for (var x in {}) break SEVEN;
+>x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8))
+>x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8))
+>x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8))
+
+EIGHT:
+for (var x in {}){
+>x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8))
+
+    var fn = function () { }
+>fn : Symbol(fn, Decl(forInBreakStatements.ts, 34, 7))
+
+    break EIGHT;
+}
+
diff --git a/tests/baselines/reference/forInBreakStatements.types b/tests/baselines/reference/forInBreakStatements.types
new file mode 100644
index 00000000000..7714429e5af
--- /dev/null
+++ b/tests/baselines/reference/forInBreakStatements.types
@@ -0,0 +1,93 @@
+=== tests/cases/conformance/statements/breakStatements/forInBreakStatements.ts ===
+
+for(var x in {}) {
+>x : any
+>{} : {}
+
+    break;
+}
+
+ONE:
+>ONE : any
+
+for(var x in {}) {
+>x : any
+>{} : {}
+
+    break ONE;
+>ONE : any
+}
+
+TWO:
+>TWO : any
+
+THREE:
+>THREE : any
+
+for(var x in {}) {
+>x : any
+>{} : {}
+
+    break THREE;
+>THREE : any
+}
+
+FOUR:
+>FOUR : any
+
+for(var x in {}) {
+>x : any
+>{} : {}
+
+    FIVE:
+>FIVE : any
+
+    for(var x in {}) {
+>x : any
+>{} : {}
+
+        break FOUR;
+>FOUR : any
+    }
+}
+
+for(var x in {}) {
+>x : any
+>{} : {}
+
+    SIX:
+>SIX : any
+
+    for(var x in {}) break SIX;
+>x : any
+>{} : {}
+>SIX : any
+}
+
+SEVEN:
+>SEVEN : any
+
+for (var x in {}) for (var x in {}) for (var x in {}) break SEVEN;
+>x : any
+>{} : {}
+>x : any
+>{} : {}
+>x : any
+>{} : {}
+>SEVEN : any
+
+EIGHT:
+>EIGHT : any
+
+for (var x in {}){
+>x : any
+>{} : {}
+
+    var fn = function () { }
+>fn : () => void
+>function () { } : () => void
+
+    break EIGHT;
+>EIGHT : any
+}
+
diff --git a/tests/baselines/reference/forInContinueStatements.errors.txt b/tests/baselines/reference/forInContinueStatements.errors.txt
deleted file mode 100644
index 7a3a74e5aee..00000000000
--- a/tests/baselines/reference/forInContinueStatements.errors.txt
+++ /dev/null
@@ -1,46 +0,0 @@
-tests/cases/conformance/statements/continueStatements/forInContinueStatements.ts(10,1): error TS7028: Unused label.
-tests/cases/conformance/statements/continueStatements/forInContinueStatements.ts(18,5): error TS7028: Unused label.
-
-
-==== tests/cases/conformance/statements/continueStatements/forInContinueStatements.ts (2 errors) ====
-    for(var x in {}) {
-        continue;
-    }
-    
-    ONE:
-    for(var x in {}) {
-        continue ONE;
-    }
-    
-    TWO:
-    ~~~
-!!! error TS7028: Unused label.
-    THREE:
-    for(var x in {}) {
-        continue THREE;
-    }
-    
-    FOUR:
-    for(var x in {}) {
-        FIVE:
-        ~~~~
-!!! error TS7028: Unused label.
-        for(var x in {}) {
-            continue FOUR;
-        }
-    }
-    
-    for(var x in {}) {
-        SIX:
-        for(var x in {}) continue SIX;
-    }
-    
-    SEVEN:
-    for (var x in {}) for (var x in {}) for (var x in {}) continue SEVEN;
-    
-    EIGHT:
-    for (var x in {}){
-        var fn = function () { }
-        continue EIGHT;
-    }
-    
\ No newline at end of file
diff --git a/tests/baselines/reference/forInContinueStatements.js b/tests/baselines/reference/forInContinueStatements.js
index 8b036c59721..ca530dd5d6c 100644
--- a/tests/baselines/reference/forInContinueStatements.js
+++ b/tests/baselines/reference/forInContinueStatements.js
@@ -1,4 +1,5 @@
 //// [forInContinueStatements.ts]
+
 for(var x in {}) {
     continue;
 }
diff --git a/tests/baselines/reference/forInContinueStatements.symbols b/tests/baselines/reference/forInContinueStatements.symbols
new file mode 100644
index 00000000000..a0edea53f3e
--- /dev/null
+++ b/tests/baselines/reference/forInContinueStatements.symbols
@@ -0,0 +1,59 @@
+=== tests/cases/conformance/statements/continueStatements/forInContinueStatements.ts ===
+
+for(var x in {}) {
+>x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8))
+
+    continue;
+}
+
+ONE:
+for(var x in {}) {
+>x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8))
+
+    continue ONE;
+}
+
+TWO:
+THREE:
+for(var x in {}) {
+>x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8))
+
+    continue THREE;
+}
+
+FOUR:
+for(var x in {}) {
+>x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8))
+
+    FIVE:
+    for(var x in {}) {
+>x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8))
+
+        continue FOUR;
+    }
+}
+
+for(var x in {}) {
+>x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8))
+
+    SIX:
+    for(var x in {}) continue SIX;
+>x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8))
+}
+
+SEVEN:
+for (var x in {}) for (var x in {}) for (var x in {}) continue SEVEN;
+>x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8))
+>x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8))
+>x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8))
+
+EIGHT:
+for (var x in {}){
+>x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8))
+
+    var fn = function () { }
+>fn : Symbol(fn, Decl(forInContinueStatements.ts, 34, 7))
+
+    continue EIGHT;
+}
+
diff --git a/tests/baselines/reference/forInContinueStatements.types b/tests/baselines/reference/forInContinueStatements.types
new file mode 100644
index 00000000000..572fd16053d
--- /dev/null
+++ b/tests/baselines/reference/forInContinueStatements.types
@@ -0,0 +1,93 @@
+=== tests/cases/conformance/statements/continueStatements/forInContinueStatements.ts ===
+
+for(var x in {}) {
+>x : any
+>{} : {}
+
+    continue;
+}
+
+ONE:
+>ONE : any
+
+for(var x in {}) {
+>x : any
+>{} : {}
+
+    continue ONE;
+>ONE : any
+}
+
+TWO:
+>TWO : any
+
+THREE:
+>THREE : any
+
+for(var x in {}) {
+>x : any
+>{} : {}
+
+    continue THREE;
+>THREE : any
+}
+
+FOUR:
+>FOUR : any
+
+for(var x in {}) {
+>x : any
+>{} : {}
+
+    FIVE:
+>FIVE : any
+
+    for(var x in {}) {
+>x : any
+>{} : {}
+
+        continue FOUR;
+>FOUR : any
+    }
+}
+
+for(var x in {}) {
+>x : any
+>{} : {}
+
+    SIX:
+>SIX : any
+
+    for(var x in {}) continue SIX;
+>x : any
+>{} : {}
+>SIX : any
+}
+
+SEVEN:
+>SEVEN : any
+
+for (var x in {}) for (var x in {}) for (var x in {}) continue SEVEN;
+>x : any
+>{} : {}
+>x : any
+>{} : {}
+>x : any
+>{} : {}
+>SEVEN : any
+
+EIGHT:
+>EIGHT : any
+
+for (var x in {}){
+>x : any
+>{} : {}
+
+    var fn = function () { }
+>fn : () => void
+>function () { } : () => void
+
+    continue EIGHT;
+>EIGHT : any
+}
+
diff --git a/tests/baselines/reference/forStatements.errors.txt b/tests/baselines/reference/forStatements.errors.txt
deleted file mode 100644
index 5f1e6f10c79..00000000000
--- a/tests/baselines/reference/forStatements.errors.txt
+++ /dev/null
@@ -1,52 +0,0 @@
-tests/cases/conformance/statements/forStatements/forStatements.ts(26,1): error TS7027: Unreachable code detected.
-
-
-==== tests/cases/conformance/statements/forStatements/forStatements.ts (1 errors) ====
-    interface I {
-        id: number;
-    }
-    
-    class C implements I {
-        id: number;
-    }
-    
-    class D<T>{
-        source: T;
-        recurse: D<T>;
-        wrapped: D<D<T>>
-    }
-    
-    function F(x: string): number { return 42; }
-    
-    module M {
-        export class A {
-            name: string;
-        }
-    
-        export function F2(x: number): string { return x.toString(); }
-    }
-    
-    for(var aNumber: number = 9.9;;){} 
-    for(var aString: string = 'this is a string';;){}
-    ~~~
-!!! error TS7027: Unreachable code detected.
-    for(var aDate: Date = new Date(12);;){}
-    for(var anObject: Object = new Object();;){}
-    
-    for(var anAny: any = null;;){}
-    for(var aSecondAny: any = undefined;;){}
-    for(var aVoid: void = undefined;;){}
-    
-    for(var anInterface: I = new C();;){}
-    for(var aClass: C = new C();;){}
-    for(var aGenericClass: D<string> = new D<string>();;){}
-    for(var anObjectLiteral: I = { id: 12 };;){}
-    for(var anOtherObjectLiteral: { id: number } = new C();;){}
-    
-    for(var aFunction: typeof F = F;;){}
-    for(var anOtherFunction: (x: string) => number = F;;){}
-    for(var aLambda: typeof F = (x) => 2;;){}
-    
-    for(var aModule: typeof M = M;;){}
-    for(var aClassInModule: M.A = new M.A();;){}
-    for(var aFunctionInModule: typeof M.F2 = (x) => 'this is a string';;){}
\ No newline at end of file
diff --git a/tests/baselines/reference/forStatements.js b/tests/baselines/reference/forStatements.js
index 39fdb6c8871..253fafc81e8 100644
--- a/tests/baselines/reference/forStatements.js
+++ b/tests/baselines/reference/forStatements.js
@@ -1,4 +1,5 @@
 //// [forStatements.ts]
+
 interface I {
     id: number;
 }
diff --git a/tests/baselines/reference/forStatements.symbols b/tests/baselines/reference/forStatements.symbols
new file mode 100644
index 00000000000..2d5250217f9
--- /dev/null
+++ b/tests/baselines/reference/forStatements.symbols
@@ -0,0 +1,146 @@
+=== tests/cases/conformance/statements/forStatements/forStatements.ts ===
+
+interface I {
+>I : Symbol(I, Decl(forStatements.ts, 0, 0))
+
+    id: number;
+>id : Symbol(id, Decl(forStatements.ts, 1, 13))
+}
+
+class C implements I {
+>C : Symbol(C, Decl(forStatements.ts, 3, 1))
+>I : Symbol(I, Decl(forStatements.ts, 0, 0))
+
+    id: number;
+>id : Symbol(id, Decl(forStatements.ts, 5, 22))
+}
+
+class D<T>{
+>D : Symbol(D, Decl(forStatements.ts, 7, 1))
+>T : Symbol(T, Decl(forStatements.ts, 9, 8))
+
+    source: T;
+>source : Symbol(source, Decl(forStatements.ts, 9, 11))
+>T : Symbol(T, Decl(forStatements.ts, 9, 8))
+
+    recurse: D<T>;
+>recurse : Symbol(recurse, Decl(forStatements.ts, 10, 14))
+>D : Symbol(D, Decl(forStatements.ts, 7, 1))
+>T : Symbol(T, Decl(forStatements.ts, 9, 8))
+
+    wrapped: D<D<T>>
+>wrapped : Symbol(wrapped, Decl(forStatements.ts, 11, 18))
+>D : Symbol(D, Decl(forStatements.ts, 7, 1))
+>D : Symbol(D, Decl(forStatements.ts, 7, 1))
+>T : Symbol(T, Decl(forStatements.ts, 9, 8))
+}
+
+function F(x: string): number { return 42; }
+>F : Symbol(F, Decl(forStatements.ts, 13, 1))
+>x : Symbol(x, Decl(forStatements.ts, 15, 11))
+
+module M {
+>M : Symbol(M, Decl(forStatements.ts, 15, 44))
+
+    export class A {
+>A : Symbol(A, Decl(forStatements.ts, 17, 10))
+
+        name: string;
+>name : Symbol(name, Decl(forStatements.ts, 18, 20))
+    }
+
+    export function F2(x: number): string { return x.toString(); }
+>F2 : Symbol(F2, Decl(forStatements.ts, 20, 5))
+>x : Symbol(x, Decl(forStatements.ts, 22, 23))
+>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+>x : Symbol(x, Decl(forStatements.ts, 22, 23))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+}
+
+for(var aNumber: number = 9.9;;){} 
+>aNumber : Symbol(aNumber, Decl(forStatements.ts, 25, 7))
+
+for(var aString: string = 'this is a string';;){}
+>aString : Symbol(aString, Decl(forStatements.ts, 26, 7))
+
+for(var aDate: Date = new Date(12);;){}
+>aDate : Symbol(aDate, Decl(forStatements.ts, 27, 7))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+
+for(var anObject: Object = new Object();;){}
+>anObject : Symbol(anObject, Decl(forStatements.ts, 28, 7))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+
+for(var anAny: any = null;;){}
+>anAny : Symbol(anAny, Decl(forStatements.ts, 30, 7))
+
+for(var aSecondAny: any = undefined;;){}
+>aSecondAny : Symbol(aSecondAny, Decl(forStatements.ts, 31, 7))
+>undefined : Symbol(undefined)
+
+for(var aVoid: void = undefined;;){}
+>aVoid : Symbol(aVoid, Decl(forStatements.ts, 32, 7))
+>undefined : Symbol(undefined)
+
+for(var anInterface: I = new C();;){}
+>anInterface : Symbol(anInterface, Decl(forStatements.ts, 34, 7))
+>I : Symbol(I, Decl(forStatements.ts, 0, 0))
+>C : Symbol(C, Decl(forStatements.ts, 3, 1))
+
+for(var aClass: C = new C();;){}
+>aClass : Symbol(aClass, Decl(forStatements.ts, 35, 7))
+>C : Symbol(C, Decl(forStatements.ts, 3, 1))
+>C : Symbol(C, Decl(forStatements.ts, 3, 1))
+
+for(var aGenericClass: D<string> = new D<string>();;){}
+>aGenericClass : Symbol(aGenericClass, Decl(forStatements.ts, 36, 7))
+>D : Symbol(D, Decl(forStatements.ts, 7, 1))
+>D : Symbol(D, Decl(forStatements.ts, 7, 1))
+
+for(var anObjectLiteral: I = { id: 12 };;){}
+>anObjectLiteral : Symbol(anObjectLiteral, Decl(forStatements.ts, 37, 7))
+>I : Symbol(I, Decl(forStatements.ts, 0, 0))
+>id : Symbol(id, Decl(forStatements.ts, 37, 30))
+
+for(var anOtherObjectLiteral: { id: number } = new C();;){}
+>anOtherObjectLiteral : Symbol(anOtherObjectLiteral, Decl(forStatements.ts, 38, 7))
+>id : Symbol(id, Decl(forStatements.ts, 38, 31))
+>C : Symbol(C, Decl(forStatements.ts, 3, 1))
+
+for(var aFunction: typeof F = F;;){}
+>aFunction : Symbol(aFunction, Decl(forStatements.ts, 40, 7))
+>F : Symbol(F, Decl(forStatements.ts, 13, 1))
+>F : Symbol(F, Decl(forStatements.ts, 13, 1))
+
+for(var anOtherFunction: (x: string) => number = F;;){}
+>anOtherFunction : Symbol(anOtherFunction, Decl(forStatements.ts, 41, 7))
+>x : Symbol(x, Decl(forStatements.ts, 41, 26))
+>F : Symbol(F, Decl(forStatements.ts, 13, 1))
+
+for(var aLambda: typeof F = (x) => 2;;){}
+>aLambda : Symbol(aLambda, Decl(forStatements.ts, 42, 7))
+>F : Symbol(F, Decl(forStatements.ts, 13, 1))
+>x : Symbol(x, Decl(forStatements.ts, 42, 29))
+
+for(var aModule: typeof M = M;;){}
+>aModule : Symbol(aModule, Decl(forStatements.ts, 44, 7))
+>M : Symbol(M, Decl(forStatements.ts, 15, 44))
+>M : Symbol(M, Decl(forStatements.ts, 15, 44))
+
+for(var aClassInModule: M.A = new M.A();;){}
+>aClassInModule : Symbol(aClassInModule, Decl(forStatements.ts, 45, 7))
+>M : Symbol(M, Decl(forStatements.ts, 15, 44))
+>A : Symbol(M.A, Decl(forStatements.ts, 17, 10))
+>M.A : Symbol(M.A, Decl(forStatements.ts, 17, 10))
+>M : Symbol(M, Decl(forStatements.ts, 15, 44))
+>A : Symbol(M.A, Decl(forStatements.ts, 17, 10))
+
+for(var aFunctionInModule: typeof M.F2 = (x) => 'this is a string';;){}
+>aFunctionInModule : Symbol(aFunctionInModule, Decl(forStatements.ts, 46, 7))
+>M.F2 : Symbol(M.F2, Decl(forStatements.ts, 20, 5))
+>M : Symbol(M, Decl(forStatements.ts, 15, 44))
+>F2 : Symbol(M.F2, Decl(forStatements.ts, 20, 5))
+>x : Symbol(x, Decl(forStatements.ts, 46, 42))
+
diff --git a/tests/baselines/reference/forStatements.types b/tests/baselines/reference/forStatements.types
new file mode 100644
index 00000000000..95b198a7fec
--- /dev/null
+++ b/tests/baselines/reference/forStatements.types
@@ -0,0 +1,165 @@
+=== tests/cases/conformance/statements/forStatements/forStatements.ts ===
+
+interface I {
+>I : I
+
+    id: number;
+>id : number
+}
+
+class C implements I {
+>C : C
+>I : I
+
+    id: number;
+>id : number
+}
+
+class D<T>{
+>D : D<T>
+>T : T
+
+    source: T;
+>source : T
+>T : T
+
+    recurse: D<T>;
+>recurse : D<T>
+>D : D<T>
+>T : T
+
+    wrapped: D<D<T>>
+>wrapped : D<D<T>>
+>D : D<T>
+>D : D<T>
+>T : T
+}
+
+function F(x: string): number { return 42; }
+>F : (x: string) => number
+>x : string
+>42 : number
+
+module M {
+>M : typeof M
+
+    export class A {
+>A : A
+
+        name: string;
+>name : string
+    }
+
+    export function F2(x: number): string { return x.toString(); }
+>F2 : (x: number) => string
+>x : number
+>x.toString() : string
+>x.toString : (radix?: number) => string
+>x : number
+>toString : (radix?: number) => string
+}
+
+for(var aNumber: number = 9.9;;){} 
+>aNumber : number
+>9.9 : number
+
+for(var aString: string = 'this is a string';;){}
+>aString : string
+>'this is a string' : string
+
+for(var aDate: Date = new Date(12);;){}
+>aDate : Date
+>Date : Date
+>new Date(12) : Date
+>Date : DateConstructor
+>12 : number
+
+for(var anObject: Object = new Object();;){}
+>anObject : Object
+>Object : Object
+>new Object() : Object
+>Object : ObjectConstructor
+
+for(var anAny: any = null;;){}
+>anAny : any
+>null : null
+
+for(var aSecondAny: any = undefined;;){}
+>aSecondAny : any
+>undefined : undefined
+
+for(var aVoid: void = undefined;;){}
+>aVoid : void
+>undefined : undefined
+
+for(var anInterface: I = new C();;){}
+>anInterface : I
+>I : I
+>new C() : C
+>C : typeof C
+
+for(var aClass: C = new C();;){}
+>aClass : C
+>C : C
+>new C() : C
+>C : typeof C
+
+for(var aGenericClass: D<string> = new D<string>();;){}
+>aGenericClass : D<string>
+>D : D<T>
+>new D<string>() : D<string>
+>D : typeof D
+
+for(var anObjectLiteral: I = { id: 12 };;){}
+>anObjectLiteral : I
+>I : I
+>{ id: 12 } : { id: number; }
+>id : number
+>12 : number
+
+for(var anOtherObjectLiteral: { id: number } = new C();;){}
+>anOtherObjectLiteral : { id: number; }
+>id : number
+>new C() : C
+>C : typeof C
+
+for(var aFunction: typeof F = F;;){}
+>aFunction : (x: string) => number
+>F : (x: string) => number
+>F : (x: string) => number
+
+for(var anOtherFunction: (x: string) => number = F;;){}
+>anOtherFunction : (x: string) => number
+>x : string
+>F : (x: string) => number
+
+for(var aLambda: typeof F = (x) => 2;;){}
+>aLambda : (x: string) => number
+>F : (x: string) => number
+>(x) => 2 : (x: string) => number
+>x : string
+>2 : number
+
+for(var aModule: typeof M = M;;){}
+>aModule : typeof M
+>M : typeof M
+>M : typeof M
+
+for(var aClassInModule: M.A = new M.A();;){}
+>aClassInModule : M.A
+>M : any
+>A : M.A
+>new M.A() : M.A
+>M.A : typeof M.A
+>M : typeof M
+>A : typeof M.A
+
+for(var aFunctionInModule: typeof M.F2 = (x) => 'this is a string';;){}
+>aFunctionInModule : (x: number) => string
+>M.F2 : (x: number) => string
+>M : typeof M
+>F2 : (x: number) => string
+>(x) => 'this is a string' : (x: number) => string
+>x : number
+>'this is a string' : string
+
diff --git a/tests/baselines/reference/forStatementsMultipleInvalidDecl.errors.txt b/tests/baselines/reference/forStatementsMultipleInvalidDecl.errors.txt
index fa1c87824d7..f1869ae7fca 100644
--- a/tests/baselines/reference/forStatementsMultipleInvalidDecl.errors.txt
+++ b/tests/baselines/reference/forStatementsMultipleInvalidDecl.errors.txt
@@ -1,19 +1,19 @@
-tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(32,1): error TS7027: Unreachable code detected.
-tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(32,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'a' must be of type 'any', but here has type 'number'.
-tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(33,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'a' must be of type 'any', but here has type 'string'.
-tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(34,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'a' must be of type 'any', but here has type 'C'.
-tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(35,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'a' must be of type 'any', but here has type 'D<string>'.
-tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(36,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'a' must be of type 'any', but here has type 'typeof M'.
-tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(39,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'b' must be of type 'I', but here has type 'C'.
-tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(40,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'b' must be of type 'I', but here has type 'C2'.
-tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(43,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'f' must be of type '(x: string) => number', but here has type '(x: number) => string'.
-tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(46,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type 'number[]'.
-tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(47,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type '(C | D<string>)[]'.
-tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(50,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr2' must be of type 'D<string>[]', but here has type 'D<number>[]'.
-tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(53,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'm' must be of type 'typeof M', but here has type 'typeof A'.
+tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(33,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'a' must be of type 'any', but here has type 'number'.
+tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(34,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'a' must be of type 'any', but here has type 'string'.
+tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(35,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'a' must be of type 'any', but here has type 'C'.
+tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(36,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'a' must be of type 'any', but here has type 'D<string>'.
+tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(37,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'a' must be of type 'any', but here has type 'typeof M'.
+tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(40,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'b' must be of type 'I', but here has type 'C'.
+tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(41,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'b' must be of type 'I', but here has type 'C2'.
+tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(44,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'f' must be of type '(x: string) => number', but here has type '(x: number) => string'.
+tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(47,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type 'number[]'.
+tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(48,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type '(C | D<string>)[]'.
+tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(51,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr2' must be of type 'D<string>[]', but here has type 'D<number>[]'.
+tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(54,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'm' must be of type 'typeof M', but here has type 'typeof A'.
 
 
-==== tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts (13 errors) ====
+==== tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts (12 errors) ====
+    
     interface I {
         id: number;
     }
@@ -46,8 +46,6 @@ tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDec
     // all of these are errors
     for( var a: any;;){}
     for( var a = 1;;){}
-    ~~~
-!!! error TS7027: Unreachable code detected.
              ~
 !!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'a' must be of type 'any', but here has type 'number'.
     for( var a = 'a string';;){}
diff --git a/tests/baselines/reference/forStatementsMultipleInvalidDecl.js b/tests/baselines/reference/forStatementsMultipleInvalidDecl.js
index 1dde9981880..20639c687cb 100644
--- a/tests/baselines/reference/forStatementsMultipleInvalidDecl.js
+++ b/tests/baselines/reference/forStatementsMultipleInvalidDecl.js
@@ -1,4 +1,5 @@
 //// [forStatementsMultipleInvalidDecl.ts]
+
 interface I {
     id: number;
 }
diff --git a/tests/baselines/reference/forStatementsMultipleValidDecl.errors.txt b/tests/baselines/reference/forStatementsMultipleValidDecl.errors.txt
deleted file mode 100644
index eb871af31c0..00000000000
--- a/tests/baselines/reference/forStatementsMultipleValidDecl.errors.txt
+++ /dev/null
@@ -1,39 +0,0 @@
-tests/cases/conformance/statements/forStatements/forStatementsMultipleValidDecl.ts(4,1): error TS7027: Unreachable code detected.
-
-
-==== tests/cases/conformance/statements/forStatements/forStatementsMultipleValidDecl.ts (1 errors) ====
-    // all expected to be valid
-    
-    for (var x: number; ;) { }
-    for (var x = 2; ;) { }
-    ~~~
-!!! error TS7027: Unreachable code detected.
-    
-    for (var x = <number>undefined; ;) { }
-    // new declaration space, making redeclaring x as a string valid
-    function declSpace() {
-        for (var x = 'this is a string'; ;) { }
-    }
-    interface Point { x: number; y: number; }
-    
-    for (var p: Point; ;) { }
-    for (var p = { x: 1, y: 2 }; ;) { }
-    for (var p: Point = { x: 0, y: undefined }; ;) { }
-    for (var p = { x: 1, y: <number>undefined }; ;) { }
-    for (var p: { x: number; y: number; } = { x: 1, y: 2 }; ;) { }
-    for (var p = <{ x: number; y: number; }>{ x: 0, y: undefined }; ;) { }
-    for (var p: typeof p; ;) { }
-    
-    for (var fn = function (s: string) { return 42; }; ;) { }
-    for (var fn = (s: string) => 3; ;) { }
-    for (var fn: (s: string) => number; ;) { }
-    for (var fn: { (s: string): number }; ;) { }
-    for (var fn = <(s: string) => number> null; ;) { }
-    for (var fn: typeof fn; ;) { }
-    
-    for (var a: string[]; ;) { }
-    for (var a = ['a', 'b']; ;) { }
-    for (var a = <string[]>[]; ;) { }
-    for (var a: string[] = []; ;) { }
-    for (var a = new Array<string>(); ;) { }
-    for (var a: typeof a; ;) { }
\ No newline at end of file
diff --git a/tests/baselines/reference/forStatementsMultipleValidDecl.js b/tests/baselines/reference/forStatementsMultipleValidDecl.js
index e95e37d63ac..6913894a15f 100644
--- a/tests/baselines/reference/forStatementsMultipleValidDecl.js
+++ b/tests/baselines/reference/forStatementsMultipleValidDecl.js
@@ -1,4 +1,5 @@
 //// [forStatementsMultipleValidDecl.ts]
+
 // all expected to be valid
 
 for (var x: number; ;) { }
diff --git a/tests/baselines/reference/forStatementsMultipleValidDecl.symbols b/tests/baselines/reference/forStatementsMultipleValidDecl.symbols
new file mode 100644
index 00000000000..d2d8ac01003
--- /dev/null
+++ b/tests/baselines/reference/forStatementsMultipleValidDecl.symbols
@@ -0,0 +1,111 @@
+=== tests/cases/conformance/statements/forStatements/forStatementsMultipleValidDecl.ts ===
+
+// all expected to be valid
+
+for (var x: number; ;) { }
+>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 3, 8), Decl(forStatementsMultipleValidDecl.ts, 4, 8), Decl(forStatementsMultipleValidDecl.ts, 6, 8))
+
+for (var x = 2; ;) { }
+>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 3, 8), Decl(forStatementsMultipleValidDecl.ts, 4, 8), Decl(forStatementsMultipleValidDecl.ts, 6, 8))
+
+for (var x = <number>undefined; ;) { }
+>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 3, 8), Decl(forStatementsMultipleValidDecl.ts, 4, 8), Decl(forStatementsMultipleValidDecl.ts, 6, 8))
+>undefined : Symbol(undefined)
+
+// new declaration space, making redeclaring x as a string valid
+function declSpace() {
+>declSpace : Symbol(declSpace, Decl(forStatementsMultipleValidDecl.ts, 6, 38))
+
+    for (var x = 'this is a string'; ;) { }
+>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 9, 12))
+}
+interface Point { x: number; y: number; }
+>Point : Symbol(Point, Decl(forStatementsMultipleValidDecl.ts, 10, 1))
+>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 11, 17))
+>y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 11, 28))
+
+for (var p: Point; ;) { }
+>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8))
+>Point : Symbol(Point, Decl(forStatementsMultipleValidDecl.ts, 10, 1))
+
+for (var p = { x: 1, y: 2 }; ;) { }
+>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8))
+>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 14, 14))
+>y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 14, 20))
+
+for (var p: Point = { x: 0, y: undefined }; ;) { }
+>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8))
+>Point : Symbol(Point, Decl(forStatementsMultipleValidDecl.ts, 10, 1))
+>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 15, 21))
+>y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 15, 27))
+>undefined : Symbol(undefined)
+
+for (var p = { x: 1, y: <number>undefined }; ;) { }
+>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8))
+>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 16, 14))
+>y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 16, 20))
+>undefined : Symbol(undefined)
+
+for (var p: { x: number; y: number; } = { x: 1, y: 2 }; ;) { }
+>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8))
+>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 17, 13))
+>y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 17, 24))
+>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 17, 41))
+>y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 17, 47))
+
+for (var p = <{ x: number; y: number; }>{ x: 0, y: undefined }; ;) { }
+>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8))
+>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 18, 15))
+>y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 18, 26))
+>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 18, 41))
+>y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 18, 47))
+>undefined : Symbol(undefined)
+
+for (var p: typeof p; ;) { }
+>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8))
+>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8))
+
+for (var fn = function (s: string) { return 42; }; ;) { }
+>fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8), Decl(forStatementsMultipleValidDecl.ts, 26, 8))
+>s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 21, 24))
+
+for (var fn = (s: string) => 3; ;) { }
+>fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8), Decl(forStatementsMultipleValidDecl.ts, 26, 8))
+>s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 22, 15))
+
+for (var fn: (s: string) => number; ;) { }
+>fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8), Decl(forStatementsMultipleValidDecl.ts, 26, 8))
+>s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 23, 14))
+
+for (var fn: { (s: string): number }; ;) { }
+>fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8), Decl(forStatementsMultipleValidDecl.ts, 26, 8))
+>s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 24, 16))
+
+for (var fn = <(s: string) => number> null; ;) { }
+>fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8), Decl(forStatementsMultipleValidDecl.ts, 26, 8))
+>s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 25, 16))
+
+for (var fn: typeof fn; ;) { }
+>fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8), Decl(forStatementsMultipleValidDecl.ts, 26, 8))
+>fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8), Decl(forStatementsMultipleValidDecl.ts, 26, 8))
+
+for (var a: string[]; ;) { }
+>a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8), Decl(forStatementsMultipleValidDecl.ts, 33, 8))
+
+for (var a = ['a', 'b']; ;) { }
+>a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8), Decl(forStatementsMultipleValidDecl.ts, 33, 8))
+
+for (var a = <string[]>[]; ;) { }
+>a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8), Decl(forStatementsMultipleValidDecl.ts, 33, 8))
+
+for (var a: string[] = []; ;) { }
+>a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8), Decl(forStatementsMultipleValidDecl.ts, 33, 8))
+
+for (var a = new Array<string>(); ;) { }
+>a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8), Decl(forStatementsMultipleValidDecl.ts, 33, 8))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+
+for (var a: typeof a; ;) { }
+>a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8), Decl(forStatementsMultipleValidDecl.ts, 33, 8))
+>a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8), Decl(forStatementsMultipleValidDecl.ts, 33, 8))
+
diff --git a/tests/baselines/reference/forStatementsMultipleValidDecl.types b/tests/baselines/reference/forStatementsMultipleValidDecl.types
new file mode 100644
index 00000000000..acb26f17312
--- /dev/null
+++ b/tests/baselines/reference/forStatementsMultipleValidDecl.types
@@ -0,0 +1,141 @@
+=== tests/cases/conformance/statements/forStatements/forStatementsMultipleValidDecl.ts ===
+
+// all expected to be valid
+
+for (var x: number; ;) { }
+>x : number
+
+for (var x = 2; ;) { }
+>x : number
+>2 : number
+
+for (var x = <number>undefined; ;) { }
+>x : number
+><number>undefined : number
+>undefined : undefined
+
+// new declaration space, making redeclaring x as a string valid
+function declSpace() {
+>declSpace : () => void
+
+    for (var x = 'this is a string'; ;) { }
+>x : string
+>'this is a string' : string
+}
+interface Point { x: number; y: number; }
+>Point : Point
+>x : number
+>y : number
+
+for (var p: Point; ;) { }
+>p : Point
+>Point : Point
+
+for (var p = { x: 1, y: 2 }; ;) { }
+>p : Point
+>{ x: 1, y: 2 } : { x: number; y: number; }
+>x : number
+>1 : number
+>y : number
+>2 : number
+
+for (var p: Point = { x: 0, y: undefined }; ;) { }
+>p : Point
+>Point : Point
+>{ x: 0, y: undefined } : { x: number; y: undefined; }
+>x : number
+>0 : number
+>y : undefined
+>undefined : undefined
+
+for (var p = { x: 1, y: <number>undefined }; ;) { }
+>p : Point
+>{ x: 1, y: <number>undefined } : { x: number; y: number; }
+>x : number
+>1 : number
+>y : number
+><number>undefined : number
+>undefined : undefined
+
+for (var p: { x: number; y: number; } = { x: 1, y: 2 }; ;) { }
+>p : Point
+>x : number
+>y : number
+>{ x: 1, y: 2 } : { x: number; y: number; }
+>x : number
+>1 : number
+>y : number
+>2 : number
+
+for (var p = <{ x: number; y: number; }>{ x: 0, y: undefined }; ;) { }
+>p : Point
+><{ x: number; y: number; }>{ x: 0, y: undefined } : { x: number; y: number; }
+>x : number
+>y : number
+>{ x: 0, y: undefined } : { x: number; y: undefined; }
+>x : number
+>0 : number
+>y : undefined
+>undefined : undefined
+
+for (var p: typeof p; ;) { }
+>p : Point
+>p : Point
+
+for (var fn = function (s: string) { return 42; }; ;) { }
+>fn : (s: string) => number
+>function (s: string) { return 42; } : (s: string) => number
+>s : string
+>42 : number
+
+for (var fn = (s: string) => 3; ;) { }
+>fn : (s: string) => number
+>(s: string) => 3 : (s: string) => number
+>s : string
+>3 : number
+
+for (var fn: (s: string) => number; ;) { }
+>fn : (s: string) => number
+>s : string
+
+for (var fn: { (s: string): number }; ;) { }
+>fn : (s: string) => number
+>s : string
+
+for (var fn = <(s: string) => number> null; ;) { }
+>fn : (s: string) => number
+><(s: string) => number> null : (s: string) => number
+>s : string
+>null : null
+
+for (var fn: typeof fn; ;) { }
+>fn : (s: string) => number
+>fn : (s: string) => number
+
+for (var a: string[]; ;) { }
+>a : string[]
+
+for (var a = ['a', 'b']; ;) { }
+>a : string[]
+>['a', 'b'] : string[]
+>'a' : string
+>'b' : string
+
+for (var a = <string[]>[]; ;) { }
+>a : string[]
+><string[]>[] : string[]
+>[] : undefined[]
+
+for (var a: string[] = []; ;) { }
+>a : string[]
+>[] : undefined[]
+
+for (var a = new Array<string>(); ;) { }
+>a : string[]
+>new Array<string>() : string[]
+>Array : ArrayConstructor
+
+for (var a: typeof a; ;) { }
+>a : string[]
+>a : string[]
+
diff --git a/tests/baselines/reference/functionImplementationErrors.errors.txt b/tests/baselines/reference/functionImplementationErrors.errors.txt
index bde939a1578..86ecb6a6057 100644
--- a/tests/baselines/reference/functionImplementationErrors.errors.txt
+++ b/tests/baselines/reference/functionImplementationErrors.errors.txt
@@ -1,46 +1,32 @@
-tests/cases/conformance/functions/functionImplementationErrors.ts(2,10): error TS2354: No best common type exists among return expressions.
-tests/cases/conformance/functions/functionImplementationErrors.ts(4,5): error TS7027: Unreachable code detected.
-tests/cases/conformance/functions/functionImplementationErrors.ts(6,19): error TS2354: No best common type exists among return expressions.
-tests/cases/conformance/functions/functionImplementationErrors.ts(8,5): error TS7027: Unreachable code detected.
-tests/cases/conformance/functions/functionImplementationErrors.ts(10,10): error TS2354: No best common type exists among return expressions.
-tests/cases/conformance/functions/functionImplementationErrors.ts(12,5): error TS7027: Unreachable code detected.
-tests/cases/conformance/functions/functionImplementationErrors.ts(16,10): error TS2354: No best common type exists among return expressions.
-tests/cases/conformance/functions/functionImplementationErrors.ts(20,9): error TS7027: Unreachable code detected.
-tests/cases/conformance/functions/functionImplementationErrors.ts(25,16): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
-tests/cases/conformance/functions/functionImplementationErrors.ts(30,17): error TS2373: Initializer of parameter 'n' cannot reference identifier 'm' declared after it.
-tests/cases/conformance/functions/functionImplementationErrors.ts(35,17): error TS2373: Initializer of parameter 'n' cannot reference identifier 'm' declared after it.
-tests/cases/conformance/functions/functionImplementationErrors.ts(42,5): error TS7027: Unreachable code detected.
-tests/cases/conformance/functions/functionImplementationErrors.ts(49,10): error TS2354: No best common type exists among return expressions.
-tests/cases/conformance/functions/functionImplementationErrors.ts(51,5): error TS7027: Unreachable code detected.
-tests/cases/conformance/functions/functionImplementationErrors.ts(53,10): error TS2354: No best common type exists among return expressions.
-tests/cases/conformance/functions/functionImplementationErrors.ts(55,5): error TS7027: Unreachable code detected.
-tests/cases/conformance/functions/functionImplementationErrors.ts(57,11): error TS2354: No best common type exists among return expressions.
-tests/cases/conformance/functions/functionImplementationErrors.ts(59,5): error TS7027: Unreachable code detected.
-tests/cases/conformance/functions/functionImplementationErrors.ts(61,10): error TS2354: No best common type exists among return expressions.
-tests/cases/conformance/functions/functionImplementationErrors.ts(63,5): error TS7027: Unreachable code detected.
-tests/cases/conformance/functions/functionImplementationErrors.ts(65,11): error TS2354: No best common type exists among return expressions.
-tests/cases/conformance/functions/functionImplementationErrors.ts(67,5): error TS7027: Unreachable code detected.
-tests/cases/conformance/functions/functionImplementationErrors.ts(69,11): error TS2354: No best common type exists among return expressions.
-tests/cases/conformance/functions/functionImplementationErrors.ts(71,5): error TS7027: Unreachable code detected.
+tests/cases/conformance/functions/functionImplementationErrors.ts(3,10): error TS2354: No best common type exists among return expressions.
+tests/cases/conformance/functions/functionImplementationErrors.ts(7,19): error TS2354: No best common type exists among return expressions.
+tests/cases/conformance/functions/functionImplementationErrors.ts(11,10): error TS2354: No best common type exists among return expressions.
+tests/cases/conformance/functions/functionImplementationErrors.ts(17,10): error TS2354: No best common type exists among return expressions.
+tests/cases/conformance/functions/functionImplementationErrors.ts(26,16): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
+tests/cases/conformance/functions/functionImplementationErrors.ts(31,17): error TS2373: Initializer of parameter 'n' cannot reference identifier 'm' declared after it.
+tests/cases/conformance/functions/functionImplementationErrors.ts(36,17): error TS2373: Initializer of parameter 'n' cannot reference identifier 'm' declared after it.
+tests/cases/conformance/functions/functionImplementationErrors.ts(50,10): error TS2354: No best common type exists among return expressions.
+tests/cases/conformance/functions/functionImplementationErrors.ts(54,10): error TS2354: No best common type exists among return expressions.
+tests/cases/conformance/functions/functionImplementationErrors.ts(58,11): error TS2354: No best common type exists among return expressions.
+tests/cases/conformance/functions/functionImplementationErrors.ts(62,10): error TS2354: No best common type exists among return expressions.
+tests/cases/conformance/functions/functionImplementationErrors.ts(66,11): error TS2354: No best common type exists among return expressions.
+tests/cases/conformance/functions/functionImplementationErrors.ts(70,11): error TS2354: No best common type exists among return expressions.
 
 
-==== tests/cases/conformance/functions/functionImplementationErrors.ts (24 errors) ====
+==== tests/cases/conformance/functions/functionImplementationErrors.ts (13 errors) ====
+    
     // FunctionExpression with no return type annotation with multiple return statements with unrelated types
     var f1 = function () {
              ~~~~~~~~
 !!! error TS2354: No best common type exists among return expressions.
         return '';
         return 3;
-        ~~~~~~
-!!! error TS7027: Unreachable code detected.
     };
     var f2 = function x() {
                       ~
 !!! error TS2354: No best common type exists among return expressions.
         return '';
         return 3;
-        ~~~~~~
-!!! error TS7027: Unreachable code detected.
     };
     var f3 = () => {
              ~~~~~~~
@@ -48,8 +34,6 @@ tests/cases/conformance/functions/functionImplementationErrors.ts(71,5): error T
     ~~~~~~~~~~~~~~
         return 3;
     ~~~~~~~~~~~~~
-        ~~~~~~
-!!! error TS7027: Unreachable code detected.
     };
     ~
 !!! error TS2354: No best common type exists among return expressions.
@@ -62,8 +46,6 @@ tests/cases/conformance/functions/functionImplementationErrors.ts(71,5): error T
             return [''];
         } else {
             return [1];
-            ~~~~~~
-!!! error TS7027: Unreachable code detected.
         }
     }
     
@@ -92,8 +74,6 @@ tests/cases/conformance/functions/functionImplementationErrors.ts(71,5): error T
     undefined === function (): number {
         throw undefined;
         var x = 4;
-        ~~~
-!!! error TS7027: Unreachable code detected.
     };
     
     class Base { private x; }
@@ -105,16 +85,12 @@ tests/cases/conformance/functions/functionImplementationErrors.ts(71,5): error T
 !!! error TS2354: No best common type exists among return expressions.
         return new Derived1();
         return new Derived2();    
-        ~~~~~~
-!!! error TS7027: Unreachable code detected.
     }
     var f9 = function () {
              ~~~~~~~~
 !!! error TS2354: No best common type exists among return expressions.
         return new Derived1();
         return new Derived2();
-        ~~~~~~
-!!! error TS7027: Unreachable code detected.
     };
     var f10 = () => {
               ~~~~~~~
@@ -122,8 +98,6 @@ tests/cases/conformance/functions/functionImplementationErrors.ts(71,5): error T
     ~~~~~~~~~~~~~~~~~~~~~~~~~~
         return new Derived2();
     ~~~~~~~~~~~~~~~~~~~~~~~~~~
-        ~~~~~~
-!!! error TS7027: Unreachable code detected.
     };
     ~
 !!! error TS2354: No best common type exists among return expressions.
@@ -132,16 +106,12 @@ tests/cases/conformance/functions/functionImplementationErrors.ts(71,5): error T
 !!! error TS2354: No best common type exists among return expressions.
         return new Base();
         return new AnotherClass();
-        ~~~~~~
-!!! error TS7027: Unreachable code detected.
     }
     var f12 = function () {
               ~~~~~~~~
 !!! error TS2354: No best common type exists among return expressions.
         return new Base();
         return new AnotherClass();
-        ~~~~~~
-!!! error TS7027: Unreachable code detected.
     };
     var f13 = () => {
               ~~~~~~~
@@ -149,8 +119,6 @@ tests/cases/conformance/functions/functionImplementationErrors.ts(71,5): error T
     ~~~~~~~~~~~~~~~~~~~~~~
         return new AnotherClass();
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-        ~~~~~~
-!!! error TS7027: Unreachable code detected.
     };
     ~
 !!! error TS2354: No best common type exists among return expressions.
diff --git a/tests/baselines/reference/functionImplementationErrors.js b/tests/baselines/reference/functionImplementationErrors.js
index 42be5f21458..4436f1bc94f 100644
--- a/tests/baselines/reference/functionImplementationErrors.js
+++ b/tests/baselines/reference/functionImplementationErrors.js
@@ -1,4 +1,5 @@
 //// [functionImplementationErrors.ts]
+
 // FunctionExpression with no return type annotation with multiple return statements with unrelated types
 var f1 = function () {
     return '';
diff --git a/tests/baselines/reference/functionImplementations.errors.txt b/tests/baselines/reference/functionImplementations.errors.txt
deleted file mode 100644
index f3e4d6404c6..00000000000
--- a/tests/baselines/reference/functionImplementations.errors.txt
+++ /dev/null
@@ -1,183 +0,0 @@
-tests/cases/conformance/functions/functionImplementations.ts(69,5): error TS7027: Unreachable code detected.
-tests/cases/conformance/functions/functionImplementations.ts(81,24): error TS7027: Unreachable code detected.
-tests/cases/conformance/functions/functionImplementations.ts(86,24): error TS7027: Unreachable code detected.
-tests/cases/conformance/functions/functionImplementations.ts(137,5): error TS7027: Unreachable code detected.
-tests/cases/conformance/functions/functionImplementations.ts(141,5): error TS7027: Unreachable code detected.
-tests/cases/conformance/functions/functionImplementations.ts(146,5): error TS7027: Unreachable code detected.
-tests/cases/conformance/functions/functionImplementations.ts(150,5): error TS7027: Unreachable code detected.
-tests/cases/conformance/functions/functionImplementations.ts(154,5): error TS7027: Unreachable code detected.
-
-
-==== tests/cases/conformance/functions/functionImplementations.ts (8 errors) ====
-    // FunctionExpression with no return type annotation and no return statement returns void
-    var v: void = function () { } ();
-    
-    // FunctionExpression f with no return type annotation and directly references f in its body returns any
-    var a: any = function f() {
-        return f;
-    };
-    var a: any = function f() {
-        return f();
-    };
-    
-    // FunctionExpression f with no return type annotation and indirectly references f in its body returns any
-    var a: any = function f() {
-        var x = f;
-        return x;
-    };
-    
-    // Two mutually recursive function implementations with no return type annotations
-    function rec1() {
-        return rec2();
-    }
-    function rec2() {
-        return rec1();
-    }
-    var a = rec1();
-    var a = rec2();
-    
-    // Two mutually recursive function implementations with return type annotation in one
-    function rec3(): number {
-        return rec4();
-    }
-    function rec4() {
-        return rec3();
-    }
-    var n: number;
-    var n = rec3();
-    var n = rec4();
-    
-    // FunctionExpression with no return type annotation and returns a number
-    var n = function () {
-        return 3;
-    } ();
-    
-    // FunctionExpression with no return type annotation and returns null
-    var nu = null;
-    var nu = function () {
-        return null;
-    } ();
-    
-    // FunctionExpression with no return type annotation and returns undefined
-    var un = undefined;
-    var un = function () {
-        return undefined;
-    } ();
-    
-    // FunctionExpression with no return type annotation and returns a type parameter type
-    var n = function <T>(x: T) {
-        return x;
-    } (4);
-    
-    // FunctionExpression with no return type annotation and returns a constrained type parameter type
-    var n = function <T extends {}>(x: T) {
-        return x;
-    } (4);
-    
-    // FunctionExpression with no return type annotation with multiple return statements with identical types
-    var n = function () {
-        return 3;
-        return 5;
-        ~~~~~~
-!!! error TS7027: Unreachable code detected.
-    }();
-    
-    // Otherwise, the inferred return type is the first of the types of the return statement expressions
-    // in the function body that is a supertype of each of the others, 
-    // ignoring return statements with no expressions.
-    // A compile - time error occurs if no return statement expression has a type that is a supertype of each of the others.
-    // FunctionExpression with no return type annotation with multiple return statements with subtype relation between returns
-    class Base { private m; }
-    class Derived extends Base { private q; }
-    var b: Base;
-    var b = function () {
-        return new Base(); return new Derived();
-                           ~~~~~~
-!!! error TS7027: Unreachable code detected.
-    } ();
-    
-    // FunctionExpression with no return type annotation with multiple return statements with one a recursive call
-    var a = function f() {
-        return new Base(); return new Derived(); return f(); // ?
-                           ~~~~~~
-!!! error TS7027: Unreachable code detected.
-    } ();
-    
-    // FunctionExpression with non -void return type annotation with a single throw statement
-    undefined === function (): number {
-        throw undefined;
-    };
-    
-    // Type of 'this' in function implementation is 'any'
-    function thisFunc() {
-        var x = this;
-        var x: any;
-    }
-    
-    // Function signature with optional parameter, no type annotation and initializer has initializer's type
-    function opt1(n = 4) {
-        var m = n;
-        var m: number;
-    }
-    
-    // Function signature with optional parameter, no type annotation and initializer has initializer's widened type
-    function opt2(n = { x: null, y: undefined }) {
-        var m = n;
-        var m: { x: any; y: any };
-    }
-    
-    // Function signature with initializer referencing other parameter to the left
-    function opt3(n: number, m = n) {
-        var y = m;
-        var y: number;
-    }
-    
-    // Function signature with optional parameter has correct codegen 
-    // (tested above)
-    
-    // FunctionExpression with non -void return type annotation return with no expression
-    function f6(): number {
-        return;
-    }
-    
-    class Derived2 extends Base { private r: string; }
-    class AnotherClass { private x }
-    // if f is a contextually typed function expression, the inferred return type is the union type
-    // of the types of the return statement expressions in the function body, 
-    // ignoring return statements with no expressions.
-    var f7: (x: number) => string | number = x => { // should be (x: number) => number | string
-        if (x < 0) { return x; }
-        return x.toString();
-    }
-    var f8: (x: number) => any = x => { // should be (x: number) => Base
-        return new Base();
-        return new Derived2();
-        ~~~~~~
-!!! error TS7027: Unreachable code detected.
-    }
-    var f9: (x: number) => any = x => { // should be (x: number) => Base
-        return new Base();
-        return new Derived();
-        ~~~~~~
-!!! error TS7027: Unreachable code detected.
-        return new Derived2();
-    }
-    var f10: (x: number) => any = x => { // should be (x: number) => Derived | Derived1
-        return new Derived();
-        return new Derived2();
-        ~~~~~~
-!!! error TS7027: Unreachable code detected.
-    }
-    var f11: (x: number) => any = x => { // should be (x: number) => Base | AnotherClass
-        return new Base();
-        return new AnotherClass();
-        ~~~~~~
-!!! error TS7027: Unreachable code detected.
-    }
-    var f12: (x: number) => any = x => { // should be (x: number) => Base | AnotherClass
-        return new Base();
-        return; // should be ignored
-        ~~~~~~
-!!! error TS7027: Unreachable code detected.
-        return new AnotherClass();
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/functionImplementations.js b/tests/baselines/reference/functionImplementations.js
index 3fc040650e4..512da960b78 100644
--- a/tests/baselines/reference/functionImplementations.js
+++ b/tests/baselines/reference/functionImplementations.js
@@ -1,4 +1,5 @@
 //// [functionImplementations.ts]
+
 // FunctionExpression with no return type annotation and no return statement returns void
 var v: void = function () { } ();
 
diff --git a/tests/baselines/reference/functionImplementations.symbols b/tests/baselines/reference/functionImplementations.symbols
new file mode 100644
index 00000000000..07945b5f765
--- /dev/null
+++ b/tests/baselines/reference/functionImplementations.symbols
@@ -0,0 +1,345 @@
+=== tests/cases/conformance/functions/functionImplementations.ts ===
+
+// FunctionExpression with no return type annotation and no return statement returns void
+var v: void = function () { } ();
+>v : Symbol(v, Decl(functionImplementations.ts, 2, 3))
+
+// FunctionExpression f with no return type annotation and directly references f in its body returns any
+var a: any = function f() {
+>a : Symbol(a, Decl(functionImplementations.ts, 5, 3), Decl(functionImplementations.ts, 8, 3), Decl(functionImplementations.ts, 13, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 26, 3), Decl(functionImplementations.ts, 85, 3))
+>f : Symbol(f, Decl(functionImplementations.ts, 5, 12))
+
+    return f;
+>f : Symbol(f, Decl(functionImplementations.ts, 5, 12))
+
+};
+var a: any = function f() {
+>a : Symbol(a, Decl(functionImplementations.ts, 5, 3), Decl(functionImplementations.ts, 8, 3), Decl(functionImplementations.ts, 13, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 26, 3), Decl(functionImplementations.ts, 85, 3))
+>f : Symbol(f, Decl(functionImplementations.ts, 8, 12))
+
+    return f();
+>f : Symbol(f, Decl(functionImplementations.ts, 8, 12))
+
+};
+
+// FunctionExpression f with no return type annotation and indirectly references f in its body returns any
+var a: any = function f() {
+>a : Symbol(a, Decl(functionImplementations.ts, 5, 3), Decl(functionImplementations.ts, 8, 3), Decl(functionImplementations.ts, 13, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 26, 3), Decl(functionImplementations.ts, 85, 3))
+>f : Symbol(f, Decl(functionImplementations.ts, 13, 12))
+
+    var x = f;
+>x : Symbol(x, Decl(functionImplementations.ts, 14, 7))
+>f : Symbol(f, Decl(functionImplementations.ts, 13, 12))
+
+    return x;
+>x : Symbol(x, Decl(functionImplementations.ts, 14, 7))
+
+};
+
+// Two mutually recursive function implementations with no return type annotations
+function rec1() {
+>rec1 : Symbol(rec1, Decl(functionImplementations.ts, 16, 2))
+
+    return rec2();
+>rec2 : Symbol(rec2, Decl(functionImplementations.ts, 21, 1))
+}
+function rec2() {
+>rec2 : Symbol(rec2, Decl(functionImplementations.ts, 21, 1))
+
+    return rec1();
+>rec1 : Symbol(rec1, Decl(functionImplementations.ts, 16, 2))
+}
+var a = rec1();
+>a : Symbol(a, Decl(functionImplementations.ts, 5, 3), Decl(functionImplementations.ts, 8, 3), Decl(functionImplementations.ts, 13, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 26, 3), Decl(functionImplementations.ts, 85, 3))
+>rec1 : Symbol(rec1, Decl(functionImplementations.ts, 16, 2))
+
+var a = rec2();
+>a : Symbol(a, Decl(functionImplementations.ts, 5, 3), Decl(functionImplementations.ts, 8, 3), Decl(functionImplementations.ts, 13, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 26, 3), Decl(functionImplementations.ts, 85, 3))
+>rec2 : Symbol(rec2, Decl(functionImplementations.ts, 21, 1))
+
+// Two mutually recursive function implementations with return type annotation in one
+function rec3(): number {
+>rec3 : Symbol(rec3, Decl(functionImplementations.ts, 26, 15))
+
+    return rec4();
+>rec4 : Symbol(rec4, Decl(functionImplementations.ts, 31, 1))
+}
+function rec4() {
+>rec4 : Symbol(rec4, Decl(functionImplementations.ts, 31, 1))
+
+    return rec3();
+>rec3 : Symbol(rec3, Decl(functionImplementations.ts, 26, 15))
+}
+var n: number;
+>n : Symbol(n, Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 37, 3), Decl(functionImplementations.ts, 40, 3), Decl(functionImplementations.ts, 57, 3), Decl(functionImplementations.ts, 62, 3), Decl(functionImplementations.ts, 67, 3))
+
+var n = rec3();
+>n : Symbol(n, Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 37, 3), Decl(functionImplementations.ts, 40, 3), Decl(functionImplementations.ts, 57, 3), Decl(functionImplementations.ts, 62, 3), Decl(functionImplementations.ts, 67, 3))
+>rec3 : Symbol(rec3, Decl(functionImplementations.ts, 26, 15))
+
+var n = rec4();
+>n : Symbol(n, Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 37, 3), Decl(functionImplementations.ts, 40, 3), Decl(functionImplementations.ts, 57, 3), Decl(functionImplementations.ts, 62, 3), Decl(functionImplementations.ts, 67, 3))
+>rec4 : Symbol(rec4, Decl(functionImplementations.ts, 31, 1))
+
+// FunctionExpression with no return type annotation and returns a number
+var n = function () {
+>n : Symbol(n, Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 37, 3), Decl(functionImplementations.ts, 40, 3), Decl(functionImplementations.ts, 57, 3), Decl(functionImplementations.ts, 62, 3), Decl(functionImplementations.ts, 67, 3))
+
+    return 3;
+} ();
+
+// FunctionExpression with no return type annotation and returns null
+var nu = null;
+>nu : Symbol(nu, Decl(functionImplementations.ts, 45, 3), Decl(functionImplementations.ts, 46, 3))
+
+var nu = function () {
+>nu : Symbol(nu, Decl(functionImplementations.ts, 45, 3), Decl(functionImplementations.ts, 46, 3))
+
+    return null;
+} ();
+
+// FunctionExpression with no return type annotation and returns undefined
+var un = undefined;
+>un : Symbol(un, Decl(functionImplementations.ts, 51, 3), Decl(functionImplementations.ts, 52, 3))
+>undefined : Symbol(undefined)
+
+var un = function () {
+>un : Symbol(un, Decl(functionImplementations.ts, 51, 3), Decl(functionImplementations.ts, 52, 3))
+
+    return undefined;
+>undefined : Symbol(undefined)
+
+} ();
+
+// FunctionExpression with no return type annotation and returns a type parameter type
+var n = function <T>(x: T) {
+>n : Symbol(n, Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 37, 3), Decl(functionImplementations.ts, 40, 3), Decl(functionImplementations.ts, 57, 3), Decl(functionImplementations.ts, 62, 3), Decl(functionImplementations.ts, 67, 3))
+>T : Symbol(T, Decl(functionImplementations.ts, 57, 18))
+>x : Symbol(x, Decl(functionImplementations.ts, 57, 21))
+>T : Symbol(T, Decl(functionImplementations.ts, 57, 18))
+
+    return x;
+>x : Symbol(x, Decl(functionImplementations.ts, 57, 21))
+
+} (4);
+
+// FunctionExpression with no return type annotation and returns a constrained type parameter type
+var n = function <T extends {}>(x: T) {
+>n : Symbol(n, Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 37, 3), Decl(functionImplementations.ts, 40, 3), Decl(functionImplementations.ts, 57, 3), Decl(functionImplementations.ts, 62, 3), Decl(functionImplementations.ts, 67, 3))
+>T : Symbol(T, Decl(functionImplementations.ts, 62, 18))
+>x : Symbol(x, Decl(functionImplementations.ts, 62, 32))
+>T : Symbol(T, Decl(functionImplementations.ts, 62, 18))
+
+    return x;
+>x : Symbol(x, Decl(functionImplementations.ts, 62, 32))
+
+} (4);
+
+// FunctionExpression with no return type annotation with multiple return statements with identical types
+var n = function () {
+>n : Symbol(n, Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 37, 3), Decl(functionImplementations.ts, 40, 3), Decl(functionImplementations.ts, 57, 3), Decl(functionImplementations.ts, 62, 3), Decl(functionImplementations.ts, 67, 3))
+
+    return 3;
+    return 5;
+}();
+
+// Otherwise, the inferred return type is the first of the types of the return statement expressions
+// in the function body that is a supertype of each of the others, 
+// ignoring return statements with no expressions.
+// A compile - time error occurs if no return statement expression has a type that is a supertype of each of the others.
+// FunctionExpression with no return type annotation with multiple return statements with subtype relation between returns
+class Base { private m; }
+>Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4))
+>m : Symbol(m, Decl(functionImplementations.ts, 77, 12))
+
+class Derived extends Base { private q; }
+>Derived : Symbol(Derived, Decl(functionImplementations.ts, 77, 25))
+>Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4))
+>q : Symbol(q, Decl(functionImplementations.ts, 78, 28))
+
+var b: Base;
+>b : Symbol(b, Decl(functionImplementations.ts, 79, 3), Decl(functionImplementations.ts, 80, 3))
+>Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4))
+
+var b = function () {
+>b : Symbol(b, Decl(functionImplementations.ts, 79, 3), Decl(functionImplementations.ts, 80, 3))
+
+    return new Base(); return new Derived();
+>Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4))
+>Derived : Symbol(Derived, Decl(functionImplementations.ts, 77, 25))
+
+} ();
+
+// FunctionExpression with no return type annotation with multiple return statements with one a recursive call
+var a = function f() {
+>a : Symbol(a, Decl(functionImplementations.ts, 5, 3), Decl(functionImplementations.ts, 8, 3), Decl(functionImplementations.ts, 13, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 26, 3), Decl(functionImplementations.ts, 85, 3))
+>f : Symbol(f, Decl(functionImplementations.ts, 85, 7))
+
+    return new Base(); return new Derived(); return f(); // ?
+>Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4))
+>Derived : Symbol(Derived, Decl(functionImplementations.ts, 77, 25))
+>f : Symbol(f, Decl(functionImplementations.ts, 85, 7))
+
+} ();
+
+// FunctionExpression with non -void return type annotation with a single throw statement
+undefined === function (): number {
+>undefined : Symbol(undefined)
+
+    throw undefined;
+>undefined : Symbol(undefined)
+
+};
+
+// Type of 'this' in function implementation is 'any'
+function thisFunc() {
+>thisFunc : Symbol(thisFunc, Decl(functionImplementations.ts, 92, 2))
+
+    var x = this;
+>x : Symbol(x, Decl(functionImplementations.ts, 96, 7), Decl(functionImplementations.ts, 97, 7))
+
+    var x: any;
+>x : Symbol(x, Decl(functionImplementations.ts, 96, 7), Decl(functionImplementations.ts, 97, 7))
+}
+
+// Function signature with optional parameter, no type annotation and initializer has initializer's type
+function opt1(n = 4) {
+>opt1 : Symbol(opt1, Decl(functionImplementations.ts, 98, 1))
+>n : Symbol(n, Decl(functionImplementations.ts, 101, 14))
+
+    var m = n;
+>m : Symbol(m, Decl(functionImplementations.ts, 102, 7), Decl(functionImplementations.ts, 103, 7))
+>n : Symbol(n, Decl(functionImplementations.ts, 101, 14))
+
+    var m: number;
+>m : Symbol(m, Decl(functionImplementations.ts, 102, 7), Decl(functionImplementations.ts, 103, 7))
+}
+
+// Function signature with optional parameter, no type annotation and initializer has initializer's widened type
+function opt2(n = { x: null, y: undefined }) {
+>opt2 : Symbol(opt2, Decl(functionImplementations.ts, 104, 1))
+>n : Symbol(n, Decl(functionImplementations.ts, 107, 14))
+>x : Symbol(x, Decl(functionImplementations.ts, 107, 19))
+>y : Symbol(y, Decl(functionImplementations.ts, 107, 28))
+>undefined : Symbol(undefined)
+
+    var m = n;
+>m : Symbol(m, Decl(functionImplementations.ts, 108, 7), Decl(functionImplementations.ts, 109, 7))
+>n : Symbol(n, Decl(functionImplementations.ts, 107, 14))
+
+    var m: { x: any; y: any };
+>m : Symbol(m, Decl(functionImplementations.ts, 108, 7), Decl(functionImplementations.ts, 109, 7))
+>x : Symbol(x, Decl(functionImplementations.ts, 109, 12))
+>y : Symbol(y, Decl(functionImplementations.ts, 109, 20))
+}
+
+// Function signature with initializer referencing other parameter to the left
+function opt3(n: number, m = n) {
+>opt3 : Symbol(opt3, Decl(functionImplementations.ts, 110, 1))
+>n : Symbol(n, Decl(functionImplementations.ts, 113, 14))
+>m : Symbol(m, Decl(functionImplementations.ts, 113, 24))
+>n : Symbol(n, Decl(functionImplementations.ts, 113, 14))
+
+    var y = m;
+>y : Symbol(y, Decl(functionImplementations.ts, 114, 7), Decl(functionImplementations.ts, 115, 7))
+>m : Symbol(m, Decl(functionImplementations.ts, 113, 24))
+
+    var y: number;
+>y : Symbol(y, Decl(functionImplementations.ts, 114, 7), Decl(functionImplementations.ts, 115, 7))
+}
+
+// Function signature with optional parameter has correct codegen 
+// (tested above)
+
+// FunctionExpression with non -void return type annotation return with no expression
+function f6(): number {
+>f6 : Symbol(f6, Decl(functionImplementations.ts, 116, 1))
+
+    return;
+}
+
+class Derived2 extends Base { private r: string; }
+>Derived2 : Symbol(Derived2, Decl(functionImplementations.ts, 124, 1))
+>Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4))
+>r : Symbol(r, Decl(functionImplementations.ts, 126, 29))
+
+class AnotherClass { private x }
+>AnotherClass : Symbol(AnotherClass, Decl(functionImplementations.ts, 126, 50))
+>x : Symbol(x, Decl(functionImplementations.ts, 127, 20))
+
+// if f is a contextually typed function expression, the inferred return type is the union type
+// of the types of the return statement expressions in the function body, 
+// ignoring return statements with no expressions.
+var f7: (x: number) => string | number = x => { // should be (x: number) => number | string
+>f7 : Symbol(f7, Decl(functionImplementations.ts, 131, 3))
+>x : Symbol(x, Decl(functionImplementations.ts, 131, 9))
+>x : Symbol(x, Decl(functionImplementations.ts, 131, 40))
+
+    if (x < 0) { return x; }
+>x : Symbol(x, Decl(functionImplementations.ts, 131, 40))
+>x : Symbol(x, Decl(functionImplementations.ts, 131, 40))
+
+    return x.toString();
+>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+>x : Symbol(x, Decl(functionImplementations.ts, 131, 40))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+}
+var f8: (x: number) => any = x => { // should be (x: number) => Base
+>f8 : Symbol(f8, Decl(functionImplementations.ts, 135, 3))
+>x : Symbol(x, Decl(functionImplementations.ts, 135, 9))
+>x : Symbol(x, Decl(functionImplementations.ts, 135, 28))
+
+    return new Base();
+>Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4))
+
+    return new Derived2();
+>Derived2 : Symbol(Derived2, Decl(functionImplementations.ts, 124, 1))
+}
+var f9: (x: number) => any = x => { // should be (x: number) => Base
+>f9 : Symbol(f9, Decl(functionImplementations.ts, 139, 3))
+>x : Symbol(x, Decl(functionImplementations.ts, 139, 9))
+>x : Symbol(x, Decl(functionImplementations.ts, 139, 28))
+
+    return new Base();
+>Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4))
+
+    return new Derived();
+>Derived : Symbol(Derived, Decl(functionImplementations.ts, 77, 25))
+
+    return new Derived2();
+>Derived2 : Symbol(Derived2, Decl(functionImplementations.ts, 124, 1))
+}
+var f10: (x: number) => any = x => { // should be (x: number) => Derived | Derived1
+>f10 : Symbol(f10, Decl(functionImplementations.ts, 144, 3))
+>x : Symbol(x, Decl(functionImplementations.ts, 144, 10))
+>x : Symbol(x, Decl(functionImplementations.ts, 144, 29))
+
+    return new Derived();
+>Derived : Symbol(Derived, Decl(functionImplementations.ts, 77, 25))
+
+    return new Derived2();
+>Derived2 : Symbol(Derived2, Decl(functionImplementations.ts, 124, 1))
+}
+var f11: (x: number) => any = x => { // should be (x: number) => Base | AnotherClass
+>f11 : Symbol(f11, Decl(functionImplementations.ts, 148, 3))
+>x : Symbol(x, Decl(functionImplementations.ts, 148, 10))
+>x : Symbol(x, Decl(functionImplementations.ts, 148, 29))
+
+    return new Base();
+>Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4))
+
+    return new AnotherClass();
+>AnotherClass : Symbol(AnotherClass, Decl(functionImplementations.ts, 126, 50))
+}
+var f12: (x: number) => any = x => { // should be (x: number) => Base | AnotherClass
+>f12 : Symbol(f12, Decl(functionImplementations.ts, 152, 3))
+>x : Symbol(x, Decl(functionImplementations.ts, 152, 10))
+>x : Symbol(x, Decl(functionImplementations.ts, 152, 29))
+
+    return new Base();
+>Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4))
+
+    return; // should be ignored
+    return new AnotherClass();
+>AnotherClass : Symbol(AnotherClass, Decl(functionImplementations.ts, 126, 50))
+}
diff --git a/tests/baselines/reference/functionImplementations.types b/tests/baselines/reference/functionImplementations.types
new file mode 100644
index 00000000000..6690ca68c98
--- /dev/null
+++ b/tests/baselines/reference/functionImplementations.types
@@ -0,0 +1,417 @@
+=== tests/cases/conformance/functions/functionImplementations.ts ===
+
+// FunctionExpression with no return type annotation and no return statement returns void
+var v: void = function () { } ();
+>v : void
+>function () { } () : void
+>function () { } : () => void
+
+// FunctionExpression f with no return type annotation and directly references f in its body returns any
+var a: any = function f() {
+>a : any
+>function f() {    return f;} : () => any
+>f : () => any
+
+    return f;
+>f : () => any
+
+};
+var a: any = function f() {
+>a : any
+>function f() {    return f();} : () => any
+>f : () => any
+
+    return f();
+>f() : any
+>f : () => any
+
+};
+
+// FunctionExpression f with no return type annotation and indirectly references f in its body returns any
+var a: any = function f() {
+>a : any
+>function f() {    var x = f;    return x;} : () => any
+>f : () => any
+
+    var x = f;
+>x : () => any
+>f : () => any
+
+    return x;
+>x : () => any
+
+};
+
+// Two mutually recursive function implementations with no return type annotations
+function rec1() {
+>rec1 : () => any
+
+    return rec2();
+>rec2() : any
+>rec2 : () => any
+}
+function rec2() {
+>rec2 : () => any
+
+    return rec1();
+>rec1() : any
+>rec1 : () => any
+}
+var a = rec1();
+>a : any
+>rec1() : any
+>rec1 : () => any
+
+var a = rec2();
+>a : any
+>rec2() : any
+>rec2 : () => any
+
+// Two mutually recursive function implementations with return type annotation in one
+function rec3(): number {
+>rec3 : () => number
+
+    return rec4();
+>rec4() : number
+>rec4 : () => number
+}
+function rec4() {
+>rec4 : () => number
+
+    return rec3();
+>rec3() : number
+>rec3 : () => number
+}
+var n: number;
+>n : number
+
+var n = rec3();
+>n : number
+>rec3() : number
+>rec3 : () => number
+
+var n = rec4();
+>n : number
+>rec4() : number
+>rec4 : () => number
+
+// FunctionExpression with no return type annotation and returns a number
+var n = function () {
+>n : number
+>function () {    return 3;} () : number
+>function () {    return 3;} : () => number
+
+    return 3;
+>3 : number
+
+} ();
+
+// FunctionExpression with no return type annotation and returns null
+var nu = null;
+>nu : any
+>null : null
+
+var nu = function () {
+>nu : any
+>function () {    return null;} () : any
+>function () {    return null;} : () => any
+
+    return null;
+>null : null
+
+} ();
+
+// FunctionExpression with no return type annotation and returns undefined
+var un = undefined;
+>un : any
+>undefined : undefined
+
+var un = function () {
+>un : any
+>function () {    return undefined;} () : any
+>function () {    return undefined;} : () => any
+
+    return undefined;
+>undefined : undefined
+
+} ();
+
+// FunctionExpression with no return type annotation and returns a type parameter type
+var n = function <T>(x: T) {
+>n : number
+>function <T>(x: T) {    return x;} (4) : number
+>function <T>(x: T) {    return x;} : <T>(x: T) => T
+>T : T
+>x : T
+>T : T
+
+    return x;
+>x : T
+
+} (4);
+>4 : number
+
+// FunctionExpression with no return type annotation and returns a constrained type parameter type
+var n = function <T extends {}>(x: T) {
+>n : number
+>function <T extends {}>(x: T) {    return x;} (4) : number
+>function <T extends {}>(x: T) {    return x;} : <T extends {}>(x: T) => T
+>T : T
+>x : T
+>T : T
+
+    return x;
+>x : T
+
+} (4);
+>4 : number
+
+// FunctionExpression with no return type annotation with multiple return statements with identical types
+var n = function () {
+>n : number
+>function () {    return 3;    return 5;}() : number
+>function () {    return 3;    return 5;} : () => number
+
+    return 3;
+>3 : number
+
+    return 5;
+>5 : number
+
+}();
+
+// Otherwise, the inferred return type is the first of the types of the return statement expressions
+// in the function body that is a supertype of each of the others, 
+// ignoring return statements with no expressions.
+// A compile - time error occurs if no return statement expression has a type that is a supertype of each of the others.
+// FunctionExpression with no return type annotation with multiple return statements with subtype relation between returns
+class Base { private m; }
+>Base : Base
+>m : any
+
+class Derived extends Base { private q; }
+>Derived : Derived
+>Base : Base
+>q : any
+
+var b: Base;
+>b : Base
+>Base : Base
+
+var b = function () {
+>b : Base
+>function () {    return new Base(); return new Derived();} () : Base
+>function () {    return new Base(); return new Derived();} : () => Base
+
+    return new Base(); return new Derived();
+>new Base() : Base
+>Base : typeof Base
+>new Derived() : Derived
+>Derived : typeof Derived
+
+} ();
+
+// FunctionExpression with no return type annotation with multiple return statements with one a recursive call
+var a = function f() {
+>a : any
+>function f() {    return new Base(); return new Derived(); return f(); // ?} () : any
+>function f() {    return new Base(); return new Derived(); return f(); // ?} : () => any
+>f : () => any
+
+    return new Base(); return new Derived(); return f(); // ?
+>new Base() : Base
+>Base : typeof Base
+>new Derived() : Derived
+>Derived : typeof Derived
+>f() : any
+>f : () => any
+
+} ();
+
+// FunctionExpression with non -void return type annotation with a single throw statement
+undefined === function (): number {
+>undefined === function (): number {    throw undefined;} : boolean
+>undefined : undefined
+>function (): number {    throw undefined;} : () => number
+
+    throw undefined;
+>undefined : undefined
+
+};
+
+// Type of 'this' in function implementation is 'any'
+function thisFunc() {
+>thisFunc : () => void
+
+    var x = this;
+>x : any
+>this : any
+
+    var x: any;
+>x : any
+}
+
+// Function signature with optional parameter, no type annotation and initializer has initializer's type
+function opt1(n = 4) {
+>opt1 : (n?: number) => void
+>n : number
+>4 : number
+
+    var m = n;
+>m : number
+>n : number
+
+    var m: number;
+>m : number
+}
+
+// Function signature with optional parameter, no type annotation and initializer has initializer's widened type
+function opt2(n = { x: null, y: undefined }) {
+>opt2 : (n?: { x: any; y: any; }) => void
+>n : { x: any; y: any; }
+>{ x: null, y: undefined } : { x: null; y: undefined; }
+>x : null
+>null : null
+>y : undefined
+>undefined : undefined
+
+    var m = n;
+>m : { x: any; y: any; }
+>n : { x: any; y: any; }
+
+    var m: { x: any; y: any };
+>m : { x: any; y: any; }
+>x : any
+>y : any
+}
+
+// Function signature with initializer referencing other parameter to the left
+function opt3(n: number, m = n) {
+>opt3 : (n: number, m?: number) => void
+>n : number
+>m : number
+>n : number
+
+    var y = m;
+>y : number
+>m : number
+
+    var y: number;
+>y : number
+}
+
+// Function signature with optional parameter has correct codegen 
+// (tested above)
+
+// FunctionExpression with non -void return type annotation return with no expression
+function f6(): number {
+>f6 : () => number
+
+    return;
+}
+
+class Derived2 extends Base { private r: string; }
+>Derived2 : Derived2
+>Base : Base
+>r : string
+
+class AnotherClass { private x }
+>AnotherClass : AnotherClass
+>x : any
+
+// if f is a contextually typed function expression, the inferred return type is the union type
+// of the types of the return statement expressions in the function body, 
+// ignoring return statements with no expressions.
+var f7: (x: number) => string | number = x => { // should be (x: number) => number | string
+>f7 : (x: number) => string | number
+>x : number
+>x => { // should be (x: number) => number | string    if (x < 0) { return x; }    return x.toString();} : (x: number) => number | string
+>x : number
+
+    if (x < 0) { return x; }
+>x < 0 : boolean
+>x : number
+>0 : number
+>x : number
+
+    return x.toString();
+>x.toString() : string
+>x.toString : (radix?: number) => string
+>x : number
+>toString : (radix?: number) => string
+}
+var f8: (x: number) => any = x => { // should be (x: number) => Base
+>f8 : (x: number) => any
+>x : number
+>x => { // should be (x: number) => Base    return new Base();    return new Derived2();} : (x: number) => Base
+>x : number
+
+    return new Base();
+>new Base() : Base
+>Base : typeof Base
+
+    return new Derived2();
+>new Derived2() : Derived2
+>Derived2 : typeof Derived2
+}
+var f9: (x: number) => any = x => { // should be (x: number) => Base
+>f9 : (x: number) => any
+>x : number
+>x => { // should be (x: number) => Base    return new Base();    return new Derived();    return new Derived2();} : (x: number) => Base
+>x : number
+
+    return new Base();
+>new Base() : Base
+>Base : typeof Base
+
+    return new Derived();
+>new Derived() : Derived
+>Derived : typeof Derived
+
+    return new Derived2();
+>new Derived2() : Derived2
+>Derived2 : typeof Derived2
+}
+var f10: (x: number) => any = x => { // should be (x: number) => Derived | Derived1
+>f10 : (x: number) => any
+>x : number
+>x => { // should be (x: number) => Derived | Derived1    return new Derived();    return new Derived2();} : (x: number) => Derived | Derived2
+>x : number
+
+    return new Derived();
+>new Derived() : Derived
+>Derived : typeof Derived
+
+    return new Derived2();
+>new Derived2() : Derived2
+>Derived2 : typeof Derived2
+}
+var f11: (x: number) => any = x => { // should be (x: number) => Base | AnotherClass
+>f11 : (x: number) => any
+>x : number
+>x => { // should be (x: number) => Base | AnotherClass    return new Base();    return new AnotherClass();} : (x: number) => Base | AnotherClass
+>x : number
+
+    return new Base();
+>new Base() : Base
+>Base : typeof Base
+
+    return new AnotherClass();
+>new AnotherClass() : AnotherClass
+>AnotherClass : typeof AnotherClass
+}
+var f12: (x: number) => any = x => { // should be (x: number) => Base | AnotherClass
+>f12 : (x: number) => any
+>x : number
+>x => { // should be (x: number) => Base | AnotherClass    return new Base();    return; // should be ignored    return new AnotherClass();} : (x: number) => Base | AnotherClass
+>x : number
+
+    return new Base();
+>new Base() : Base
+>Base : typeof Base
+
+    return; // should be ignored
+    return new AnotherClass();
+>new AnotherClass() : AnotherClass
+>AnotherClass : typeof AnotherClass
+}
diff --git a/tests/baselines/reference/functionOverloads12.errors.txt b/tests/baselines/reference/functionOverloads12.errors.txt
deleted file mode 100644
index fac5cd71afe..00000000000
--- a/tests/baselines/reference/functionOverloads12.errors.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-tests/cases/compiler/functionOverloads12.ts(3,48): error TS7027: Unreachable code detected.
-
-
-==== tests/cases/compiler/functionOverloads12.ts (1 errors) ====
-    function foo():string;
-    function foo():number;
-    function foo():any { if (true) return ""; else return 0;}
-                                                   ~~~~~~
-!!! error TS7027: Unreachable code detected.
-    
\ No newline at end of file
diff --git a/tests/baselines/reference/functionOverloads12.js b/tests/baselines/reference/functionOverloads12.js
index 4681e43ee5b..8d834e8180f 100644
--- a/tests/baselines/reference/functionOverloads12.js
+++ b/tests/baselines/reference/functionOverloads12.js
@@ -1,4 +1,5 @@
 //// [functionOverloads12.ts]
+
 function foo():string;
 function foo():number;
 function foo():any { if (true) return ""; else return 0;}
diff --git a/tests/baselines/reference/functionOverloads12.symbols b/tests/baselines/reference/functionOverloads12.symbols
new file mode 100644
index 00000000000..4744f98c9f2
--- /dev/null
+++ b/tests/baselines/reference/functionOverloads12.symbols
@@ -0,0 +1,11 @@
+=== tests/cases/compiler/functionOverloads12.ts ===
+
+function foo():string;
+>foo : Symbol(foo, Decl(functionOverloads12.ts, 0, 0), Decl(functionOverloads12.ts, 1, 22), Decl(functionOverloads12.ts, 2, 22))
+
+function foo():number;
+>foo : Symbol(foo, Decl(functionOverloads12.ts, 0, 0), Decl(functionOverloads12.ts, 1, 22), Decl(functionOverloads12.ts, 2, 22))
+
+function foo():any { if (true) return ""; else return 0;}
+>foo : Symbol(foo, Decl(functionOverloads12.ts, 0, 0), Decl(functionOverloads12.ts, 1, 22), Decl(functionOverloads12.ts, 2, 22))
+
diff --git a/tests/baselines/reference/functionOverloads12.types b/tests/baselines/reference/functionOverloads12.types
new file mode 100644
index 00000000000..5db8ff68cd4
--- /dev/null
+++ b/tests/baselines/reference/functionOverloads12.types
@@ -0,0 +1,14 @@
+=== tests/cases/compiler/functionOverloads12.ts ===
+
+function foo():string;
+>foo : { (): string; (): number; }
+
+function foo():number;
+>foo : { (): string; (): number; }
+
+function foo():any { if (true) return ""; else return 0;}
+>foo : { (): string; (): number; }
+>true : boolean
+>"" : string
+>0 : number
+
diff --git a/tests/baselines/reference/functionReturn.errors.txt b/tests/baselines/reference/functionReturn.errors.txt
deleted file mode 100644
index d5f78b2534d..00000000000
--- a/tests/baselines/reference/functionReturn.errors.txt
+++ /dev/null
@@ -1,23 +0,0 @@
-tests/cases/compiler/functionReturn.ts(9,5): error TS7027: Unreachable code detected.
-tests/cases/compiler/functionReturn.ts(13,5): error TS7027: Unreachable code detected.
-
-
-==== tests/cases/compiler/functionReturn.ts (2 errors) ====
-    function f0(): void { }
-    function f1() {
-        var n: any = f0();
-    }
-    function f2(): any { }
-    function f3(): string { return; }
-    function f4(): string {
-        return '';
-        return;
-        ~~~~~~
-!!! error TS7027: Unreachable code detected.
-    }
-    function f5(): string {
-        return '';
-        return undefined;
-        ~~~~~~
-!!! error TS7027: Unreachable code detected.
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/functionReturn.js b/tests/baselines/reference/functionReturn.js
index c433eec190d..42d0de5fd7c 100644
--- a/tests/baselines/reference/functionReturn.js
+++ b/tests/baselines/reference/functionReturn.js
@@ -1,4 +1,5 @@
 //// [functionReturn.ts]
+
 function f0(): void { }
 function f1() {
     var n: any = f0();
diff --git a/tests/baselines/reference/functionReturn.symbols b/tests/baselines/reference/functionReturn.symbols
new file mode 100644
index 00000000000..630e435635b
--- /dev/null
+++ b/tests/baselines/reference/functionReturn.symbols
@@ -0,0 +1,31 @@
+=== tests/cases/compiler/functionReturn.ts ===
+
+function f0(): void { }
+>f0 : Symbol(f0, Decl(functionReturn.ts, 0, 0))
+
+function f1() {
+>f1 : Symbol(f1, Decl(functionReturn.ts, 1, 23))
+
+    var n: any = f0();
+>n : Symbol(n, Decl(functionReturn.ts, 3, 7))
+>f0 : Symbol(f0, Decl(functionReturn.ts, 0, 0))
+}
+function f2(): any { }
+>f2 : Symbol(f2, Decl(functionReturn.ts, 4, 1))
+
+function f3(): string { return; }
+>f3 : Symbol(f3, Decl(functionReturn.ts, 5, 22))
+
+function f4(): string {
+>f4 : Symbol(f4, Decl(functionReturn.ts, 6, 33))
+
+    return '';
+    return;
+}
+function f5(): string {
+>f5 : Symbol(f5, Decl(functionReturn.ts, 10, 1))
+
+    return '';
+    return undefined;
+>undefined : Symbol(undefined)
+}
diff --git a/tests/baselines/reference/functionReturn.types b/tests/baselines/reference/functionReturn.types
new file mode 100644
index 00000000000..f9c0b36fbc2
--- /dev/null
+++ b/tests/baselines/reference/functionReturn.types
@@ -0,0 +1,36 @@
+=== tests/cases/compiler/functionReturn.ts ===
+
+function f0(): void { }
+>f0 : () => void
+
+function f1() {
+>f1 : () => void
+
+    var n: any = f0();
+>n : any
+>f0() : void
+>f0 : () => void
+}
+function f2(): any { }
+>f2 : () => any
+
+function f3(): string { return; }
+>f3 : () => string
+
+function f4(): string {
+>f4 : () => string
+
+    return '';
+>'' : string
+
+    return;
+}
+function f5(): string {
+>f5 : () => string
+
+    return '';
+>'' : string
+
+    return undefined;
+>undefined : undefined
+}
diff --git a/tests/baselines/reference/functionWithMultipleReturnStatements.errors.txt b/tests/baselines/reference/functionWithMultipleReturnStatements.errors.txt
index 4c21fc6814c..a981d337093 100644
--- a/tests/baselines/reference/functionWithMultipleReturnStatements.errors.txt
+++ b/tests/baselines/reference/functionWithMultipleReturnStatements.errors.txt
@@ -1,20 +1,16 @@
-tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(4,10): error TS2354: No best common type exists among return expressions.
-tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(8,9): error TS7027: Unreachable code detected.
-tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(12,10): error TS2354: No best common type exists among return expressions.
-tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(15,12): error TS7027: Unreachable code detected.
-tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(22,10): error TS2354: No best common type exists among return expressions.
-tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(31,10): error TS2354: No best common type exists among return expressions.
-tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(43,10): error TS2354: No best common type exists among return expressions.
-tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(45,5): error TS7027: Unreachable code detected.
-tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(48,10): error TS2354: No best common type exists among return expressions.
-tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(52,9): error TS7027: Unreachable code detected.
-tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(56,10): error TS2354: No best common type exists among return expressions.
-tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(56,13): error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
-tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(56,26): error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
-tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(60,9): error TS7027: Unreachable code detected.
+tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(5,10): error TS2354: No best common type exists among return expressions.
+tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(13,10): error TS2354: No best common type exists among return expressions.
+tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(23,10): error TS2354: No best common type exists among return expressions.
+tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(32,10): error TS2354: No best common type exists among return expressions.
+tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(44,10): error TS2354: No best common type exists among return expressions.
+tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(49,10): error TS2354: No best common type exists among return expressions.
+tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(57,10): error TS2354: No best common type exists among return expressions.
+tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(57,13): error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
+tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(57,26): error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
 
 
-==== tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts (14 errors) ====
+==== tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts (9 errors) ====
+    
     // return type of a function with multiple returns is the BCT of each return statement
     // it is an error if there is no single BCT, these are error cases
     
@@ -25,8 +21,6 @@ tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMulti
             return 1;
         } else {
             return '';
-            ~~~~~~
-!!! error TS7027: Unreachable code detected.
         }
     }
     
@@ -36,8 +30,6 @@ tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMulti
         if (true) {
             return 1;
         } else if (false) {
-               ~~
-!!! error TS7027: Unreachable code detected.
             return 2;
         } else {
             return '';
@@ -74,8 +66,6 @@ tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMulti
 !!! error TS2354: No best common type exists among return expressions.
         return 1;
         return '';
-        ~~~~~~
-!!! error TS7027: Unreachable code detected.
     }
     
     function f6<T, U>(x: T, y:U) {
@@ -85,8 +75,6 @@ tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMulti
             return x;
         } else {
             return y;
-            ~~~~~~
-!!! error TS7027: Unreachable code detected.
         }
     }
     
@@ -101,8 +89,6 @@ tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMulti
             return x;
         } else {
             return y;
-            ~~~~~~
-!!! error TS7027: Unreachable code detected.
         }
     }
     
\ No newline at end of file
diff --git a/tests/baselines/reference/functionWithMultipleReturnStatements.js b/tests/baselines/reference/functionWithMultipleReturnStatements.js
index 347a05d0f33..d44c37ebbf0 100644
--- a/tests/baselines/reference/functionWithMultipleReturnStatements.js
+++ b/tests/baselines/reference/functionWithMultipleReturnStatements.js
@@ -1,4 +1,5 @@
 //// [functionWithMultipleReturnStatements.ts]
+
 // return type of a function with multiple returns is the BCT of each return statement
 // it is an error if there is no single BCT, these are error cases
 
diff --git a/tests/baselines/reference/functionWithMultipleReturnStatements2.errors.txt b/tests/baselines/reference/functionWithMultipleReturnStatements2.errors.txt
index a965a1a9a99..0399c7a79a6 100644
--- a/tests/baselines/reference/functionWithMultipleReturnStatements2.errors.txt
+++ b/tests/baselines/reference/functionWithMultipleReturnStatements2.errors.txt
@@ -1,16 +1,9 @@
-tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts(8,9): error TS7027: Unreachable code detected.
-tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts(15,12): error TS7027: Unreachable code detected.
-tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts(36,5): error TS7027: Unreachable code detected.
-tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts(43,9): error TS7027: Unreachable code detected.
-tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts(58,10): error TS2354: No best common type exists among return expressions.
-tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts(62,9): error TS7027: Unreachable code detected.
-tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts(67,10): error TS2354: No best common type exists among return expressions.
-tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts(71,9): error TS7027: Unreachable code detected.
-tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts(80,9): error TS7027: Unreachable code detected.
-tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts(89,9): error TS7027: Unreachable code detected.
+tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts(59,10): error TS2354: No best common type exists among return expressions.
+tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts(68,10): error TS2354: No best common type exists among return expressions.
 
 
-==== tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts (10 errors) ====
+==== tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts (2 errors) ====
+    
     // return type of a function with multiple returns is the BCT of each return statement
     // no errors expected here
     
@@ -19,8 +12,6 @@ tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMulti
             return 1;
         } else {
             return null;
-            ~~~~~~
-!!! error TS7027: Unreachable code detected.
         }
     }
     
@@ -28,8 +19,6 @@ tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMulti
         if (true) {
             return 1;
         } else if (false) {
-               ~~
-!!! error TS7027: Unreachable code detected.
             return null;
         } else {
             return 2;
@@ -51,8 +40,6 @@ tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMulti
     function f5() {
         return 1;
         return new Object();
-        ~~~~~~
-!!! error TS7027: Unreachable code detected.
     }
     
     function f6<T>(x: T) {
@@ -60,8 +47,6 @@ tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMulti
             return x;
         } else {
             return null;
-            ~~~~~~
-!!! error TS7027: Unreachable code detected.
         }
     }
     
@@ -83,8 +68,6 @@ tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMulti
             return a;
         } else {
             return b;
-            ~~~~~~
-!!! error TS7027: Unreachable code detected.
         }
     }
     
@@ -96,8 +79,6 @@ tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMulti
             return b;
         } else {
             return a;
-            ~~~~~~
-!!! error TS7027: Unreachable code detected.
         }
     }
     
@@ -107,8 +88,6 @@ tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMulti
             return (x: number) => { }
         } else {
             return (x: Object) => { }
-            ~~~~~~
-!!! error TS7027: Unreachable code detected.
         }
     }
     
@@ -118,7 +97,5 @@ tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMulti
             return (x: Object) => { }
         } else {
             return (x: number) => { }        
-            ~~~~~~
-!!! error TS7027: Unreachable code detected.
         }
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/functionWithMultipleReturnStatements2.js b/tests/baselines/reference/functionWithMultipleReturnStatements2.js
index 4674c6db953..efee5816fb6 100644
--- a/tests/baselines/reference/functionWithMultipleReturnStatements2.js
+++ b/tests/baselines/reference/functionWithMultipleReturnStatements2.js
@@ -1,4 +1,5 @@
 //// [functionWithMultipleReturnStatements2.ts]
+
 // return type of a function with multiple returns is the BCT of each return statement
 // no errors expected here
 
diff --git a/tests/baselines/reference/functionWithNoBestCommonType1.errors.txt b/tests/baselines/reference/functionWithNoBestCommonType1.errors.txt
index 4cc440ee397..86234b7dd81 100644
--- a/tests/baselines/reference/functionWithNoBestCommonType1.errors.txt
+++ b/tests/baselines/reference/functionWithNoBestCommonType1.errors.txt
@@ -1,15 +1,13 @@
-tests/cases/compiler/functionWithNoBestCommonType1.ts(1,10): error TS2354: No best common type exists among return expressions.
-tests/cases/compiler/functionWithNoBestCommonType1.ts(3,5): error TS7027: Unreachable code detected.
+tests/cases/compiler/functionWithNoBestCommonType1.ts(2,10): error TS2354: No best common type exists among return expressions.
 
 
-==== tests/cases/compiler/functionWithNoBestCommonType1.ts (2 errors) ====
+==== tests/cases/compiler/functionWithNoBestCommonType1.ts (1 errors) ====
+    
     function foo() {
              ~~~
 !!! error TS2354: No best common type exists among return expressions.
         return true;
         return bar();
-        ~~~~~~
-!!! error TS7027: Unreachable code detected.
     }
     
     function bar(): void {
diff --git a/tests/baselines/reference/functionWithNoBestCommonType1.js b/tests/baselines/reference/functionWithNoBestCommonType1.js
index f7114fb40d8..4d197c24334 100644
--- a/tests/baselines/reference/functionWithNoBestCommonType1.js
+++ b/tests/baselines/reference/functionWithNoBestCommonType1.js
@@ -1,4 +1,5 @@
 //// [functionWithNoBestCommonType1.ts]
+
 function foo() {
     return true;
     return bar();
diff --git a/tests/baselines/reference/functionWithNoBestCommonType2.errors.txt b/tests/baselines/reference/functionWithNoBestCommonType2.errors.txt
index a93161b27b8..6ce898e447c 100644
--- a/tests/baselines/reference/functionWithNoBestCommonType2.errors.txt
+++ b/tests/baselines/reference/functionWithNoBestCommonType2.errors.txt
@@ -1,15 +1,13 @@
-tests/cases/compiler/functionWithNoBestCommonType2.ts(1,9): error TS2354: No best common type exists among return expressions.
-tests/cases/compiler/functionWithNoBestCommonType2.ts(3,4): error TS7027: Unreachable code detected.
+tests/cases/compiler/functionWithNoBestCommonType2.ts(2,9): error TS2354: No best common type exists among return expressions.
 
 
-==== tests/cases/compiler/functionWithNoBestCommonType2.ts (2 errors) ====
+==== tests/cases/compiler/functionWithNoBestCommonType2.ts (1 errors) ====
+    
     var v = function () {
             ~~~~~~~~
 !!! error TS2354: No best common type exists among return expressions.
        return true;
        return bar();
-       ~~~~~~
-!!! error TS7027: Unreachable code detected.
     };
     
     function bar(): void {
diff --git a/tests/baselines/reference/functionWithNoBestCommonType2.js b/tests/baselines/reference/functionWithNoBestCommonType2.js
index 8e903518ec0..06a133b2db8 100644
--- a/tests/baselines/reference/functionWithNoBestCommonType2.js
+++ b/tests/baselines/reference/functionWithNoBestCommonType2.js
@@ -1,4 +1,5 @@
 //// [functionWithNoBestCommonType2.ts]
+
 var v = function () {
    return true;
    return bar();
diff --git a/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.errors.txt b/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.errors.txt
index 3a128de4cee..58ffd051d4d 100644
--- a/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.errors.txt
+++ b/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.errors.txt
@@ -1,12 +1,10 @@
-tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(2,16): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
-tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(68,5): error TS7027: Unreachable code detected.
-tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(74,5): error TS7027: Unreachable code detected.
-tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(94,16): error TS2378: A 'get' accessor must return a value.
-tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(116,9): error TS7027: Unreachable code detected.
-tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(117,5): error TS1003: Identifier expected.
+tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(3,16): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
+tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(95,16): error TS2378: A 'get' accessor must return a value.
+tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(118,5): error TS1003: Identifier expected.
 
 
-==== tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts (6 errors) ====
+==== tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts (3 errors) ====
+    
     
     function f1(): string {
                    ~~~~~~
@@ -77,16 +75,12 @@ tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(117,5): e
         // if no return statements are present but we are annotated.
         throw undefined;
         throw null;
-        ~~~~~
-!!! error TS7027: Unreachable code detected.
     }
     
     function f15(): number {
         // Fine, since we have a return statement somewhere.
         throw undefined;
         throw null;
-        ~~~~~
-!!! error TS7027: Unreachable code detected.
         return;
     }
     
@@ -131,8 +125,6 @@ tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(117,5): e
             // if no return statements are present but we are a get accessor.
             throw null;
             throw undefined.
-            ~~~~~
-!!! error TS7027: Unreachable code detected.
         }
         ~
 !!! error TS1003: Identifier expected.
diff --git a/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.js b/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.js
index 592a03d7158..f76e5342aee 100644
--- a/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.js
+++ b/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.js
@@ -1,5 +1,6 @@
 //// [functionsMissingReturnStatementsAndExpressions.ts]
 
+
 function f1(): string {
     // errors because there are no return statements
 }
diff --git a/tests/baselines/reference/generatedContextualTyping.errors.txt b/tests/baselines/reference/generatedContextualTyping.errors.txt
deleted file mode 100644
index a2f95cdcb23..00000000000
--- a/tests/baselines/reference/generatedContextualTyping.errors.txt
+++ /dev/null
@@ -1,393 +0,0 @@
-tests/cases/conformance/expressions/contextualTyping/generatedContextualTyping.ts(150,56): error TS7027: Unreachable code detected.
-tests/cases/conformance/expressions/contextualTyping/generatedContextualTyping.ts(151,72): error TS7027: Unreachable code detected.
-tests/cases/conformance/expressions/contextualTyping/generatedContextualTyping.ts(152,78): error TS7027: Unreachable code detected.
-tests/cases/conformance/expressions/contextualTyping/generatedContextualTyping.ts(153,59): error TS7027: Unreachable code detected.
-tests/cases/conformance/expressions/contextualTyping/generatedContextualTyping.ts(154,75): error TS7027: Unreachable code detected.
-tests/cases/conformance/expressions/contextualTyping/generatedContextualTyping.ts(155,81): error TS7027: Unreachable code detected.
-tests/cases/conformance/expressions/contextualTyping/generatedContextualTyping.ts(156,44): error TS7027: Unreachable code detected.
-tests/cases/conformance/expressions/contextualTyping/generatedContextualTyping.ts(157,49): error TS7027: Unreachable code detected.
-tests/cases/conformance/expressions/contextualTyping/generatedContextualTyping.ts(158,60): error TS7027: Unreachable code detected.
-tests/cases/conformance/expressions/contextualTyping/generatedContextualTyping.ts(159,59): error TS7027: Unreachable code detected.
-tests/cases/conformance/expressions/contextualTyping/generatedContextualTyping.ts(160,84): error TS7027: Unreachable code detected.
-tests/cases/conformance/expressions/contextualTyping/generatedContextualTyping.ts(161,77): error TS7027: Unreachable code detected.
-
-
-==== tests/cases/conformance/expressions/contextualTyping/generatedContextualTyping.ts (12 errors) ====
-    class Base { private p; }
-    class Derived1 extends Base { private m; }
-    class Derived2 extends Base { private n; }
-    interface Genric<T> { func(n: T[]); }
-    var b = new Base(), d1 = new Derived1(), d2 = new Derived2();
-    var x1: () => Base[] = () => [d1, d2];
-    var x2: () => Base[] = function() { return [d1, d2] };
-    var x3: () => Base[] = function named() { return [d1, d2] };
-    var x4: { (): Base[]; } = () => [d1, d2];
-    var x5: { (): Base[]; } = function() { return [d1, d2] };
-    var x6: { (): Base[]; } = function named() { return [d1, d2] };
-    var x7: Base[] = [d1, d2];
-    var x8: Array<Base> = [d1, d2];
-    var x9: { [n: number]: Base; } = [d1, d2];
-    var x10: {n: Base[]; }  = { n: [d1, d2] };
-    var x11: (s: Base[]) => any = n => { var n: Base[]; return null; };
-    var x12: Genric<Base> = { func: n => { return [d1, d2]; } };
-    class x13 { member: () => Base[] = () => [d1, d2] }
-    class x14 { member: () => Base[] = function() { return [d1, d2] } }
-    class x15 { member: () => Base[] = function named() { return [d1, d2] } }
-    class x16 { member: { (): Base[]; } = () => [d1, d2] }
-    class x17 { member: { (): Base[]; } = function() { return [d1, d2] } }
-    class x18 { member: { (): Base[]; } = function named() { return [d1, d2] } }
-    class x19 { member: Base[] = [d1, d2] }
-    class x20 { member: Array<Base> = [d1, d2] }
-    class x21 { member: { [n: number]: Base; } = [d1, d2] }
-    class x22 { member: {n: Base[]; }  = { n: [d1, d2] } }
-    class x23 { member: (s: Base[]) => any = n => { var n: Base[]; return null; } }
-    class x24 { member: Genric<Base> = { func: n => { return [d1, d2]; } } }
-    class x25 { private member: () => Base[] = () => [d1, d2] }
-    class x26 { private member: () => Base[] = function() { return [d1, d2] } }
-    class x27 { private member: () => Base[] = function named() { return [d1, d2] } }
-    class x28 { private member: { (): Base[]; } = () => [d1, d2] }
-    class x29 { private member: { (): Base[]; } = function() { return [d1, d2] } }
-    class x30 { private member: { (): Base[]; } = function named() { return [d1, d2] } }
-    class x31 { private member: Base[] = [d1, d2] }
-    class x32 { private member: Array<Base> = [d1, d2] }
-    class x33 { private member: { [n: number]: Base; } = [d1, d2] }
-    class x34 { private member: {n: Base[]; }  = { n: [d1, d2] } }
-    class x35 { private member: (s: Base[]) => any = n => { var n: Base[]; return null; } }
-    class x36 { private member: Genric<Base> = { func: n => { return [d1, d2]; } } }
-    class x37 { public member: () => Base[] = () => [d1, d2] }
-    class x38 { public member: () => Base[] = function() { return [d1, d2] } }
-    class x39 { public member: () => Base[] = function named() { return [d1, d2] } }
-    class x40 { public member: { (): Base[]; } = () => [d1, d2] }
-    class x41 { public member: { (): Base[]; } = function() { return [d1, d2] } }
-    class x42 { public member: { (): Base[]; } = function named() { return [d1, d2] } }
-    class x43 { public member: Base[] = [d1, d2] }
-    class x44 { public member: Array<Base> = [d1, d2] }
-    class x45 { public member: { [n: number]: Base; } = [d1, d2] }
-    class x46 { public member: {n: Base[]; }  = { n: [d1, d2] } }
-    class x47 { public member: (s: Base[]) => any = n => { var n: Base[]; return null; } }
-    class x48 { public member: Genric<Base> = { func: n => { return [d1, d2]; } } }
-    class x49 { static member: () => Base[] = () => [d1, d2] }
-    class x50 { static member: () => Base[] = function() { return [d1, d2] } }
-    class x51 { static member: () => Base[] = function named() { return [d1, d2] } }
-    class x52 { static member: { (): Base[]; } = () => [d1, d2] }
-    class x53 { static member: { (): Base[]; } = function() { return [d1, d2] } }
-    class x54 { static member: { (): Base[]; } = function named() { return [d1, d2] } }
-    class x55 { static member: Base[] = [d1, d2] }
-    class x56 { static member: Array<Base> = [d1, d2] }
-    class x57 { static member: { [n: number]: Base; } = [d1, d2] }
-    class x58 { static member: {n: Base[]; }  = { n: [d1, d2] } }
-    class x59 { static member: (s: Base[]) => any = n => { var n: Base[]; return null; } }
-    class x60 { static member: Genric<Base> = { func: n => { return [d1, d2]; } } }
-    class x61 { private static member: () => Base[] = () => [d1, d2] }
-    class x62 { private static member: () => Base[] = function() { return [d1, d2] } }
-    class x63 { private static member: () => Base[] = function named() { return [d1, d2] } }
-    class x64 { private static member: { (): Base[]; } = () => [d1, d2] }
-    class x65 { private static member: { (): Base[]; } = function() { return [d1, d2] } }
-    class x66 { private static member: { (): Base[]; } = function named() { return [d1, d2] } }
-    class x67 { private static member: Base[] = [d1, d2] }
-    class x68 { private static member: Array<Base> = [d1, d2] }
-    class x69 { private static member: { [n: number]: Base; } = [d1, d2] }
-    class x70 { private static member: {n: Base[]; }  = { n: [d1, d2] } }
-    class x71 { private static member: (s: Base[]) => any = n => { var n: Base[]; return null; } }
-    class x72 { private static member: Genric<Base> = { func: n => { return [d1, d2]; } } }
-    class x73 { public static member: () => Base[] = () => [d1, d2] }
-    class x74 { public static member: () => Base[] = function() { return [d1, d2] } }
-    class x75 { public static member: () => Base[] = function named() { return [d1, d2] } }
-    class x76 { public static member: { (): Base[]; } = () => [d1, d2] }
-    class x77 { public static member: { (): Base[]; } = function() { return [d1, d2] } }
-    class x78 { public static member: { (): Base[]; } = function named() { return [d1, d2] } }
-    class x79 { public static member: Base[] = [d1, d2] }
-    class x80 { public static member: Array<Base> = [d1, d2] }
-    class x81 { public static member: { [n: number]: Base; } = [d1, d2] }
-    class x82 { public static member: {n: Base[]; }  = { n: [d1, d2] } }
-    class x83 { public static member: (s: Base[]) => any = n => { var n: Base[]; return null; } }
-    class x84 { public static member: Genric<Base> = { func: n => { return [d1, d2]; } } }
-    class x85 { constructor(parm: () => Base[] = () => [d1, d2]) { } }
-    class x86 { constructor(parm: () => Base[] = function() { return [d1, d2] }) { } }
-    class x87 { constructor(parm: () => Base[] = function named() { return [d1, d2] }) { } }
-    class x88 { constructor(parm: { (): Base[]; } = () => [d1, d2]) { } }
-    class x89 { constructor(parm: { (): Base[]; } = function() { return [d1, d2] }) { } }
-    class x90 { constructor(parm: { (): Base[]; } = function named() { return [d1, d2] }) { } }
-    class x91 { constructor(parm: Base[] = [d1, d2]) { } }
-    class x92 { constructor(parm: Array<Base> = [d1, d2]) { } }
-    class x93 { constructor(parm: { [n: number]: Base; } = [d1, d2]) { } }
-    class x94 { constructor(parm: {n: Base[]; }  = { n: [d1, d2] }) { } }
-    class x95 { constructor(parm: (s: Base[]) => any = n => { var n: Base[]; return null; }) { } }
-    class x96 { constructor(parm: Genric<Base> = { func: n => { return [d1, d2]; } }) { } }
-    class x97 { constructor(public parm: () => Base[] = () => [d1, d2]) { } }
-    class x98 { constructor(public parm: () => Base[] = function() { return [d1, d2] }) { } }
-    class x99 { constructor(public parm: () => Base[] = function named() { return [d1, d2] }) { } }
-    class x100 { constructor(public parm: { (): Base[]; } = () => [d1, d2]) { } }
-    class x101 { constructor(public parm: { (): Base[]; } = function() { return [d1, d2] }) { } }
-    class x102 { constructor(public parm: { (): Base[]; } = function named() { return [d1, d2] }) { } }
-    class x103 { constructor(public parm: Base[] = [d1, d2]) { } }
-    class x104 { constructor(public parm: Array<Base> = [d1, d2]) { } }
-    class x105 { constructor(public parm: { [n: number]: Base; } = [d1, d2]) { } }
-    class x106 { constructor(public parm: {n: Base[]; }  = { n: [d1, d2] }) { } }
-    class x107 { constructor(public parm: (s: Base[]) => any = n => { var n: Base[]; return null; }) { } }
-    class x108 { constructor(public parm: Genric<Base> = { func: n => { return [d1, d2]; } }) { } }
-    class x109 { constructor(private parm: () => Base[] = () => [d1, d2]) { } }
-    class x110 { constructor(private parm: () => Base[] = function() { return [d1, d2] }) { } }
-    class x111 { constructor(private parm: () => Base[] = function named() { return [d1, d2] }) { } }
-    class x112 { constructor(private parm: { (): Base[]; } = () => [d1, d2]) { } }
-    class x113 { constructor(private parm: { (): Base[]; } = function() { return [d1, d2] }) { } }
-    class x114 { constructor(private parm: { (): Base[]; } = function named() { return [d1, d2] }) { } }
-    class x115 { constructor(private parm: Base[] = [d1, d2]) { } }
-    class x116 { constructor(private parm: Array<Base> = [d1, d2]) { } }
-    class x117 { constructor(private parm: { [n: number]: Base; } = [d1, d2]) { } }
-    class x118 { constructor(private parm: {n: Base[]; }  = { n: [d1, d2] }) { } }
-    class x119 { constructor(private parm: (s: Base[]) => any = n => { var n: Base[]; return null; }) { } }
-    class x120 { constructor(private parm: Genric<Base> = { func: n => { return [d1, d2]; } }) { } }
-    function x121(parm: () => Base[] = () => [d1, d2]) { }
-    function x122(parm: () => Base[] = function() { return [d1, d2] }) { }
-    function x123(parm: () => Base[] = function named() { return [d1, d2] }) { }
-    function x124(parm: { (): Base[]; } = () => [d1, d2]) { }
-    function x125(parm: { (): Base[]; } = function() { return [d1, d2] }) { }
-    function x126(parm: { (): Base[]; } = function named() { return [d1, d2] }) { }
-    function x127(parm: Base[] = [d1, d2]) { }
-    function x128(parm: Array<Base> = [d1, d2]) { }
-    function x129(parm: { [n: number]: Base; } = [d1, d2]) { }
-    function x130(parm: {n: Base[]; }  = { n: [d1, d2] }) { }
-    function x131(parm: (s: Base[]) => any = n => { var n: Base[]; return null; }) { }
-    function x132(parm: Genric<Base> = { func: n => { return [d1, d2]; } }) { }
-    function x133(): () => Base[] { return () => [d1, d2]; }
-    function x134(): () => Base[] { return function() { return [d1, d2] }; }
-    function x135(): () => Base[] { return function named() { return [d1, d2] }; }
-    function x136(): { (): Base[]; } { return () => [d1, d2]; }
-    function x137(): { (): Base[]; } { return function() { return [d1, d2] }; }
-    function x138(): { (): Base[]; } { return function named() { return [d1, d2] }; }
-    function x139(): Base[] { return [d1, d2]; }
-    function x140(): Array<Base> { return [d1, d2]; }
-    function x141(): { [n: number]: Base; } { return [d1, d2]; }
-    function x142(): {n: Base[]; }  { return { n: [d1, d2] }; }
-    function x143(): (s: Base[]) => any { return n => { var n: Base[]; return null; }; }
-    function x144(): Genric<Base> { return { func: n => { return [d1, d2]; } }; }
-    function x145(): () => Base[] { return () => [d1, d2]; return () => [d1, d2]; }
-                                                           ~~~~~~
-!!! error TS7027: Unreachable code detected.
-    function x146(): () => Base[] { return function() { return [d1, d2] }; return function() { return [d1, d2] }; }
-                                                                           ~~~~~~
-!!! error TS7027: Unreachable code detected.
-    function x147(): () => Base[] { return function named() { return [d1, d2] }; return function named() { return [d1, d2] }; }
-                                                                                 ~~~~~~
-!!! error TS7027: Unreachable code detected.
-    function x148(): { (): Base[]; } { return () => [d1, d2]; return () => [d1, d2]; }
-                                                              ~~~~~~
-!!! error TS7027: Unreachable code detected.
-    function x149(): { (): Base[]; } { return function() { return [d1, d2] }; return function() { return [d1, d2] }; }
-                                                                              ~~~~~~
-!!! error TS7027: Unreachable code detected.
-    function x150(): { (): Base[]; } { return function named() { return [d1, d2] }; return function named() { return [d1, d2] }; }
-                                                                                    ~~~~~~
-!!! error TS7027: Unreachable code detected.
-    function x151(): Base[] { return [d1, d2]; return [d1, d2]; }
-                                               ~~~~~~
-!!! error TS7027: Unreachable code detected.
-    function x152(): Array<Base> { return [d1, d2]; return [d1, d2]; }
-                                                    ~~~~~~
-!!! error TS7027: Unreachable code detected.
-    function x153(): { [n: number]: Base; } { return [d1, d2]; return [d1, d2]; }
-                                                               ~~~~~~
-!!! error TS7027: Unreachable code detected.
-    function x154(): {n: Base[]; }  { return { n: [d1, d2] }; return { n: [d1, d2] }; }
-                                                              ~~~~~~
-!!! error TS7027: Unreachable code detected.
-    function x155(): (s: Base[]) => any { return n => { var n: Base[]; return null; }; return n => { var n: Base[]; return null; }; }
-                                                                                       ~~~~~~
-!!! error TS7027: Unreachable code detected.
-    function x156(): Genric<Base> { return { func: n => { return [d1, d2]; } }; return { func: n => { return [d1, d2]; } }; }
-                                                                                ~~~~~~
-!!! error TS7027: Unreachable code detected.
-    var x157: () => () => Base[] = () => { return () => [d1, d2]; };
-    var x158: () => () => Base[] = () => { return function() { return [d1, d2] }; };
-    var x159: () => () => Base[] = () => { return function named() { return [d1, d2] }; };
-    var x160: () => { (): Base[]; } = () => { return () => [d1, d2]; };
-    var x161: () => { (): Base[]; } = () => { return function() { return [d1, d2] }; };
-    var x162: () => { (): Base[]; } = () => { return function named() { return [d1, d2] }; };
-    var x163: () => Base[] = () => { return [d1, d2]; };
-    var x164: () => Array<Base> = () => { return [d1, d2]; };
-    var x165: () => { [n: number]: Base; } = () => { return [d1, d2]; };
-    var x166: () => {n: Base[]; }  = () => { return { n: [d1, d2] }; };
-    var x167: () => (s: Base[]) => any = () => { return n => { var n: Base[]; return null; }; };
-    var x168: () => Genric<Base> = () => { return { func: n => { return [d1, d2]; } }; };
-    var x169: () => () => Base[] = function() { return () => [d1, d2]; };
-    var x170: () => () => Base[] = function() { return function() { return [d1, d2] }; };
-    var x171: () => () => Base[] = function() { return function named() { return [d1, d2] }; };
-    var x172: () => { (): Base[]; } = function() { return () => [d1, d2]; };
-    var x173: () => { (): Base[]; } = function() { return function() { return [d1, d2] }; };
-    var x174: () => { (): Base[]; } = function() { return function named() { return [d1, d2] }; };
-    var x175: () => Base[] = function() { return [d1, d2]; };
-    var x176: () => Array<Base> = function() { return [d1, d2]; };
-    var x177: () => { [n: number]: Base; } = function() { return [d1, d2]; };
-    var x178: () => {n: Base[]; }  = function() { return { n: [d1, d2] }; };
-    var x179: () => (s: Base[]) => any = function() { return n => { var n: Base[]; return null; }; };
-    var x180: () => Genric<Base> = function() { return { func: n => { return [d1, d2]; } }; };
-    module x181 { var t: () => Base[] = () => [d1, d2]; }
-    module x182 { var t: () => Base[] = function() { return [d1, d2] }; }
-    module x183 { var t: () => Base[] = function named() { return [d1, d2] }; }
-    module x184 { var t: { (): Base[]; } = () => [d1, d2]; }
-    module x185 { var t: { (): Base[]; } = function() { return [d1, d2] }; }
-    module x186 { var t: { (): Base[]; } = function named() { return [d1, d2] }; }
-    module x187 { var t: Base[] = [d1, d2]; }
-    module x188 { var t: Array<Base> = [d1, d2]; }
-    module x189 { var t: { [n: number]: Base; } = [d1, d2]; }
-    module x190 { var t: {n: Base[]; }  = { n: [d1, d2] }; }
-    module x191 { var t: (s: Base[]) => any = n => { var n: Base[]; return null; }; }
-    module x192 { var t: Genric<Base> = { func: n => { return [d1, d2]; } }; }
-    module x193 { export var t: () => Base[] = () => [d1, d2]; }
-    module x194 { export var t: () => Base[] = function() { return [d1, d2] }; }
-    module x195 { export var t: () => Base[] = function named() { return [d1, d2] }; }
-    module x196 { export var t: { (): Base[]; } = () => [d1, d2]; }
-    module x197 { export var t: { (): Base[]; } = function() { return [d1, d2] }; }
-    module x198 { export var t: { (): Base[]; } = function named() { return [d1, d2] }; }
-    module x199 { export var t: Base[] = [d1, d2]; }
-    module x200 { export var t: Array<Base> = [d1, d2]; }
-    module x201 { export var t: { [n: number]: Base; } = [d1, d2]; }
-    module x202 { export var t: {n: Base[]; }  = { n: [d1, d2] }; }
-    module x203 { export var t: (s: Base[]) => any = n => { var n: Base[]; return null; }; }
-    module x204 { export var t: Genric<Base> = { func: n => { return [d1, d2]; } }; }
-    var x206 = <() => Base[]>function() { return [d1, d2] };
-    var x207 = <() => Base[]>function named() { return [d1, d2] };
-    var x209 = <{ (): Base[]; }>function() { return [d1, d2] };
-    var x210 = <{ (): Base[]; }>function named() { return [d1, d2] };
-    var x211 = <Base[]>[d1, d2];
-    var x212 = <Array<Base>>[d1, d2];
-    var x213 = <{ [n: number]: Base; }>[d1, d2];
-    var x214 = <{n: Base[]; } >{ n: [d1, d2] };
-    var x216 = <Genric<Base>>{ func: n => { return [d1, d2]; } };
-    var x217 = (<() => Base[]>undefined) || function() { return [d1, d2] };
-    var x218 = (<() => Base[]>undefined) || function named() { return [d1, d2] };
-    var x219 = (<{ (): Base[]; }>undefined) || function() { return [d1, d2] };
-    var x220 = (<{ (): Base[]; }>undefined) || function named() { return [d1, d2] };
-    var x221 = (<Base[]>undefined) || [d1, d2];
-    var x222 = (<Array<Base>>undefined) || [d1, d2];
-    var x223 = (<{ [n: number]: Base; }>undefined) || [d1, d2];
-    var x224 = (<{n: Base[]; } >undefined) || { n: [d1, d2] };
-    var x225: () => Base[]; x225 = () => [d1, d2];
-    var x226: () => Base[]; x226 = function() { return [d1, d2] };
-    var x227: () => Base[]; x227 = function named() { return [d1, d2] };
-    var x228: { (): Base[]; }; x228 = () => [d1, d2];
-    var x229: { (): Base[]; }; x229 = function() { return [d1, d2] };
-    var x230: { (): Base[]; }; x230 = function named() { return [d1, d2] };
-    var x231: Base[]; x231 = [d1, d2];
-    var x232: Array<Base>; x232 = [d1, d2];
-    var x233: { [n: number]: Base; }; x233 = [d1, d2];
-    var x234: {n: Base[]; } ; x234 = { n: [d1, d2] };
-    var x235: (s: Base[]) => any; x235 = n => { var n: Base[]; return null; };
-    var x236: Genric<Base>; x236 = { func: n => { return [d1, d2]; } };
-    var x237: { n: () => Base[]; } = { n: () => [d1, d2] };
-    var x238: { n: () => Base[]; } = { n: function() { return [d1, d2] } };
-    var x239: { n: () => Base[]; } = { n: function named() { return [d1, d2] } };
-    var x240: { n: { (): Base[]; }; } = { n: () => [d1, d2] };
-    var x241: { n: { (): Base[]; }; } = { n: function() { return [d1, d2] } };
-    var x242: { n: { (): Base[]; }; } = { n: function named() { return [d1, d2] } };
-    var x243: { n: Base[]; } = { n: [d1, d2] };
-    var x244: { n: Array<Base>; } = { n: [d1, d2] };
-    var x245: { n: { [n: number]: Base; }; } = { n: [d1, d2] };
-    var x246: { n: {n: Base[]; } ; } = { n: { n: [d1, d2] } };
-    var x247: { n: (s: Base[]) => any; } = { n: n => { var n: Base[]; return null; } };
-    var x248: { n: Genric<Base>; } = { n: { func: n => { return [d1, d2]; } } };
-    var x252: { (): Base[]; }[] = [() => [d1, d2]];
-    var x253: { (): Base[]; }[] = [function() { return [d1, d2] }];
-    var x254: { (): Base[]; }[] = [function named() { return [d1, d2] }];
-    var x255: Base[][] = [[d1, d2]];
-    var x256: Array<Base>[] = [[d1, d2]];
-    var x257: { [n: number]: Base; }[] = [[d1, d2]];
-    var x258: {n: Base[]; } [] = [{ n: [d1, d2] }];
-    var x260: Genric<Base>[] = [{ func: n => { return [d1, d2]; } }];
-    var x261: () => Base[] = function() { return [d1, d2] } || undefined;
-    var x262: () => Base[] = function named() { return [d1, d2] } || undefined;
-    var x263: { (): Base[]; } = function() { return [d1, d2] } || undefined;
-    var x264: { (): Base[]; } = function named() { return [d1, d2] } || undefined;
-    var x265: Base[] = [d1, d2] || undefined;
-    var x266: Array<Base> = [d1, d2] || undefined;
-    var x267: { [n: number]: Base; } = [d1, d2] || undefined;
-    var x268: {n: Base[]; }  = { n: [d1, d2] } || undefined;
-    var x269: () => Base[] = undefined || function() { return [d1, d2] };
-    var x270: () => Base[] = undefined || function named() { return [d1, d2] };
-    var x271: { (): Base[]; } = undefined || function() { return [d1, d2] };
-    var x272: { (): Base[]; } = undefined || function named() { return [d1, d2] };
-    var x273: Base[] = undefined || [d1, d2];
-    var x274: Array<Base> = undefined || [d1, d2];
-    var x275: { [n: number]: Base; } = undefined || [d1, d2];
-    var x276: {n: Base[]; }  = undefined || { n: [d1, d2] };
-    var x277: () => Base[] = function() { return [d1, d2] } || function() { return [d1, d2] };
-    var x278: () => Base[] = function named() { return [d1, d2] } || function named() { return [d1, d2] };
-    var x279: { (): Base[]; } = function() { return [d1, d2] } || function() { return [d1, d2] };
-    var x280: { (): Base[]; } = function named() { return [d1, d2] } || function named() { return [d1, d2] };
-    var x281: Base[] = [d1, d2] || [d1, d2];
-    var x282: Array<Base> = [d1, d2] || [d1, d2];
-    var x283: { [n: number]: Base; } = [d1, d2] || [d1, d2];
-    var x284: {n: Base[]; }  = { n: [d1, d2] } || { n: [d1, d2] };
-    var x285: () => Base[] = true ? () => [d1, d2] : () => [d1, d2];
-    var x286: () => Base[] = true ? function() { return [d1, d2] } : function() { return [d1, d2] };
-    var x287: () => Base[] = true ? function named() { return [d1, d2] } : function named() { return [d1, d2] };
-    var x288: { (): Base[]; } = true ? () => [d1, d2] : () => [d1, d2];
-    var x289: { (): Base[]; } = true ? function() { return [d1, d2] } : function() { return [d1, d2] };
-    var x290: { (): Base[]; } = true ? function named() { return [d1, d2] } : function named() { return [d1, d2] };
-    var x291: Base[] = true ? [d1, d2] : [d1, d2];
-    var x292: Array<Base> = true ? [d1, d2] : [d1, d2];
-    var x293: { [n: number]: Base; } = true ? [d1, d2] : [d1, d2];
-    var x294: {n: Base[]; }  = true ? { n: [d1, d2] } : { n: [d1, d2] };
-    var x295: (s: Base[]) => any = true ? n => { var n: Base[]; return null; } : n => { var n: Base[]; return null; };
-    var x296: Genric<Base> = true ? { func: n => { return [d1, d2]; } } : { func: n => { return [d1, d2]; } };
-    var x297: () => Base[] = true ? undefined : () => [d1, d2];
-    var x298: () => Base[] = true ? undefined : function() { return [d1, d2] };
-    var x299: () => Base[] = true ? undefined : function named() { return [d1, d2] };
-    var x300: { (): Base[]; } = true ? undefined : () => [d1, d2];
-    var x301: { (): Base[]; } = true ? undefined : function() { return [d1, d2] };
-    var x302: { (): Base[]; } = true ? undefined : function named() { return [d1, d2] };
-    var x303: Base[] = true ? undefined : [d1, d2];
-    var x304: Array<Base> = true ? undefined : [d1, d2];
-    var x305: { [n: number]: Base; } = true ? undefined : [d1, d2];
-    var x306: {n: Base[]; }  = true ? undefined : { n: [d1, d2] };
-    var x307: (s: Base[]) => any = true ? undefined : n => { var n: Base[]; return null; };
-    var x308: Genric<Base> = true ? undefined : { func: n => { return [d1, d2]; } };
-    var x309: () => Base[] = true ? () => [d1, d2] : undefined;
-    var x310: () => Base[] = true ? function() { return [d1, d2] } : undefined;
-    var x311: () => Base[] = true ? function named() { return [d1, d2] } : undefined;
-    var x312: { (): Base[]; } = true ? () => [d1, d2] : undefined;
-    var x313: { (): Base[]; } = true ? function() { return [d1, d2] } : undefined;
-    var x314: { (): Base[]; } = true ? function named() { return [d1, d2] } : undefined;
-    var x315: Base[] = true ? [d1, d2] : undefined;
-    var x316: Array<Base> = true ? [d1, d2] : undefined;
-    var x317: { [n: number]: Base; } = true ? [d1, d2] : undefined;
-    var x318: {n: Base[]; }  = true ? { n: [d1, d2] } : undefined;
-    var x319: (s: Base[]) => any = true ? n => { var n: Base[]; return null; } : undefined;
-    var x320: Genric<Base> = true ? { func: n => { return [d1, d2]; } } : undefined;
-    function x321(n: () => Base[]) { }; x321(() => [d1, d2]);
-    function x322(n: () => Base[]) { }; x322(function() { return [d1, d2] });
-    function x323(n: () => Base[]) { }; x323(function named() { return [d1, d2] });
-    function x324(n: { (): Base[]; }) { }; x324(() => [d1, d2]);
-    function x325(n: { (): Base[]; }) { }; x325(function() { return [d1, d2] });
-    function x326(n: { (): Base[]; }) { }; x326(function named() { return [d1, d2] });
-    function x327(n: Base[]) { }; x327([d1, d2]);
-    function x328(n: Array<Base>) { }; x328([d1, d2]);
-    function x329(n: { [n: number]: Base; }) { }; x329([d1, d2]);
-    function x330(n: {n: Base[]; } ) { }; x330({ n: [d1, d2] });
-    function x331(n: (s: Base[]) => any) { }; x331(n => { var n: Base[]; return null; });
-    function x332(n: Genric<Base>) { }; x332({ func: n => { return [d1, d2]; } });
-    var x333 = (n: () => Base[]) => n; x333(() => [d1, d2]);
-    var x334 = (n: () => Base[]) => n; x334(function() { return [d1, d2] });
-    var x335 = (n: () => Base[]) => n; x335(function named() { return [d1, d2] });
-    var x336 = (n: { (): Base[]; }) => n; x336(() => [d1, d2]);
-    var x337 = (n: { (): Base[]; }) => n; x337(function() { return [d1, d2] });
-    var x338 = (n: { (): Base[]; }) => n; x338(function named() { return [d1, d2] });
-    var x339 = (n: Base[]) => n; x339([d1, d2]);
-    var x340 = (n: Array<Base>) => n; x340([d1, d2]);
-    var x341 = (n: { [n: number]: Base; }) => n; x341([d1, d2]);
-    var x342 = (n: {n: Base[]; } ) => n; x342({ n: [d1, d2] });
-    var x343 = (n: (s: Base[]) => any) => n; x343(n => { var n: Base[]; return null; });
-    var x344 = (n: Genric<Base>) => n; x344({ func: n => { return [d1, d2]; } });
-    var x345 = function(n: () => Base[]) { }; x345(() => [d1, d2]);
-    var x346 = function(n: () => Base[]) { }; x346(function() { return [d1, d2] });
-    var x347 = function(n: () => Base[]) { }; x347(function named() { return [d1, d2] });
-    var x348 = function(n: { (): Base[]; }) { }; x348(() => [d1, d2]);
-    var x349 = function(n: { (): Base[]; }) { }; x349(function() { return [d1, d2] });
-    var x350 = function(n: { (): Base[]; }) { }; x350(function named() { return [d1, d2] });
-    var x351 = function(n: Base[]) { }; x351([d1, d2]);
-    var x352 = function(n: Array<Base>) { }; x352([d1, d2]);
-    var x353 = function(n: { [n: number]: Base; }) { }; x353([d1, d2]);
-    var x354 = function(n: {n: Base[]; } ) { }; x354({ n: [d1, d2] });
-    var x355 = function(n: (s: Base[]) => any) { }; x355(n => { var n: Base[]; return null; });
-    var x356 = function(n: Genric<Base>) { }; x356({ func: n => { return [d1, d2]; } });
\ No newline at end of file
diff --git a/tests/baselines/reference/generatedContextualTyping.js b/tests/baselines/reference/generatedContextualTyping.js
index 1f7d2b8035f..a867d4b7629 100644
--- a/tests/baselines/reference/generatedContextualTyping.js
+++ b/tests/baselines/reference/generatedContextualTyping.js
@@ -1,4 +1,5 @@
 //// [generatedContextualTyping.ts]
+
 class Base { private p; }
 class Derived1 extends Base { private m; }
 class Derived2 extends Base { private n; }
diff --git a/tests/baselines/reference/generatedContextualTyping.symbols b/tests/baselines/reference/generatedContextualTyping.symbols
new file mode 100644
index 00000000000..bc50fcc25c6
--- /dev/null
+++ b/tests/baselines/reference/generatedContextualTyping.symbols
@@ -0,0 +1,2832 @@
+=== tests/cases/conformance/expressions/contextualTyping/generatedContextualTyping.ts ===
+
+class Base { private p; }
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>p : Symbol(p, Decl(generatedContextualTyping.ts, 1, 12))
+
+class Derived1 extends Base { private m; }
+>Derived1 : Symbol(Derived1, Decl(generatedContextualTyping.ts, 1, 25))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>m : Symbol(m, Decl(generatedContextualTyping.ts, 2, 29))
+
+class Derived2 extends Base { private n; }
+>Derived2 : Symbol(Derived2, Decl(generatedContextualTyping.ts, 2, 42))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 3, 29))
+
+interface Genric<T> { func(n: T[]); }
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
+>T : Symbol(T, Decl(generatedContextualTyping.ts, 4, 17))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 4, 21))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 4, 27))
+>T : Symbol(T, Decl(generatedContextualTyping.ts, 4, 17))
+
+var b = new Base(), d1 = new Derived1(), d2 = new Derived2();
+>b : Symbol(b, Decl(generatedContextualTyping.ts, 5, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>Derived1 : Symbol(Derived1, Decl(generatedContextualTyping.ts, 1, 25))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>Derived2 : Symbol(Derived2, Decl(generatedContextualTyping.ts, 2, 42))
+
+var x1: () => Base[] = () => [d1, d2];
+>x1 : Symbol(x1, Decl(generatedContextualTyping.ts, 6, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x2: () => Base[] = function() { return [d1, d2] };
+>x2 : Symbol(x2, Decl(generatedContextualTyping.ts, 7, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x3: () => Base[] = function named() { return [d1, d2] };
+>x3 : Symbol(x3, Decl(generatedContextualTyping.ts, 8, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 8, 22))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x4: { (): Base[]; } = () => [d1, d2];
+>x4 : Symbol(x4, Decl(generatedContextualTyping.ts, 9, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x5: { (): Base[]; } = function() { return [d1, d2] };
+>x5 : Symbol(x5, Decl(generatedContextualTyping.ts, 10, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x6: { (): Base[]; } = function named() { return [d1, d2] };
+>x6 : Symbol(x6, Decl(generatedContextualTyping.ts, 11, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 11, 25))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x7: Base[] = [d1, d2];
+>x7 : Symbol(x7, Decl(generatedContextualTyping.ts, 12, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x8: Array<Base> = [d1, d2];
+>x8 : Symbol(x8, Decl(generatedContextualTyping.ts, 13, 3))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x9: { [n: number]: Base; } = [d1, d2];
+>x9 : Symbol(x9, Decl(generatedContextualTyping.ts, 14, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 14, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x10: {n: Base[]; }  = { n: [d1, d2] };
+>x10 : Symbol(x10, Decl(generatedContextualTyping.ts, 15, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 15, 10))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 15, 27))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x11: (s: Base[]) => any = n => { var n: Base[]; return null; };
+>x11 : Symbol(x11, Decl(generatedContextualTyping.ts, 16, 3))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 16, 10))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 16, 29), Decl(generatedContextualTyping.ts, 16, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 16, 29), Decl(generatedContextualTyping.ts, 16, 40))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+
+var x12: Genric<Base> = { func: n => { return [d1, d2]; } };
+>x12 : Symbol(x12, Decl(generatedContextualTyping.ts, 17, 3))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 17, 25))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 17, 31))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x13 { member: () => Base[] = () => [d1, d2] }
+>x13 : Symbol(x13, Decl(generatedContextualTyping.ts, 17, 60))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 18, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x14 { member: () => Base[] = function() { return [d1, d2] } }
+>x14 : Symbol(x14, Decl(generatedContextualTyping.ts, 18, 51))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 19, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x15 { member: () => Base[] = function named() { return [d1, d2] } }
+>x15 : Symbol(x15, Decl(generatedContextualTyping.ts, 19, 67))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 20, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 20, 34))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x16 { member: { (): Base[]; } = () => [d1, d2] }
+>x16 : Symbol(x16, Decl(generatedContextualTyping.ts, 20, 73))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 21, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x17 { member: { (): Base[]; } = function() { return [d1, d2] } }
+>x17 : Symbol(x17, Decl(generatedContextualTyping.ts, 21, 54))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 22, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x18 { member: { (): Base[]; } = function named() { return [d1, d2] } }
+>x18 : Symbol(x18, Decl(generatedContextualTyping.ts, 22, 70))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 23, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 23, 37))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x19 { member: Base[] = [d1, d2] }
+>x19 : Symbol(x19, Decl(generatedContextualTyping.ts, 23, 76))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 24, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x20 { member: Array<Base> = [d1, d2] }
+>x20 : Symbol(x20, Decl(generatedContextualTyping.ts, 24, 39))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 25, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x21 { member: { [n: number]: Base; } = [d1, d2] }
+>x21 : Symbol(x21, Decl(generatedContextualTyping.ts, 25, 44))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 26, 11))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 26, 23))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x22 { member: {n: Base[]; }  = { n: [d1, d2] } }
+>x22 : Symbol(x22, Decl(generatedContextualTyping.ts, 26, 55))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 27, 11))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 27, 21))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 27, 38))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x23 { member: (s: Base[]) => any = n => { var n: Base[]; return null; } }
+>x23 : Symbol(x23, Decl(generatedContextualTyping.ts, 27, 54))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 28, 11))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 28, 21))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 28, 40), Decl(generatedContextualTyping.ts, 28, 51))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 28, 40), Decl(generatedContextualTyping.ts, 28, 51))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+
+class x24 { member: Genric<Base> = { func: n => { return [d1, d2]; } } }
+>x24 : Symbol(x24, Decl(generatedContextualTyping.ts, 28, 79))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 29, 11))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 29, 36))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 29, 42))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x25 { private member: () => Base[] = () => [d1, d2] }
+>x25 : Symbol(x25, Decl(generatedContextualTyping.ts, 29, 72))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 30, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x26 { private member: () => Base[] = function() { return [d1, d2] } }
+>x26 : Symbol(x26, Decl(generatedContextualTyping.ts, 30, 59))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 31, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x27 { private member: () => Base[] = function named() { return [d1, d2] } }
+>x27 : Symbol(x27, Decl(generatedContextualTyping.ts, 31, 75))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 32, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 32, 42))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x28 { private member: { (): Base[]; } = () => [d1, d2] }
+>x28 : Symbol(x28, Decl(generatedContextualTyping.ts, 32, 81))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 33, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x29 { private member: { (): Base[]; } = function() { return [d1, d2] } }
+>x29 : Symbol(x29, Decl(generatedContextualTyping.ts, 33, 62))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 34, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x30 { private member: { (): Base[]; } = function named() { return [d1, d2] } }
+>x30 : Symbol(x30, Decl(generatedContextualTyping.ts, 34, 78))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 35, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 35, 45))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x31 { private member: Base[] = [d1, d2] }
+>x31 : Symbol(x31, Decl(generatedContextualTyping.ts, 35, 84))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 36, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x32 { private member: Array<Base> = [d1, d2] }
+>x32 : Symbol(x32, Decl(generatedContextualTyping.ts, 36, 47))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 37, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x33 { private member: { [n: number]: Base; } = [d1, d2] }
+>x33 : Symbol(x33, Decl(generatedContextualTyping.ts, 37, 52))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 38, 11))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 38, 31))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x34 { private member: {n: Base[]; }  = { n: [d1, d2] } }
+>x34 : Symbol(x34, Decl(generatedContextualTyping.ts, 38, 63))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 39, 11))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 39, 29))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 39, 46))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x35 { private member: (s: Base[]) => any = n => { var n: Base[]; return null; } }
+>x35 : Symbol(x35, Decl(generatedContextualTyping.ts, 39, 62))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 40, 11))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 40, 29))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 40, 48), Decl(generatedContextualTyping.ts, 40, 59))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 40, 48), Decl(generatedContextualTyping.ts, 40, 59))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+
+class x36 { private member: Genric<Base> = { func: n => { return [d1, d2]; } } }
+>x36 : Symbol(x36, Decl(generatedContextualTyping.ts, 40, 87))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 41, 11))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 41, 44))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 41, 50))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x37 { public member: () => Base[] = () => [d1, d2] }
+>x37 : Symbol(x37, Decl(generatedContextualTyping.ts, 41, 80))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 42, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x38 { public member: () => Base[] = function() { return [d1, d2] } }
+>x38 : Symbol(x38, Decl(generatedContextualTyping.ts, 42, 58))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 43, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x39 { public member: () => Base[] = function named() { return [d1, d2] } }
+>x39 : Symbol(x39, Decl(generatedContextualTyping.ts, 43, 74))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 44, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 44, 41))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x40 { public member: { (): Base[]; } = () => [d1, d2] }
+>x40 : Symbol(x40, Decl(generatedContextualTyping.ts, 44, 80))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 45, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x41 { public member: { (): Base[]; } = function() { return [d1, d2] } }
+>x41 : Symbol(x41, Decl(generatedContextualTyping.ts, 45, 61))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 46, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x42 { public member: { (): Base[]; } = function named() { return [d1, d2] } }
+>x42 : Symbol(x42, Decl(generatedContextualTyping.ts, 46, 77))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 47, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 47, 44))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x43 { public member: Base[] = [d1, d2] }
+>x43 : Symbol(x43, Decl(generatedContextualTyping.ts, 47, 83))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 48, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x44 { public member: Array<Base> = [d1, d2] }
+>x44 : Symbol(x44, Decl(generatedContextualTyping.ts, 48, 46))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 49, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x45 { public member: { [n: number]: Base; } = [d1, d2] }
+>x45 : Symbol(x45, Decl(generatedContextualTyping.ts, 49, 51))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 50, 11))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 50, 30))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x46 { public member: {n: Base[]; }  = { n: [d1, d2] } }
+>x46 : Symbol(x46, Decl(generatedContextualTyping.ts, 50, 62))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 51, 11))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 51, 28))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 51, 45))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x47 { public member: (s: Base[]) => any = n => { var n: Base[]; return null; } }
+>x47 : Symbol(x47, Decl(generatedContextualTyping.ts, 51, 61))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 52, 11))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 52, 28))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 52, 47), Decl(generatedContextualTyping.ts, 52, 58))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 52, 47), Decl(generatedContextualTyping.ts, 52, 58))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+
+class x48 { public member: Genric<Base> = { func: n => { return [d1, d2]; } } }
+>x48 : Symbol(x48, Decl(generatedContextualTyping.ts, 52, 86))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 53, 11))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 53, 43))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 53, 49))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x49 { static member: () => Base[] = () => [d1, d2] }
+>x49 : Symbol(x49, Decl(generatedContextualTyping.ts, 53, 79))
+>member : Symbol(x49.member, Decl(generatedContextualTyping.ts, 54, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x50 { static member: () => Base[] = function() { return [d1, d2] } }
+>x50 : Symbol(x50, Decl(generatedContextualTyping.ts, 54, 58))
+>member : Symbol(x50.member, Decl(generatedContextualTyping.ts, 55, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x51 { static member: () => Base[] = function named() { return [d1, d2] } }
+>x51 : Symbol(x51, Decl(generatedContextualTyping.ts, 55, 74))
+>member : Symbol(x51.member, Decl(generatedContextualTyping.ts, 56, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 56, 41))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x52 { static member: { (): Base[]; } = () => [d1, d2] }
+>x52 : Symbol(x52, Decl(generatedContextualTyping.ts, 56, 80))
+>member : Symbol(x52.member, Decl(generatedContextualTyping.ts, 57, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x53 { static member: { (): Base[]; } = function() { return [d1, d2] } }
+>x53 : Symbol(x53, Decl(generatedContextualTyping.ts, 57, 61))
+>member : Symbol(x53.member, Decl(generatedContextualTyping.ts, 58, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x54 { static member: { (): Base[]; } = function named() { return [d1, d2] } }
+>x54 : Symbol(x54, Decl(generatedContextualTyping.ts, 58, 77))
+>member : Symbol(x54.member, Decl(generatedContextualTyping.ts, 59, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 59, 44))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x55 { static member: Base[] = [d1, d2] }
+>x55 : Symbol(x55, Decl(generatedContextualTyping.ts, 59, 83))
+>member : Symbol(x55.member, Decl(generatedContextualTyping.ts, 60, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x56 { static member: Array<Base> = [d1, d2] }
+>x56 : Symbol(x56, Decl(generatedContextualTyping.ts, 60, 46))
+>member : Symbol(x56.member, Decl(generatedContextualTyping.ts, 61, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x57 { static member: { [n: number]: Base; } = [d1, d2] }
+>x57 : Symbol(x57, Decl(generatedContextualTyping.ts, 61, 51))
+>member : Symbol(x57.member, Decl(generatedContextualTyping.ts, 62, 11))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 62, 30))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x58 { static member: {n: Base[]; }  = { n: [d1, d2] } }
+>x58 : Symbol(x58, Decl(generatedContextualTyping.ts, 62, 62))
+>member : Symbol(x58.member, Decl(generatedContextualTyping.ts, 63, 11))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 63, 28))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 63, 45))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x59 { static member: (s: Base[]) => any = n => { var n: Base[]; return null; } }
+>x59 : Symbol(x59, Decl(generatedContextualTyping.ts, 63, 61))
+>member : Symbol(x59.member, Decl(generatedContextualTyping.ts, 64, 11))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 64, 28))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 64, 47), Decl(generatedContextualTyping.ts, 64, 58))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 64, 47), Decl(generatedContextualTyping.ts, 64, 58))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+
+class x60 { static member: Genric<Base> = { func: n => { return [d1, d2]; } } }
+>x60 : Symbol(x60, Decl(generatedContextualTyping.ts, 64, 86))
+>member : Symbol(x60.member, Decl(generatedContextualTyping.ts, 65, 11))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 65, 43))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 65, 49))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x61 { private static member: () => Base[] = () => [d1, d2] }
+>x61 : Symbol(x61, Decl(generatedContextualTyping.ts, 65, 79))
+>member : Symbol(x61.member, Decl(generatedContextualTyping.ts, 66, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x62 { private static member: () => Base[] = function() { return [d1, d2] } }
+>x62 : Symbol(x62, Decl(generatedContextualTyping.ts, 66, 66))
+>member : Symbol(x62.member, Decl(generatedContextualTyping.ts, 67, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x63 { private static member: () => Base[] = function named() { return [d1, d2] } }
+>x63 : Symbol(x63, Decl(generatedContextualTyping.ts, 67, 82))
+>member : Symbol(x63.member, Decl(generatedContextualTyping.ts, 68, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 68, 49))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x64 { private static member: { (): Base[]; } = () => [d1, d2] }
+>x64 : Symbol(x64, Decl(generatedContextualTyping.ts, 68, 88))
+>member : Symbol(x64.member, Decl(generatedContextualTyping.ts, 69, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x65 { private static member: { (): Base[]; } = function() { return [d1, d2] } }
+>x65 : Symbol(x65, Decl(generatedContextualTyping.ts, 69, 69))
+>member : Symbol(x65.member, Decl(generatedContextualTyping.ts, 70, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x66 { private static member: { (): Base[]; } = function named() { return [d1, d2] } }
+>x66 : Symbol(x66, Decl(generatedContextualTyping.ts, 70, 85))
+>member : Symbol(x66.member, Decl(generatedContextualTyping.ts, 71, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 71, 52))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x67 { private static member: Base[] = [d1, d2] }
+>x67 : Symbol(x67, Decl(generatedContextualTyping.ts, 71, 91))
+>member : Symbol(x67.member, Decl(generatedContextualTyping.ts, 72, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x68 { private static member: Array<Base> = [d1, d2] }
+>x68 : Symbol(x68, Decl(generatedContextualTyping.ts, 72, 54))
+>member : Symbol(x68.member, Decl(generatedContextualTyping.ts, 73, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x69 { private static member: { [n: number]: Base; } = [d1, d2] }
+>x69 : Symbol(x69, Decl(generatedContextualTyping.ts, 73, 59))
+>member : Symbol(x69.member, Decl(generatedContextualTyping.ts, 74, 11))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 74, 38))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x70 { private static member: {n: Base[]; }  = { n: [d1, d2] } }
+>x70 : Symbol(x70, Decl(generatedContextualTyping.ts, 74, 70))
+>member : Symbol(x70.member, Decl(generatedContextualTyping.ts, 75, 11))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 75, 36))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 75, 53))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x71 { private static member: (s: Base[]) => any = n => { var n: Base[]; return null; } }
+>x71 : Symbol(x71, Decl(generatedContextualTyping.ts, 75, 69))
+>member : Symbol(x71.member, Decl(generatedContextualTyping.ts, 76, 11))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 76, 36))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 76, 55), Decl(generatedContextualTyping.ts, 76, 66))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 76, 55), Decl(generatedContextualTyping.ts, 76, 66))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+
+class x72 { private static member: Genric<Base> = { func: n => { return [d1, d2]; } } }
+>x72 : Symbol(x72, Decl(generatedContextualTyping.ts, 76, 94))
+>member : Symbol(x72.member, Decl(generatedContextualTyping.ts, 77, 11))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 77, 51))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 77, 57))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x73 { public static member: () => Base[] = () => [d1, d2] }
+>x73 : Symbol(x73, Decl(generatedContextualTyping.ts, 77, 87))
+>member : Symbol(x73.member, Decl(generatedContextualTyping.ts, 78, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x74 { public static member: () => Base[] = function() { return [d1, d2] } }
+>x74 : Symbol(x74, Decl(generatedContextualTyping.ts, 78, 65))
+>member : Symbol(x74.member, Decl(generatedContextualTyping.ts, 79, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x75 { public static member: () => Base[] = function named() { return [d1, d2] } }
+>x75 : Symbol(x75, Decl(generatedContextualTyping.ts, 79, 81))
+>member : Symbol(x75.member, Decl(generatedContextualTyping.ts, 80, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 80, 48))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x76 { public static member: { (): Base[]; } = () => [d1, d2] }
+>x76 : Symbol(x76, Decl(generatedContextualTyping.ts, 80, 87))
+>member : Symbol(x76.member, Decl(generatedContextualTyping.ts, 81, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x77 { public static member: { (): Base[]; } = function() { return [d1, d2] } }
+>x77 : Symbol(x77, Decl(generatedContextualTyping.ts, 81, 68))
+>member : Symbol(x77.member, Decl(generatedContextualTyping.ts, 82, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x78 { public static member: { (): Base[]; } = function named() { return [d1, d2] } }
+>x78 : Symbol(x78, Decl(generatedContextualTyping.ts, 82, 84))
+>member : Symbol(x78.member, Decl(generatedContextualTyping.ts, 83, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 83, 51))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x79 { public static member: Base[] = [d1, d2] }
+>x79 : Symbol(x79, Decl(generatedContextualTyping.ts, 83, 90))
+>member : Symbol(x79.member, Decl(generatedContextualTyping.ts, 84, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x80 { public static member: Array<Base> = [d1, d2] }
+>x80 : Symbol(x80, Decl(generatedContextualTyping.ts, 84, 53))
+>member : Symbol(x80.member, Decl(generatedContextualTyping.ts, 85, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x81 { public static member: { [n: number]: Base; } = [d1, d2] }
+>x81 : Symbol(x81, Decl(generatedContextualTyping.ts, 85, 58))
+>member : Symbol(x81.member, Decl(generatedContextualTyping.ts, 86, 11))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 86, 37))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x82 { public static member: {n: Base[]; }  = { n: [d1, d2] } }
+>x82 : Symbol(x82, Decl(generatedContextualTyping.ts, 86, 69))
+>member : Symbol(x82.member, Decl(generatedContextualTyping.ts, 87, 11))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 87, 35))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 87, 52))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x83 { public static member: (s: Base[]) => any = n => { var n: Base[]; return null; } }
+>x83 : Symbol(x83, Decl(generatedContextualTyping.ts, 87, 68))
+>member : Symbol(x83.member, Decl(generatedContextualTyping.ts, 88, 11))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 88, 35))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 88, 54), Decl(generatedContextualTyping.ts, 88, 65))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 88, 54), Decl(generatedContextualTyping.ts, 88, 65))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+
+class x84 { public static member: Genric<Base> = { func: n => { return [d1, d2]; } } }
+>x84 : Symbol(x84, Decl(generatedContextualTyping.ts, 88, 93))
+>member : Symbol(x84.member, Decl(generatedContextualTyping.ts, 89, 11))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 89, 50))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 89, 56))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x85 { constructor(parm: () => Base[] = () => [d1, d2]) { } }
+>x85 : Symbol(x85, Decl(generatedContextualTyping.ts, 89, 86))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 90, 24))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x86 { constructor(parm: () => Base[] = function() { return [d1, d2] }) { } }
+>x86 : Symbol(x86, Decl(generatedContextualTyping.ts, 90, 66))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 91, 24))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x87 { constructor(parm: () => Base[] = function named() { return [d1, d2] }) { } }
+>x87 : Symbol(x87, Decl(generatedContextualTyping.ts, 91, 82))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 92, 24))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 92, 44))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x88 { constructor(parm: { (): Base[]; } = () => [d1, d2]) { } }
+>x88 : Symbol(x88, Decl(generatedContextualTyping.ts, 92, 88))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 93, 24))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x89 { constructor(parm: { (): Base[]; } = function() { return [d1, d2] }) { } }
+>x89 : Symbol(x89, Decl(generatedContextualTyping.ts, 93, 69))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 94, 24))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x90 { constructor(parm: { (): Base[]; } = function named() { return [d1, d2] }) { } }
+>x90 : Symbol(x90, Decl(generatedContextualTyping.ts, 94, 85))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 95, 24))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 95, 47))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x91 { constructor(parm: Base[] = [d1, d2]) { } }
+>x91 : Symbol(x91, Decl(generatedContextualTyping.ts, 95, 91))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 96, 24))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x92 { constructor(parm: Array<Base> = [d1, d2]) { } }
+>x92 : Symbol(x92, Decl(generatedContextualTyping.ts, 96, 54))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 97, 24))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x93 { constructor(parm: { [n: number]: Base; } = [d1, d2]) { } }
+>x93 : Symbol(x93, Decl(generatedContextualTyping.ts, 97, 59))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 98, 24))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 98, 33))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x94 { constructor(parm: {n: Base[]; }  = { n: [d1, d2] }) { } }
+>x94 : Symbol(x94, Decl(generatedContextualTyping.ts, 98, 70))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 99, 24))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 99, 31))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 99, 48))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x95 { constructor(parm: (s: Base[]) => any = n => { var n: Base[]; return null; }) { } }
+>x95 : Symbol(x95, Decl(generatedContextualTyping.ts, 99, 69))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 100, 24))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 100, 31))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 100, 50), Decl(generatedContextualTyping.ts, 100, 61))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 100, 50), Decl(generatedContextualTyping.ts, 100, 61))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+
+class x96 { constructor(parm: Genric<Base> = { func: n => { return [d1, d2]; } }) { } }
+>x96 : Symbol(x96, Decl(generatedContextualTyping.ts, 100, 94))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 101, 24))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 101, 46))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 101, 52))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x97 { constructor(public parm: () => Base[] = () => [d1, d2]) { } }
+>x97 : Symbol(x97, Decl(generatedContextualTyping.ts, 101, 87))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 102, 24))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x98 { constructor(public parm: () => Base[] = function() { return [d1, d2] }) { } }
+>x98 : Symbol(x98, Decl(generatedContextualTyping.ts, 102, 73))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 103, 24))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x99 { constructor(public parm: () => Base[] = function named() { return [d1, d2] }) { } }
+>x99 : Symbol(x99, Decl(generatedContextualTyping.ts, 103, 89))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 104, 24))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 104, 51))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x100 { constructor(public parm: { (): Base[]; } = () => [d1, d2]) { } }
+>x100 : Symbol(x100, Decl(generatedContextualTyping.ts, 104, 95))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 105, 25))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x101 { constructor(public parm: { (): Base[]; } = function() { return [d1, d2] }) { } }
+>x101 : Symbol(x101, Decl(generatedContextualTyping.ts, 105, 77))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 106, 25))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x102 { constructor(public parm: { (): Base[]; } = function named() { return [d1, d2] }) { } }
+>x102 : Symbol(x102, Decl(generatedContextualTyping.ts, 106, 93))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 107, 25))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 107, 55))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x103 { constructor(public parm: Base[] = [d1, d2]) { } }
+>x103 : Symbol(x103, Decl(generatedContextualTyping.ts, 107, 99))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 108, 25))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x104 { constructor(public parm: Array<Base> = [d1, d2]) { } }
+>x104 : Symbol(x104, Decl(generatedContextualTyping.ts, 108, 62))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 109, 25))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x105 { constructor(public parm: { [n: number]: Base; } = [d1, d2]) { } }
+>x105 : Symbol(x105, Decl(generatedContextualTyping.ts, 109, 67))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 110, 25))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 110, 41))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x106 { constructor(public parm: {n: Base[]; }  = { n: [d1, d2] }) { } }
+>x106 : Symbol(x106, Decl(generatedContextualTyping.ts, 110, 78))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 111, 25))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 111, 39))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 111, 56))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x107 { constructor(public parm: (s: Base[]) => any = n => { var n: Base[]; return null; }) { } }
+>x107 : Symbol(x107, Decl(generatedContextualTyping.ts, 111, 77))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 112, 25))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 112, 39))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 112, 58), Decl(generatedContextualTyping.ts, 112, 69))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 112, 58), Decl(generatedContextualTyping.ts, 112, 69))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+
+class x108 { constructor(public parm: Genric<Base> = { func: n => { return [d1, d2]; } }) { } }
+>x108 : Symbol(x108, Decl(generatedContextualTyping.ts, 112, 102))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 113, 25))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 113, 54))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 113, 60))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x109 { constructor(private parm: () => Base[] = () => [d1, d2]) { } }
+>x109 : Symbol(x109, Decl(generatedContextualTyping.ts, 113, 95))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 114, 25))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x110 { constructor(private parm: () => Base[] = function() { return [d1, d2] }) { } }
+>x110 : Symbol(x110, Decl(generatedContextualTyping.ts, 114, 75))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 115, 25))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x111 { constructor(private parm: () => Base[] = function named() { return [d1, d2] }) { } }
+>x111 : Symbol(x111, Decl(generatedContextualTyping.ts, 115, 91))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 116, 25))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 116, 53))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x112 { constructor(private parm: { (): Base[]; } = () => [d1, d2]) { } }
+>x112 : Symbol(x112, Decl(generatedContextualTyping.ts, 116, 97))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 117, 25))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x113 { constructor(private parm: { (): Base[]; } = function() { return [d1, d2] }) { } }
+>x113 : Symbol(x113, Decl(generatedContextualTyping.ts, 117, 78))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 118, 25))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x114 { constructor(private parm: { (): Base[]; } = function named() { return [d1, d2] }) { } }
+>x114 : Symbol(x114, Decl(generatedContextualTyping.ts, 118, 94))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 119, 25))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 119, 56))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x115 { constructor(private parm: Base[] = [d1, d2]) { } }
+>x115 : Symbol(x115, Decl(generatedContextualTyping.ts, 119, 100))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 120, 25))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x116 { constructor(private parm: Array<Base> = [d1, d2]) { } }
+>x116 : Symbol(x116, Decl(generatedContextualTyping.ts, 120, 63))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 121, 25))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x117 { constructor(private parm: { [n: number]: Base; } = [d1, d2]) { } }
+>x117 : Symbol(x117, Decl(generatedContextualTyping.ts, 121, 68))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 122, 25))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 122, 42))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x118 { constructor(private parm: {n: Base[]; }  = { n: [d1, d2] }) { } }
+>x118 : Symbol(x118, Decl(generatedContextualTyping.ts, 122, 79))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 123, 25))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 123, 40))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 123, 57))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x119 { constructor(private parm: (s: Base[]) => any = n => { var n: Base[]; return null; }) { } }
+>x119 : Symbol(x119, Decl(generatedContextualTyping.ts, 123, 78))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 124, 25))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 124, 40))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 124, 59), Decl(generatedContextualTyping.ts, 124, 70))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 124, 59), Decl(generatedContextualTyping.ts, 124, 70))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+
+class x120 { constructor(private parm: Genric<Base> = { func: n => { return [d1, d2]; } }) { } }
+>x120 : Symbol(x120, Decl(generatedContextualTyping.ts, 124, 103))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 125, 25))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 125, 55))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 125, 61))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x121(parm: () => Base[] = () => [d1, d2]) { }
+>x121 : Symbol(x121, Decl(generatedContextualTyping.ts, 125, 96))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 126, 14))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x122(parm: () => Base[] = function() { return [d1, d2] }) { }
+>x122 : Symbol(x122, Decl(generatedContextualTyping.ts, 126, 54))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 127, 14))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x123(parm: () => Base[] = function named() { return [d1, d2] }) { }
+>x123 : Symbol(x123, Decl(generatedContextualTyping.ts, 127, 70))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 128, 14))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 128, 34))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x124(parm: { (): Base[]; } = () => [d1, d2]) { }
+>x124 : Symbol(x124, Decl(generatedContextualTyping.ts, 128, 76))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 129, 14))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x125(parm: { (): Base[]; } = function() { return [d1, d2] }) { }
+>x125 : Symbol(x125, Decl(generatedContextualTyping.ts, 129, 57))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 130, 14))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x126(parm: { (): Base[]; } = function named() { return [d1, d2] }) { }
+>x126 : Symbol(x126, Decl(generatedContextualTyping.ts, 130, 73))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 131, 14))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 131, 37))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x127(parm: Base[] = [d1, d2]) { }
+>x127 : Symbol(x127, Decl(generatedContextualTyping.ts, 131, 79))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 132, 14))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x128(parm: Array<Base> = [d1, d2]) { }
+>x128 : Symbol(x128, Decl(generatedContextualTyping.ts, 132, 42))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 133, 14))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x129(parm: { [n: number]: Base; } = [d1, d2]) { }
+>x129 : Symbol(x129, Decl(generatedContextualTyping.ts, 133, 47))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 134, 14))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 134, 23))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x130(parm: {n: Base[]; }  = { n: [d1, d2] }) { }
+>x130 : Symbol(x130, Decl(generatedContextualTyping.ts, 134, 58))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 135, 14))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 135, 21))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 135, 38))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x131(parm: (s: Base[]) => any = n => { var n: Base[]; return null; }) { }
+>x131 : Symbol(x131, Decl(generatedContextualTyping.ts, 135, 57))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 136, 14))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 136, 21))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 136, 40), Decl(generatedContextualTyping.ts, 136, 51))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 136, 40), Decl(generatedContextualTyping.ts, 136, 51))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+
+function x132(parm: Genric<Base> = { func: n => { return [d1, d2]; } }) { }
+>x132 : Symbol(x132, Decl(generatedContextualTyping.ts, 136, 82))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 137, 14))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 137, 36))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 137, 42))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x133(): () => Base[] { return () => [d1, d2]; }
+>x133 : Symbol(x133, Decl(generatedContextualTyping.ts, 137, 75))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x134(): () => Base[] { return function() { return [d1, d2] }; }
+>x134 : Symbol(x134, Decl(generatedContextualTyping.ts, 138, 56))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x135(): () => Base[] { return function named() { return [d1, d2] }; }
+>x135 : Symbol(x135, Decl(generatedContextualTyping.ts, 139, 72))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 140, 38))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x136(): { (): Base[]; } { return () => [d1, d2]; }
+>x136 : Symbol(x136, Decl(generatedContextualTyping.ts, 140, 78))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x137(): { (): Base[]; } { return function() { return [d1, d2] }; }
+>x137 : Symbol(x137, Decl(generatedContextualTyping.ts, 141, 59))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x138(): { (): Base[]; } { return function named() { return [d1, d2] }; }
+>x138 : Symbol(x138, Decl(generatedContextualTyping.ts, 142, 75))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 143, 41))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x139(): Base[] { return [d1, d2]; }
+>x139 : Symbol(x139, Decl(generatedContextualTyping.ts, 143, 81))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x140(): Array<Base> { return [d1, d2]; }
+>x140 : Symbol(x140, Decl(generatedContextualTyping.ts, 144, 44))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x141(): { [n: number]: Base; } { return [d1, d2]; }
+>x141 : Symbol(x141, Decl(generatedContextualTyping.ts, 145, 49))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 146, 20))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x142(): {n: Base[]; }  { return { n: [d1, d2] }; }
+>x142 : Symbol(x142, Decl(generatedContextualTyping.ts, 146, 60))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 147, 18))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 147, 42))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x143(): (s: Base[]) => any { return n => { var n: Base[]; return null; }; }
+>x143 : Symbol(x143, Decl(generatedContextualTyping.ts, 147, 59))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 148, 18))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 148, 44), Decl(generatedContextualTyping.ts, 148, 55))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 148, 44), Decl(generatedContextualTyping.ts, 148, 55))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+
+function x144(): Genric<Base> { return { func: n => { return [d1, d2]; } }; }
+>x144 : Symbol(x144, Decl(generatedContextualTyping.ts, 148, 84))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 149, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 149, 46))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x145(): () => Base[] { return () => [d1, d2]; return () => [d1, d2]; }
+>x145 : Symbol(x145, Decl(generatedContextualTyping.ts, 149, 77))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x146(): () => Base[] { return function() { return [d1, d2] }; return function() { return [d1, d2] }; }
+>x146 : Symbol(x146, Decl(generatedContextualTyping.ts, 150, 79))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x147(): () => Base[] { return function named() { return [d1, d2] }; return function named() { return [d1, d2] }; }
+>x147 : Symbol(x147, Decl(generatedContextualTyping.ts, 151, 111))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 152, 38))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 152, 83))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x148(): { (): Base[]; } { return () => [d1, d2]; return () => [d1, d2]; }
+>x148 : Symbol(x148, Decl(generatedContextualTyping.ts, 152, 123))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x149(): { (): Base[]; } { return function() { return [d1, d2] }; return function() { return [d1, d2] }; }
+>x149 : Symbol(x149, Decl(generatedContextualTyping.ts, 153, 82))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x150(): { (): Base[]; } { return function named() { return [d1, d2] }; return function named() { return [d1, d2] }; }
+>x150 : Symbol(x150, Decl(generatedContextualTyping.ts, 154, 114))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 155, 41))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 155, 86))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x151(): Base[] { return [d1, d2]; return [d1, d2]; }
+>x151 : Symbol(x151, Decl(generatedContextualTyping.ts, 155, 126))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x152(): Array<Base> { return [d1, d2]; return [d1, d2]; }
+>x152 : Symbol(x152, Decl(generatedContextualTyping.ts, 156, 61))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x153(): { [n: number]: Base; } { return [d1, d2]; return [d1, d2]; }
+>x153 : Symbol(x153, Decl(generatedContextualTyping.ts, 157, 66))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 158, 20))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x154(): {n: Base[]; }  { return { n: [d1, d2] }; return { n: [d1, d2] }; }
+>x154 : Symbol(x154, Decl(generatedContextualTyping.ts, 158, 77))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 18))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 42))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 66))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x155(): (s: Base[]) => any { return n => { var n: Base[]; return null; }; return n => { var n: Base[]; return null; }; }
+>x155 : Symbol(x155, Decl(generatedContextualTyping.ts, 159, 83))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 160, 18))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 160, 44), Decl(generatedContextualTyping.ts, 160, 55))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 160, 44), Decl(generatedContextualTyping.ts, 160, 55))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 160, 89), Decl(generatedContextualTyping.ts, 160, 100))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 160, 89), Decl(generatedContextualTyping.ts, 160, 100))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+
+function x156(): Genric<Base> { return { func: n => { return [d1, d2]; } }; return { func: n => { return [d1, d2]; } }; }
+>x156 : Symbol(x156, Decl(generatedContextualTyping.ts, 160, 129))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 161, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 161, 46))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 161, 84))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 161, 90))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x157: () => () => Base[] = () => { return () => [d1, d2]; };
+>x157 : Symbol(x157, Decl(generatedContextualTyping.ts, 162, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x158: () => () => Base[] = () => { return function() { return [d1, d2] }; };
+>x158 : Symbol(x158, Decl(generatedContextualTyping.ts, 163, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x159: () => () => Base[] = () => { return function named() { return [d1, d2] }; };
+>x159 : Symbol(x159, Decl(generatedContextualTyping.ts, 164, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 164, 45))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x160: () => { (): Base[]; } = () => { return () => [d1, d2]; };
+>x160 : Symbol(x160, Decl(generatedContextualTyping.ts, 165, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x161: () => { (): Base[]; } = () => { return function() { return [d1, d2] }; };
+>x161 : Symbol(x161, Decl(generatedContextualTyping.ts, 166, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x162: () => { (): Base[]; } = () => { return function named() { return [d1, d2] }; };
+>x162 : Symbol(x162, Decl(generatedContextualTyping.ts, 167, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 167, 48))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x163: () => Base[] = () => { return [d1, d2]; };
+>x163 : Symbol(x163, Decl(generatedContextualTyping.ts, 168, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x164: () => Array<Base> = () => { return [d1, d2]; };
+>x164 : Symbol(x164, Decl(generatedContextualTyping.ts, 169, 3))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x165: () => { [n: number]: Base; } = () => { return [d1, d2]; };
+>x165 : Symbol(x165, Decl(generatedContextualTyping.ts, 170, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 170, 19))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x166: () => {n: Base[]; }  = () => { return { n: [d1, d2] }; };
+>x166 : Symbol(x166, Decl(generatedContextualTyping.ts, 171, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 171, 17))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 171, 49))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x167: () => (s: Base[]) => any = () => { return n => { var n: Base[]; return null; }; };
+>x167 : Symbol(x167, Decl(generatedContextualTyping.ts, 172, 3))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 172, 17))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 172, 51), Decl(generatedContextualTyping.ts, 172, 62))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 172, 51), Decl(generatedContextualTyping.ts, 172, 62))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+
+var x168: () => Genric<Base> = () => { return { func: n => { return [d1, d2]; } }; };
+>x168 : Symbol(x168, Decl(generatedContextualTyping.ts, 173, 3))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 173, 47))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 173, 53))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x169: () => () => Base[] = function() { return () => [d1, d2]; };
+>x169 : Symbol(x169, Decl(generatedContextualTyping.ts, 174, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x170: () => () => Base[] = function() { return function() { return [d1, d2] }; };
+>x170 : Symbol(x170, Decl(generatedContextualTyping.ts, 175, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x171: () => () => Base[] = function() { return function named() { return [d1, d2] }; };
+>x171 : Symbol(x171, Decl(generatedContextualTyping.ts, 176, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 176, 50))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x172: () => { (): Base[]; } = function() { return () => [d1, d2]; };
+>x172 : Symbol(x172, Decl(generatedContextualTyping.ts, 177, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x173: () => { (): Base[]; } = function() { return function() { return [d1, d2] }; };
+>x173 : Symbol(x173, Decl(generatedContextualTyping.ts, 178, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x174: () => { (): Base[]; } = function() { return function named() { return [d1, d2] }; };
+>x174 : Symbol(x174, Decl(generatedContextualTyping.ts, 179, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 179, 53))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x175: () => Base[] = function() { return [d1, d2]; };
+>x175 : Symbol(x175, Decl(generatedContextualTyping.ts, 180, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x176: () => Array<Base> = function() { return [d1, d2]; };
+>x176 : Symbol(x176, Decl(generatedContextualTyping.ts, 181, 3))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x177: () => { [n: number]: Base; } = function() { return [d1, d2]; };
+>x177 : Symbol(x177, Decl(generatedContextualTyping.ts, 182, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 182, 19))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x178: () => {n: Base[]; }  = function() { return { n: [d1, d2] }; };
+>x178 : Symbol(x178, Decl(generatedContextualTyping.ts, 183, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 183, 17))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 183, 54))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x179: () => (s: Base[]) => any = function() { return n => { var n: Base[]; return null; }; };
+>x179 : Symbol(x179, Decl(generatedContextualTyping.ts, 184, 3))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 184, 17))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 184, 56), Decl(generatedContextualTyping.ts, 184, 67))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 184, 56), Decl(generatedContextualTyping.ts, 184, 67))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+
+var x180: () => Genric<Base> = function() { return { func: n => { return [d1, d2]; } }; };
+>x180 : Symbol(x180, Decl(generatedContextualTyping.ts, 185, 3))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 185, 52))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 185, 58))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+module x181 { var t: () => Base[] = () => [d1, d2]; }
+>x181 : Symbol(x181, Decl(generatedContextualTyping.ts, 185, 90))
+>t : Symbol(t, Decl(generatedContextualTyping.ts, 186, 17))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+module x182 { var t: () => Base[] = function() { return [d1, d2] }; }
+>x182 : Symbol(x182, Decl(generatedContextualTyping.ts, 186, 53))
+>t : Symbol(t, Decl(generatedContextualTyping.ts, 187, 17))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+module x183 { var t: () => Base[] = function named() { return [d1, d2] }; }
+>x183 : Symbol(x183, Decl(generatedContextualTyping.ts, 187, 69))
+>t : Symbol(t, Decl(generatedContextualTyping.ts, 188, 17))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 188, 35))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+module x184 { var t: { (): Base[]; } = () => [d1, d2]; }
+>x184 : Symbol(x184, Decl(generatedContextualTyping.ts, 188, 75))
+>t : Symbol(t, Decl(generatedContextualTyping.ts, 189, 17))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+module x185 { var t: { (): Base[]; } = function() { return [d1, d2] }; }
+>x185 : Symbol(x185, Decl(generatedContextualTyping.ts, 189, 56))
+>t : Symbol(t, Decl(generatedContextualTyping.ts, 190, 17))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+module x186 { var t: { (): Base[]; } = function named() { return [d1, d2] }; }
+>x186 : Symbol(x186, Decl(generatedContextualTyping.ts, 190, 72))
+>t : Symbol(t, Decl(generatedContextualTyping.ts, 191, 17))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 191, 38))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+module x187 { var t: Base[] = [d1, d2]; }
+>x187 : Symbol(x187, Decl(generatedContextualTyping.ts, 191, 78))
+>t : Symbol(t, Decl(generatedContextualTyping.ts, 192, 17))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+module x188 { var t: Array<Base> = [d1, d2]; }
+>x188 : Symbol(x188, Decl(generatedContextualTyping.ts, 192, 41))
+>t : Symbol(t, Decl(generatedContextualTyping.ts, 193, 17))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+module x189 { var t: { [n: number]: Base; } = [d1, d2]; }
+>x189 : Symbol(x189, Decl(generatedContextualTyping.ts, 193, 46))
+>t : Symbol(t, Decl(generatedContextualTyping.ts, 194, 17))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 194, 24))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+module x190 { var t: {n: Base[]; }  = { n: [d1, d2] }; }
+>x190 : Symbol(x190, Decl(generatedContextualTyping.ts, 194, 57))
+>t : Symbol(t, Decl(generatedContextualTyping.ts, 195, 17))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 195, 22))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 195, 39))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+module x191 { var t: (s: Base[]) => any = n => { var n: Base[]; return null; }; }
+>x191 : Symbol(x191, Decl(generatedContextualTyping.ts, 195, 56))
+>t : Symbol(t, Decl(generatedContextualTyping.ts, 196, 17))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 196, 22))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 196, 41), Decl(generatedContextualTyping.ts, 196, 52))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 196, 41), Decl(generatedContextualTyping.ts, 196, 52))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+
+module x192 { var t: Genric<Base> = { func: n => { return [d1, d2]; } }; }
+>x192 : Symbol(x192, Decl(generatedContextualTyping.ts, 196, 81))
+>t : Symbol(t, Decl(generatedContextualTyping.ts, 197, 17))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 197, 37))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 197, 43))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+module x193 { export var t: () => Base[] = () => [d1, d2]; }
+>x193 : Symbol(x193, Decl(generatedContextualTyping.ts, 197, 74))
+>t : Symbol(t, Decl(generatedContextualTyping.ts, 198, 24))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+module x194 { export var t: () => Base[] = function() { return [d1, d2] }; }
+>x194 : Symbol(x194, Decl(generatedContextualTyping.ts, 198, 60))
+>t : Symbol(t, Decl(generatedContextualTyping.ts, 199, 24))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+module x195 { export var t: () => Base[] = function named() { return [d1, d2] }; }
+>x195 : Symbol(x195, Decl(generatedContextualTyping.ts, 199, 76))
+>t : Symbol(t, Decl(generatedContextualTyping.ts, 200, 24))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 200, 42))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+module x196 { export var t: { (): Base[]; } = () => [d1, d2]; }
+>x196 : Symbol(x196, Decl(generatedContextualTyping.ts, 200, 82))
+>t : Symbol(t, Decl(generatedContextualTyping.ts, 201, 24))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+module x197 { export var t: { (): Base[]; } = function() { return [d1, d2] }; }
+>x197 : Symbol(x197, Decl(generatedContextualTyping.ts, 201, 63))
+>t : Symbol(t, Decl(generatedContextualTyping.ts, 202, 24))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+module x198 { export var t: { (): Base[]; } = function named() { return [d1, d2] }; }
+>x198 : Symbol(x198, Decl(generatedContextualTyping.ts, 202, 79))
+>t : Symbol(t, Decl(generatedContextualTyping.ts, 203, 24))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 203, 45))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+module x199 { export var t: Base[] = [d1, d2]; }
+>x199 : Symbol(x199, Decl(generatedContextualTyping.ts, 203, 85))
+>t : Symbol(t, Decl(generatedContextualTyping.ts, 204, 24))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+module x200 { export var t: Array<Base> = [d1, d2]; }
+>x200 : Symbol(x200, Decl(generatedContextualTyping.ts, 204, 48))
+>t : Symbol(t, Decl(generatedContextualTyping.ts, 205, 24))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+module x201 { export var t: { [n: number]: Base; } = [d1, d2]; }
+>x201 : Symbol(x201, Decl(generatedContextualTyping.ts, 205, 53))
+>t : Symbol(t, Decl(generatedContextualTyping.ts, 206, 24))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 206, 31))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+module x202 { export var t: {n: Base[]; }  = { n: [d1, d2] }; }
+>x202 : Symbol(x202, Decl(generatedContextualTyping.ts, 206, 64))
+>t : Symbol(t, Decl(generatedContextualTyping.ts, 207, 24))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 207, 29))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 207, 46))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+module x203 { export var t: (s: Base[]) => any = n => { var n: Base[]; return null; }; }
+>x203 : Symbol(x203, Decl(generatedContextualTyping.ts, 207, 63))
+>t : Symbol(t, Decl(generatedContextualTyping.ts, 208, 24))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 208, 29))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 208, 48), Decl(generatedContextualTyping.ts, 208, 59))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 208, 48), Decl(generatedContextualTyping.ts, 208, 59))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+
+module x204 { export var t: Genric<Base> = { func: n => { return [d1, d2]; } }; }
+>x204 : Symbol(x204, Decl(generatedContextualTyping.ts, 208, 88))
+>t : Symbol(t, Decl(generatedContextualTyping.ts, 209, 24))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 209, 44))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 209, 50))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x206 = <() => Base[]>function() { return [d1, d2] };
+>x206 : Symbol(x206, Decl(generatedContextualTyping.ts, 210, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x207 = <() => Base[]>function named() { return [d1, d2] };
+>x207 : Symbol(x207, Decl(generatedContextualTyping.ts, 211, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 211, 25))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x209 = <{ (): Base[]; }>function() { return [d1, d2] };
+>x209 : Symbol(x209, Decl(generatedContextualTyping.ts, 212, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x210 = <{ (): Base[]; }>function named() { return [d1, d2] };
+>x210 : Symbol(x210, Decl(generatedContextualTyping.ts, 213, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 213, 28))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x211 = <Base[]>[d1, d2];
+>x211 : Symbol(x211, Decl(generatedContextualTyping.ts, 214, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x212 = <Array<Base>>[d1, d2];
+>x212 : Symbol(x212, Decl(generatedContextualTyping.ts, 215, 3))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x213 = <{ [n: number]: Base; }>[d1, d2];
+>x213 : Symbol(x213, Decl(generatedContextualTyping.ts, 216, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 216, 15))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x214 = <{n: Base[]; } >{ n: [d1, d2] };
+>x214 : Symbol(x214, Decl(generatedContextualTyping.ts, 217, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 217, 13))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 217, 28))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x216 = <Genric<Base>>{ func: n => { return [d1, d2]; } };
+>x216 : Symbol(x216, Decl(generatedContextualTyping.ts, 218, 3))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 218, 26))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 218, 32))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x217 = (<() => Base[]>undefined) || function() { return [d1, d2] };
+>x217 : Symbol(x217, Decl(generatedContextualTyping.ts, 219, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>undefined : Symbol(undefined)
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x218 = (<() => Base[]>undefined) || function named() { return [d1, d2] };
+>x218 : Symbol(x218, Decl(generatedContextualTyping.ts, 220, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>undefined : Symbol(undefined)
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 220, 39))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x219 = (<{ (): Base[]; }>undefined) || function() { return [d1, d2] };
+>x219 : Symbol(x219, Decl(generatedContextualTyping.ts, 221, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>undefined : Symbol(undefined)
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x220 = (<{ (): Base[]; }>undefined) || function named() { return [d1, d2] };
+>x220 : Symbol(x220, Decl(generatedContextualTyping.ts, 222, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>undefined : Symbol(undefined)
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 222, 42))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x221 = (<Base[]>undefined) || [d1, d2];
+>x221 : Symbol(x221, Decl(generatedContextualTyping.ts, 223, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>undefined : Symbol(undefined)
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x222 = (<Array<Base>>undefined) || [d1, d2];
+>x222 : Symbol(x222, Decl(generatedContextualTyping.ts, 224, 3))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>undefined : Symbol(undefined)
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x223 = (<{ [n: number]: Base; }>undefined) || [d1, d2];
+>x223 : Symbol(x223, Decl(generatedContextualTyping.ts, 225, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 225, 16))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>undefined : Symbol(undefined)
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x224 = (<{n: Base[]; } >undefined) || { n: [d1, d2] };
+>x224 : Symbol(x224, Decl(generatedContextualTyping.ts, 226, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 226, 14))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>undefined : Symbol(undefined)
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 226, 43))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x225: () => Base[]; x225 = () => [d1, d2];
+>x225 : Symbol(x225, Decl(generatedContextualTyping.ts, 227, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x225 : Symbol(x225, Decl(generatedContextualTyping.ts, 227, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x226: () => Base[]; x226 = function() { return [d1, d2] };
+>x226 : Symbol(x226, Decl(generatedContextualTyping.ts, 228, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x226 : Symbol(x226, Decl(generatedContextualTyping.ts, 228, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x227: () => Base[]; x227 = function named() { return [d1, d2] };
+>x227 : Symbol(x227, Decl(generatedContextualTyping.ts, 229, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x227 : Symbol(x227, Decl(generatedContextualTyping.ts, 229, 3))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 229, 30))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x228: { (): Base[]; }; x228 = () => [d1, d2];
+>x228 : Symbol(x228, Decl(generatedContextualTyping.ts, 230, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x228 : Symbol(x228, Decl(generatedContextualTyping.ts, 230, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x229: { (): Base[]; }; x229 = function() { return [d1, d2] };
+>x229 : Symbol(x229, Decl(generatedContextualTyping.ts, 231, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x229 : Symbol(x229, Decl(generatedContextualTyping.ts, 231, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x230: { (): Base[]; }; x230 = function named() { return [d1, d2] };
+>x230 : Symbol(x230, Decl(generatedContextualTyping.ts, 232, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x230 : Symbol(x230, Decl(generatedContextualTyping.ts, 232, 3))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 232, 33))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x231: Base[]; x231 = [d1, d2];
+>x231 : Symbol(x231, Decl(generatedContextualTyping.ts, 233, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x231 : Symbol(x231, Decl(generatedContextualTyping.ts, 233, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x232: Array<Base>; x232 = [d1, d2];
+>x232 : Symbol(x232, Decl(generatedContextualTyping.ts, 234, 3))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x232 : Symbol(x232, Decl(generatedContextualTyping.ts, 234, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x233: { [n: number]: Base; }; x233 = [d1, d2];
+>x233 : Symbol(x233, Decl(generatedContextualTyping.ts, 235, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 235, 13))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x233 : Symbol(x233, Decl(generatedContextualTyping.ts, 235, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x234: {n: Base[]; } ; x234 = { n: [d1, d2] };
+>x234 : Symbol(x234, Decl(generatedContextualTyping.ts, 236, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 236, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x234 : Symbol(x234, Decl(generatedContextualTyping.ts, 236, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 236, 34))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x235: (s: Base[]) => any; x235 = n => { var n: Base[]; return null; };
+>x235 : Symbol(x235, Decl(generatedContextualTyping.ts, 237, 3))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 237, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x235 : Symbol(x235, Decl(generatedContextualTyping.ts, 237, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 237, 36), Decl(generatedContextualTyping.ts, 237, 47))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 237, 36), Decl(generatedContextualTyping.ts, 237, 47))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+
+var x236: Genric<Base>; x236 = { func: n => { return [d1, d2]; } };
+>x236 : Symbol(x236, Decl(generatedContextualTyping.ts, 238, 3))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x236 : Symbol(x236, Decl(generatedContextualTyping.ts, 238, 3))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 238, 32))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 238, 38))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x237: { n: () => Base[]; } = { n: () => [d1, d2] };
+>x237 : Symbol(x237, Decl(generatedContextualTyping.ts, 239, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 239, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 239, 34))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x238: { n: () => Base[]; } = { n: function() { return [d1, d2] } };
+>x238 : Symbol(x238, Decl(generatedContextualTyping.ts, 240, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 240, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 240, 34))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x239: { n: () => Base[]; } = { n: function named() { return [d1, d2] } };
+>x239 : Symbol(x239, Decl(generatedContextualTyping.ts, 241, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 241, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 241, 34))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 241, 37))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x240: { n: { (): Base[]; }; } = { n: () => [d1, d2] };
+>x240 : Symbol(x240, Decl(generatedContextualTyping.ts, 242, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 242, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 242, 37))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x241: { n: { (): Base[]; }; } = { n: function() { return [d1, d2] } };
+>x241 : Symbol(x241, Decl(generatedContextualTyping.ts, 243, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 243, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 243, 37))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x242: { n: { (): Base[]; }; } = { n: function named() { return [d1, d2] } };
+>x242 : Symbol(x242, Decl(generatedContextualTyping.ts, 244, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 244, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 244, 37))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 244, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x243: { n: Base[]; } = { n: [d1, d2] };
+>x243 : Symbol(x243, Decl(generatedContextualTyping.ts, 245, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 245, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 245, 28))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x244: { n: Array<Base>; } = { n: [d1, d2] };
+>x244 : Symbol(x244, Decl(generatedContextualTyping.ts, 246, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 246, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 246, 33))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x245: { n: { [n: number]: Base; }; } = { n: [d1, d2] };
+>x245 : Symbol(x245, Decl(generatedContextualTyping.ts, 247, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 11))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 18))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 44))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x246: { n: {n: Base[]; } ; } = { n: { n: [d1, d2] } };
+>x246 : Symbol(x246, Decl(generatedContextualTyping.ts, 248, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 11))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 16))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 36))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 41))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x247: { n: (s: Base[]) => any; } = { n: n => { var n: Base[]; return null; } };
+>x247 : Symbol(x247, Decl(generatedContextualTyping.ts, 249, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 11))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 249, 16))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 43), Decl(generatedContextualTyping.ts, 249, 54))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 43), Decl(generatedContextualTyping.ts, 249, 54))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+
+var x248: { n: Genric<Base>; } = { n: { func: n => { return [d1, d2]; } } };
+>x248 : Symbol(x248, Decl(generatedContextualTyping.ts, 250, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 250, 11))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 250, 34))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 250, 39))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 250, 45))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x252: { (): Base[]; }[] = [() => [d1, d2]];
+>x252 : Symbol(x252, Decl(generatedContextualTyping.ts, 251, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x253: { (): Base[]; }[] = [function() { return [d1, d2] }];
+>x253 : Symbol(x253, Decl(generatedContextualTyping.ts, 252, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x254: { (): Base[]; }[] = [function named() { return [d1, d2] }];
+>x254 : Symbol(x254, Decl(generatedContextualTyping.ts, 253, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 253, 31))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x255: Base[][] = [[d1, d2]];
+>x255 : Symbol(x255, Decl(generatedContextualTyping.ts, 254, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x256: Array<Base>[] = [[d1, d2]];
+>x256 : Symbol(x256, Decl(generatedContextualTyping.ts, 255, 3))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x257: { [n: number]: Base; }[] = [[d1, d2]];
+>x257 : Symbol(x257, Decl(generatedContextualTyping.ts, 256, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 256, 13))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x258: {n: Base[]; } [] = [{ n: [d1, d2] }];
+>x258 : Symbol(x258, Decl(generatedContextualTyping.ts, 257, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 257, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 257, 31))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x260: Genric<Base>[] = [{ func: n => { return [d1, d2]; } }];
+>x260 : Symbol(x260, Decl(generatedContextualTyping.ts, 258, 3))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 258, 29))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 258, 35))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x261: () => Base[] = function() { return [d1, d2] } || undefined;
+>x261 : Symbol(x261, Decl(generatedContextualTyping.ts, 259, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>undefined : Symbol(undefined)
+
+var x262: () => Base[] = function named() { return [d1, d2] } || undefined;
+>x262 : Symbol(x262, Decl(generatedContextualTyping.ts, 260, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 260, 24))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>undefined : Symbol(undefined)
+
+var x263: { (): Base[]; } = function() { return [d1, d2] } || undefined;
+>x263 : Symbol(x263, Decl(generatedContextualTyping.ts, 261, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>undefined : Symbol(undefined)
+
+var x264: { (): Base[]; } = function named() { return [d1, d2] } || undefined;
+>x264 : Symbol(x264, Decl(generatedContextualTyping.ts, 262, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 262, 27))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>undefined : Symbol(undefined)
+
+var x265: Base[] = [d1, d2] || undefined;
+>x265 : Symbol(x265, Decl(generatedContextualTyping.ts, 263, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>undefined : Symbol(undefined)
+
+var x266: Array<Base> = [d1, d2] || undefined;
+>x266 : Symbol(x266, Decl(generatedContextualTyping.ts, 264, 3))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>undefined : Symbol(undefined)
+
+var x267: { [n: number]: Base; } = [d1, d2] || undefined;
+>x267 : Symbol(x267, Decl(generatedContextualTyping.ts, 265, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 265, 13))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>undefined : Symbol(undefined)
+
+var x268: {n: Base[]; }  = { n: [d1, d2] } || undefined;
+>x268 : Symbol(x268, Decl(generatedContextualTyping.ts, 266, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 266, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 266, 28))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>undefined : Symbol(undefined)
+
+var x269: () => Base[] = undefined || function() { return [d1, d2] };
+>x269 : Symbol(x269, Decl(generatedContextualTyping.ts, 267, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>undefined : Symbol(undefined)
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x270: () => Base[] = undefined || function named() { return [d1, d2] };
+>x270 : Symbol(x270, Decl(generatedContextualTyping.ts, 268, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>undefined : Symbol(undefined)
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 268, 37))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x271: { (): Base[]; } = undefined || function() { return [d1, d2] };
+>x271 : Symbol(x271, Decl(generatedContextualTyping.ts, 269, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>undefined : Symbol(undefined)
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x272: { (): Base[]; } = undefined || function named() { return [d1, d2] };
+>x272 : Symbol(x272, Decl(generatedContextualTyping.ts, 270, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>undefined : Symbol(undefined)
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 270, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x273: Base[] = undefined || [d1, d2];
+>x273 : Symbol(x273, Decl(generatedContextualTyping.ts, 271, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>undefined : Symbol(undefined)
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x274: Array<Base> = undefined || [d1, d2];
+>x274 : Symbol(x274, Decl(generatedContextualTyping.ts, 272, 3))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>undefined : Symbol(undefined)
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x275: { [n: number]: Base; } = undefined || [d1, d2];
+>x275 : Symbol(x275, Decl(generatedContextualTyping.ts, 273, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 273, 13))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>undefined : Symbol(undefined)
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x276: {n: Base[]; }  = undefined || { n: [d1, d2] };
+>x276 : Symbol(x276, Decl(generatedContextualTyping.ts, 274, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 274, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>undefined : Symbol(undefined)
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 274, 41))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x277: () => Base[] = function() { return [d1, d2] } || function() { return [d1, d2] };
+>x277 : Symbol(x277, Decl(generatedContextualTyping.ts, 275, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x278: () => Base[] = function named() { return [d1, d2] } || function named() { return [d1, d2] };
+>x278 : Symbol(x278, Decl(generatedContextualTyping.ts, 276, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 276, 24))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 276, 64))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x279: { (): Base[]; } = function() { return [d1, d2] } || function() { return [d1, d2] };
+>x279 : Symbol(x279, Decl(generatedContextualTyping.ts, 277, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x280: { (): Base[]; } = function named() { return [d1, d2] } || function named() { return [d1, d2] };
+>x280 : Symbol(x280, Decl(generatedContextualTyping.ts, 278, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 278, 27))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 278, 67))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x281: Base[] = [d1, d2] || [d1, d2];
+>x281 : Symbol(x281, Decl(generatedContextualTyping.ts, 279, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x282: Array<Base> = [d1, d2] || [d1, d2];
+>x282 : Symbol(x282, Decl(generatedContextualTyping.ts, 280, 3))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x283: { [n: number]: Base; } = [d1, d2] || [d1, d2];
+>x283 : Symbol(x283, Decl(generatedContextualTyping.ts, 281, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 281, 13))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x284: {n: Base[]; }  = { n: [d1, d2] } || { n: [d1, d2] };
+>x284 : Symbol(x284, Decl(generatedContextualTyping.ts, 282, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 282, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 282, 28))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 282, 47))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x285: () => Base[] = true ? () => [d1, d2] : () => [d1, d2];
+>x285 : Symbol(x285, Decl(generatedContextualTyping.ts, 283, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x286: () => Base[] = true ? function() { return [d1, d2] } : function() { return [d1, d2] };
+>x286 : Symbol(x286, Decl(generatedContextualTyping.ts, 284, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x287: () => Base[] = true ? function named() { return [d1, d2] } : function named() { return [d1, d2] };
+>x287 : Symbol(x287, Decl(generatedContextualTyping.ts, 285, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 285, 31))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 285, 70))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x288: { (): Base[]; } = true ? () => [d1, d2] : () => [d1, d2];
+>x288 : Symbol(x288, Decl(generatedContextualTyping.ts, 286, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x289: { (): Base[]; } = true ? function() { return [d1, d2] } : function() { return [d1, d2] };
+>x289 : Symbol(x289, Decl(generatedContextualTyping.ts, 287, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x290: { (): Base[]; } = true ? function named() { return [d1, d2] } : function named() { return [d1, d2] };
+>x290 : Symbol(x290, Decl(generatedContextualTyping.ts, 288, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 288, 34))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 288, 73))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x291: Base[] = true ? [d1, d2] : [d1, d2];
+>x291 : Symbol(x291, Decl(generatedContextualTyping.ts, 289, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x292: Array<Base> = true ? [d1, d2] : [d1, d2];
+>x292 : Symbol(x292, Decl(generatedContextualTyping.ts, 290, 3))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x293: { [n: number]: Base; } = true ? [d1, d2] : [d1, d2];
+>x293 : Symbol(x293, Decl(generatedContextualTyping.ts, 291, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 291, 13))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x294: {n: Base[]; }  = true ? { n: [d1, d2] } : { n: [d1, d2] };
+>x294 : Symbol(x294, Decl(generatedContextualTyping.ts, 292, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 35))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 53))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x295: (s: Base[]) => any = true ? n => { var n: Base[]; return null; } : n => { var n: Base[]; return null; };
+>x295 : Symbol(x295, Decl(generatedContextualTyping.ts, 293, 3))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 293, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 293, 37), Decl(generatedContextualTyping.ts, 293, 48))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 293, 37), Decl(generatedContextualTyping.ts, 293, 48))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 293, 76), Decl(generatedContextualTyping.ts, 293, 87))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 293, 76), Decl(generatedContextualTyping.ts, 293, 87))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+
+var x296: Genric<Base> = true ? { func: n => { return [d1, d2]; } } : { func: n => { return [d1, d2]; } };
+>x296 : Symbol(x296, Decl(generatedContextualTyping.ts, 294, 3))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 294, 33))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 294, 39))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 294, 71))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 294, 77))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x297: () => Base[] = true ? undefined : () => [d1, d2];
+>x297 : Symbol(x297, Decl(generatedContextualTyping.ts, 295, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>undefined : Symbol(undefined)
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x298: () => Base[] = true ? undefined : function() { return [d1, d2] };
+>x298 : Symbol(x298, Decl(generatedContextualTyping.ts, 296, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>undefined : Symbol(undefined)
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x299: () => Base[] = true ? undefined : function named() { return [d1, d2] };
+>x299 : Symbol(x299, Decl(generatedContextualTyping.ts, 297, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>undefined : Symbol(undefined)
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 297, 43))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x300: { (): Base[]; } = true ? undefined : () => [d1, d2];
+>x300 : Symbol(x300, Decl(generatedContextualTyping.ts, 298, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>undefined : Symbol(undefined)
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x301: { (): Base[]; } = true ? undefined : function() { return [d1, d2] };
+>x301 : Symbol(x301, Decl(generatedContextualTyping.ts, 299, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>undefined : Symbol(undefined)
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x302: { (): Base[]; } = true ? undefined : function named() { return [d1, d2] };
+>x302 : Symbol(x302, Decl(generatedContextualTyping.ts, 300, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>undefined : Symbol(undefined)
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 300, 46))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x303: Base[] = true ? undefined : [d1, d2];
+>x303 : Symbol(x303, Decl(generatedContextualTyping.ts, 301, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>undefined : Symbol(undefined)
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x304: Array<Base> = true ? undefined : [d1, d2];
+>x304 : Symbol(x304, Decl(generatedContextualTyping.ts, 302, 3))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>undefined : Symbol(undefined)
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x305: { [n: number]: Base; } = true ? undefined : [d1, d2];
+>x305 : Symbol(x305, Decl(generatedContextualTyping.ts, 303, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 303, 13))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>undefined : Symbol(undefined)
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x306: {n: Base[]; }  = true ? undefined : { n: [d1, d2] };
+>x306 : Symbol(x306, Decl(generatedContextualTyping.ts, 304, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 304, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>undefined : Symbol(undefined)
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 304, 47))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x307: (s: Base[]) => any = true ? undefined : n => { var n: Base[]; return null; };
+>x307 : Symbol(x307, Decl(generatedContextualTyping.ts, 305, 3))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 305, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>undefined : Symbol(undefined)
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 305, 49), Decl(generatedContextualTyping.ts, 305, 60))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 305, 49), Decl(generatedContextualTyping.ts, 305, 60))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+
+var x308: Genric<Base> = true ? undefined : { func: n => { return [d1, d2]; } };
+>x308 : Symbol(x308, Decl(generatedContextualTyping.ts, 306, 3))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>undefined : Symbol(undefined)
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 306, 45))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 306, 51))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x309: () => Base[] = true ? () => [d1, d2] : undefined;
+>x309 : Symbol(x309, Decl(generatedContextualTyping.ts, 307, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>undefined : Symbol(undefined)
+
+var x310: () => Base[] = true ? function() { return [d1, d2] } : undefined;
+>x310 : Symbol(x310, Decl(generatedContextualTyping.ts, 308, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>undefined : Symbol(undefined)
+
+var x311: () => Base[] = true ? function named() { return [d1, d2] } : undefined;
+>x311 : Symbol(x311, Decl(generatedContextualTyping.ts, 309, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 309, 31))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>undefined : Symbol(undefined)
+
+var x312: { (): Base[]; } = true ? () => [d1, d2] : undefined;
+>x312 : Symbol(x312, Decl(generatedContextualTyping.ts, 310, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>undefined : Symbol(undefined)
+
+var x313: { (): Base[]; } = true ? function() { return [d1, d2] } : undefined;
+>x313 : Symbol(x313, Decl(generatedContextualTyping.ts, 311, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>undefined : Symbol(undefined)
+
+var x314: { (): Base[]; } = true ? function named() { return [d1, d2] } : undefined;
+>x314 : Symbol(x314, Decl(generatedContextualTyping.ts, 312, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 312, 34))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>undefined : Symbol(undefined)
+
+var x315: Base[] = true ? [d1, d2] : undefined;
+>x315 : Symbol(x315, Decl(generatedContextualTyping.ts, 313, 3))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>undefined : Symbol(undefined)
+
+var x316: Array<Base> = true ? [d1, d2] : undefined;
+>x316 : Symbol(x316, Decl(generatedContextualTyping.ts, 314, 3))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>undefined : Symbol(undefined)
+
+var x317: { [n: number]: Base; } = true ? [d1, d2] : undefined;
+>x317 : Symbol(x317, Decl(generatedContextualTyping.ts, 315, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 315, 13))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>undefined : Symbol(undefined)
+
+var x318: {n: Base[]; }  = true ? { n: [d1, d2] } : undefined;
+>x318 : Symbol(x318, Decl(generatedContextualTyping.ts, 316, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 316, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 316, 35))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>undefined : Symbol(undefined)
+
+var x319: (s: Base[]) => any = true ? n => { var n: Base[]; return null; } : undefined;
+>x319 : Symbol(x319, Decl(generatedContextualTyping.ts, 317, 3))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 317, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 317, 37), Decl(generatedContextualTyping.ts, 317, 48))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 317, 37), Decl(generatedContextualTyping.ts, 317, 48))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>undefined : Symbol(undefined)
+
+var x320: Genric<Base> = true ? { func: n => { return [d1, d2]; } } : undefined;
+>x320 : Symbol(x320, Decl(generatedContextualTyping.ts, 318, 3))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 318, 33))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 318, 39))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>undefined : Symbol(undefined)
+
+function x321(n: () => Base[]) { }; x321(() => [d1, d2]);
+>x321 : Symbol(x321, Decl(generatedContextualTyping.ts, 318, 80))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 319, 14))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x321 : Symbol(x321, Decl(generatedContextualTyping.ts, 318, 80))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x322(n: () => Base[]) { }; x322(function() { return [d1, d2] });
+>x322 : Symbol(x322, Decl(generatedContextualTyping.ts, 319, 57))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 320, 14))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x322 : Symbol(x322, Decl(generatedContextualTyping.ts, 319, 57))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x323(n: () => Base[]) { }; x323(function named() { return [d1, d2] });
+>x323 : Symbol(x323, Decl(generatedContextualTyping.ts, 320, 73))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 321, 14))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x323 : Symbol(x323, Decl(generatedContextualTyping.ts, 320, 73))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 321, 41))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x324(n: { (): Base[]; }) { }; x324(() => [d1, d2]);
+>x324 : Symbol(x324, Decl(generatedContextualTyping.ts, 321, 79))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 322, 14))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x324 : Symbol(x324, Decl(generatedContextualTyping.ts, 321, 79))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x325(n: { (): Base[]; }) { }; x325(function() { return [d1, d2] });
+>x325 : Symbol(x325, Decl(generatedContextualTyping.ts, 322, 60))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 323, 14))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x325 : Symbol(x325, Decl(generatedContextualTyping.ts, 322, 60))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x326(n: { (): Base[]; }) { }; x326(function named() { return [d1, d2] });
+>x326 : Symbol(x326, Decl(generatedContextualTyping.ts, 323, 76))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 324, 14))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x326 : Symbol(x326, Decl(generatedContextualTyping.ts, 323, 76))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 324, 44))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x327(n: Base[]) { }; x327([d1, d2]);
+>x327 : Symbol(x327, Decl(generatedContextualTyping.ts, 324, 82))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 325, 14))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x327 : Symbol(x327, Decl(generatedContextualTyping.ts, 324, 82))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x328(n: Array<Base>) { }; x328([d1, d2]);
+>x328 : Symbol(x328, Decl(generatedContextualTyping.ts, 325, 45))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 326, 14))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x328 : Symbol(x328, Decl(generatedContextualTyping.ts, 325, 45))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x329(n: { [n: number]: Base; }) { }; x329([d1, d2]);
+>x329 : Symbol(x329, Decl(generatedContextualTyping.ts, 326, 50))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 327, 14))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 327, 20))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x329 : Symbol(x329, Decl(generatedContextualTyping.ts, 326, 50))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x330(n: {n: Base[]; } ) { }; x330({ n: [d1, d2] });
+>x330 : Symbol(x330, Decl(generatedContextualTyping.ts, 327, 61))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 328, 14))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 328, 18))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x330 : Symbol(x330, Decl(generatedContextualTyping.ts, 327, 61))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 328, 44))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x331(n: (s: Base[]) => any) { }; x331(n => { var n: Base[]; return null; });
+>x331 : Symbol(x331, Decl(generatedContextualTyping.ts, 328, 60))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 329, 14))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 329, 18))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x331 : Symbol(x331, Decl(generatedContextualTyping.ts, 328, 60))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 329, 47), Decl(generatedContextualTyping.ts, 329, 57))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 329, 47), Decl(generatedContextualTyping.ts, 329, 57))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+
+function x332(n: Genric<Base>) { }; x332({ func: n => { return [d1, d2]; } });
+>x332 : Symbol(x332, Decl(generatedContextualTyping.ts, 329, 85))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 330, 14))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x332 : Symbol(x332, Decl(generatedContextualTyping.ts, 329, 85))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 330, 42))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 330, 48))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x333 = (n: () => Base[]) => n; x333(() => [d1, d2]);
+>x333 : Symbol(x333, Decl(generatedContextualTyping.ts, 331, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 331, 12))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 331, 12))
+>x333 : Symbol(x333, Decl(generatedContextualTyping.ts, 331, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x334 = (n: () => Base[]) => n; x334(function() { return [d1, d2] });
+>x334 : Symbol(x334, Decl(generatedContextualTyping.ts, 332, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 332, 12))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 332, 12))
+>x334 : Symbol(x334, Decl(generatedContextualTyping.ts, 332, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x335 = (n: () => Base[]) => n; x335(function named() { return [d1, d2] });
+>x335 : Symbol(x335, Decl(generatedContextualTyping.ts, 333, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 333, 12))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 333, 12))
+>x335 : Symbol(x335, Decl(generatedContextualTyping.ts, 333, 3))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 333, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x336 = (n: { (): Base[]; }) => n; x336(() => [d1, d2]);
+>x336 : Symbol(x336, Decl(generatedContextualTyping.ts, 334, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 334, 12))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 334, 12))
+>x336 : Symbol(x336, Decl(generatedContextualTyping.ts, 334, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x337 = (n: { (): Base[]; }) => n; x337(function() { return [d1, d2] });
+>x337 : Symbol(x337, Decl(generatedContextualTyping.ts, 335, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 335, 12))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 335, 12))
+>x337 : Symbol(x337, Decl(generatedContextualTyping.ts, 335, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x338 = (n: { (): Base[]; }) => n; x338(function named() { return [d1, d2] });
+>x338 : Symbol(x338, Decl(generatedContextualTyping.ts, 336, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 336, 12))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 336, 12))
+>x338 : Symbol(x338, Decl(generatedContextualTyping.ts, 336, 3))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 336, 43))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x339 = (n: Base[]) => n; x339([d1, d2]);
+>x339 : Symbol(x339, Decl(generatedContextualTyping.ts, 337, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 337, 12))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 337, 12))
+>x339 : Symbol(x339, Decl(generatedContextualTyping.ts, 337, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x340 = (n: Array<Base>) => n; x340([d1, d2]);
+>x340 : Symbol(x340, Decl(generatedContextualTyping.ts, 338, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 338, 12))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 338, 12))
+>x340 : Symbol(x340, Decl(generatedContextualTyping.ts, 338, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x341 = (n: { [n: number]: Base; }) => n; x341([d1, d2]);
+>x341 : Symbol(x341, Decl(generatedContextualTyping.ts, 339, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 339, 12))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 339, 18))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 339, 12))
+>x341 : Symbol(x341, Decl(generatedContextualTyping.ts, 339, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x342 = (n: {n: Base[]; } ) => n; x342({ n: [d1, d2] });
+>x342 : Symbol(x342, Decl(generatedContextualTyping.ts, 340, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 12))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 16))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 12))
+>x342 : Symbol(x342, Decl(generatedContextualTyping.ts, 340, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 43))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x343 = (n: (s: Base[]) => any) => n; x343(n => { var n: Base[]; return null; });
+>x343 : Symbol(x343, Decl(generatedContextualTyping.ts, 341, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 341, 12))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 341, 16))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 341, 12))
+>x343 : Symbol(x343, Decl(generatedContextualTyping.ts, 341, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 341, 46), Decl(generatedContextualTyping.ts, 341, 56))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 341, 46), Decl(generatedContextualTyping.ts, 341, 56))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+
+var x344 = (n: Genric<Base>) => n; x344({ func: n => { return [d1, d2]; } });
+>x344 : Symbol(x344, Decl(generatedContextualTyping.ts, 342, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 342, 12))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 342, 12))
+>x344 : Symbol(x344, Decl(generatedContextualTyping.ts, 342, 3))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 342, 41))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 342, 47))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x345 = function(n: () => Base[]) { }; x345(() => [d1, d2]);
+>x345 : Symbol(x345, Decl(generatedContextualTyping.ts, 343, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 343, 20))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x345 : Symbol(x345, Decl(generatedContextualTyping.ts, 343, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x346 = function(n: () => Base[]) { }; x346(function() { return [d1, d2] });
+>x346 : Symbol(x346, Decl(generatedContextualTyping.ts, 344, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 344, 20))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x346 : Symbol(x346, Decl(generatedContextualTyping.ts, 344, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x347 = function(n: () => Base[]) { }; x347(function named() { return [d1, d2] });
+>x347 : Symbol(x347, Decl(generatedContextualTyping.ts, 345, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 345, 20))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x347 : Symbol(x347, Decl(generatedContextualTyping.ts, 345, 3))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 345, 47))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x348 = function(n: { (): Base[]; }) { }; x348(() => [d1, d2]);
+>x348 : Symbol(x348, Decl(generatedContextualTyping.ts, 346, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 346, 20))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x348 : Symbol(x348, Decl(generatedContextualTyping.ts, 346, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x349 = function(n: { (): Base[]; }) { }; x349(function() { return [d1, d2] });
+>x349 : Symbol(x349, Decl(generatedContextualTyping.ts, 347, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 347, 20))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x349 : Symbol(x349, Decl(generatedContextualTyping.ts, 347, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x350 = function(n: { (): Base[]; }) { }; x350(function named() { return [d1, d2] });
+>x350 : Symbol(x350, Decl(generatedContextualTyping.ts, 348, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 348, 20))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x350 : Symbol(x350, Decl(generatedContextualTyping.ts, 348, 3))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 348, 50))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x351 = function(n: Base[]) { }; x351([d1, d2]);
+>x351 : Symbol(x351, Decl(generatedContextualTyping.ts, 349, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 349, 20))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x351 : Symbol(x351, Decl(generatedContextualTyping.ts, 349, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x352 = function(n: Array<Base>) { }; x352([d1, d2]);
+>x352 : Symbol(x352, Decl(generatedContextualTyping.ts, 350, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 350, 20))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x352 : Symbol(x352, Decl(generatedContextualTyping.ts, 350, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x353 = function(n: { [n: number]: Base; }) { }; x353([d1, d2]);
+>x353 : Symbol(x353, Decl(generatedContextualTyping.ts, 351, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 351, 20))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 351, 26))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x353 : Symbol(x353, Decl(generatedContextualTyping.ts, 351, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x354 = function(n: {n: Base[]; } ) { }; x354({ n: [d1, d2] });
+>x354 : Symbol(x354, Decl(generatedContextualTyping.ts, 352, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 352, 20))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 352, 24))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x354 : Symbol(x354, Decl(generatedContextualTyping.ts, 352, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 352, 50))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x355 = function(n: (s: Base[]) => any) { }; x355(n => { var n: Base[]; return null; });
+>x355 : Symbol(x355, Decl(generatedContextualTyping.ts, 353, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 353, 20))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 353, 24))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x355 : Symbol(x355, Decl(generatedContextualTyping.ts, 353, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 353, 53), Decl(generatedContextualTyping.ts, 353, 63))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 353, 53), Decl(generatedContextualTyping.ts, 353, 63))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+
+var x356 = function(n: Genric<Base>) { }; x356({ func: n => { return [d1, d2]; } });
+>x356 : Symbol(x356, Decl(generatedContextualTyping.ts, 354, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 354, 20))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x356 : Symbol(x356, Decl(generatedContextualTyping.ts, 354, 3))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 354, 48))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 354, 54))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
diff --git a/tests/baselines/reference/generatedContextualTyping.types b/tests/baselines/reference/generatedContextualTyping.types
new file mode 100644
index 00000000000..2e9625cdb8b
--- /dev/null
+++ b/tests/baselines/reference/generatedContextualTyping.types
@@ -0,0 +1,3769 @@
+=== tests/cases/conformance/expressions/contextualTyping/generatedContextualTyping.ts ===
+
+class Base { private p; }
+>Base : Base
+>p : any
+
+class Derived1 extends Base { private m; }
+>Derived1 : Derived1
+>Base : Base
+>m : any
+
+class Derived2 extends Base { private n; }
+>Derived2 : Derived2
+>Base : Base
+>n : any
+
+interface Genric<T> { func(n: T[]); }
+>Genric : Genric<T>
+>T : T
+>func : (n: T[]) => any
+>n : T[]
+>T : T
+
+var b = new Base(), d1 = new Derived1(), d2 = new Derived2();
+>b : Base
+>new Base() : Base
+>Base : typeof Base
+>d1 : Derived1
+>new Derived1() : Derived1
+>Derived1 : typeof Derived1
+>d2 : Derived2
+>new Derived2() : Derived2
+>Derived2 : typeof Derived2
+
+var x1: () => Base[] = () => [d1, d2];
+>x1 : () => Base[]
+>Base : Base
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x2: () => Base[] = function() { return [d1, d2] };
+>x2 : () => Base[]
+>Base : Base
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x3: () => Base[] = function named() { return [d1, d2] };
+>x3 : () => Base[]
+>Base : Base
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x4: { (): Base[]; } = () => [d1, d2];
+>x4 : () => Base[]
+>Base : Base
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x5: { (): Base[]; } = function() { return [d1, d2] };
+>x5 : () => Base[]
+>Base : Base
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x6: { (): Base[]; } = function named() { return [d1, d2] };
+>x6 : () => Base[]
+>Base : Base
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x7: Base[] = [d1, d2];
+>x7 : Base[]
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x8: Array<Base> = [d1, d2];
+>x8 : Base[]
+>Array : T[]
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x9: { [n: number]: Base; } = [d1, d2];
+>x9 : { [n: number]: Base; }
+>n : number
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x10: {n: Base[]; }  = { n: [d1, d2] };
+>x10 : { n: Base[]; }
+>n : Base[]
+>Base : Base
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x11: (s: Base[]) => any = n => { var n: Base[]; return null; };
+>x11 : (s: Base[]) => any
+>s : Base[]
+>Base : Base
+>n => { var n: Base[]; return null; } : (n: Base[]) => any
+>n : Base[]
+>n : Base[]
+>Base : Base
+>null : null
+
+var x12: Genric<Base> = { func: n => { return [d1, d2]; } };
+>x12 : Genric<Base>
+>Genric : Genric<T>
+>Base : Base
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
+>n : Base[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x13 { member: () => Base[] = () => [d1, d2] }
+>x13 : x13
+>member : () => Base[]
+>Base : Base
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x14 { member: () => Base[] = function() { return [d1, d2] } }
+>x14 : x14
+>member : () => Base[]
+>Base : Base
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x15 { member: () => Base[] = function named() { return [d1, d2] } }
+>x15 : x15
+>member : () => Base[]
+>Base : Base
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x16 { member: { (): Base[]; } = () => [d1, d2] }
+>x16 : x16
+>member : () => Base[]
+>Base : Base
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x17 { member: { (): Base[]; } = function() { return [d1, d2] } }
+>x17 : x17
+>member : () => Base[]
+>Base : Base
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x18 { member: { (): Base[]; } = function named() { return [d1, d2] } }
+>x18 : x18
+>member : () => Base[]
+>Base : Base
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x19 { member: Base[] = [d1, d2] }
+>x19 : x19
+>member : Base[]
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x20 { member: Array<Base> = [d1, d2] }
+>x20 : x20
+>member : Base[]
+>Array : T[]
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x21 { member: { [n: number]: Base; } = [d1, d2] }
+>x21 : x21
+>member : { [n: number]: Base; }
+>n : number
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x22 { member: {n: Base[]; }  = { n: [d1, d2] } }
+>x22 : x22
+>member : { n: Base[]; }
+>n : Base[]
+>Base : Base
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x23 { member: (s: Base[]) => any = n => { var n: Base[]; return null; } }
+>x23 : x23
+>member : (s: Base[]) => any
+>s : Base[]
+>Base : Base
+>n => { var n: Base[]; return null; } : (n: Base[]) => any
+>n : Base[]
+>n : Base[]
+>Base : Base
+>null : null
+
+class x24 { member: Genric<Base> = { func: n => { return [d1, d2]; } } }
+>x24 : x24
+>member : Genric<Base>
+>Genric : Genric<T>
+>Base : Base
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
+>n : Base[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x25 { private member: () => Base[] = () => [d1, d2] }
+>x25 : x25
+>member : () => Base[]
+>Base : Base
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x26 { private member: () => Base[] = function() { return [d1, d2] } }
+>x26 : x26
+>member : () => Base[]
+>Base : Base
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x27 { private member: () => Base[] = function named() { return [d1, d2] } }
+>x27 : x27
+>member : () => Base[]
+>Base : Base
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x28 { private member: { (): Base[]; } = () => [d1, d2] }
+>x28 : x28
+>member : () => Base[]
+>Base : Base
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x29 { private member: { (): Base[]; } = function() { return [d1, d2] } }
+>x29 : x29
+>member : () => Base[]
+>Base : Base
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x30 { private member: { (): Base[]; } = function named() { return [d1, d2] } }
+>x30 : x30
+>member : () => Base[]
+>Base : Base
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x31 { private member: Base[] = [d1, d2] }
+>x31 : x31
+>member : Base[]
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x32 { private member: Array<Base> = [d1, d2] }
+>x32 : x32
+>member : Base[]
+>Array : T[]
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x33 { private member: { [n: number]: Base; } = [d1, d2] }
+>x33 : x33
+>member : { [n: number]: Base; }
+>n : number
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x34 { private member: {n: Base[]; }  = { n: [d1, d2] } }
+>x34 : x34
+>member : { n: Base[]; }
+>n : Base[]
+>Base : Base
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x35 { private member: (s: Base[]) => any = n => { var n: Base[]; return null; } }
+>x35 : x35
+>member : (s: Base[]) => any
+>s : Base[]
+>Base : Base
+>n => { var n: Base[]; return null; } : (n: Base[]) => any
+>n : Base[]
+>n : Base[]
+>Base : Base
+>null : null
+
+class x36 { private member: Genric<Base> = { func: n => { return [d1, d2]; } } }
+>x36 : x36
+>member : Genric<Base>
+>Genric : Genric<T>
+>Base : Base
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
+>n : Base[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x37 { public member: () => Base[] = () => [d1, d2] }
+>x37 : x37
+>member : () => Base[]
+>Base : Base
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x38 { public member: () => Base[] = function() { return [d1, d2] } }
+>x38 : x38
+>member : () => Base[]
+>Base : Base
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x39 { public member: () => Base[] = function named() { return [d1, d2] } }
+>x39 : x39
+>member : () => Base[]
+>Base : Base
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x40 { public member: { (): Base[]; } = () => [d1, d2] }
+>x40 : x40
+>member : () => Base[]
+>Base : Base
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x41 { public member: { (): Base[]; } = function() { return [d1, d2] } }
+>x41 : x41
+>member : () => Base[]
+>Base : Base
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x42 { public member: { (): Base[]; } = function named() { return [d1, d2] } }
+>x42 : x42
+>member : () => Base[]
+>Base : Base
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x43 { public member: Base[] = [d1, d2] }
+>x43 : x43
+>member : Base[]
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x44 { public member: Array<Base> = [d1, d2] }
+>x44 : x44
+>member : Base[]
+>Array : T[]
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x45 { public member: { [n: number]: Base; } = [d1, d2] }
+>x45 : x45
+>member : { [n: number]: Base; }
+>n : number
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x46 { public member: {n: Base[]; }  = { n: [d1, d2] } }
+>x46 : x46
+>member : { n: Base[]; }
+>n : Base[]
+>Base : Base
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x47 { public member: (s: Base[]) => any = n => { var n: Base[]; return null; } }
+>x47 : x47
+>member : (s: Base[]) => any
+>s : Base[]
+>Base : Base
+>n => { var n: Base[]; return null; } : (n: Base[]) => any
+>n : Base[]
+>n : Base[]
+>Base : Base
+>null : null
+
+class x48 { public member: Genric<Base> = { func: n => { return [d1, d2]; } } }
+>x48 : x48
+>member : Genric<Base>
+>Genric : Genric<T>
+>Base : Base
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
+>n : Base[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x49 { static member: () => Base[] = () => [d1, d2] }
+>x49 : x49
+>member : () => Base[]
+>Base : Base
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x50 { static member: () => Base[] = function() { return [d1, d2] } }
+>x50 : x50
+>member : () => Base[]
+>Base : Base
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x51 { static member: () => Base[] = function named() { return [d1, d2] } }
+>x51 : x51
+>member : () => Base[]
+>Base : Base
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x52 { static member: { (): Base[]; } = () => [d1, d2] }
+>x52 : x52
+>member : () => Base[]
+>Base : Base
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x53 { static member: { (): Base[]; } = function() { return [d1, d2] } }
+>x53 : x53
+>member : () => Base[]
+>Base : Base
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x54 { static member: { (): Base[]; } = function named() { return [d1, d2] } }
+>x54 : x54
+>member : () => Base[]
+>Base : Base
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x55 { static member: Base[] = [d1, d2] }
+>x55 : x55
+>member : Base[]
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x56 { static member: Array<Base> = [d1, d2] }
+>x56 : x56
+>member : Base[]
+>Array : T[]
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x57 { static member: { [n: number]: Base; } = [d1, d2] }
+>x57 : x57
+>member : { [n: number]: Base; }
+>n : number
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x58 { static member: {n: Base[]; }  = { n: [d1, d2] } }
+>x58 : x58
+>member : { n: Base[]; }
+>n : Base[]
+>Base : Base
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x59 { static member: (s: Base[]) => any = n => { var n: Base[]; return null; } }
+>x59 : x59
+>member : (s: Base[]) => any
+>s : Base[]
+>Base : Base
+>n => { var n: Base[]; return null; } : (n: Base[]) => any
+>n : Base[]
+>n : Base[]
+>Base : Base
+>null : null
+
+class x60 { static member: Genric<Base> = { func: n => { return [d1, d2]; } } }
+>x60 : x60
+>member : Genric<Base>
+>Genric : Genric<T>
+>Base : Base
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
+>n : Base[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x61 { private static member: () => Base[] = () => [d1, d2] }
+>x61 : x61
+>member : () => Base[]
+>Base : Base
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x62 { private static member: () => Base[] = function() { return [d1, d2] } }
+>x62 : x62
+>member : () => Base[]
+>Base : Base
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x63 { private static member: () => Base[] = function named() { return [d1, d2] } }
+>x63 : x63
+>member : () => Base[]
+>Base : Base
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x64 { private static member: { (): Base[]; } = () => [d1, d2] }
+>x64 : x64
+>member : () => Base[]
+>Base : Base
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x65 { private static member: { (): Base[]; } = function() { return [d1, d2] } }
+>x65 : x65
+>member : () => Base[]
+>Base : Base
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x66 { private static member: { (): Base[]; } = function named() { return [d1, d2] } }
+>x66 : x66
+>member : () => Base[]
+>Base : Base
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x67 { private static member: Base[] = [d1, d2] }
+>x67 : x67
+>member : Base[]
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x68 { private static member: Array<Base> = [d1, d2] }
+>x68 : x68
+>member : Base[]
+>Array : T[]
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x69 { private static member: { [n: number]: Base; } = [d1, d2] }
+>x69 : x69
+>member : { [n: number]: Base; }
+>n : number
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x70 { private static member: {n: Base[]; }  = { n: [d1, d2] } }
+>x70 : x70
+>member : { n: Base[]; }
+>n : Base[]
+>Base : Base
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x71 { private static member: (s: Base[]) => any = n => { var n: Base[]; return null; } }
+>x71 : x71
+>member : (s: Base[]) => any
+>s : Base[]
+>Base : Base
+>n => { var n: Base[]; return null; } : (n: Base[]) => any
+>n : Base[]
+>n : Base[]
+>Base : Base
+>null : null
+
+class x72 { private static member: Genric<Base> = { func: n => { return [d1, d2]; } } }
+>x72 : x72
+>member : Genric<Base>
+>Genric : Genric<T>
+>Base : Base
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
+>n : Base[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x73 { public static member: () => Base[] = () => [d1, d2] }
+>x73 : x73
+>member : () => Base[]
+>Base : Base
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x74 { public static member: () => Base[] = function() { return [d1, d2] } }
+>x74 : x74
+>member : () => Base[]
+>Base : Base
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x75 { public static member: () => Base[] = function named() { return [d1, d2] } }
+>x75 : x75
+>member : () => Base[]
+>Base : Base
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x76 { public static member: { (): Base[]; } = () => [d1, d2] }
+>x76 : x76
+>member : () => Base[]
+>Base : Base
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x77 { public static member: { (): Base[]; } = function() { return [d1, d2] } }
+>x77 : x77
+>member : () => Base[]
+>Base : Base
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x78 { public static member: { (): Base[]; } = function named() { return [d1, d2] } }
+>x78 : x78
+>member : () => Base[]
+>Base : Base
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x79 { public static member: Base[] = [d1, d2] }
+>x79 : x79
+>member : Base[]
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x80 { public static member: Array<Base> = [d1, d2] }
+>x80 : x80
+>member : Base[]
+>Array : T[]
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x81 { public static member: { [n: number]: Base; } = [d1, d2] }
+>x81 : x81
+>member : { [n: number]: Base; }
+>n : number
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x82 { public static member: {n: Base[]; }  = { n: [d1, d2] } }
+>x82 : x82
+>member : { n: Base[]; }
+>n : Base[]
+>Base : Base
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x83 { public static member: (s: Base[]) => any = n => { var n: Base[]; return null; } }
+>x83 : x83
+>member : (s: Base[]) => any
+>s : Base[]
+>Base : Base
+>n => { var n: Base[]; return null; } : (n: Base[]) => any
+>n : Base[]
+>n : Base[]
+>Base : Base
+>null : null
+
+class x84 { public static member: Genric<Base> = { func: n => { return [d1, d2]; } } }
+>x84 : x84
+>member : Genric<Base>
+>Genric : Genric<T>
+>Base : Base
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
+>n : Base[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x85 { constructor(parm: () => Base[] = () => [d1, d2]) { } }
+>x85 : x85
+>parm : () => Base[]
+>Base : Base
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x86 { constructor(parm: () => Base[] = function() { return [d1, d2] }) { } }
+>x86 : x86
+>parm : () => Base[]
+>Base : Base
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x87 { constructor(parm: () => Base[] = function named() { return [d1, d2] }) { } }
+>x87 : x87
+>parm : () => Base[]
+>Base : Base
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x88 { constructor(parm: { (): Base[]; } = () => [d1, d2]) { } }
+>x88 : x88
+>parm : () => Base[]
+>Base : Base
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x89 { constructor(parm: { (): Base[]; } = function() { return [d1, d2] }) { } }
+>x89 : x89
+>parm : () => Base[]
+>Base : Base
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x90 { constructor(parm: { (): Base[]; } = function named() { return [d1, d2] }) { } }
+>x90 : x90
+>parm : () => Base[]
+>Base : Base
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x91 { constructor(parm: Base[] = [d1, d2]) { } }
+>x91 : x91
+>parm : Base[]
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x92 { constructor(parm: Array<Base> = [d1, d2]) { } }
+>x92 : x92
+>parm : Base[]
+>Array : T[]
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x93 { constructor(parm: { [n: number]: Base; } = [d1, d2]) { } }
+>x93 : x93
+>parm : { [n: number]: Base; }
+>n : number
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x94 { constructor(parm: {n: Base[]; }  = { n: [d1, d2] }) { } }
+>x94 : x94
+>parm : { n: Base[]; }
+>n : Base[]
+>Base : Base
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x95 { constructor(parm: (s: Base[]) => any = n => { var n: Base[]; return null; }) { } }
+>x95 : x95
+>parm : (s: Base[]) => any
+>s : Base[]
+>Base : Base
+>n => { var n: Base[]; return null; } : (n: Base[]) => any
+>n : Base[]
+>n : Base[]
+>Base : Base
+>null : null
+
+class x96 { constructor(parm: Genric<Base> = { func: n => { return [d1, d2]; } }) { } }
+>x96 : x96
+>parm : Genric<Base>
+>Genric : Genric<T>
+>Base : Base
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
+>n : Base[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x97 { constructor(public parm: () => Base[] = () => [d1, d2]) { } }
+>x97 : x97
+>parm : () => Base[]
+>Base : Base
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x98 { constructor(public parm: () => Base[] = function() { return [d1, d2] }) { } }
+>x98 : x98
+>parm : () => Base[]
+>Base : Base
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x99 { constructor(public parm: () => Base[] = function named() { return [d1, d2] }) { } }
+>x99 : x99
+>parm : () => Base[]
+>Base : Base
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x100 { constructor(public parm: { (): Base[]; } = () => [d1, d2]) { } }
+>x100 : x100
+>parm : () => Base[]
+>Base : Base
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x101 { constructor(public parm: { (): Base[]; } = function() { return [d1, d2] }) { } }
+>x101 : x101
+>parm : () => Base[]
+>Base : Base
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x102 { constructor(public parm: { (): Base[]; } = function named() { return [d1, d2] }) { } }
+>x102 : x102
+>parm : () => Base[]
+>Base : Base
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x103 { constructor(public parm: Base[] = [d1, d2]) { } }
+>x103 : x103
+>parm : Base[]
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x104 { constructor(public parm: Array<Base> = [d1, d2]) { } }
+>x104 : x104
+>parm : Base[]
+>Array : T[]
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x105 { constructor(public parm: { [n: number]: Base; } = [d1, d2]) { } }
+>x105 : x105
+>parm : { [n: number]: Base; }
+>n : number
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x106 { constructor(public parm: {n: Base[]; }  = { n: [d1, d2] }) { } }
+>x106 : x106
+>parm : { n: Base[]; }
+>n : Base[]
+>Base : Base
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x107 { constructor(public parm: (s: Base[]) => any = n => { var n: Base[]; return null; }) { } }
+>x107 : x107
+>parm : (s: Base[]) => any
+>s : Base[]
+>Base : Base
+>n => { var n: Base[]; return null; } : (n: Base[]) => any
+>n : Base[]
+>n : Base[]
+>Base : Base
+>null : null
+
+class x108 { constructor(public parm: Genric<Base> = { func: n => { return [d1, d2]; } }) { } }
+>x108 : x108
+>parm : Genric<Base>
+>Genric : Genric<T>
+>Base : Base
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
+>n : Base[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x109 { constructor(private parm: () => Base[] = () => [d1, d2]) { } }
+>x109 : x109
+>parm : () => Base[]
+>Base : Base
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x110 { constructor(private parm: () => Base[] = function() { return [d1, d2] }) { } }
+>x110 : x110
+>parm : () => Base[]
+>Base : Base
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x111 { constructor(private parm: () => Base[] = function named() { return [d1, d2] }) { } }
+>x111 : x111
+>parm : () => Base[]
+>Base : Base
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x112 { constructor(private parm: { (): Base[]; } = () => [d1, d2]) { } }
+>x112 : x112
+>parm : () => Base[]
+>Base : Base
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x113 { constructor(private parm: { (): Base[]; } = function() { return [d1, d2] }) { } }
+>x113 : x113
+>parm : () => Base[]
+>Base : Base
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x114 { constructor(private parm: { (): Base[]; } = function named() { return [d1, d2] }) { } }
+>x114 : x114
+>parm : () => Base[]
+>Base : Base
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x115 { constructor(private parm: Base[] = [d1, d2]) { } }
+>x115 : x115
+>parm : Base[]
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x116 { constructor(private parm: Array<Base> = [d1, d2]) { } }
+>x116 : x116
+>parm : Base[]
+>Array : T[]
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x117 { constructor(private parm: { [n: number]: Base; } = [d1, d2]) { } }
+>x117 : x117
+>parm : { [n: number]: Base; }
+>n : number
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x118 { constructor(private parm: {n: Base[]; }  = { n: [d1, d2] }) { } }
+>x118 : x118
+>parm : { n: Base[]; }
+>n : Base[]
+>Base : Base
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+class x119 { constructor(private parm: (s: Base[]) => any = n => { var n: Base[]; return null; }) { } }
+>x119 : x119
+>parm : (s: Base[]) => any
+>s : Base[]
+>Base : Base
+>n => { var n: Base[]; return null; } : (n: Base[]) => any
+>n : Base[]
+>n : Base[]
+>Base : Base
+>null : null
+
+class x120 { constructor(private parm: Genric<Base> = { func: n => { return [d1, d2]; } }) { } }
+>x120 : x120
+>parm : Genric<Base>
+>Genric : Genric<T>
+>Base : Base
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
+>n : Base[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x121(parm: () => Base[] = () => [d1, d2]) { }
+>x121 : (parm?: () => Base[]) => void
+>parm : () => Base[]
+>Base : Base
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x122(parm: () => Base[] = function() { return [d1, d2] }) { }
+>x122 : (parm?: () => Base[]) => void
+>parm : () => Base[]
+>Base : Base
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x123(parm: () => Base[] = function named() { return [d1, d2] }) { }
+>x123 : (parm?: () => Base[]) => void
+>parm : () => Base[]
+>Base : Base
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x124(parm: { (): Base[]; } = () => [d1, d2]) { }
+>x124 : (parm?: () => Base[]) => void
+>parm : () => Base[]
+>Base : Base
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x125(parm: { (): Base[]; } = function() { return [d1, d2] }) { }
+>x125 : (parm?: () => Base[]) => void
+>parm : () => Base[]
+>Base : Base
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x126(parm: { (): Base[]; } = function named() { return [d1, d2] }) { }
+>x126 : (parm?: () => Base[]) => void
+>parm : () => Base[]
+>Base : Base
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x127(parm: Base[] = [d1, d2]) { }
+>x127 : (parm?: Base[]) => void
+>parm : Base[]
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x128(parm: Array<Base> = [d1, d2]) { }
+>x128 : (parm?: Base[]) => void
+>parm : Base[]
+>Array : T[]
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x129(parm: { [n: number]: Base; } = [d1, d2]) { }
+>x129 : (parm?: { [n: number]: Base; }) => void
+>parm : { [n: number]: Base; }
+>n : number
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x130(parm: {n: Base[]; }  = { n: [d1, d2] }) { }
+>x130 : (parm?: { n: Base[]; }) => void
+>parm : { n: Base[]; }
+>n : Base[]
+>Base : Base
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x131(parm: (s: Base[]) => any = n => { var n: Base[]; return null; }) { }
+>x131 : (parm?: (s: Base[]) => any) => void
+>parm : (s: Base[]) => any
+>s : Base[]
+>Base : Base
+>n => { var n: Base[]; return null; } : (n: Base[]) => any
+>n : Base[]
+>n : Base[]
+>Base : Base
+>null : null
+
+function x132(parm: Genric<Base> = { func: n => { return [d1, d2]; } }) { }
+>x132 : (parm?: Genric<Base>) => void
+>parm : Genric<Base>
+>Genric : Genric<T>
+>Base : Base
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
+>n : Base[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x133(): () => Base[] { return () => [d1, d2]; }
+>x133 : () => () => Base[]
+>Base : Base
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x134(): () => Base[] { return function() { return [d1, d2] }; }
+>x134 : () => () => Base[]
+>Base : Base
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x135(): () => Base[] { return function named() { return [d1, d2] }; }
+>x135 : () => () => Base[]
+>Base : Base
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x136(): { (): Base[]; } { return () => [d1, d2]; }
+>x136 : () => () => Base[]
+>Base : Base
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x137(): { (): Base[]; } { return function() { return [d1, d2] }; }
+>x137 : () => () => Base[]
+>Base : Base
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x138(): { (): Base[]; } { return function named() { return [d1, d2] }; }
+>x138 : () => () => Base[]
+>Base : Base
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x139(): Base[] { return [d1, d2]; }
+>x139 : () => Base[]
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x140(): Array<Base> { return [d1, d2]; }
+>x140 : () => Base[]
+>Array : T[]
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x141(): { [n: number]: Base; } { return [d1, d2]; }
+>x141 : () => { [n: number]: Base; }
+>n : number
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x142(): {n: Base[]; }  { return { n: [d1, d2] }; }
+>x142 : () => { n: Base[]; }
+>n : Base[]
+>Base : Base
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x143(): (s: Base[]) => any { return n => { var n: Base[]; return null; }; }
+>x143 : () => (s: Base[]) => any
+>s : Base[]
+>Base : Base
+>n => { var n: Base[]; return null; } : (n: Base[]) => any
+>n : Base[]
+>n : Base[]
+>Base : Base
+>null : null
+
+function x144(): Genric<Base> { return { func: n => { return [d1, d2]; } }; }
+>x144 : () => Genric<Base>
+>Genric : Genric<T>
+>Base : Base
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
+>n : Base[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x145(): () => Base[] { return () => [d1, d2]; return () => [d1, d2]; }
+>x145 : () => () => Base[]
+>Base : Base
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x146(): () => Base[] { return function() { return [d1, d2] }; return function() { return [d1, d2] }; }
+>x146 : () => () => Base[]
+>Base : Base
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x147(): () => Base[] { return function named() { return [d1, d2] }; return function named() { return [d1, d2] }; }
+>x147 : () => () => Base[]
+>Base : Base
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x148(): { (): Base[]; } { return () => [d1, d2]; return () => [d1, d2]; }
+>x148 : () => () => Base[]
+>Base : Base
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x149(): { (): Base[]; } { return function() { return [d1, d2] }; return function() { return [d1, d2] }; }
+>x149 : () => () => Base[]
+>Base : Base
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x150(): { (): Base[]; } { return function named() { return [d1, d2] }; return function named() { return [d1, d2] }; }
+>x150 : () => () => Base[]
+>Base : Base
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x151(): Base[] { return [d1, d2]; return [d1, d2]; }
+>x151 : () => Base[]
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x152(): Array<Base> { return [d1, d2]; return [d1, d2]; }
+>x152 : () => Base[]
+>Array : T[]
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x153(): { [n: number]: Base; } { return [d1, d2]; return [d1, d2]; }
+>x153 : () => { [n: number]: Base; }
+>n : number
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x154(): {n: Base[]; }  { return { n: [d1, d2] }; return { n: [d1, d2] }; }
+>x154 : () => { n: Base[]; }
+>n : Base[]
+>Base : Base
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x155(): (s: Base[]) => any { return n => { var n: Base[]; return null; }; return n => { var n: Base[]; return null; }; }
+>x155 : () => (s: Base[]) => any
+>s : Base[]
+>Base : Base
+>n => { var n: Base[]; return null; } : (n: Base[]) => any
+>n : Base[]
+>n : Base[]
+>Base : Base
+>null : null
+>n => { var n: Base[]; return null; } : (n: Base[]) => any
+>n : Base[]
+>n : Base[]
+>Base : Base
+>null : null
+
+function x156(): Genric<Base> { return { func: n => { return [d1, d2]; } }; return { func: n => { return [d1, d2]; } }; }
+>x156 : () => Genric<Base>
+>Genric : Genric<T>
+>Base : Base
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
+>n : Base[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
+>n : Base[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x157: () => () => Base[] = () => { return () => [d1, d2]; };
+>x157 : () => () => Base[]
+>Base : Base
+>() => { return () => [d1, d2]; } : () => () => (Derived1 | Derived2)[]
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x158: () => () => Base[] = () => { return function() { return [d1, d2] }; };
+>x158 : () => () => Base[]
+>Base : Base
+>() => { return function() { return [d1, d2] }; } : () => () => (Derived1 | Derived2)[]
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x159: () => () => Base[] = () => { return function named() { return [d1, d2] }; };
+>x159 : () => () => Base[]
+>Base : Base
+>() => { return function named() { return [d1, d2] }; } : () => () => (Derived1 | Derived2)[]
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x160: () => { (): Base[]; } = () => { return () => [d1, d2]; };
+>x160 : () => () => Base[]
+>Base : Base
+>() => { return () => [d1, d2]; } : () => () => (Derived1 | Derived2)[]
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x161: () => { (): Base[]; } = () => { return function() { return [d1, d2] }; };
+>x161 : () => () => Base[]
+>Base : Base
+>() => { return function() { return [d1, d2] }; } : () => () => (Derived1 | Derived2)[]
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x162: () => { (): Base[]; } = () => { return function named() { return [d1, d2] }; };
+>x162 : () => () => Base[]
+>Base : Base
+>() => { return function named() { return [d1, d2] }; } : () => () => (Derived1 | Derived2)[]
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x163: () => Base[] = () => { return [d1, d2]; };
+>x163 : () => Base[]
+>Base : Base
+>() => { return [d1, d2]; } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x164: () => Array<Base> = () => { return [d1, d2]; };
+>x164 : () => Base[]
+>Array : T[]
+>Base : Base
+>() => { return [d1, d2]; } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x165: () => { [n: number]: Base; } = () => { return [d1, d2]; };
+>x165 : () => { [n: number]: Base; }
+>n : number
+>Base : Base
+>() => { return [d1, d2]; } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x166: () => {n: Base[]; }  = () => { return { n: [d1, d2] }; };
+>x166 : () => { n: Base[]; }
+>n : Base[]
+>Base : Base
+>() => { return { n: [d1, d2] }; } : () => { n: (Derived1 | Derived2)[]; }
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x167: () => (s: Base[]) => any = () => { return n => { var n: Base[]; return null; }; };
+>x167 : () => (s: Base[]) => any
+>s : Base[]
+>Base : Base
+>() => { return n => { var n: Base[]; return null; }; } : () => (n: Base[]) => any
+>n => { var n: Base[]; return null; } : (n: Base[]) => any
+>n : Base[]
+>n : Base[]
+>Base : Base
+>null : null
+
+var x168: () => Genric<Base> = () => { return { func: n => { return [d1, d2]; } }; };
+>x168 : () => Genric<Base>
+>Genric : Genric<T>
+>Base : Base
+>() => { return { func: n => { return [d1, d2]; } }; } : () => { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
+>n : Base[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x169: () => () => Base[] = function() { return () => [d1, d2]; };
+>x169 : () => () => Base[]
+>Base : Base
+>function() { return () => [d1, d2]; } : () => () => (Derived1 | Derived2)[]
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x170: () => () => Base[] = function() { return function() { return [d1, d2] }; };
+>x170 : () => () => Base[]
+>Base : Base
+>function() { return function() { return [d1, d2] }; } : () => () => (Derived1 | Derived2)[]
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x171: () => () => Base[] = function() { return function named() { return [d1, d2] }; };
+>x171 : () => () => Base[]
+>Base : Base
+>function() { return function named() { return [d1, d2] }; } : () => () => (Derived1 | Derived2)[]
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x172: () => { (): Base[]; } = function() { return () => [d1, d2]; };
+>x172 : () => () => Base[]
+>Base : Base
+>function() { return () => [d1, d2]; } : () => () => (Derived1 | Derived2)[]
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x173: () => { (): Base[]; } = function() { return function() { return [d1, d2] }; };
+>x173 : () => () => Base[]
+>Base : Base
+>function() { return function() { return [d1, d2] }; } : () => () => (Derived1 | Derived2)[]
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x174: () => { (): Base[]; } = function() { return function named() { return [d1, d2] }; };
+>x174 : () => () => Base[]
+>Base : Base
+>function() { return function named() { return [d1, d2] }; } : () => () => (Derived1 | Derived2)[]
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x175: () => Base[] = function() { return [d1, d2]; };
+>x175 : () => Base[]
+>Base : Base
+>function() { return [d1, d2]; } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x176: () => Array<Base> = function() { return [d1, d2]; };
+>x176 : () => Base[]
+>Array : T[]
+>Base : Base
+>function() { return [d1, d2]; } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x177: () => { [n: number]: Base; } = function() { return [d1, d2]; };
+>x177 : () => { [n: number]: Base; }
+>n : number
+>Base : Base
+>function() { return [d1, d2]; } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x178: () => {n: Base[]; }  = function() { return { n: [d1, d2] }; };
+>x178 : () => { n: Base[]; }
+>n : Base[]
+>Base : Base
+>function() { return { n: [d1, d2] }; } : () => { n: (Derived1 | Derived2)[]; }
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x179: () => (s: Base[]) => any = function() { return n => { var n: Base[]; return null; }; };
+>x179 : () => (s: Base[]) => any
+>s : Base[]
+>Base : Base
+>function() { return n => { var n: Base[]; return null; }; } : () => (n: Base[]) => any
+>n => { var n: Base[]; return null; } : (n: Base[]) => any
+>n : Base[]
+>n : Base[]
+>Base : Base
+>null : null
+
+var x180: () => Genric<Base> = function() { return { func: n => { return [d1, d2]; } }; };
+>x180 : () => Genric<Base>
+>Genric : Genric<T>
+>Base : Base
+>function() { return { func: n => { return [d1, d2]; } }; } : () => { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
+>n : Base[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+module x181 { var t: () => Base[] = () => [d1, d2]; }
+>x181 : typeof x181
+>t : () => Base[]
+>Base : Base
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+module x182 { var t: () => Base[] = function() { return [d1, d2] }; }
+>x182 : typeof x182
+>t : () => Base[]
+>Base : Base
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+module x183 { var t: () => Base[] = function named() { return [d1, d2] }; }
+>x183 : typeof x183
+>t : () => Base[]
+>Base : Base
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+module x184 { var t: { (): Base[]; } = () => [d1, d2]; }
+>x184 : typeof x184
+>t : () => Base[]
+>Base : Base
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+module x185 { var t: { (): Base[]; } = function() { return [d1, d2] }; }
+>x185 : typeof x185
+>t : () => Base[]
+>Base : Base
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+module x186 { var t: { (): Base[]; } = function named() { return [d1, d2] }; }
+>x186 : typeof x186
+>t : () => Base[]
+>Base : Base
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+module x187 { var t: Base[] = [d1, d2]; }
+>x187 : typeof x187
+>t : Base[]
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+module x188 { var t: Array<Base> = [d1, d2]; }
+>x188 : typeof x188
+>t : Base[]
+>Array : T[]
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+module x189 { var t: { [n: number]: Base; } = [d1, d2]; }
+>x189 : typeof x189
+>t : { [n: number]: Base; }
+>n : number
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+module x190 { var t: {n: Base[]; }  = { n: [d1, d2] }; }
+>x190 : typeof x190
+>t : { n: Base[]; }
+>n : Base[]
+>Base : Base
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+module x191 { var t: (s: Base[]) => any = n => { var n: Base[]; return null; }; }
+>x191 : typeof x191
+>t : (s: Base[]) => any
+>s : Base[]
+>Base : Base
+>n => { var n: Base[]; return null; } : (n: Base[]) => any
+>n : Base[]
+>n : Base[]
+>Base : Base
+>null : null
+
+module x192 { var t: Genric<Base> = { func: n => { return [d1, d2]; } }; }
+>x192 : typeof x192
+>t : Genric<Base>
+>Genric : Genric<T>
+>Base : Base
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
+>n : Base[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+module x193 { export var t: () => Base[] = () => [d1, d2]; }
+>x193 : typeof x193
+>t : () => Base[]
+>Base : Base
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+module x194 { export var t: () => Base[] = function() { return [d1, d2] }; }
+>x194 : typeof x194
+>t : () => Base[]
+>Base : Base
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+module x195 { export var t: () => Base[] = function named() { return [d1, d2] }; }
+>x195 : typeof x195
+>t : () => Base[]
+>Base : Base
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+module x196 { export var t: { (): Base[]; } = () => [d1, d2]; }
+>x196 : typeof x196
+>t : () => Base[]
+>Base : Base
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+module x197 { export var t: { (): Base[]; } = function() { return [d1, d2] }; }
+>x197 : typeof x197
+>t : () => Base[]
+>Base : Base
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+module x198 { export var t: { (): Base[]; } = function named() { return [d1, d2] }; }
+>x198 : typeof x198
+>t : () => Base[]
+>Base : Base
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+module x199 { export var t: Base[] = [d1, d2]; }
+>x199 : typeof x199
+>t : Base[]
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+module x200 { export var t: Array<Base> = [d1, d2]; }
+>x200 : typeof x200
+>t : Base[]
+>Array : T[]
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+module x201 { export var t: { [n: number]: Base; } = [d1, d2]; }
+>x201 : typeof x201
+>t : { [n: number]: Base; }
+>n : number
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+module x202 { export var t: {n: Base[]; }  = { n: [d1, d2] }; }
+>x202 : typeof x202
+>t : { n: Base[]; }
+>n : Base[]
+>Base : Base
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+module x203 { export var t: (s: Base[]) => any = n => { var n: Base[]; return null; }; }
+>x203 : typeof x203
+>t : (s: Base[]) => any
+>s : Base[]
+>Base : Base
+>n => { var n: Base[]; return null; } : (n: Base[]) => any
+>n : Base[]
+>n : Base[]
+>Base : Base
+>null : null
+
+module x204 { export var t: Genric<Base> = { func: n => { return [d1, d2]; } }; }
+>x204 : typeof x204
+>t : Genric<Base>
+>Genric : Genric<T>
+>Base : Base
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
+>n : Base[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x206 = <() => Base[]>function() { return [d1, d2] };
+>x206 : () => Base[]
+><() => Base[]>function() { return [d1, d2] } : () => Base[]
+>Base : Base
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x207 = <() => Base[]>function named() { return [d1, d2] };
+>x207 : () => Base[]
+><() => Base[]>function named() { return [d1, d2] } : () => Base[]
+>Base : Base
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x209 = <{ (): Base[]; }>function() { return [d1, d2] };
+>x209 : () => Base[]
+><{ (): Base[]; }>function() { return [d1, d2] } : () => Base[]
+>Base : Base
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x210 = <{ (): Base[]; }>function named() { return [d1, d2] };
+>x210 : () => Base[]
+><{ (): Base[]; }>function named() { return [d1, d2] } : () => Base[]
+>Base : Base
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x211 = <Base[]>[d1, d2];
+>x211 : Base[]
+><Base[]>[d1, d2] : Base[]
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x212 = <Array<Base>>[d1, d2];
+>x212 : Base[]
+><Array<Base>>[d1, d2] : Base[]
+>Array : T[]
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x213 = <{ [n: number]: Base; }>[d1, d2];
+>x213 : { [n: number]: Base; }
+><{ [n: number]: Base; }>[d1, d2] : { [n: number]: Base; }
+>n : number
+>Base : Base
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x214 = <{n: Base[]; } >{ n: [d1, d2] };
+>x214 : { n: Base[]; }
+><{n: Base[]; } >{ n: [d1, d2] } : { n: Base[]; }
+>n : Base[]
+>Base : Base
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x216 = <Genric<Base>>{ func: n => { return [d1, d2]; } };
+>x216 : Genric<Base>
+><Genric<Base>>{ func: n => { return [d1, d2]; } } : Genric<Base>
+>Genric : Genric<T>
+>Base : Base
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
+>n : Base[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x217 = (<() => Base[]>undefined) || function() { return [d1, d2] };
+>x217 : () => Base[]
+>(<() => Base[]>undefined) || function() { return [d1, d2] } : () => Base[]
+>(<() => Base[]>undefined) : () => Base[]
+><() => Base[]>undefined : () => Base[]
+>Base : Base
+>undefined : undefined
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x218 = (<() => Base[]>undefined) || function named() { return [d1, d2] };
+>x218 : () => Base[]
+>(<() => Base[]>undefined) || function named() { return [d1, d2] } : () => Base[]
+>(<() => Base[]>undefined) : () => Base[]
+><() => Base[]>undefined : () => Base[]
+>Base : Base
+>undefined : undefined
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x219 = (<{ (): Base[]; }>undefined) || function() { return [d1, d2] };
+>x219 : () => Base[]
+>(<{ (): Base[]; }>undefined) || function() { return [d1, d2] } : () => Base[]
+>(<{ (): Base[]; }>undefined) : () => Base[]
+><{ (): Base[]; }>undefined : () => Base[]
+>Base : Base
+>undefined : undefined
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x220 = (<{ (): Base[]; }>undefined) || function named() { return [d1, d2] };
+>x220 : () => Base[]
+>(<{ (): Base[]; }>undefined) || function named() { return [d1, d2] } : () => Base[]
+>(<{ (): Base[]; }>undefined) : () => Base[]
+><{ (): Base[]; }>undefined : () => Base[]
+>Base : Base
+>undefined : undefined
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x221 = (<Base[]>undefined) || [d1, d2];
+>x221 : Base[]
+>(<Base[]>undefined) || [d1, d2] : Base[]
+>(<Base[]>undefined) : Base[]
+><Base[]>undefined : Base[]
+>Base : Base
+>undefined : undefined
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x222 = (<Array<Base>>undefined) || [d1, d2];
+>x222 : Base[]
+>(<Array<Base>>undefined) || [d1, d2] : Base[]
+>(<Array<Base>>undefined) : Base[]
+><Array<Base>>undefined : Base[]
+>Array : T[]
+>Base : Base
+>undefined : undefined
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x223 = (<{ [n: number]: Base; }>undefined) || [d1, d2];
+>x223 : { [n: number]: Base; }
+>(<{ [n: number]: Base; }>undefined) || [d1, d2] : { [n: number]: Base; }
+>(<{ [n: number]: Base; }>undefined) : { [n: number]: Base; }
+><{ [n: number]: Base; }>undefined : { [n: number]: Base; }
+>n : number
+>Base : Base
+>undefined : undefined
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x224 = (<{n: Base[]; } >undefined) || { n: [d1, d2] };
+>x224 : { n: Base[]; }
+>(<{n: Base[]; } >undefined) || { n: [d1, d2] } : { n: Base[]; }
+>(<{n: Base[]; } >undefined) : { n: Base[]; }
+><{n: Base[]; } >undefined : { n: Base[]; }
+>n : Base[]
+>Base : Base
+>undefined : undefined
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x225: () => Base[]; x225 = () => [d1, d2];
+>x225 : () => Base[]
+>Base : Base
+>x225 = () => [d1, d2] : () => (Derived1 | Derived2)[]
+>x225 : () => Base[]
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x226: () => Base[]; x226 = function() { return [d1, d2] };
+>x226 : () => Base[]
+>Base : Base
+>x226 = function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>x226 : () => Base[]
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x227: () => Base[]; x227 = function named() { return [d1, d2] };
+>x227 : () => Base[]
+>Base : Base
+>x227 = function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>x227 : () => Base[]
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x228: { (): Base[]; }; x228 = () => [d1, d2];
+>x228 : () => Base[]
+>Base : Base
+>x228 = () => [d1, d2] : () => (Derived1 | Derived2)[]
+>x228 : () => Base[]
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x229: { (): Base[]; }; x229 = function() { return [d1, d2] };
+>x229 : () => Base[]
+>Base : Base
+>x229 = function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>x229 : () => Base[]
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x230: { (): Base[]; }; x230 = function named() { return [d1, d2] };
+>x230 : () => Base[]
+>Base : Base
+>x230 = function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>x230 : () => Base[]
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x231: Base[]; x231 = [d1, d2];
+>x231 : Base[]
+>Base : Base
+>x231 = [d1, d2] : (Derived1 | Derived2)[]
+>x231 : Base[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x232: Array<Base>; x232 = [d1, d2];
+>x232 : Base[]
+>Array : T[]
+>Base : Base
+>x232 = [d1, d2] : (Derived1 | Derived2)[]
+>x232 : Base[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x233: { [n: number]: Base; }; x233 = [d1, d2];
+>x233 : { [n: number]: Base; }
+>n : number
+>Base : Base
+>x233 = [d1, d2] : (Derived1 | Derived2)[]
+>x233 : { [n: number]: Base; }
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x234: {n: Base[]; } ; x234 = { n: [d1, d2] };
+>x234 : { n: Base[]; }
+>n : Base[]
+>Base : Base
+>x234 = { n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>x234 : { n: Base[]; }
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x235: (s: Base[]) => any; x235 = n => { var n: Base[]; return null; };
+>x235 : (s: Base[]) => any
+>s : Base[]
+>Base : Base
+>x235 = n => { var n: Base[]; return null; } : (n: Base[]) => any
+>x235 : (s: Base[]) => any
+>n => { var n: Base[]; return null; } : (n: Base[]) => any
+>n : Base[]
+>n : Base[]
+>Base : Base
+>null : null
+
+var x236: Genric<Base>; x236 = { func: n => { return [d1, d2]; } };
+>x236 : Genric<Base>
+>Genric : Genric<T>
+>Base : Base
+>x236 = { func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>x236 : Genric<Base>
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
+>n : Base[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x237: { n: () => Base[]; } = { n: () => [d1, d2] };
+>x237 : { n: () => Base[]; }
+>n : () => Base[]
+>Base : Base
+>{ n: () => [d1, d2] } : { n: () => (Derived1 | Derived2)[]; }
+>n : () => (Derived1 | Derived2)[]
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x238: { n: () => Base[]; } = { n: function() { return [d1, d2] } };
+>x238 : { n: () => Base[]; }
+>n : () => Base[]
+>Base : Base
+>{ n: function() { return [d1, d2] } } : { n: () => (Derived1 | Derived2)[]; }
+>n : () => (Derived1 | Derived2)[]
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x239: { n: () => Base[]; } = { n: function named() { return [d1, d2] } };
+>x239 : { n: () => Base[]; }
+>n : () => Base[]
+>Base : Base
+>{ n: function named() { return [d1, d2] } } : { n: () => (Derived1 | Derived2)[]; }
+>n : () => (Derived1 | Derived2)[]
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x240: { n: { (): Base[]; }; } = { n: () => [d1, d2] };
+>x240 : { n: () => Base[]; }
+>n : () => Base[]
+>Base : Base
+>{ n: () => [d1, d2] } : { n: () => (Derived1 | Derived2)[]; }
+>n : () => (Derived1 | Derived2)[]
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x241: { n: { (): Base[]; }; } = { n: function() { return [d1, d2] } };
+>x241 : { n: () => Base[]; }
+>n : () => Base[]
+>Base : Base
+>{ n: function() { return [d1, d2] } } : { n: () => (Derived1 | Derived2)[]; }
+>n : () => (Derived1 | Derived2)[]
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x242: { n: { (): Base[]; }; } = { n: function named() { return [d1, d2] } };
+>x242 : { n: () => Base[]; }
+>n : () => Base[]
+>Base : Base
+>{ n: function named() { return [d1, d2] } } : { n: () => (Derived1 | Derived2)[]; }
+>n : () => (Derived1 | Derived2)[]
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x243: { n: Base[]; } = { n: [d1, d2] };
+>x243 : { n: Base[]; }
+>n : Base[]
+>Base : Base
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x244: { n: Array<Base>; } = { n: [d1, d2] };
+>x244 : { n: Base[]; }
+>n : Base[]
+>Array : T[]
+>Base : Base
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x245: { n: { [n: number]: Base; }; } = { n: [d1, d2] };
+>x245 : { n: { [n: number]: Base; }; }
+>n : { [n: number]: Base; }
+>n : number
+>Base : Base
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x246: { n: {n: Base[]; } ; } = { n: { n: [d1, d2] } };
+>x246 : { n: { n: Base[]; }; }
+>n : { n: Base[]; }
+>n : Base[]
+>Base : Base
+>{ n: { n: [d1, d2] } } : { n: { n: (Derived1 | Derived2)[]; }; }
+>n : { n: (Derived1 | Derived2)[]; }
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x247: { n: (s: Base[]) => any; } = { n: n => { var n: Base[]; return null; } };
+>x247 : { n: (s: Base[]) => any; }
+>n : (s: Base[]) => any
+>s : Base[]
+>Base : Base
+>{ n: n => { var n: Base[]; return null; } } : { n: (n: Base[]) => any; }
+>n : (n: Base[]) => any
+>n => { var n: Base[]; return null; } : (n: Base[]) => any
+>n : Base[]
+>n : Base[]
+>Base : Base
+>null : null
+
+var x248: { n: Genric<Base>; } = { n: { func: n => { return [d1, d2]; } } };
+>x248 : { n: Genric<Base>; }
+>n : Genric<Base>
+>Genric : Genric<T>
+>Base : Base
+>{ n: { func: n => { return [d1, d2]; } } } : { n: { func: (n: Base[]) => (Derived1 | Derived2)[]; }; }
+>n : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
+>n : Base[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x252: { (): Base[]; }[] = [() => [d1, d2]];
+>x252 : (() => Base[])[]
+>Base : Base
+>[() => [d1, d2]] : (() => (Derived1 | Derived2)[])[]
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x253: { (): Base[]; }[] = [function() { return [d1, d2] }];
+>x253 : (() => Base[])[]
+>Base : Base
+>[function() { return [d1, d2] }] : (() => (Derived1 | Derived2)[])[]
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x254: { (): Base[]; }[] = [function named() { return [d1, d2] }];
+>x254 : (() => Base[])[]
+>Base : Base
+>[function named() { return [d1, d2] }] : (() => (Derived1 | Derived2)[])[]
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x255: Base[][] = [[d1, d2]];
+>x255 : Base[][]
+>Base : Base
+>[[d1, d2]] : (Derived1 | Derived2)[][]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x256: Array<Base>[] = [[d1, d2]];
+>x256 : Base[][]
+>Array : T[]
+>Base : Base
+>[[d1, d2]] : (Derived1 | Derived2)[][]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x257: { [n: number]: Base; }[] = [[d1, d2]];
+>x257 : { [n: number]: Base; }[]
+>n : number
+>Base : Base
+>[[d1, d2]] : (Derived1 | Derived2)[][]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x258: {n: Base[]; } [] = [{ n: [d1, d2] }];
+>x258 : { n: Base[]; }[]
+>n : Base[]
+>Base : Base
+>[{ n: [d1, d2] }] : { n: (Derived1 | Derived2)[]; }[]
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x260: Genric<Base>[] = [{ func: n => { return [d1, d2]; } }];
+>x260 : Genric<Base>[]
+>Genric : Genric<T>
+>Base : Base
+>[{ func: n => { return [d1, d2]; } }] : { func: (n: Base[]) => (Derived1 | Derived2)[]; }[]
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
+>n : Base[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x261: () => Base[] = function() { return [d1, d2] } || undefined;
+>x261 : () => Base[]
+>Base : Base
+>function() { return [d1, d2] } || undefined : () => (Derived1 | Derived2)[]
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>undefined : undefined
+
+var x262: () => Base[] = function named() { return [d1, d2] } || undefined;
+>x262 : () => Base[]
+>Base : Base
+>function named() { return [d1, d2] } || undefined : () => (Derived1 | Derived2)[]
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>undefined : undefined
+
+var x263: { (): Base[]; } = function() { return [d1, d2] } || undefined;
+>x263 : () => Base[]
+>Base : Base
+>function() { return [d1, d2] } || undefined : () => (Derived1 | Derived2)[]
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>undefined : undefined
+
+var x264: { (): Base[]; } = function named() { return [d1, d2] } || undefined;
+>x264 : () => Base[]
+>Base : Base
+>function named() { return [d1, d2] } || undefined : () => (Derived1 | Derived2)[]
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>undefined : undefined
+
+var x265: Base[] = [d1, d2] || undefined;
+>x265 : Base[]
+>Base : Base
+>[d1, d2] || undefined : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>undefined : undefined
+
+var x266: Array<Base> = [d1, d2] || undefined;
+>x266 : Base[]
+>Array : T[]
+>Base : Base
+>[d1, d2] || undefined : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>undefined : undefined
+
+var x267: { [n: number]: Base; } = [d1, d2] || undefined;
+>x267 : { [n: number]: Base; }
+>n : number
+>Base : Base
+>[d1, d2] || undefined : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>undefined : undefined
+
+var x268: {n: Base[]; }  = { n: [d1, d2] } || undefined;
+>x268 : { n: Base[]; }
+>n : Base[]
+>Base : Base
+>{ n: [d1, d2] } || undefined : { n: (Derived1 | Derived2)[]; }
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>undefined : undefined
+
+var x269: () => Base[] = undefined || function() { return [d1, d2] };
+>x269 : () => Base[]
+>Base : Base
+>undefined || function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>undefined : undefined
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x270: () => Base[] = undefined || function named() { return [d1, d2] };
+>x270 : () => Base[]
+>Base : Base
+>undefined || function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>undefined : undefined
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x271: { (): Base[]; } = undefined || function() { return [d1, d2] };
+>x271 : () => Base[]
+>Base : Base
+>undefined || function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>undefined : undefined
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x272: { (): Base[]; } = undefined || function named() { return [d1, d2] };
+>x272 : () => Base[]
+>Base : Base
+>undefined || function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>undefined : undefined
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x273: Base[] = undefined || [d1, d2];
+>x273 : Base[]
+>Base : Base
+>undefined || [d1, d2] : (Derived1 | Derived2)[]
+>undefined : undefined
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x274: Array<Base> = undefined || [d1, d2];
+>x274 : Base[]
+>Array : T[]
+>Base : Base
+>undefined || [d1, d2] : (Derived1 | Derived2)[]
+>undefined : undefined
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x275: { [n: number]: Base; } = undefined || [d1, d2];
+>x275 : { [n: number]: Base; }
+>n : number
+>Base : Base
+>undefined || [d1, d2] : (Derived1 | Derived2)[]
+>undefined : undefined
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x276: {n: Base[]; }  = undefined || { n: [d1, d2] };
+>x276 : { n: Base[]; }
+>n : Base[]
+>Base : Base
+>undefined || { n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>undefined : undefined
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x277: () => Base[] = function() { return [d1, d2] } || function() { return [d1, d2] };
+>x277 : () => Base[]
+>Base : Base
+>function() { return [d1, d2] } || function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x278: () => Base[] = function named() { return [d1, d2] } || function named() { return [d1, d2] };
+>x278 : () => Base[]
+>Base : Base
+>function named() { return [d1, d2] } || function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x279: { (): Base[]; } = function() { return [d1, d2] } || function() { return [d1, d2] };
+>x279 : () => Base[]
+>Base : Base
+>function() { return [d1, d2] } || function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x280: { (): Base[]; } = function named() { return [d1, d2] } || function named() { return [d1, d2] };
+>x280 : () => Base[]
+>Base : Base
+>function named() { return [d1, d2] } || function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x281: Base[] = [d1, d2] || [d1, d2];
+>x281 : Base[]
+>Base : Base
+>[d1, d2] || [d1, d2] : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x282: Array<Base> = [d1, d2] || [d1, d2];
+>x282 : Base[]
+>Array : T[]
+>Base : Base
+>[d1, d2] || [d1, d2] : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x283: { [n: number]: Base; } = [d1, d2] || [d1, d2];
+>x283 : { [n: number]: Base; }
+>n : number
+>Base : Base
+>[d1, d2] || [d1, d2] : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x284: {n: Base[]; }  = { n: [d1, d2] } || { n: [d1, d2] };
+>x284 : { n: Base[]; }
+>n : Base[]
+>Base : Base
+>{ n: [d1, d2] } || { n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x285: () => Base[] = true ? () => [d1, d2] : () => [d1, d2];
+>x285 : () => Base[]
+>Base : Base
+>true ? () => [d1, d2] : () => [d1, d2] : () => (Derived1 | Derived2)[]
+>true : boolean
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x286: () => Base[] = true ? function() { return [d1, d2] } : function() { return [d1, d2] };
+>x286 : () => Base[]
+>Base : Base
+>true ? function() { return [d1, d2] } : function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>true : boolean
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x287: () => Base[] = true ? function named() { return [d1, d2] } : function named() { return [d1, d2] };
+>x287 : () => Base[]
+>Base : Base
+>true ? function named() { return [d1, d2] } : function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>true : boolean
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x288: { (): Base[]; } = true ? () => [d1, d2] : () => [d1, d2];
+>x288 : () => Base[]
+>Base : Base
+>true ? () => [d1, d2] : () => [d1, d2] : () => (Derived1 | Derived2)[]
+>true : boolean
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x289: { (): Base[]; } = true ? function() { return [d1, d2] } : function() { return [d1, d2] };
+>x289 : () => Base[]
+>Base : Base
+>true ? function() { return [d1, d2] } : function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>true : boolean
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x290: { (): Base[]; } = true ? function named() { return [d1, d2] } : function named() { return [d1, d2] };
+>x290 : () => Base[]
+>Base : Base
+>true ? function named() { return [d1, d2] } : function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>true : boolean
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x291: Base[] = true ? [d1, d2] : [d1, d2];
+>x291 : Base[]
+>Base : Base
+>true ? [d1, d2] : [d1, d2] : (Derived1 | Derived2)[]
+>true : boolean
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x292: Array<Base> = true ? [d1, d2] : [d1, d2];
+>x292 : Base[]
+>Array : T[]
+>Base : Base
+>true ? [d1, d2] : [d1, d2] : (Derived1 | Derived2)[]
+>true : boolean
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x293: { [n: number]: Base; } = true ? [d1, d2] : [d1, d2];
+>x293 : { [n: number]: Base; }
+>n : number
+>Base : Base
+>true ? [d1, d2] : [d1, d2] : (Derived1 | Derived2)[]
+>true : boolean
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x294: {n: Base[]; }  = true ? { n: [d1, d2] } : { n: [d1, d2] };
+>x294 : { n: Base[]; }
+>n : Base[]
+>Base : Base
+>true ? { n: [d1, d2] } : { n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>true : boolean
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x295: (s: Base[]) => any = true ? n => { var n: Base[]; return null; } : n => { var n: Base[]; return null; };
+>x295 : (s: Base[]) => any
+>s : Base[]
+>Base : Base
+>true ? n => { var n: Base[]; return null; } : n => { var n: Base[]; return null; } : (n: Base[]) => any
+>true : boolean
+>n => { var n: Base[]; return null; } : (n: Base[]) => any
+>n : Base[]
+>n : Base[]
+>Base : Base
+>null : null
+>n => { var n: Base[]; return null; } : (n: Base[]) => any
+>n : Base[]
+>n : Base[]
+>Base : Base
+>null : null
+
+var x296: Genric<Base> = true ? { func: n => { return [d1, d2]; } } : { func: n => { return [d1, d2]; } };
+>x296 : Genric<Base>
+>Genric : Genric<T>
+>Base : Base
+>true ? { func: n => { return [d1, d2]; } } : { func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>true : boolean
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
+>n : Base[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
+>n : Base[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x297: () => Base[] = true ? undefined : () => [d1, d2];
+>x297 : () => Base[]
+>Base : Base
+>true ? undefined : () => [d1, d2] : () => (Derived1 | Derived2)[]
+>true : boolean
+>undefined : undefined
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x298: () => Base[] = true ? undefined : function() { return [d1, d2] };
+>x298 : () => Base[]
+>Base : Base
+>true ? undefined : function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>true : boolean
+>undefined : undefined
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x299: () => Base[] = true ? undefined : function named() { return [d1, d2] };
+>x299 : () => Base[]
+>Base : Base
+>true ? undefined : function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>true : boolean
+>undefined : undefined
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x300: { (): Base[]; } = true ? undefined : () => [d1, d2];
+>x300 : () => Base[]
+>Base : Base
+>true ? undefined : () => [d1, d2] : () => (Derived1 | Derived2)[]
+>true : boolean
+>undefined : undefined
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x301: { (): Base[]; } = true ? undefined : function() { return [d1, d2] };
+>x301 : () => Base[]
+>Base : Base
+>true ? undefined : function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>true : boolean
+>undefined : undefined
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x302: { (): Base[]; } = true ? undefined : function named() { return [d1, d2] };
+>x302 : () => Base[]
+>Base : Base
+>true ? undefined : function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>true : boolean
+>undefined : undefined
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x303: Base[] = true ? undefined : [d1, d2];
+>x303 : Base[]
+>Base : Base
+>true ? undefined : [d1, d2] : (Derived1 | Derived2)[]
+>true : boolean
+>undefined : undefined
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x304: Array<Base> = true ? undefined : [d1, d2];
+>x304 : Base[]
+>Array : T[]
+>Base : Base
+>true ? undefined : [d1, d2] : (Derived1 | Derived2)[]
+>true : boolean
+>undefined : undefined
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x305: { [n: number]: Base; } = true ? undefined : [d1, d2];
+>x305 : { [n: number]: Base; }
+>n : number
+>Base : Base
+>true ? undefined : [d1, d2] : (Derived1 | Derived2)[]
+>true : boolean
+>undefined : undefined
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x306: {n: Base[]; }  = true ? undefined : { n: [d1, d2] };
+>x306 : { n: Base[]; }
+>n : Base[]
+>Base : Base
+>true ? undefined : { n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>true : boolean
+>undefined : undefined
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x307: (s: Base[]) => any = true ? undefined : n => { var n: Base[]; return null; };
+>x307 : (s: Base[]) => any
+>s : Base[]
+>Base : Base
+>true ? undefined : n => { var n: Base[]; return null; } : (n: Base[]) => any
+>true : boolean
+>undefined : undefined
+>n => { var n: Base[]; return null; } : (n: Base[]) => any
+>n : Base[]
+>n : Base[]
+>Base : Base
+>null : null
+
+var x308: Genric<Base> = true ? undefined : { func: n => { return [d1, d2]; } };
+>x308 : Genric<Base>
+>Genric : Genric<T>
+>Base : Base
+>true ? undefined : { func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>true : boolean
+>undefined : undefined
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
+>n : Base[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x309: () => Base[] = true ? () => [d1, d2] : undefined;
+>x309 : () => Base[]
+>Base : Base
+>true ? () => [d1, d2] : undefined : () => (Derived1 | Derived2)[]
+>true : boolean
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>undefined : undefined
+
+var x310: () => Base[] = true ? function() { return [d1, d2] } : undefined;
+>x310 : () => Base[]
+>Base : Base
+>true ? function() { return [d1, d2] } : undefined : () => (Derived1 | Derived2)[]
+>true : boolean
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>undefined : undefined
+
+var x311: () => Base[] = true ? function named() { return [d1, d2] } : undefined;
+>x311 : () => Base[]
+>Base : Base
+>true ? function named() { return [d1, d2] } : undefined : () => (Derived1 | Derived2)[]
+>true : boolean
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>undefined : undefined
+
+var x312: { (): Base[]; } = true ? () => [d1, d2] : undefined;
+>x312 : () => Base[]
+>Base : Base
+>true ? () => [d1, d2] : undefined : () => (Derived1 | Derived2)[]
+>true : boolean
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>undefined : undefined
+
+var x313: { (): Base[]; } = true ? function() { return [d1, d2] } : undefined;
+>x313 : () => Base[]
+>Base : Base
+>true ? function() { return [d1, d2] } : undefined : () => (Derived1 | Derived2)[]
+>true : boolean
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>undefined : undefined
+
+var x314: { (): Base[]; } = true ? function named() { return [d1, d2] } : undefined;
+>x314 : () => Base[]
+>Base : Base
+>true ? function named() { return [d1, d2] } : undefined : () => (Derived1 | Derived2)[]
+>true : boolean
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>undefined : undefined
+
+var x315: Base[] = true ? [d1, d2] : undefined;
+>x315 : Base[]
+>Base : Base
+>true ? [d1, d2] : undefined : (Derived1 | Derived2)[]
+>true : boolean
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>undefined : undefined
+
+var x316: Array<Base> = true ? [d1, d2] : undefined;
+>x316 : Base[]
+>Array : T[]
+>Base : Base
+>true ? [d1, d2] : undefined : (Derived1 | Derived2)[]
+>true : boolean
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>undefined : undefined
+
+var x317: { [n: number]: Base; } = true ? [d1, d2] : undefined;
+>x317 : { [n: number]: Base; }
+>n : number
+>Base : Base
+>true ? [d1, d2] : undefined : (Derived1 | Derived2)[]
+>true : boolean
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>undefined : undefined
+
+var x318: {n: Base[]; }  = true ? { n: [d1, d2] } : undefined;
+>x318 : { n: Base[]; }
+>n : Base[]
+>Base : Base
+>true ? { n: [d1, d2] } : undefined : { n: (Derived1 | Derived2)[]; }
+>true : boolean
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>undefined : undefined
+
+var x319: (s: Base[]) => any = true ? n => { var n: Base[]; return null; } : undefined;
+>x319 : (s: Base[]) => any
+>s : Base[]
+>Base : Base
+>true ? n => { var n: Base[]; return null; } : undefined : (n: Base[]) => any
+>true : boolean
+>n => { var n: Base[]; return null; } : (n: Base[]) => any
+>n : Base[]
+>n : Base[]
+>Base : Base
+>null : null
+>undefined : undefined
+
+var x320: Genric<Base> = true ? { func: n => { return [d1, d2]; } } : undefined;
+>x320 : Genric<Base>
+>Genric : Genric<T>
+>Base : Base
+>true ? { func: n => { return [d1, d2]; } } : undefined : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>true : boolean
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
+>n : Base[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+>undefined : undefined
+
+function x321(n: () => Base[]) { }; x321(() => [d1, d2]);
+>x321 : (n: () => Base[]) => void
+>n : () => Base[]
+>Base : Base
+>x321(() => [d1, d2]) : void
+>x321 : (n: () => Base[]) => void
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x322(n: () => Base[]) { }; x322(function() { return [d1, d2] });
+>x322 : (n: () => Base[]) => void
+>n : () => Base[]
+>Base : Base
+>x322(function() { return [d1, d2] }) : void
+>x322 : (n: () => Base[]) => void
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x323(n: () => Base[]) { }; x323(function named() { return [d1, d2] });
+>x323 : (n: () => Base[]) => void
+>n : () => Base[]
+>Base : Base
+>x323(function named() { return [d1, d2] }) : void
+>x323 : (n: () => Base[]) => void
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x324(n: { (): Base[]; }) { }; x324(() => [d1, d2]);
+>x324 : (n: () => Base[]) => void
+>n : () => Base[]
+>Base : Base
+>x324(() => [d1, d2]) : void
+>x324 : (n: () => Base[]) => void
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x325(n: { (): Base[]; }) { }; x325(function() { return [d1, d2] });
+>x325 : (n: () => Base[]) => void
+>n : () => Base[]
+>Base : Base
+>x325(function() { return [d1, d2] }) : void
+>x325 : (n: () => Base[]) => void
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x326(n: { (): Base[]; }) { }; x326(function named() { return [d1, d2] });
+>x326 : (n: () => Base[]) => void
+>n : () => Base[]
+>Base : Base
+>x326(function named() { return [d1, d2] }) : void
+>x326 : (n: () => Base[]) => void
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x327(n: Base[]) { }; x327([d1, d2]);
+>x327 : (n: Base[]) => void
+>n : Base[]
+>Base : Base
+>x327([d1, d2]) : void
+>x327 : (n: Base[]) => void
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x328(n: Array<Base>) { }; x328([d1, d2]);
+>x328 : (n: Base[]) => void
+>n : Base[]
+>Array : T[]
+>Base : Base
+>x328([d1, d2]) : void
+>x328 : (n: Base[]) => void
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x329(n: { [n: number]: Base; }) { }; x329([d1, d2]);
+>x329 : (n: { [n: number]: Base; }) => void
+>n : { [n: number]: Base; }
+>n : number
+>Base : Base
+>x329([d1, d2]) : void
+>x329 : (n: { [n: number]: Base; }) => void
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x330(n: {n: Base[]; } ) { }; x330({ n: [d1, d2] });
+>x330 : (n: { n: Base[]; }) => void
+>n : { n: Base[]; }
+>n : Base[]
+>Base : Base
+>x330({ n: [d1, d2] }) : void
+>x330 : (n: { n: Base[]; }) => void
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+function x331(n: (s: Base[]) => any) { }; x331(n => { var n: Base[]; return null; });
+>x331 : (n: (s: Base[]) => any) => void
+>n : (s: Base[]) => any
+>s : Base[]
+>Base : Base
+>x331(n => { var n: Base[]; return null; }) : void
+>x331 : (n: (s: Base[]) => any) => void
+>n => { var n: Base[]; return null; } : (n: Base[]) => any
+>n : Base[]
+>n : Base[]
+>Base : Base
+>null : null
+
+function x332(n: Genric<Base>) { }; x332({ func: n => { return [d1, d2]; } });
+>x332 : (n: Genric<Base>) => void
+>n : Genric<Base>
+>Genric : Genric<T>
+>Base : Base
+>x332({ func: n => { return [d1, d2]; } }) : void
+>x332 : (n: Genric<Base>) => void
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
+>n : Base[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x333 = (n: () => Base[]) => n; x333(() => [d1, d2]);
+>x333 : (n: () => Base[]) => () => Base[]
+>(n: () => Base[]) => n : (n: () => Base[]) => () => Base[]
+>n : () => Base[]
+>Base : Base
+>n : () => Base[]
+>x333(() => [d1, d2]) : () => Base[]
+>x333 : (n: () => Base[]) => () => Base[]
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x334 = (n: () => Base[]) => n; x334(function() { return [d1, d2] });
+>x334 : (n: () => Base[]) => () => Base[]
+>(n: () => Base[]) => n : (n: () => Base[]) => () => Base[]
+>n : () => Base[]
+>Base : Base
+>n : () => Base[]
+>x334(function() { return [d1, d2] }) : () => Base[]
+>x334 : (n: () => Base[]) => () => Base[]
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x335 = (n: () => Base[]) => n; x335(function named() { return [d1, d2] });
+>x335 : (n: () => Base[]) => () => Base[]
+>(n: () => Base[]) => n : (n: () => Base[]) => () => Base[]
+>n : () => Base[]
+>Base : Base
+>n : () => Base[]
+>x335(function named() { return [d1, d2] }) : () => Base[]
+>x335 : (n: () => Base[]) => () => Base[]
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x336 = (n: { (): Base[]; }) => n; x336(() => [d1, d2]);
+>x336 : (n: () => Base[]) => () => Base[]
+>(n: { (): Base[]; }) => n : (n: () => Base[]) => () => Base[]
+>n : () => Base[]
+>Base : Base
+>n : () => Base[]
+>x336(() => [d1, d2]) : () => Base[]
+>x336 : (n: () => Base[]) => () => Base[]
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x337 = (n: { (): Base[]; }) => n; x337(function() { return [d1, d2] });
+>x337 : (n: () => Base[]) => () => Base[]
+>(n: { (): Base[]; }) => n : (n: () => Base[]) => () => Base[]
+>n : () => Base[]
+>Base : Base
+>n : () => Base[]
+>x337(function() { return [d1, d2] }) : () => Base[]
+>x337 : (n: () => Base[]) => () => Base[]
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x338 = (n: { (): Base[]; }) => n; x338(function named() { return [d1, d2] });
+>x338 : (n: () => Base[]) => () => Base[]
+>(n: { (): Base[]; }) => n : (n: () => Base[]) => () => Base[]
+>n : () => Base[]
+>Base : Base
+>n : () => Base[]
+>x338(function named() { return [d1, d2] }) : () => Base[]
+>x338 : (n: () => Base[]) => () => Base[]
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x339 = (n: Base[]) => n; x339([d1, d2]);
+>x339 : (n: Base[]) => Base[]
+>(n: Base[]) => n : (n: Base[]) => Base[]
+>n : Base[]
+>Base : Base
+>n : Base[]
+>x339([d1, d2]) : Base[]
+>x339 : (n: Base[]) => Base[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x340 = (n: Array<Base>) => n; x340([d1, d2]);
+>x340 : (n: Base[]) => Base[]
+>(n: Array<Base>) => n : (n: Base[]) => Base[]
+>n : Base[]
+>Array : T[]
+>Base : Base
+>n : Base[]
+>x340([d1, d2]) : Base[]
+>x340 : (n: Base[]) => Base[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x341 = (n: { [n: number]: Base; }) => n; x341([d1, d2]);
+>x341 : (n: { [n: number]: Base; }) => { [n: number]: Base; }
+>(n: { [n: number]: Base; }) => n : (n: { [n: number]: Base; }) => { [n: number]: Base; }
+>n : { [n: number]: Base; }
+>n : number
+>Base : Base
+>n : { [n: number]: Base; }
+>x341([d1, d2]) : { [n: number]: Base; }
+>x341 : (n: { [n: number]: Base; }) => { [n: number]: Base; }
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x342 = (n: {n: Base[]; } ) => n; x342({ n: [d1, d2] });
+>x342 : (n: { n: Base[]; }) => { n: Base[]; }
+>(n: {n: Base[]; } ) => n : (n: { n: Base[]; }) => { n: Base[]; }
+>n : { n: Base[]; }
+>n : Base[]
+>Base : Base
+>n : { n: Base[]; }
+>x342({ n: [d1, d2] }) : { n: Base[]; }
+>x342 : (n: { n: Base[]; }) => { n: Base[]; }
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x343 = (n: (s: Base[]) => any) => n; x343(n => { var n: Base[]; return null; });
+>x343 : (n: (s: Base[]) => any) => (s: Base[]) => any
+>(n: (s: Base[]) => any) => n : (n: (s: Base[]) => any) => (s: Base[]) => any
+>n : (s: Base[]) => any
+>s : Base[]
+>Base : Base
+>n : (s: Base[]) => any
+>x343(n => { var n: Base[]; return null; }) : (s: Base[]) => any
+>x343 : (n: (s: Base[]) => any) => (s: Base[]) => any
+>n => { var n: Base[]; return null; } : (n: Base[]) => any
+>n : Base[]
+>n : Base[]
+>Base : Base
+>null : null
+
+var x344 = (n: Genric<Base>) => n; x344({ func: n => { return [d1, d2]; } });
+>x344 : (n: Genric<Base>) => Genric<Base>
+>(n: Genric<Base>) => n : (n: Genric<Base>) => Genric<Base>
+>n : Genric<Base>
+>Genric : Genric<T>
+>Base : Base
+>n : Genric<Base>
+>x344({ func: n => { return [d1, d2]; } }) : Genric<Base>
+>x344 : (n: Genric<Base>) => Genric<Base>
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
+>n : Base[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x345 = function(n: () => Base[]) { }; x345(() => [d1, d2]);
+>x345 : (n: () => Base[]) => void
+>function(n: () => Base[]) { } : (n: () => Base[]) => void
+>n : () => Base[]
+>Base : Base
+>x345(() => [d1, d2]) : void
+>x345 : (n: () => Base[]) => void
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x346 = function(n: () => Base[]) { }; x346(function() { return [d1, d2] });
+>x346 : (n: () => Base[]) => void
+>function(n: () => Base[]) { } : (n: () => Base[]) => void
+>n : () => Base[]
+>Base : Base
+>x346(function() { return [d1, d2] }) : void
+>x346 : (n: () => Base[]) => void
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x347 = function(n: () => Base[]) { }; x347(function named() { return [d1, d2] });
+>x347 : (n: () => Base[]) => void
+>function(n: () => Base[]) { } : (n: () => Base[]) => void
+>n : () => Base[]
+>Base : Base
+>x347(function named() { return [d1, d2] }) : void
+>x347 : (n: () => Base[]) => void
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x348 = function(n: { (): Base[]; }) { }; x348(() => [d1, d2]);
+>x348 : (n: () => Base[]) => void
+>function(n: { (): Base[]; }) { } : (n: () => Base[]) => void
+>n : () => Base[]
+>Base : Base
+>x348(() => [d1, d2]) : void
+>x348 : (n: () => Base[]) => void
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x349 = function(n: { (): Base[]; }) { }; x349(function() { return [d1, d2] });
+>x349 : (n: () => Base[]) => void
+>function(n: { (): Base[]; }) { } : (n: () => Base[]) => void
+>n : () => Base[]
+>Base : Base
+>x349(function() { return [d1, d2] }) : void
+>x349 : (n: () => Base[]) => void
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x350 = function(n: { (): Base[]; }) { }; x350(function named() { return [d1, d2] });
+>x350 : (n: () => Base[]) => void
+>function(n: { (): Base[]; }) { } : (n: () => Base[]) => void
+>n : () => Base[]
+>Base : Base
+>x350(function named() { return [d1, d2] }) : void
+>x350 : (n: () => Base[]) => void
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x351 = function(n: Base[]) { }; x351([d1, d2]);
+>x351 : (n: Base[]) => void
+>function(n: Base[]) { } : (n: Base[]) => void
+>n : Base[]
+>Base : Base
+>x351([d1, d2]) : void
+>x351 : (n: Base[]) => void
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x352 = function(n: Array<Base>) { }; x352([d1, d2]);
+>x352 : (n: Base[]) => void
+>function(n: Array<Base>) { } : (n: Base[]) => void
+>n : Base[]
+>Array : T[]
+>Base : Base
+>x352([d1, d2]) : void
+>x352 : (n: Base[]) => void
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x353 = function(n: { [n: number]: Base; }) { }; x353([d1, d2]);
+>x353 : (n: { [n: number]: Base; }) => void
+>function(n: { [n: number]: Base; }) { } : (n: { [n: number]: Base; }) => void
+>n : { [n: number]: Base; }
+>n : number
+>Base : Base
+>x353([d1, d2]) : void
+>x353 : (n: { [n: number]: Base; }) => void
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x354 = function(n: {n: Base[]; } ) { }; x354({ n: [d1, d2] });
+>x354 : (n: { n: Base[]; }) => void
+>function(n: {n: Base[]; } ) { } : (n: { n: Base[]; }) => void
+>n : { n: Base[]; }
+>n : Base[]
+>Base : Base
+>x354({ n: [d1, d2] }) : void
+>x354 : (n: { n: Base[]; }) => void
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
+var x355 = function(n: (s: Base[]) => any) { }; x355(n => { var n: Base[]; return null; });
+>x355 : (n: (s: Base[]) => any) => void
+>function(n: (s: Base[]) => any) { } : (n: (s: Base[]) => any) => void
+>n : (s: Base[]) => any
+>s : Base[]
+>Base : Base
+>x355(n => { var n: Base[]; return null; }) : void
+>x355 : (n: (s: Base[]) => any) => void
+>n => { var n: Base[]; return null; } : (n: Base[]) => any
+>n : Base[]
+>n : Base[]
+>Base : Base
+>null : null
+
+var x356 = function(n: Genric<Base>) { }; x356({ func: n => { return [d1, d2]; } });
+>x356 : (n: Genric<Base>) => void
+>function(n: Genric<Base>) { } : (n: Genric<Base>) => void
+>n : Genric<Base>
+>Genric : Genric<T>
+>Base : Base
+>x356({ func: n => { return [d1, d2]; } }) : void
+>x356 : (n: Genric<Base>) => void
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
+>n : Base[]
+>[d1, d2] : (Derived1 | Derived2)[]
+>d1 : Derived1
+>d2 : Derived2
+
diff --git a/tests/baselines/reference/ifDoWhileStatements.errors.txt b/tests/baselines/reference/ifDoWhileStatements.errors.txt
deleted file mode 100644
index fb8985e634b..00000000000
--- a/tests/baselines/reference/ifDoWhileStatements.errors.txt
+++ /dev/null
@@ -1,168 +0,0 @@
-tests/cases/conformance/statements/ifDoWhileStatements/ifDoWhileStatements.ts(42,1): error TS7027: Unreachable code detected.
-
-
-==== tests/cases/conformance/statements/ifDoWhileStatements/ifDoWhileStatements.ts (1 errors) ====
-    interface I {
-        id: number;
-    }
-    
-    class C implements I {
-        id: number;
-        name: string;
-    }
-    
-    class C2 extends C {
-        valid: boolean;
-    }
-    
-    class D<T>{
-        source: T;
-        recurse: D<T>;
-        wrapped: D<D<T>>
-    }
-    
-    function F(x: string): number { return 42; }
-    function F2(x: number): boolean { return x < 42; }
-    
-    module M {
-        export class A {
-            name: string;
-        }
-    
-        export function F2(x: number): string { return x.toString(); }
-    }
-    
-    module N {
-        export class A {
-            id: number;
-        }
-    
-        export function F2(x: number): string { return x.toString(); }
-    }
-    
-    // literals
-    if (true) { }
-    while (true) { }
-    do { }while(true)
-    ~~
-!!! error TS7027: Unreachable code detected.
-    
-    if (null) { }
-    while (null) { }
-    do { }while(null)
-    
-    if (undefined) { }
-    while (undefined) { }
-    do { }while(undefined)
-    
-    if (0.0) { }
-    while (0.0) { }
-    do { }while(0.0)
-    
-    if ('a string') { }
-    while ('a string') { }
-    do { }while('a string')
-    
-    if ('') { }
-    while ('') { }
-    do { }while('')
-    
-    if (/[a-z]/) { }
-    while (/[a-z]/) { }
-    do { }while(/[a-z]/)
-    
-    if ([]) { }
-    while ([]) { }
-    do { }while([])
-    
-    if ([1, 2]) { }
-    while ([1, 2]) { }
-    do { }while([1, 2])
-    
-    if ({}) { }
-    while ({}) { }
-    do { }while({})
-    
-    if ({ x: 1, y: 'a' }) { }
-    while ({ x: 1, y: 'a' }) { }
-    do { }while({ x: 1, y: 'a' })
-    
-    if (() => 43) { }
-    while (() => 43) { }
-    do { }while(() => 43)
-    
-    if (new C()) { }
-    while (new C()) { }
-    do { }while(new C())
-    
-    if (new D<C>()) { }
-    while (new D<C>()) { }
-    do { }while(new D<C>())
-    
-    // references
-    var a = true;
-    if (a) { }
-    while (a) { }
-    do { }while(a)
-    
-    var b = null;
-    if (b) { }
-    while (b) { }
-    do { }while(b)
-    
-    var c = undefined;
-    if (c) { }
-    while (c) { }
-    do { }while(c)
-    
-    var d = 0.0;
-    if (d) { }
-    while (d) { }
-    do { }while(d)
-    
-    var e = 'a string';
-    if (e) { }
-    while (e) { }
-    do { }while(e)
-    
-    var f = '';
-    if (f) { }
-    while (f) { }
-    do { }while(f)
-    
-    var g = /[a-z]/
-    if (g) { }
-    while (g) { }
-    do { }while(g)
-    
-    var h = [];
-    if (h) { }
-    while (h) { }
-    do { }while(h)
-    
-    var i = [1, 2];
-    if (i) { }
-    while (i) { }
-    do { }while(i)
-    
-    var j = {};
-    if (j) { }
-    while (j) { }
-    do { }while(j)
-    
-    var k = { x: 1, y: 'a' };
-    if (k) { }
-    while (k) { }
-    do { }while(k)
-    
-    function fn(x?: string): I { return null; }
-    if (fn()) { }
-    while (fn()) { }
-    do { }while(fn())
-    
-    if (fn) { }
-    while (fn) { }
-    do { }while(fn)
-    
-    
-    
\ No newline at end of file
diff --git a/tests/baselines/reference/ifDoWhileStatements.js b/tests/baselines/reference/ifDoWhileStatements.js
index 020d3f053d1..a2553c674b0 100644
--- a/tests/baselines/reference/ifDoWhileStatements.js
+++ b/tests/baselines/reference/ifDoWhileStatements.js
@@ -1,4 +1,5 @@
 //// [ifDoWhileStatements.ts]
+
 interface I {
     id: number;
 }
diff --git a/tests/baselines/reference/ifDoWhileStatements.symbols b/tests/baselines/reference/ifDoWhileStatements.symbols
new file mode 100644
index 00000000000..80c8fc7f1d8
--- /dev/null
+++ b/tests/baselines/reference/ifDoWhileStatements.symbols
@@ -0,0 +1,337 @@
+=== tests/cases/conformance/statements/ifDoWhileStatements/ifDoWhileStatements.ts ===
+
+interface I {
+>I : Symbol(I, Decl(ifDoWhileStatements.ts, 0, 0))
+
+    id: number;
+>id : Symbol(id, Decl(ifDoWhileStatements.ts, 1, 13))
+}
+
+class C implements I {
+>C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1))
+>I : Symbol(I, Decl(ifDoWhileStatements.ts, 0, 0))
+
+    id: number;
+>id : Symbol(id, Decl(ifDoWhileStatements.ts, 5, 22))
+
+    name: string;
+>name : Symbol(name, Decl(ifDoWhileStatements.ts, 6, 15))
+}
+
+class C2 extends C {
+>C2 : Symbol(C2, Decl(ifDoWhileStatements.ts, 8, 1))
+>C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1))
+
+    valid: boolean;
+>valid : Symbol(valid, Decl(ifDoWhileStatements.ts, 10, 20))
+}
+
+class D<T>{
+>D : Symbol(D, Decl(ifDoWhileStatements.ts, 12, 1))
+>T : Symbol(T, Decl(ifDoWhileStatements.ts, 14, 8))
+
+    source: T;
+>source : Symbol(source, Decl(ifDoWhileStatements.ts, 14, 11))
+>T : Symbol(T, Decl(ifDoWhileStatements.ts, 14, 8))
+
+    recurse: D<T>;
+>recurse : Symbol(recurse, Decl(ifDoWhileStatements.ts, 15, 14))
+>D : Symbol(D, Decl(ifDoWhileStatements.ts, 12, 1))
+>T : Symbol(T, Decl(ifDoWhileStatements.ts, 14, 8))
+
+    wrapped: D<D<T>>
+>wrapped : Symbol(wrapped, Decl(ifDoWhileStatements.ts, 16, 18))
+>D : Symbol(D, Decl(ifDoWhileStatements.ts, 12, 1))
+>D : Symbol(D, Decl(ifDoWhileStatements.ts, 12, 1))
+>T : Symbol(T, Decl(ifDoWhileStatements.ts, 14, 8))
+}
+
+function F(x: string): number { return 42; }
+>F : Symbol(F, Decl(ifDoWhileStatements.ts, 18, 1))
+>x : Symbol(x, Decl(ifDoWhileStatements.ts, 20, 11))
+
+function F2(x: number): boolean { return x < 42; }
+>F2 : Symbol(F2, Decl(ifDoWhileStatements.ts, 20, 44))
+>x : Symbol(x, Decl(ifDoWhileStatements.ts, 21, 12))
+>x : Symbol(x, Decl(ifDoWhileStatements.ts, 21, 12))
+
+module M {
+>M : Symbol(M, Decl(ifDoWhileStatements.ts, 21, 50))
+
+    export class A {
+>A : Symbol(A, Decl(ifDoWhileStatements.ts, 23, 10))
+
+        name: string;
+>name : Symbol(name, Decl(ifDoWhileStatements.ts, 24, 20))
+    }
+
+    export function F2(x: number): string { return x.toString(); }
+>F2 : Symbol(F2, Decl(ifDoWhileStatements.ts, 26, 5))
+>x : Symbol(x, Decl(ifDoWhileStatements.ts, 28, 23))
+>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+>x : Symbol(x, Decl(ifDoWhileStatements.ts, 28, 23))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+}
+
+module N {
+>N : Symbol(N, Decl(ifDoWhileStatements.ts, 29, 1))
+
+    export class A {
+>A : Symbol(A, Decl(ifDoWhileStatements.ts, 31, 10))
+
+        id: number;
+>id : Symbol(id, Decl(ifDoWhileStatements.ts, 32, 20))
+    }
+
+    export function F2(x: number): string { return x.toString(); }
+>F2 : Symbol(F2, Decl(ifDoWhileStatements.ts, 34, 5))
+>x : Symbol(x, Decl(ifDoWhileStatements.ts, 36, 23))
+>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+>x : Symbol(x, Decl(ifDoWhileStatements.ts, 36, 23))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+}
+
+// literals
+if (true) { }
+while (true) { }
+do { }while(true)
+
+if (null) { }
+while (null) { }
+do { }while(null)
+
+if (undefined) { }
+>undefined : Symbol(undefined)
+
+while (undefined) { }
+>undefined : Symbol(undefined)
+
+do { }while(undefined)
+>undefined : Symbol(undefined)
+
+if (0.0) { }
+while (0.0) { }
+do { }while(0.0)
+
+if ('a string') { }
+while ('a string') { }
+do { }while('a string')
+
+if ('') { }
+while ('') { }
+do { }while('')
+
+if (/[a-z]/) { }
+while (/[a-z]/) { }
+do { }while(/[a-z]/)
+
+if ([]) { }
+while ([]) { }
+do { }while([])
+
+if ([1, 2]) { }
+while ([1, 2]) { }
+do { }while([1, 2])
+
+if ({}) { }
+while ({}) { }
+do { }while({})
+
+if ({ x: 1, y: 'a' }) { }
+>x : Symbol(x, Decl(ifDoWhileStatements.ts, 80, 5))
+>y : Symbol(y, Decl(ifDoWhileStatements.ts, 80, 11))
+
+while ({ x: 1, y: 'a' }) { }
+>x : Symbol(x, Decl(ifDoWhileStatements.ts, 81, 8))
+>y : Symbol(y, Decl(ifDoWhileStatements.ts, 81, 14))
+
+do { }while({ x: 1, y: 'a' })
+>x : Symbol(x, Decl(ifDoWhileStatements.ts, 82, 13))
+>y : Symbol(y, Decl(ifDoWhileStatements.ts, 82, 19))
+
+if (() => 43) { }
+while (() => 43) { }
+do { }while(() => 43)
+
+if (new C()) { }
+>C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1))
+
+while (new C()) { }
+>C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1))
+
+do { }while(new C())
+>C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1))
+
+if (new D<C>()) { }
+>D : Symbol(D, Decl(ifDoWhileStatements.ts, 12, 1))
+>C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1))
+
+while (new D<C>()) { }
+>D : Symbol(D, Decl(ifDoWhileStatements.ts, 12, 1))
+>C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1))
+
+do { }while(new D<C>())
+>D : Symbol(D, Decl(ifDoWhileStatements.ts, 12, 1))
+>C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1))
+
+// references
+var a = true;
+>a : Symbol(a, Decl(ifDoWhileStatements.ts, 97, 3))
+
+if (a) { }
+>a : Symbol(a, Decl(ifDoWhileStatements.ts, 97, 3))
+
+while (a) { }
+>a : Symbol(a, Decl(ifDoWhileStatements.ts, 97, 3))
+
+do { }while(a)
+>a : Symbol(a, Decl(ifDoWhileStatements.ts, 97, 3))
+
+var b = null;
+>b : Symbol(b, Decl(ifDoWhileStatements.ts, 102, 3))
+
+if (b) { }
+>b : Symbol(b, Decl(ifDoWhileStatements.ts, 102, 3))
+
+while (b) { }
+>b : Symbol(b, Decl(ifDoWhileStatements.ts, 102, 3))
+
+do { }while(b)
+>b : Symbol(b, Decl(ifDoWhileStatements.ts, 102, 3))
+
+var c = undefined;
+>c : Symbol(c, Decl(ifDoWhileStatements.ts, 107, 3))
+>undefined : Symbol(undefined)
+
+if (c) { }
+>c : Symbol(c, Decl(ifDoWhileStatements.ts, 107, 3))
+
+while (c) { }
+>c : Symbol(c, Decl(ifDoWhileStatements.ts, 107, 3))
+
+do { }while(c)
+>c : Symbol(c, Decl(ifDoWhileStatements.ts, 107, 3))
+
+var d = 0.0;
+>d : Symbol(d, Decl(ifDoWhileStatements.ts, 112, 3))
+
+if (d) { }
+>d : Symbol(d, Decl(ifDoWhileStatements.ts, 112, 3))
+
+while (d) { }
+>d : Symbol(d, Decl(ifDoWhileStatements.ts, 112, 3))
+
+do { }while(d)
+>d : Symbol(d, Decl(ifDoWhileStatements.ts, 112, 3))
+
+var e = 'a string';
+>e : Symbol(e, Decl(ifDoWhileStatements.ts, 117, 3))
+
+if (e) { }
+>e : Symbol(e, Decl(ifDoWhileStatements.ts, 117, 3))
+
+while (e) { }
+>e : Symbol(e, Decl(ifDoWhileStatements.ts, 117, 3))
+
+do { }while(e)
+>e : Symbol(e, Decl(ifDoWhileStatements.ts, 117, 3))
+
+var f = '';
+>f : Symbol(f, Decl(ifDoWhileStatements.ts, 122, 3))
+
+if (f) { }
+>f : Symbol(f, Decl(ifDoWhileStatements.ts, 122, 3))
+
+while (f) { }
+>f : Symbol(f, Decl(ifDoWhileStatements.ts, 122, 3))
+
+do { }while(f)
+>f : Symbol(f, Decl(ifDoWhileStatements.ts, 122, 3))
+
+var g = /[a-z]/
+>g : Symbol(g, Decl(ifDoWhileStatements.ts, 127, 3))
+
+if (g) { }
+>g : Symbol(g, Decl(ifDoWhileStatements.ts, 127, 3))
+
+while (g) { }
+>g : Symbol(g, Decl(ifDoWhileStatements.ts, 127, 3))
+
+do { }while(g)
+>g : Symbol(g, Decl(ifDoWhileStatements.ts, 127, 3))
+
+var h = [];
+>h : Symbol(h, Decl(ifDoWhileStatements.ts, 132, 3))
+
+if (h) { }
+>h : Symbol(h, Decl(ifDoWhileStatements.ts, 132, 3))
+
+while (h) { }
+>h : Symbol(h, Decl(ifDoWhileStatements.ts, 132, 3))
+
+do { }while(h)
+>h : Symbol(h, Decl(ifDoWhileStatements.ts, 132, 3))
+
+var i = [1, 2];
+>i : Symbol(i, Decl(ifDoWhileStatements.ts, 137, 3))
+
+if (i) { }
+>i : Symbol(i, Decl(ifDoWhileStatements.ts, 137, 3))
+
+while (i) { }
+>i : Symbol(i, Decl(ifDoWhileStatements.ts, 137, 3))
+
+do { }while(i)
+>i : Symbol(i, Decl(ifDoWhileStatements.ts, 137, 3))
+
+var j = {};
+>j : Symbol(j, Decl(ifDoWhileStatements.ts, 142, 3))
+
+if (j) { }
+>j : Symbol(j, Decl(ifDoWhileStatements.ts, 142, 3))
+
+while (j) { }
+>j : Symbol(j, Decl(ifDoWhileStatements.ts, 142, 3))
+
+do { }while(j)
+>j : Symbol(j, Decl(ifDoWhileStatements.ts, 142, 3))
+
+var k = { x: 1, y: 'a' };
+>k : Symbol(k, Decl(ifDoWhileStatements.ts, 147, 3))
+>x : Symbol(x, Decl(ifDoWhileStatements.ts, 147, 9))
+>y : Symbol(y, Decl(ifDoWhileStatements.ts, 147, 15))
+
+if (k) { }
+>k : Symbol(k, Decl(ifDoWhileStatements.ts, 147, 3))
+
+while (k) { }
+>k : Symbol(k, Decl(ifDoWhileStatements.ts, 147, 3))
+
+do { }while(k)
+>k : Symbol(k, Decl(ifDoWhileStatements.ts, 147, 3))
+
+function fn(x?: string): I { return null; }
+>fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 150, 14))
+>x : Symbol(x, Decl(ifDoWhileStatements.ts, 152, 12))
+>I : Symbol(I, Decl(ifDoWhileStatements.ts, 0, 0))
+
+if (fn()) { }
+>fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 150, 14))
+
+while (fn()) { }
+>fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 150, 14))
+
+do { }while(fn())
+>fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 150, 14))
+
+if (fn) { }
+>fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 150, 14))
+
+while (fn) { }
+>fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 150, 14))
+
+do { }while(fn)
+>fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 150, 14))
+
+
+
diff --git a/tests/baselines/reference/ifDoWhileStatements.types b/tests/baselines/reference/ifDoWhileStatements.types
new file mode 100644
index 00000000000..660eaa4fb63
--- /dev/null
+++ b/tests/baselines/reference/ifDoWhileStatements.types
@@ -0,0 +1,434 @@
+=== tests/cases/conformance/statements/ifDoWhileStatements/ifDoWhileStatements.ts ===
+
+interface I {
+>I : I
+
+    id: number;
+>id : number
+}
+
+class C implements I {
+>C : C
+>I : I
+
+    id: number;
+>id : number
+
+    name: string;
+>name : string
+}
+
+class C2 extends C {
+>C2 : C2
+>C : C
+
+    valid: boolean;
+>valid : boolean
+}
+
+class D<T>{
+>D : D<T>
+>T : T
+
+    source: T;
+>source : T
+>T : T
+
+    recurse: D<T>;
+>recurse : D<T>
+>D : D<T>
+>T : T
+
+    wrapped: D<D<T>>
+>wrapped : D<D<T>>
+>D : D<T>
+>D : D<T>
+>T : T
+}
+
+function F(x: string): number { return 42; }
+>F : (x: string) => number
+>x : string
+>42 : number
+
+function F2(x: number): boolean { return x < 42; }
+>F2 : (x: number) => boolean
+>x : number
+>x < 42 : boolean
+>x : number
+>42 : number
+
+module M {
+>M : typeof M
+
+    export class A {
+>A : A
+
+        name: string;
+>name : string
+    }
+
+    export function F2(x: number): string { return x.toString(); }
+>F2 : (x: number) => string
+>x : number
+>x.toString() : string
+>x.toString : (radix?: number) => string
+>x : number
+>toString : (radix?: number) => string
+}
+
+module N {
+>N : typeof N
+
+    export class A {
+>A : A
+
+        id: number;
+>id : number
+    }
+
+    export function F2(x: number): string { return x.toString(); }
+>F2 : (x: number) => string
+>x : number
+>x.toString() : string
+>x.toString : (radix?: number) => string
+>x : number
+>toString : (radix?: number) => string
+}
+
+// literals
+if (true) { }
+>true : boolean
+
+while (true) { }
+>true : boolean
+
+do { }while(true)
+>true : boolean
+
+if (null) { }
+>null : null
+
+while (null) { }
+>null : null
+
+do { }while(null)
+>null : null
+
+if (undefined) { }
+>undefined : undefined
+
+while (undefined) { }
+>undefined : undefined
+
+do { }while(undefined)
+>undefined : undefined
+
+if (0.0) { }
+>0.0 : number
+
+while (0.0) { }
+>0.0 : number
+
+do { }while(0.0)
+>0.0 : number
+
+if ('a string') { }
+>'a string' : string
+
+while ('a string') { }
+>'a string' : string
+
+do { }while('a string')
+>'a string' : string
+
+if ('') { }
+>'' : string
+
+while ('') { }
+>'' : string
+
+do { }while('')
+>'' : string
+
+if (/[a-z]/) { }
+>/[a-z]/ : RegExp
+
+while (/[a-z]/) { }
+>/[a-z]/ : RegExp
+
+do { }while(/[a-z]/)
+>/[a-z]/ : RegExp
+
+if ([]) { }
+>[] : undefined[]
+
+while ([]) { }
+>[] : undefined[]
+
+do { }while([])
+>[] : undefined[]
+
+if ([1, 2]) { }
+>[1, 2] : number[]
+>1 : number
+>2 : number
+
+while ([1, 2]) { }
+>[1, 2] : number[]
+>1 : number
+>2 : number
+
+do { }while([1, 2])
+>[1, 2] : number[]
+>1 : number
+>2 : number
+
+if ({}) { }
+>{} : {}
+
+while ({}) { }
+>{} : {}
+
+do { }while({})
+>{} : {}
+
+if ({ x: 1, y: 'a' }) { }
+>{ x: 1, y: 'a' } : { x: number; y: string; }
+>x : number
+>1 : number
+>y : string
+>'a' : string
+
+while ({ x: 1, y: 'a' }) { }
+>{ x: 1, y: 'a' } : { x: number; y: string; }
+>x : number
+>1 : number
+>y : string
+>'a' : string
+
+do { }while({ x: 1, y: 'a' })
+>{ x: 1, y: 'a' } : { x: number; y: string; }
+>x : number
+>1 : number
+>y : string
+>'a' : string
+
+if (() => 43) { }
+>() => 43 : () => number
+>43 : number
+
+while (() => 43) { }
+>() => 43 : () => number
+>43 : number
+
+do { }while(() => 43)
+>() => 43 : () => number
+>43 : number
+
+if (new C()) { }
+>new C() : C
+>C : typeof C
+
+while (new C()) { }
+>new C() : C
+>C : typeof C
+
+do { }while(new C())
+>new C() : C
+>C : typeof C
+
+if (new D<C>()) { }
+>new D<C>() : D<C>
+>D : typeof D
+>C : C
+
+while (new D<C>()) { }
+>new D<C>() : D<C>
+>D : typeof D
+>C : C
+
+do { }while(new D<C>())
+>new D<C>() : D<C>
+>D : typeof D
+>C : C
+
+// references
+var a = true;
+>a : boolean
+>true : boolean
+
+if (a) { }
+>a : boolean
+
+while (a) { }
+>a : boolean
+
+do { }while(a)
+>a : boolean
+
+var b = null;
+>b : any
+>null : null
+
+if (b) { }
+>b : any
+
+while (b) { }
+>b : any
+
+do { }while(b)
+>b : any
+
+var c = undefined;
+>c : any
+>undefined : undefined
+
+if (c) { }
+>c : any
+
+while (c) { }
+>c : any
+
+do { }while(c)
+>c : any
+
+var d = 0.0;
+>d : number
+>0.0 : number
+
+if (d) { }
+>d : number
+
+while (d) { }
+>d : number
+
+do { }while(d)
+>d : number
+
+var e = 'a string';
+>e : string
+>'a string' : string
+
+if (e) { }
+>e : string
+
+while (e) { }
+>e : string
+
+do { }while(e)
+>e : string
+
+var f = '';
+>f : string
+>'' : string
+
+if (f) { }
+>f : string
+
+while (f) { }
+>f : string
+
+do { }while(f)
+>f : string
+
+var g = /[a-z]/
+>g : RegExp
+>/[a-z]/ : RegExp
+
+if (g) { }
+>g : RegExp
+
+while (g) { }
+>g : RegExp
+
+do { }while(g)
+>g : RegExp
+
+var h = [];
+>h : any[]
+>[] : undefined[]
+
+if (h) { }
+>h : any[]
+
+while (h) { }
+>h : any[]
+
+do { }while(h)
+>h : any[]
+
+var i = [1, 2];
+>i : number[]
+>[1, 2] : number[]
+>1 : number
+>2 : number
+
+if (i) { }
+>i : number[]
+
+while (i) { }
+>i : number[]
+
+do { }while(i)
+>i : number[]
+
+var j = {};
+>j : {}
+>{} : {}
+
+if (j) { }
+>j : {}
+
+while (j) { }
+>j : {}
+
+do { }while(j)
+>j : {}
+
+var k = { x: 1, y: 'a' };
+>k : { x: number; y: string; }
+>{ x: 1, y: 'a' } : { x: number; y: string; }
+>x : number
+>1 : number
+>y : string
+>'a' : string
+
+if (k) { }
+>k : { x: number; y: string; }
+
+while (k) { }
+>k : { x: number; y: string; }
+
+do { }while(k)
+>k : { x: number; y: string; }
+
+function fn(x?: string): I { return null; }
+>fn : (x?: string) => I
+>x : string
+>I : I
+>null : null
+
+if (fn()) { }
+>fn() : I
+>fn : (x?: string) => I
+
+while (fn()) { }
+>fn() : I
+>fn : (x?: string) => I
+
+do { }while(fn())
+>fn() : I
+>fn : (x?: string) => I
+
+if (fn) { }
+>fn : (x?: string) => I
+
+while (fn) { }
+>fn : (x?: string) => I
+
+do { }while(fn)
+>fn : (x?: string) => I
+
+
+
diff --git a/tests/baselines/reference/ifElseWithStatements1.errors.txt b/tests/baselines/reference/ifElseWithStatements1.errors.txt
index f9fcb33113a..5dc4d9b0db5 100644
--- a/tests/baselines/reference/ifElseWithStatements1.errors.txt
+++ b/tests/baselines/reference/ifElseWithStatements1.errors.txt
@@ -1,10 +1,9 @@
-tests/cases/compiler/ifElseWithStatements1.ts(2,5): error TS2304: Cannot find name 'f'.
-tests/cases/compiler/ifElseWithStatements1.ts(4,5): error TS2304: Cannot find name 'f'.
-tests/cases/compiler/ifElseWithStatements1.ts(4,5): error TS7027: Unreachable code detected.
-tests/cases/compiler/ifElseWithStatements1.ts(10,9): error TS7027: Unreachable code detected.
+tests/cases/compiler/ifElseWithStatements1.ts(3,5): error TS2304: Cannot find name 'f'.
+tests/cases/compiler/ifElseWithStatements1.ts(5,5): error TS2304: Cannot find name 'f'.
 
 
-==== tests/cases/compiler/ifElseWithStatements1.ts (4 errors) ====
+==== tests/cases/compiler/ifElseWithStatements1.ts (2 errors) ====
+    
     if (true)
         f();
         ~
@@ -13,15 +12,11 @@ tests/cases/compiler/ifElseWithStatements1.ts(10,9): error TS7027: Unreachable c
         f();
         ~
 !!! error TS2304: Cannot find name 'f'.
-        ~
-!!! error TS7027: Unreachable code detected.
     
     function foo(): boolean {
         if (true)
             return true;
         else
             return false;
-            ~~~~~~
-!!! error TS7027: Unreachable code detected.
     }
     
\ No newline at end of file
diff --git a/tests/baselines/reference/ifElseWithStatements1.js b/tests/baselines/reference/ifElseWithStatements1.js
index 506e7e6a330..47df08d46ba 100644
--- a/tests/baselines/reference/ifElseWithStatements1.js
+++ b/tests/baselines/reference/ifElseWithStatements1.js
@@ -1,4 +1,5 @@
 //// [ifElseWithStatements1.ts]
+
 if (true)
     f();
 else
diff --git a/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.errors.txt b/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.errors.txt
index b1d4a1ba6ba..bab58d0e4cf 100644
--- a/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.errors.txt
+++ b/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.errors.txt
@@ -1,8 +1,8 @@
-tests/cases/compiler/inferredFunctionReturnTypeIsEmptyType.ts(1,10): error TS2354: No best common type exists among return expressions.
-tests/cases/compiler/inferredFunctionReturnTypeIsEmptyType.ts(6,9): error TS7027: Unreachable code detected.
+tests/cases/compiler/inferredFunctionReturnTypeIsEmptyType.ts(2,10): error TS2354: No best common type exists among return expressions.
 
 
-==== tests/cases/compiler/inferredFunctionReturnTypeIsEmptyType.ts (2 errors) ====
+==== tests/cases/compiler/inferredFunctionReturnTypeIsEmptyType.ts (1 errors) ====
+    
     function foo() {
              ~~~
 !!! error TS2354: No best common type exists among return expressions.
@@ -11,8 +11,6 @@ tests/cases/compiler/inferredFunctionReturnTypeIsEmptyType.ts(6,9): error TS7027
         }
         else {
             return "42";
-            ~~~~~~
-!!! error TS7027: Unreachable code detected.
         }
     };
     
\ No newline at end of file
diff --git a/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.js b/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.js
index ba528d4c133..2993a331fee 100644
--- a/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.js
+++ b/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.js
@@ -1,4 +1,5 @@
 //// [inferredFunctionReturnTypeIsEmptyType.ts]
+
 function foo() {
     if (true) {
         return 42;
diff --git a/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.errors.txt b/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.errors.txt
index 251938cc9c7..787b95f2297 100644
--- a/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.errors.txt
+++ b/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.errors.txt
@@ -1,16 +1,14 @@
-tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts(2,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
-tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts(3,21): error TS7027: Unreachable code detected.
-tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts(5,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
+tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts(3,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
+tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts(6,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
 
 
-==== tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts (3 errors) ====
+==== tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts (2 errors) ====
+    
     class a {
         static get x(): () => string {
                    ~
 !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
             return null;;
-                        ~
-!!! error TS7027: Unreachable code detected.
         }
         static set x(aValue: () => string) {
                    ~
diff --git a/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.js b/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.js
index b81b6cd1d78..fa9c6e2a8b5 100644
--- a/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.js
+++ b/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.js
@@ -1,4 +1,5 @@
 //// [inheritanceStaticPropertyOverridingAccessor.ts]
+
 class a {
     static get x(): () => string {
         return null;;
diff --git a/tests/baselines/reference/interfaceExtendingClass2.errors.txt b/tests/baselines/reference/interfaceExtendingClass2.errors.txt
index 68bd5e845ac..859cb65410e 100644
--- a/tests/baselines/reference/interfaceExtendingClass2.errors.txt
+++ b/tests/baselines/reference/interfaceExtendingClass2.errors.txt
@@ -1,11 +1,11 @@
-tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(11,5): error TS2411: Property 'a' of type '{ toString: () => {}; }' is not assignable to string index type 'Object'.
-tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(13,13): error TS1131: Property or signature expected.
-tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(14,9): error TS1128: Declaration or statement expected.
-tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(14,10): error TS7027: Unreachable code detected.
-tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(15,5): error TS1128: Declaration or statement expected.
+tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(12,5): error TS2411: Property 'a' of type '{ toString: () => {}; }' is not assignable to string index type 'Object'.
+tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(14,13): error TS1131: Property or signature expected.
+tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(15,9): error TS1128: Declaration or statement expected.
+tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(16,5): error TS1128: Declaration or statement expected.
 
 
-==== tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts (5 errors) ====
+==== tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts (4 errors) ====
+    
     class Foo {
         x: string;
         y() { }
@@ -27,8 +27,6 @@ tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtending
             };
             ~
 !!! error TS1128: Declaration or statement expected.
-             ~
-!!! error TS7027: Unreachable code detected.
         }
         ~
 !!! error TS1128: Declaration or statement expected.
\ No newline at end of file
diff --git a/tests/baselines/reference/interfaceExtendingClass2.js b/tests/baselines/reference/interfaceExtendingClass2.js
index 6e6605e2459..c4143659125 100644
--- a/tests/baselines/reference/interfaceExtendingClass2.js
+++ b/tests/baselines/reference/interfaceExtendingClass2.js
@@ -1,4 +1,5 @@
 //// [interfaceExtendingClass2.ts]
+
 class Foo {
     x: string;
     y() { }
diff --git a/tests/baselines/reference/interfaceWithPrivateMember.errors.txt b/tests/baselines/reference/interfaceWithPrivateMember.errors.txt
index aa6dfdc1032..dc1cfeabed5 100644
--- a/tests/baselines/reference/interfaceWithPrivateMember.errors.txt
+++ b/tests/baselines/reference/interfaceWithPrivateMember.errors.txt
@@ -1,12 +1,12 @@
-tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(4,5): error TS1131: Property or signature expected.
-tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(8,5): error TS1131: Property or signature expected.
-tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(12,5): error TS1131: Property or signature expected.
-tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(12,13): error TS7028: Unused label.
-tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(12,16): error TS2304: Cannot find name 'string'.
-tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(13,1): error TS1128: Declaration or statement expected.
+tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(5,5): error TS1131: Property or signature expected.
+tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(9,5): error TS1131: Property or signature expected.
+tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(13,5): error TS1131: Property or signature expected.
+tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(13,16): error TS2304: Cannot find name 'string'.
+tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(14,1): error TS1128: Declaration or statement expected.
 
 
-==== tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts (6 errors) ====
+==== tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts (5 errors) ====
+    
     // interfaces do not permit private members, these are errors
     
     interface I {
@@ -25,8 +25,6 @@ tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(13,1): er
         private y: string;
         ~~~~~~~
 !!! error TS1131: Property or signature expected.
-                ~
-!!! error TS7028: Unused label.
                    ~~~~~~
 !!! error TS2304: Cannot find name 'string'.
     }
diff --git a/tests/baselines/reference/interfaceWithPrivateMember.js b/tests/baselines/reference/interfaceWithPrivateMember.js
index 24c2cf9ecf5..ceb388b1eae 100644
--- a/tests/baselines/reference/interfaceWithPrivateMember.js
+++ b/tests/baselines/reference/interfaceWithPrivateMember.js
@@ -1,4 +1,5 @@
 //// [interfaceWithPrivateMember.ts]
+
 // interfaces do not permit private members, these are errors
 
 interface I {
diff --git a/tests/baselines/reference/invalidDoWhileBreakStatements.errors.txt b/tests/baselines/reference/invalidDoWhileBreakStatements.errors.txt
index 2a26190534e..15983bd1fc4 100644
--- a/tests/baselines/reference/invalidDoWhileBreakStatements.errors.txt
+++ b/tests/baselines/reference/invalidDoWhileBreakStatements.errors.txt
@@ -1,14 +1,13 @@
-tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(4,1): error TS1105: A 'break' statement can only be used within an enclosing iteration or switch statement.
-tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(7,1): error TS7028: Unused label.
-tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(8,4): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
-tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(11,1): error TS7027: Unreachable code detected.
-tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(14,9): error TS1107: Jump target cannot cross function boundary.
-tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(21,9): error TS1107: Jump target cannot cross function boundary.
-tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(27,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
-tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(37,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
+tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(5,1): error TS1105: A 'break' statement can only be used within an enclosing iteration or switch statement.
+tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(9,4): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
+tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(15,9): error TS1107: Jump target cannot cross function boundary.
+tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(22,9): error TS1107: Jump target cannot cross function boundary.
+tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(28,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
+tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(38,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
 
 
-==== tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts (8 errors) ====
+==== tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts (6 errors) ====
+    
     // All errors
     
     // naked break not allowed
@@ -18,16 +17,12 @@ tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements
     
     // non-existent label
     ONE:
-    ~~~
-!!! error TS7028: Unused label.
     do break TWO; while (true)
        ~~~~~~~~~~
 !!! error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
     
     // break from inside function
     TWO:
-    ~~~
-!!! error TS7027: Unreachable code detected.
     do {
         var x = () => {
             break TWO;
diff --git a/tests/baselines/reference/invalidDoWhileBreakStatements.js b/tests/baselines/reference/invalidDoWhileBreakStatements.js
index 807d58a8fea..4f48a890aa6 100644
--- a/tests/baselines/reference/invalidDoWhileBreakStatements.js
+++ b/tests/baselines/reference/invalidDoWhileBreakStatements.js
@@ -1,4 +1,5 @@
 //// [invalidDoWhileBreakStatements.ts]
+
 // All errors
 
 // naked break not allowed
diff --git a/tests/baselines/reference/invalidDoWhileContinueStatements.errors.txt b/tests/baselines/reference/invalidDoWhileContinueStatements.errors.txt
index b3938d9ba8b..3a520209293 100644
--- a/tests/baselines/reference/invalidDoWhileContinueStatements.errors.txt
+++ b/tests/baselines/reference/invalidDoWhileContinueStatements.errors.txt
@@ -1,14 +1,13 @@
-tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(4,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement.
-tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(7,1): error TS7028: Unused label.
-tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(8,4): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
-tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(11,1): error TS7027: Unreachable code detected.
-tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(14,9): error TS1107: Jump target cannot cross function boundary.
-tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(21,9): error TS1107: Jump target cannot cross function boundary.
-tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(27,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
-tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(37,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
+tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(5,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement.
+tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(9,4): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
+tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(15,9): error TS1107: Jump target cannot cross function boundary.
+tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(22,9): error TS1107: Jump target cannot cross function boundary.
+tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(28,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
+tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(38,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
 
 
-==== tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts (8 errors) ====
+==== tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts (6 errors) ====
+    
     // All errors
     
     // naked continue not allowed
@@ -18,16 +17,12 @@ tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStat
     
     // non-existent label
     ONE:
-    ~~~
-!!! error TS7028: Unused label.
     do continue TWO; while (true)
        ~~~~~~~~~~~~~
 !!! error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
     
     // continue from inside function
     TWO:
-    ~~~
-!!! error TS7027: Unreachable code detected.
     do {
         var x = () => {
             continue TWO;
diff --git a/tests/baselines/reference/invalidDoWhileContinueStatements.js b/tests/baselines/reference/invalidDoWhileContinueStatements.js
index 21a10a3451b..b77259159a9 100644
--- a/tests/baselines/reference/invalidDoWhileContinueStatements.js
+++ b/tests/baselines/reference/invalidDoWhileContinueStatements.js
@@ -1,4 +1,5 @@
 //// [invalidDoWhileContinueStatements.ts]
+
 // All errors
 
 // naked continue not allowed
diff --git a/tests/baselines/reference/invalidForBreakStatements.errors.txt b/tests/baselines/reference/invalidForBreakStatements.errors.txt
index f803cad08e1..57ae1d32c8e 100644
--- a/tests/baselines/reference/invalidForBreakStatements.errors.txt
+++ b/tests/baselines/reference/invalidForBreakStatements.errors.txt
@@ -1,14 +1,13 @@
-tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(4,1): error TS1105: A 'break' statement can only be used within an enclosing iteration or switch statement.
-tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(7,1): error TS7028: Unused label.
-tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(8,9): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
-tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(11,1): error TS7027: Unreachable code detected.
-tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(14,9): error TS1107: Jump target cannot cross function boundary.
-tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(21,9): error TS1107: Jump target cannot cross function boundary.
-tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(27,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
-tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(36,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
+tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(5,1): error TS1105: A 'break' statement can only be used within an enclosing iteration or switch statement.
+tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(9,9): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
+tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(15,9): error TS1107: Jump target cannot cross function boundary.
+tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(22,9): error TS1107: Jump target cannot cross function boundary.
+tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(28,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
+tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(37,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
 
 
-==== tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts (8 errors) ====
+==== tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts (6 errors) ====
+    
     // All errors
     
     // naked break not allowed
@@ -18,16 +17,12 @@ tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(
     
     // non-existent label
     ONE:
-    ~~~
-!!! error TS7028: Unused label.
     for(;;) break TWO;
             ~~~~~~~~~~
 !!! error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
     
     // break from inside function
     TWO:
-    ~~~
-!!! error TS7027: Unreachable code detected.
     for(;;) {
         var x = () => {
             break TWO;
diff --git a/tests/baselines/reference/invalidForBreakStatements.js b/tests/baselines/reference/invalidForBreakStatements.js
index 5e3430ecb41..50096e16720 100644
--- a/tests/baselines/reference/invalidForBreakStatements.js
+++ b/tests/baselines/reference/invalidForBreakStatements.js
@@ -1,4 +1,5 @@
 //// [invalidForBreakStatements.ts]
+
 // All errors
 
 // naked break not allowed
diff --git a/tests/baselines/reference/invalidForContinueStatements.errors.txt b/tests/baselines/reference/invalidForContinueStatements.errors.txt
index 9a252a2c572..9ebfae57e9f 100644
--- a/tests/baselines/reference/invalidForContinueStatements.errors.txt
+++ b/tests/baselines/reference/invalidForContinueStatements.errors.txt
@@ -1,14 +1,13 @@
-tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(4,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement.
-tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(7,1): error TS7028: Unused label.
-tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(8,9): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
-tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(11,1): error TS7027: Unreachable code detected.
-tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(14,9): error TS1107: Jump target cannot cross function boundary.
-tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(21,9): error TS1107: Jump target cannot cross function boundary.
-tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(27,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
-tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(36,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
+tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(5,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement.
+tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(9,9): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
+tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(15,9): error TS1107: Jump target cannot cross function boundary.
+tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(22,9): error TS1107: Jump target cannot cross function boundary.
+tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(28,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
+tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(37,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
 
 
-==== tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts (8 errors) ====
+==== tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts (6 errors) ====
+    
     // All errors
     
     // naked continue not allowed
@@ -18,16 +17,12 @@ tests/cases/conformance/statements/continueStatements/invalidForContinueStatemen
     
     // non-existent label
     ONE:
-    ~~~
-!!! error TS7028: Unused label.
     for(;;) continue TWO;
             ~~~~~~~~~~~~~
 !!! error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
     
     // continue from inside function
     TWO:
-    ~~~
-!!! error TS7027: Unreachable code detected.
     for(;;) {
         var x = () => {
             continue TWO;
diff --git a/tests/baselines/reference/invalidForContinueStatements.js b/tests/baselines/reference/invalidForContinueStatements.js
index 2db1ce69ede..7a3513bb2a3 100644
--- a/tests/baselines/reference/invalidForContinueStatements.js
+++ b/tests/baselines/reference/invalidForContinueStatements.js
@@ -1,4 +1,5 @@
 //// [invalidForContinueStatements.ts]
+
 // All errors
 
 // naked continue not allowed
diff --git a/tests/baselines/reference/invalidForInBreakStatements.errors.txt b/tests/baselines/reference/invalidForInBreakStatements.errors.txt
index a575970ff88..b1f5d64f973 100644
--- a/tests/baselines/reference/invalidForInBreakStatements.errors.txt
+++ b/tests/baselines/reference/invalidForInBreakStatements.errors.txt
@@ -1,17 +1,13 @@
-tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(4,1): error TS1105: A 'break' statement can only be used within an enclosing iteration or switch statement.
-tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(7,1): error TS7028: Unused label.
-tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(8,19): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
-tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(11,1): error TS7028: Unused label.
-tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(14,9): error TS1107: Jump target cannot cross function boundary.
-tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(18,1): error TS7028: Unused label.
-tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(21,9): error TS1107: Jump target cannot cross function boundary.
-tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(27,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
-tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(28,5): error TS7028: Unused label.
-tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(33,1): error TS7028: Unused label.
-tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(37,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
+tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(5,1): error TS1105: A 'break' statement can only be used within an enclosing iteration or switch statement.
+tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(9,19): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
+tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(15,9): error TS1107: Jump target cannot cross function boundary.
+tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(22,9): error TS1107: Jump target cannot cross function boundary.
+tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(28,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
+tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(38,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
 
 
-==== tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts (11 errors) ====
+==== tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts (6 errors) ====
+    
     // All errors
     
     // naked break not allowed
@@ -21,16 +17,12 @@ tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.t
     
     // non-existent label
     ONE:
-    ~~~
-!!! error TS7028: Unused label.
     for (var x in {}) break TWO;
                       ~~~~~~~~~~
 !!! error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
     
     // break from inside function
     TWO:
-    ~~~
-!!! error TS7028: Unused label.
     for (var x in {}) {
         var fn = () => {
             break TWO;
@@ -40,8 +32,6 @@ tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.t
     }
     
     THREE:
-    ~~~~~
-!!! error TS7028: Unused label.
     for (var x in {}) {
         var fn = function () {
             break THREE;
@@ -56,15 +46,11 @@ tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.t
         ~~~~~~~~~~~
 !!! error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
         FIVE:
-        ~~~~
-!!! error TS7028: Unused label.
         for (var x in {}) { }
     }
     
     // label on non-loop statement
     NINE:
-    ~~~~
-!!! error TS7028: Unused label.
     var y = 12;
     
     for (var x in {}) {
diff --git a/tests/baselines/reference/invalidForInBreakStatements.js b/tests/baselines/reference/invalidForInBreakStatements.js
index 1784b9a57a6..11517f2a020 100644
--- a/tests/baselines/reference/invalidForInBreakStatements.js
+++ b/tests/baselines/reference/invalidForInBreakStatements.js
@@ -1,4 +1,5 @@
 //// [invalidForInBreakStatements.ts]
+
 // All errors
 
 // naked break not allowed
diff --git a/tests/baselines/reference/invalidForInContinueStatements.errors.txt b/tests/baselines/reference/invalidForInContinueStatements.errors.txt
index 15b515742a9..f20d9c6e81c 100644
--- a/tests/baselines/reference/invalidForInContinueStatements.errors.txt
+++ b/tests/baselines/reference/invalidForInContinueStatements.errors.txt
@@ -1,17 +1,13 @@
-tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(4,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement.
-tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(7,1): error TS7028: Unused label.
-tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(8,19): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
-tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(11,1): error TS7028: Unused label.
-tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(14,9): error TS1107: Jump target cannot cross function boundary.
-tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(18,1): error TS7028: Unused label.
-tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(21,9): error TS1107: Jump target cannot cross function boundary.
-tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(27,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
-tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(28,5): error TS7028: Unused label.
-tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(33,1): error TS7028: Unused label.
-tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(37,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
+tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(5,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement.
+tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(9,19): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
+tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(15,9): error TS1107: Jump target cannot cross function boundary.
+tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(22,9): error TS1107: Jump target cannot cross function boundary.
+tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(28,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
+tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(38,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
 
 
-==== tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts (11 errors) ====
+==== tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts (6 errors) ====
+    
     // All errors
     
     // naked continue not allowed
@@ -21,16 +17,12 @@ tests/cases/conformance/statements/continueStatements/invalidForInContinueStatem
     
     // non-existent label
     ONE:
-    ~~~
-!!! error TS7028: Unused label.
     for (var x in {}) continue TWO;
                       ~~~~~~~~~~~~~
 !!! error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
     
     // continue from inside function
     TWO:
-    ~~~
-!!! error TS7028: Unused label.
     for (var x in {}) {
         var fn = () => {
             continue TWO;
@@ -40,8 +32,6 @@ tests/cases/conformance/statements/continueStatements/invalidForInContinueStatem
     }
     
     THREE:
-    ~~~~~
-!!! error TS7028: Unused label.
     for (var x in {}) {
         var fn = function () {
             continue THREE;
@@ -56,15 +46,11 @@ tests/cases/conformance/statements/continueStatements/invalidForInContinueStatem
         ~~~~~~~~~~~~~~
 !!! error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
         FIVE:
-        ~~~~
-!!! error TS7028: Unused label.
         for (var x in {}) { }
     }
     
     // label on non-loop statement
     NINE:
-    ~~~~
-!!! error TS7028: Unused label.
     var y = 12;
     
     for (var x in {}) {
diff --git a/tests/baselines/reference/invalidForInContinueStatements.js b/tests/baselines/reference/invalidForInContinueStatements.js
index 94020d00f2b..5eb0e10bf53 100644
--- a/tests/baselines/reference/invalidForInContinueStatements.js
+++ b/tests/baselines/reference/invalidForInContinueStatements.js
@@ -1,4 +1,5 @@
 //// [invalidForInContinueStatements.ts]
+
 // All errors
 
 // naked continue not allowed
diff --git a/tests/baselines/reference/invalidThrowStatement.errors.txt b/tests/baselines/reference/invalidThrowStatement.errors.txt
index d72fd7e2acd..3002bce2f1f 100644
--- a/tests/baselines/reference/invalidThrowStatement.errors.txt
+++ b/tests/baselines/reference/invalidThrowStatement.errors.txt
@@ -1,9 +1,9 @@
-tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts(1,6): error TS1109: Expression expected.
-tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts(3,1): error TS1128: Declaration or statement expected.
-tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts(3,8): error TS7027: Unreachable code detected.
+tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts(2,6): error TS1109: Expression expected.
+tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts(4,1): error TS1128: Declaration or statement expected.
 
 
-==== tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts (3 errors) ====
+==== tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts (2 errors) ====
+    
     throw; 
          ~
 !!! error TS1109: Expression expected.
@@ -11,6 +11,4 @@ tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts(3,8)
     export throw null;
     ~~~~~~
 !!! error TS1128: Declaration or statement expected.
-           ~~~~~
-!!! error TS7027: Unreachable code detected.
     
\ No newline at end of file
diff --git a/tests/baselines/reference/invalidThrowStatement.js b/tests/baselines/reference/invalidThrowStatement.js
index 4b794ab3d51..674dacf5c17 100644
--- a/tests/baselines/reference/invalidThrowStatement.js
+++ b/tests/baselines/reference/invalidThrowStatement.js
@@ -1,4 +1,5 @@
 //// [invalidThrowStatement.ts]
+
 throw; 
 
 export throw null;
diff --git a/tests/baselines/reference/invalidWhileContinueStatements.errors.txt b/tests/baselines/reference/invalidWhileContinueStatements.errors.txt
index fdc84d84f2e..e7a9ed13c40 100644
--- a/tests/baselines/reference/invalidWhileContinueStatements.errors.txt
+++ b/tests/baselines/reference/invalidWhileContinueStatements.errors.txt
@@ -1,14 +1,13 @@
-tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(4,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement.
-tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(7,1): error TS7028: Unused label.
-tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(8,14): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
-tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(11,1): error TS7027: Unreachable code detected.
-tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(14,9): error TS1107: Jump target cannot cross function boundary.
-tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(21,9): error TS1107: Jump target cannot cross function boundary.
-tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(27,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
-tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(37,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
+tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(5,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement.
+tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(9,14): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
+tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(15,9): error TS1107: Jump target cannot cross function boundary.
+tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(22,9): error TS1107: Jump target cannot cross function boundary.
+tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(28,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
+tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(38,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
 
 
-==== tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts (8 errors) ====
+==== tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts (6 errors) ====
+    
     // All errors
     
     // naked continue not allowed
@@ -18,16 +17,12 @@ tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatem
     
     // non-existent label
     ONE:
-    ~~~
-!!! error TS7028: Unused label.
     while (true) continue TWO;
                  ~~~~~~~~~~~~~
 !!! error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
     
     // continue from inside function
     TWO:
-    ~~~
-!!! error TS7027: Unreachable code detected.
     while (true){
         var x = () => {
             continue TWO;
diff --git a/tests/baselines/reference/invalidWhileContinueStatements.js b/tests/baselines/reference/invalidWhileContinueStatements.js
index b8234bf9604..16350e9b561 100644
--- a/tests/baselines/reference/invalidWhileContinueStatements.js
+++ b/tests/baselines/reference/invalidWhileContinueStatements.js
@@ -1,4 +1,5 @@
 //// [invalidWhileContinueStatements.ts]
+
 // All errors
 
 // naked continue not allowed
diff --git a/tests/baselines/reference/letAndVarRedeclaration.errors.txt b/tests/baselines/reference/letAndVarRedeclaration.errors.txt
index 3c523154c3f..50a916e8d90 100644
--- a/tests/baselines/reference/letAndVarRedeclaration.errors.txt
+++ b/tests/baselines/reference/letAndVarRedeclaration.errors.txt
@@ -1,28 +1,28 @@
-tests/cases/compiler/letAndVarRedeclaration.ts(2,5): error TS2451: Cannot redeclare block-scoped variable 'e0'.
 tests/cases/compiler/letAndVarRedeclaration.ts(3,5): error TS2451: Cannot redeclare block-scoped variable 'e0'.
-tests/cases/compiler/letAndVarRedeclaration.ts(4,10): error TS2451: Cannot redeclare block-scoped variable 'e0'.
-tests/cases/compiler/letAndVarRedeclaration.ts(7,9): error TS2451: Cannot redeclare block-scoped variable 'x1'.
+tests/cases/compiler/letAndVarRedeclaration.ts(4,5): error TS2451: Cannot redeclare block-scoped variable 'e0'.
+tests/cases/compiler/letAndVarRedeclaration.ts(5,10): error TS2451: Cannot redeclare block-scoped variable 'e0'.
 tests/cases/compiler/letAndVarRedeclaration.ts(8,9): error TS2451: Cannot redeclare block-scoped variable 'x1'.
-tests/cases/compiler/letAndVarRedeclaration.ts(9,14): error TS2451: Cannot redeclare block-scoped variable 'x1'.
-tests/cases/compiler/letAndVarRedeclaration.ts(13,9): error TS2451: Cannot redeclare block-scoped variable 'x'.
-tests/cases/compiler/letAndVarRedeclaration.ts(15,13): error TS2451: Cannot redeclare block-scoped variable 'x'.
-tests/cases/compiler/letAndVarRedeclaration.ts(18,18): error TS2451: Cannot redeclare block-scoped variable 'x'.
-tests/cases/compiler/letAndVarRedeclaration.ts(23,9): error TS2451: Cannot redeclare block-scoped variable 'x2'.
+tests/cases/compiler/letAndVarRedeclaration.ts(9,9): error TS2451: Cannot redeclare block-scoped variable 'x1'.
+tests/cases/compiler/letAndVarRedeclaration.ts(10,14): error TS2451: Cannot redeclare block-scoped variable 'x1'.
+tests/cases/compiler/letAndVarRedeclaration.ts(14,9): error TS2451: Cannot redeclare block-scoped variable 'x'.
+tests/cases/compiler/letAndVarRedeclaration.ts(16,13): error TS2451: Cannot redeclare block-scoped variable 'x'.
+tests/cases/compiler/letAndVarRedeclaration.ts(19,18): error TS2451: Cannot redeclare block-scoped variable 'x'.
 tests/cases/compiler/letAndVarRedeclaration.ts(24,9): error TS2451: Cannot redeclare block-scoped variable 'x2'.
-tests/cases/compiler/letAndVarRedeclaration.ts(25,14): error TS2451: Cannot redeclare block-scoped variable 'x2'.
-tests/cases/compiler/letAndVarRedeclaration.ts(29,9): error TS2451: Cannot redeclare block-scoped variable 'x2'.
-tests/cases/compiler/letAndVarRedeclaration.ts(31,13): error TS2451: Cannot redeclare block-scoped variable 'x2'.
-tests/cases/compiler/letAndVarRedeclaration.ts(34,18): error TS2451: Cannot redeclare block-scoped variable 'x2'.
-tests/cases/compiler/letAndVarRedeclaration.ts(38,5): error TS2451: Cannot redeclare block-scoped variable 'x11'.
-tests/cases/compiler/letAndVarRedeclaration.ts(39,10): error TS2451: Cannot redeclare block-scoped variable 'x11'.
-tests/cases/compiler/letAndVarRedeclaration.ts(43,9): error TS2451: Cannot redeclare block-scoped variable 'x11'.
-tests/cases/compiler/letAndVarRedeclaration.ts(44,14): error TS2451: Cannot redeclare block-scoped variable 'x11'.
-tests/cases/compiler/letAndVarRedeclaration.ts(48,1): error TS7027: Unreachable code detected.
-tests/cases/compiler/letAndVarRedeclaration.ts(49,9): error TS2451: Cannot redeclare block-scoped variable 'x11'.
-tests/cases/compiler/letAndVarRedeclaration.ts(50,14): error TS2451: Cannot redeclare block-scoped variable 'x11'.
+tests/cases/compiler/letAndVarRedeclaration.ts(25,9): error TS2451: Cannot redeclare block-scoped variable 'x2'.
+tests/cases/compiler/letAndVarRedeclaration.ts(26,14): error TS2451: Cannot redeclare block-scoped variable 'x2'.
+tests/cases/compiler/letAndVarRedeclaration.ts(30,9): error TS2451: Cannot redeclare block-scoped variable 'x2'.
+tests/cases/compiler/letAndVarRedeclaration.ts(32,13): error TS2451: Cannot redeclare block-scoped variable 'x2'.
+tests/cases/compiler/letAndVarRedeclaration.ts(35,18): error TS2451: Cannot redeclare block-scoped variable 'x2'.
+tests/cases/compiler/letAndVarRedeclaration.ts(39,5): error TS2451: Cannot redeclare block-scoped variable 'x11'.
+tests/cases/compiler/letAndVarRedeclaration.ts(40,10): error TS2451: Cannot redeclare block-scoped variable 'x11'.
+tests/cases/compiler/letAndVarRedeclaration.ts(44,9): error TS2451: Cannot redeclare block-scoped variable 'x11'.
+tests/cases/compiler/letAndVarRedeclaration.ts(45,14): error TS2451: Cannot redeclare block-scoped variable 'x11'.
+tests/cases/compiler/letAndVarRedeclaration.ts(50,9): error TS2451: Cannot redeclare block-scoped variable 'x11'.
+tests/cases/compiler/letAndVarRedeclaration.ts(51,14): error TS2451: Cannot redeclare block-scoped variable 'x11'.
 
 
-==== tests/cases/compiler/letAndVarRedeclaration.ts (22 errors) ====
+==== tests/cases/compiler/letAndVarRedeclaration.ts (21 errors) ====
+    
     
     let e0
         ~~
@@ -109,8 +109,6 @@ tests/cases/compiler/letAndVarRedeclaration.ts(50,14): error TS2451: Cannot rede
     }
     
     module M2 {
-    ~~~~~~
-!!! error TS7027: Unreachable code detected.
         let x11;
             ~~~
 !!! error TS2451: Cannot redeclare block-scoped variable 'x11'.
diff --git a/tests/baselines/reference/letAndVarRedeclaration.js b/tests/baselines/reference/letAndVarRedeclaration.js
index fd4bfe67cac..eb4dfc9c0e8 100644
--- a/tests/baselines/reference/letAndVarRedeclaration.js
+++ b/tests/baselines/reference/letAndVarRedeclaration.js
@@ -1,5 +1,6 @@
 //// [letAndVarRedeclaration.ts]
 
+
 let e0
 var e0;
 function e0() { }
diff --git a/tests/baselines/reference/letDeclarations-invalidContexts.errors.txt b/tests/baselines/reference/letDeclarations-invalidContexts.errors.txt
index f3144b52500..e46554ec0e6 100644
--- a/tests/baselines/reference/letDeclarations-invalidContexts.errors.txt
+++ b/tests/baselines/reference/letDeclarations-invalidContexts.errors.txt
@@ -1,17 +1,16 @@
-tests/cases/compiler/letDeclarations-invalidContexts.ts(4,5): error TS1157: 'let' declarations can only be declared inside a block.
-tests/cases/compiler/letDeclarations-invalidContexts.ts(6,5): error TS7027: Unreachable code detected.
-tests/cases/compiler/letDeclarations-invalidContexts.ts(6,5): error TS1157: 'let' declarations can only be declared inside a block.
-tests/cases/compiler/letDeclarations-invalidContexts.ts(9,5): error TS1157: 'let' declarations can only be declared inside a block.
-tests/cases/compiler/letDeclarations-invalidContexts.ts(11,1): error TS7027: Unreachable code detected.
-tests/cases/compiler/letDeclarations-invalidContexts.ts(12,5): error TS1157: 'let' declarations can only be declared inside a block.
-tests/cases/compiler/letDeclarations-invalidContexts.ts(16,7): error TS2410: All symbols within a 'with' block will be resolved to 'any'.
-tests/cases/compiler/letDeclarations-invalidContexts.ts(20,5): error TS1157: 'let' declarations can only be declared inside a block.
-tests/cases/compiler/letDeclarations-invalidContexts.ts(23,5): error TS1157: 'let' declarations can only be declared inside a block.
-tests/cases/compiler/letDeclarations-invalidContexts.ts(26,12): error TS1157: 'let' declarations can only be declared inside a block.
-tests/cases/compiler/letDeclarations-invalidContexts.ts(29,29): error TS1157: 'let' declarations can only be declared inside a block.
+tests/cases/compiler/letDeclarations-invalidContexts.ts(5,5): error TS1157: 'let' declarations can only be declared inside a block.
+tests/cases/compiler/letDeclarations-invalidContexts.ts(7,5): error TS1157: 'let' declarations can only be declared inside a block.
+tests/cases/compiler/letDeclarations-invalidContexts.ts(10,5): error TS1157: 'let' declarations can only be declared inside a block.
+tests/cases/compiler/letDeclarations-invalidContexts.ts(13,5): error TS1157: 'let' declarations can only be declared inside a block.
+tests/cases/compiler/letDeclarations-invalidContexts.ts(17,7): error TS2410: All symbols within a 'with' block will be resolved to 'any'.
+tests/cases/compiler/letDeclarations-invalidContexts.ts(21,5): error TS1157: 'let' declarations can only be declared inside a block.
+tests/cases/compiler/letDeclarations-invalidContexts.ts(24,5): error TS1157: 'let' declarations can only be declared inside a block.
+tests/cases/compiler/letDeclarations-invalidContexts.ts(27,12): error TS1157: 'let' declarations can only be declared inside a block.
+tests/cases/compiler/letDeclarations-invalidContexts.ts(30,29): error TS1157: 'let' declarations can only be declared inside a block.
 
 
-==== tests/cases/compiler/letDeclarations-invalidContexts.ts (11 errors) ====
+==== tests/cases/compiler/letDeclarations-invalidContexts.ts (9 errors) ====
+    
     
     // Errors, let must be defined inside a block
     if (true) 
@@ -20,8 +19,6 @@ tests/cases/compiler/letDeclarations-invalidContexts.ts(29,29): error TS1157: 'l
 !!! error TS1157: 'let' declarations can only be declared inside a block.
     else 
         let l2 = 0;
-        ~~~
-!!! error TS7027: Unreachable code detected.
         ~~~~~~~~~~~
 !!! error TS1157: 'let' declarations can only be declared inside a block.
     
@@ -31,8 +28,6 @@ tests/cases/compiler/letDeclarations-invalidContexts.ts(29,29): error TS1157: 'l
 !!! error TS1157: 'let' declarations can only be declared inside a block.
     
     do 
-    ~~
-!!! error TS7027: Unreachable code detected.
         let l4 = 0;
         ~~~~~~~~~~~
 !!! error TS1157: 'let' declarations can only be declared inside a block.
diff --git a/tests/baselines/reference/letDeclarations-invalidContexts.js b/tests/baselines/reference/letDeclarations-invalidContexts.js
index f8c3bb04bdb..4c3be1faed8 100644
--- a/tests/baselines/reference/letDeclarations-invalidContexts.js
+++ b/tests/baselines/reference/letDeclarations-invalidContexts.js
@@ -1,5 +1,6 @@
 //// [letDeclarations-invalidContexts.ts]
 
+
 // Errors, let must be defined inside a block
 if (true) 
     let l1 = 0;
diff --git a/tests/baselines/reference/letDeclarations-scopes.errors.txt b/tests/baselines/reference/letDeclarations-scopes.errors.txt
index 49072f30e98..1b10903af7c 100644
--- a/tests/baselines/reference/letDeclarations-scopes.errors.txt
+++ b/tests/baselines/reference/letDeclarations-scopes.errors.txt
@@ -1,10 +1,8 @@
-tests/cases/compiler/letDeclarations-scopes.ts(13,5): error TS7027: Unreachable code detected.
-tests/cases/compiler/letDeclarations-scopes.ts(22,1): error TS7027: Unreachable code detected.
-tests/cases/compiler/letDeclarations-scopes.ts(28,7): error TS2410: All symbols within a 'with' block will be resolved to 'any'.
-tests/cases/compiler/letDeclarations-scopes.ts(120,5): error TS7028: Unused label.
+tests/cases/compiler/letDeclarations-scopes.ts(29,7): error TS2410: All symbols within a 'with' block will be resolved to 'any'.
 
 
-==== tests/cases/compiler/letDeclarations-scopes.ts (4 errors) ====
+==== tests/cases/compiler/letDeclarations-scopes.ts (1 errors) ====
+    
     
     // global
     let l = "string";
@@ -18,8 +16,6 @@ tests/cases/compiler/letDeclarations-scopes.ts(120,5): error TS7028: Unused labe
     }
     else {
         let l = 0;
-        ~~~
-!!! error TS7027: Unreachable code detected.
         n = l;
     }
     
@@ -29,8 +25,6 @@ tests/cases/compiler/letDeclarations-scopes.ts(120,5): error TS7028: Unused labe
     }
     
     do {
-    ~~
-!!! error TS7027: Unreachable code detected.
        let l = 0;
         n = l;
     } while (true);
@@ -131,8 +125,6 @@ tests/cases/compiler/letDeclarations-scopes.ts(120,5): error TS7028: Unused labe
         }
     
         lable: let l2 = 0;
-        ~~~~~
-!!! error TS7028: Unused label.
     }
     
     // methods
diff --git a/tests/baselines/reference/letDeclarations-scopes.js b/tests/baselines/reference/letDeclarations-scopes.js
index d0489820d0b..3fc5976b4b7 100644
--- a/tests/baselines/reference/letDeclarations-scopes.js
+++ b/tests/baselines/reference/letDeclarations-scopes.js
@@ -1,5 +1,6 @@
 //// [letDeclarations-scopes.ts]
 
+
 // global
 let l = "string";
 
diff --git a/tests/baselines/reference/letDeclarations-validContexts.errors.txt b/tests/baselines/reference/letDeclarations-validContexts.errors.txt
index f5e8022191b..acec026daf0 100644
--- a/tests/baselines/reference/letDeclarations-validContexts.errors.txt
+++ b/tests/baselines/reference/letDeclarations-validContexts.errors.txt
@@ -1,13 +1,8 @@
-tests/cases/compiler/letDeclarations-validContexts.ts(8,5): error TS7027: Unreachable code detected.
-tests/cases/compiler/letDeclarations-validContexts.ts(15,1): error TS7027: Unreachable code detected.
-tests/cases/compiler/letDeclarations-validContexts.ts(20,7): error TS2410: All symbols within a 'with' block will be resolved to 'any'.
-tests/cases/compiler/letDeclarations-validContexts.ts(132,5): error TS7028: Unused label.
-tests/cases/compiler/letDeclarations-validContexts.ts(134,9): error TS7028: Unused label.
-tests/cases/compiler/letDeclarations-validContexts.ts(139,5): error TS7028: Unused label.
-tests/cases/compiler/letDeclarations-validContexts.ts(141,9): error TS7028: Unused label.
+tests/cases/compiler/letDeclarations-validContexts.ts(21,7): error TS2410: All symbols within a 'with' block will be resolved to 'any'.
 
 
-==== tests/cases/compiler/letDeclarations-validContexts.ts (7 errors) ====
+==== tests/cases/compiler/letDeclarations-validContexts.ts (1 errors) ====
+    
     
     
     // Control flow statements with blocks
@@ -16,8 +11,6 @@ tests/cases/compiler/letDeclarations-validContexts.ts(141,9): error TS7028: Unus
     }
     else { 
         let l2 = 0;
-        ~~~
-!!! error TS7027: Unreachable code detected.
     }
     
     while (true) { 
@@ -25,8 +18,6 @@ tests/cases/compiler/letDeclarations-validContexts.ts(141,9): error TS7028: Unus
     }
     
     do { 
-    ~~
-!!! error TS7027: Unreachable code detected.
         let l4 = 0;
     } while (true);
     
@@ -146,22 +137,14 @@ tests/cases/compiler/letDeclarations-validContexts.ts(141,9): error TS7028: Unus
     
     function f3() {
         label: let l32 = 0;
-        ~~~~~
-!!! error TS7028: Unused label.
         {
             label2: let l33 = 0;
-            ~~~~~~
-!!! error TS7028: Unused label.
         }
     }
     
     module m3 {
         label: let l34 = 0;
-        ~~~~~
-!!! error TS7028: Unused label.
         {
             label2: let l35 = 0;
-            ~~~~~~
-!!! error TS7028: Unused label.
         }
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/letDeclarations-validContexts.js b/tests/baselines/reference/letDeclarations-validContexts.js
index b11a1922383..1859a0215bb 100644
--- a/tests/baselines/reference/letDeclarations-validContexts.js
+++ b/tests/baselines/reference/letDeclarations-validContexts.js
@@ -1,6 +1,7 @@
 //// [letDeclarations-validContexts.ts]
 
 
+
 // Control flow statements with blocks
 if (true) { 
     let l1 = 0;
diff --git a/tests/baselines/reference/localTypes4.errors.txt b/tests/baselines/reference/localTypes4.errors.txt
index d6a3f0ce699..4d08644ea89 100644
--- a/tests/baselines/reference/localTypes4.errors.txt
+++ b/tests/baselines/reference/localTypes4.errors.txt
@@ -1,11 +1,11 @@
-tests/cases/conformance/types/localTypes/localTypes4.ts(10,19): error TS2304: Cannot find name 'T'.
-tests/cases/conformance/types/localTypes/localTypes4.ts(10,23): error TS2304: Cannot find name 'T'.
-tests/cases/conformance/types/localTypes/localTypes4.ts(18,16): error TS2300: Duplicate identifier 'T'.
-tests/cases/conformance/types/localTypes/localTypes4.ts(19,19): error TS2300: Duplicate identifier 'T'.
-tests/cases/conformance/types/localTypes/localTypes4.ts(35,9): error TS7027: Unreachable code detected.
+tests/cases/conformance/types/localTypes/localTypes4.ts(11,19): error TS2304: Cannot find name 'T'.
+tests/cases/conformance/types/localTypes/localTypes4.ts(11,23): error TS2304: Cannot find name 'T'.
+tests/cases/conformance/types/localTypes/localTypes4.ts(19,16): error TS2300: Duplicate identifier 'T'.
+tests/cases/conformance/types/localTypes/localTypes4.ts(20,19): error TS2300: Duplicate identifier 'T'.
 
 
-==== tests/cases/conformance/types/localTypes/localTypes4.ts (5 errors) ====
+==== tests/cases/conformance/types/localTypes/localTypes4.ts (4 errors) ====
+    
     function f1() {
         // Type parameters are in scope in parameters and return types
         function f<T>(x: T): T {
@@ -49,8 +49,6 @@ tests/cases/conformance/types/localTypes/localTypes4.ts(35,9): error TS7027: Unr
         }
         else {
             v.x = 20;
-            ~
-!!! error TS7027: Unreachable code detected.
         }
     }
     
\ No newline at end of file
diff --git a/tests/baselines/reference/localTypes4.js b/tests/baselines/reference/localTypes4.js
index 8f51761a65a..3b81175d2b6 100644
--- a/tests/baselines/reference/localTypes4.js
+++ b/tests/baselines/reference/localTypes4.js
@@ -1,4 +1,5 @@
 //// [localTypes4.ts]
+
 function f1() {
     // Type parameters are in scope in parameters and return types
     function f<T>(x: T): T {
diff --git a/tests/baselines/reference/null.errors.txt b/tests/baselines/reference/null.errors.txt
deleted file mode 100644
index b516720b241..00000000000
--- a/tests/baselines/reference/null.errors.txt
+++ /dev/null
@@ -1,30 +0,0 @@
-tests/cases/compiler/null.ts(8,5): error TS7027: Unreachable code detected.
-tests/cases/compiler/null.ts(12,5): error TS7027: Unreachable code detected.
-
-
-==== tests/cases/compiler/null.ts (2 errors) ====
-    var x=null; 
-    var y=3+x;  
-    var z=3+null; 
-    class C {
-    }
-    function f() {
-        return null;
-        return new C();
-        ~~~~~~
-!!! error TS7027: Unreachable code detected.
-    }
-    function g() {
-        return null;
-        return 3;
-        ~~~~~~
-!!! error TS7027: Unreachable code detected.
-    }
-    interface I {
-        x:any;
-        y:number;
-    }
-    var w:I={x:null,y:3};
-    
-    
-    
\ No newline at end of file
diff --git a/tests/baselines/reference/null.js b/tests/baselines/reference/null.js
index 499d6901847..ee897643fb1 100644
--- a/tests/baselines/reference/null.js
+++ b/tests/baselines/reference/null.js
@@ -1,4 +1,5 @@
 //// [null.ts]
+
 var x=null; 
 var y=3+x;  
 var z=3+null; 
diff --git a/tests/baselines/reference/null.symbols b/tests/baselines/reference/null.symbols
new file mode 100644
index 00000000000..bd3d835995b
--- /dev/null
+++ b/tests/baselines/reference/null.symbols
@@ -0,0 +1,45 @@
+=== tests/cases/compiler/null.ts ===
+
+var x=null; 
+>x : Symbol(x, Decl(null.ts, 1, 3))
+
+var y=3+x;  
+>y : Symbol(y, Decl(null.ts, 2, 3))
+>x : Symbol(x, Decl(null.ts, 1, 3))
+
+var z=3+null; 
+>z : Symbol(z, Decl(null.ts, 3, 3))
+
+class C {
+>C : Symbol(C, Decl(null.ts, 3, 13))
+}
+function f() {
+>f : Symbol(f, Decl(null.ts, 5, 1))
+
+    return null;
+    return new C();
+>C : Symbol(C, Decl(null.ts, 3, 13))
+}
+function g() {
+>g : Symbol(g, Decl(null.ts, 9, 1))
+
+    return null;
+    return 3;
+}
+interface I {
+>I : Symbol(I, Decl(null.ts, 13, 1))
+
+    x:any;
+>x : Symbol(x, Decl(null.ts, 14, 13))
+
+    y:number;
+>y : Symbol(y, Decl(null.ts, 15, 10))
+}
+var w:I={x:null,y:3};
+>w : Symbol(w, Decl(null.ts, 18, 3))
+>I : Symbol(I, Decl(null.ts, 13, 1))
+>x : Symbol(x, Decl(null.ts, 18, 9))
+>y : Symbol(y, Decl(null.ts, 18, 16))
+
+
+
diff --git a/tests/baselines/reference/null.types b/tests/baselines/reference/null.types
new file mode 100644
index 00000000000..6fd8b423f13
--- /dev/null
+++ b/tests/baselines/reference/null.types
@@ -0,0 +1,60 @@
+=== tests/cases/compiler/null.ts ===
+
+var x=null; 
+>x : any
+>null : null
+
+var y=3+x;  
+>y : any
+>3+x : any
+>3 : number
+>x : any
+
+var z=3+null; 
+>z : number
+>3+null : number
+>3 : number
+>null : null
+
+class C {
+>C : C
+}
+function f() {
+>f : () => C
+
+    return null;
+>null : null
+
+    return new C();
+>new C() : C
+>C : typeof C
+}
+function g() {
+>g : () => number
+
+    return null;
+>null : null
+
+    return 3;
+>3 : number
+}
+interface I {
+>I : I
+
+    x:any;
+>x : any
+
+    y:number;
+>y : number
+}
+var w:I={x:null,y:3};
+>w : I
+>I : I
+>{x:null,y:3} : { x: null; y: number; }
+>x : null
+>null : null
+>y : number
+>3 : number
+
+
+
diff --git a/tests/baselines/reference/overloadOnConstAsTypeAnnotation.errors.txt b/tests/baselines/reference/overloadOnConstAsTypeAnnotation.errors.txt
index 48f1ce1bd13..a78e0c8abcf 100644
--- a/tests/baselines/reference/overloadOnConstAsTypeAnnotation.errors.txt
+++ b/tests/baselines/reference/overloadOnConstAsTypeAnnotation.errors.txt
@@ -1,13 +1,11 @@
-tests/cases/compiler/overloadOnConstAsTypeAnnotation.ts(1,8): error TS2382: Specialized overload signature is not assignable to any non-specialized signature.
-tests/cases/compiler/overloadOnConstAsTypeAnnotation.ts(1,37): error TS1005: ';' expected.
-tests/cases/compiler/overloadOnConstAsTypeAnnotation.ts(1,53): error TS7027: Unreachable code detected.
+tests/cases/compiler/overloadOnConstAsTypeAnnotation.ts(2,8): error TS2382: Specialized overload signature is not assignable to any non-specialized signature.
+tests/cases/compiler/overloadOnConstAsTypeAnnotation.ts(2,37): error TS1005: ';' expected.
 
 
-==== tests/cases/compiler/overloadOnConstAsTypeAnnotation.ts (3 errors) ====
+==== tests/cases/compiler/overloadOnConstAsTypeAnnotation.ts (2 errors) ====
+    
     var f: (x: 'hi') => number = ('hi') => { return 1; };
            ~~~~~~~~~~~~~~~~~~~
 !!! error TS2382: Specialized overload signature is not assignable to any non-specialized signature.
                                         ~~
-!!! error TS1005: ';' expected.
-                                                        ~
-!!! error TS7027: Unreachable code detected.
\ No newline at end of file
+!!! error TS1005: ';' expected.
\ No newline at end of file
diff --git a/tests/baselines/reference/overloadOnConstAsTypeAnnotation.js b/tests/baselines/reference/overloadOnConstAsTypeAnnotation.js
index 48e52ba0967..aa5c8701f28 100644
--- a/tests/baselines/reference/overloadOnConstAsTypeAnnotation.js
+++ b/tests/baselines/reference/overloadOnConstAsTypeAnnotation.js
@@ -1,4 +1,5 @@
 //// [overloadOnConstAsTypeAnnotation.ts]
+
 var f: (x: 'hi') => number = ('hi') => { return 1; };
 
 //// [overloadOnConstAsTypeAnnotation.js]
diff --git a/tests/baselines/reference/parser10.1.1-8gs.errors.txt b/tests/baselines/reference/parser10.1.1-8gs.errors.txt
index c321ca1fff8..3426ccab8da 100644
--- a/tests/baselines/reference/parser10.1.1-8gs.errors.txt
+++ b/tests/baselines/reference/parser10.1.1-8gs.errors.txt
@@ -1,9 +1,9 @@
-tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts(16,7): error TS2304: Cannot find name 'NotEarlyError'.
-tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts(17,1): error TS7027: Unreachable code detected.
-tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts(17,5): error TS1212: Identifier expected. 'public' is a reserved word in strict mode
+tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts(17,7): error TS2304: Cannot find name 'NotEarlyError'.
+tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts(18,5): error TS1212: Identifier expected. 'public' is a reserved word in strict mode
 
 
-==== tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts (3 errors) ====
+==== tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts (2 errors) ====
+    
     /// Copyright (c) 2012 Ecma International.  All rights reserved. 
     /// Ecma International makes this code available under the terms and conditions set
     /// forth on http://hg.ecmascript.org/tests/test262/raw-file/tip/LICENSE (the 
@@ -23,8 +23,6 @@ tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts(17,5): error TS12
           ~~~~~~~~~~~~~
 !!! error TS2304: Cannot find name 'NotEarlyError'.
     var public = 1;
-    ~~~
-!!! error TS7027: Unreachable code detected.
         ~~~~~~
 !!! error TS1212: Identifier expected. 'public' is a reserved word in strict mode
     
\ No newline at end of file
diff --git a/tests/baselines/reference/parser10.1.1-8gs.js b/tests/baselines/reference/parser10.1.1-8gs.js
index e7d342cf1f1..fb3b96f6baf 100644
--- a/tests/baselines/reference/parser10.1.1-8gs.js
+++ b/tests/baselines/reference/parser10.1.1-8gs.js
@@ -1,4 +1,5 @@
 //// [parser10.1.1-8gs.ts]
+
 /// Copyright (c) 2012 Ecma International.  All rights reserved. 
 /// Ecma International makes this code available under the terms and conditions set
 /// forth on http://hg.ecmascript.org/tests/test262/raw-file/tip/LICENSE (the 
diff --git a/tests/baselines/reference/parser768531.errors.txt b/tests/baselines/reference/parser768531.errors.txt
deleted file mode 100644
index 8298431e0e0..00000000000
--- a/tests/baselines/reference/parser768531.errors.txt
+++ /dev/null
@@ -1,8 +0,0 @@
-tests/cases/conformance/parser/ecmascript5/Fuzz/parser768531.ts(1,2): error TS7028: Unused label.
-
-
-==== tests/cases/conformance/parser/ecmascript5/Fuzz/parser768531.ts (1 errors) ====
-    {a: 3}
-     ~
-!!! error TS7028: Unused label.
-    /x/
\ No newline at end of file
diff --git a/tests/baselines/reference/parser768531.js b/tests/baselines/reference/parser768531.js
index 26e22117717..462db3742b3 100644
--- a/tests/baselines/reference/parser768531.js
+++ b/tests/baselines/reference/parser768531.js
@@ -1,4 +1,5 @@
 //// [parser768531.ts]
+
 {a: 3}
 /x/
 
diff --git a/tests/baselines/reference/parser768531.symbols b/tests/baselines/reference/parser768531.symbols
new file mode 100644
index 00000000000..f180922c7e0
--- /dev/null
+++ b/tests/baselines/reference/parser768531.symbols
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/parser/ecmascript5/Fuzz/parser768531.ts ===
+
+No type information for this code.{a: 3}
+No type information for this code./x/
+No type information for this code.
\ No newline at end of file
diff --git a/tests/baselines/reference/parser768531.types b/tests/baselines/reference/parser768531.types
new file mode 100644
index 00000000000..434535b5cc9
--- /dev/null
+++ b/tests/baselines/reference/parser768531.types
@@ -0,0 +1,9 @@
+=== tests/cases/conformance/parser/ecmascript5/Fuzz/parser768531.ts ===
+
+{a: 3}
+>a : any
+>3 : number
+
+/x/
+>/x/ : RegExp
+
diff --git a/tests/baselines/reference/whileBreakStatements.errors.txt b/tests/baselines/reference/whileBreakStatements.errors.txt
deleted file mode 100644
index 7c63dc59d3c..00000000000
--- a/tests/baselines/reference/whileBreakStatements.errors.txt
+++ /dev/null
@@ -1,54 +0,0 @@
-tests/cases/conformance/statements/breakStatements/whileBreakStatements.ts(11,1): error TS7028: Unused label.
-tests/cases/conformance/statements/breakStatements/whileBreakStatements.ts(19,5): error TS7028: Unused label.
-tests/cases/conformance/statements/breakStatements/whileBreakStatements.ts(31,1): error TS7027: Unreachable code detected.
-
-
-==== tests/cases/conformance/statements/breakStatements/whileBreakStatements.ts (3 errors) ====
-    while(true) {
-        break;
-    } 
-    
-    ONE:
-    
-    while (true) {
-        break ONE;
-    }
-    
-    TWO:
-    ~~~
-!!! error TS7028: Unused label.
-    THREE:
-    while (true) {
-        break THREE;
-    }
-    
-    FOUR:
-    while (true) {
-        FIVE:
-        ~~~~
-!!! error TS7028: Unused label.
-        while (true) {
-            break FOUR;
-        }
-    }
-    
-    while (true) {
-        SIX:
-        while (true)
-            break SIX;
-    }
-    
-    SEVEN:
-    ~~~~~
-!!! error TS7027: Unreachable code detected.
-    while (true)
-        while (true)
-            while (true)
-                break SEVEN;
-    
-    EIGHT:
-    while (true) {
-        var fn = function () { }
-        break EIGHT;
-    }
-    
\ No newline at end of file
diff --git a/tests/baselines/reference/whileBreakStatements.js b/tests/baselines/reference/whileBreakStatements.js
index 818be39a242..15dffe3e582 100644
--- a/tests/baselines/reference/whileBreakStatements.js
+++ b/tests/baselines/reference/whileBreakStatements.js
@@ -1,4 +1,5 @@
 //// [whileBreakStatements.ts]
+
 while(true) {
     break;
 } 
diff --git a/tests/baselines/reference/whileBreakStatements.symbols b/tests/baselines/reference/whileBreakStatements.symbols
new file mode 100644
index 00000000000..022fe9a12a8
--- /dev/null
+++ b/tests/baselines/reference/whileBreakStatements.symbols
@@ -0,0 +1,46 @@
+=== tests/cases/conformance/statements/breakStatements/whileBreakStatements.ts ===
+
+while(true) {
+    break;
+} 
+
+ONE:
+
+while (true) {
+    break ONE;
+}
+
+TWO:
+THREE:
+while (true) {
+    break THREE;
+}
+
+FOUR:
+while (true) {
+    FIVE:
+    while (true) {
+        break FOUR;
+    }
+}
+
+while (true) {
+    SIX:
+    while (true)
+        break SIX;
+}
+
+SEVEN:
+while (true)
+    while (true)
+        while (true)
+            break SEVEN;
+
+EIGHT:
+while (true) {
+    var fn = function () { }
+>fn : Symbol(fn, Decl(whileBreakStatements.ts, 39, 7))
+
+    break EIGHT;
+}
+
diff --git a/tests/baselines/reference/whileBreakStatements.types b/tests/baselines/reference/whileBreakStatements.types
new file mode 100644
index 00000000000..a31d1e9b40e
--- /dev/null
+++ b/tests/baselines/reference/whileBreakStatements.types
@@ -0,0 +1,90 @@
+=== tests/cases/conformance/statements/breakStatements/whileBreakStatements.ts ===
+
+while(true) {
+>true : boolean
+
+    break;
+} 
+
+ONE:
+>ONE : any
+
+while (true) {
+>true : boolean
+
+    break ONE;
+>ONE : any
+}
+
+TWO:
+>TWO : any
+
+THREE:
+>THREE : any
+
+while (true) {
+>true : boolean
+
+    break THREE;
+>THREE : any
+}
+
+FOUR:
+>FOUR : any
+
+while (true) {
+>true : boolean
+
+    FIVE:
+>FIVE : any
+
+    while (true) {
+>true : boolean
+
+        break FOUR;
+>FOUR : any
+    }
+}
+
+while (true) {
+>true : boolean
+
+    SIX:
+>SIX : any
+
+    while (true)
+>true : boolean
+
+        break SIX;
+>SIX : any
+}
+
+SEVEN:
+>SEVEN : any
+
+while (true)
+>true : boolean
+
+    while (true)
+>true : boolean
+
+        while (true)
+>true : boolean
+
+            break SEVEN;
+>SEVEN : any
+
+EIGHT:
+>EIGHT : any
+
+while (true) {
+>true : boolean
+
+    var fn = function () { }
+>fn : () => void
+>function () { } : () => void
+
+    break EIGHT;
+>EIGHT : any
+}
+
diff --git a/tests/cases/compiler/bestCommonTypeReturnStatement.ts b/tests/cases/compiler/bestCommonTypeReturnStatement.ts
index aff173664f6..cb481147f9b 100644
--- a/tests/cases/compiler/bestCommonTypeReturnStatement.ts
+++ b/tests/cases/compiler/bestCommonTypeReturnStatement.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 interface IPromise<T> {
     then(successCallback: (promiseValue: T) => any, errorCallback?: (reason: any) => any): IPromise<any>;
 }
diff --git a/tests/cases/compiler/breakTarget3.ts b/tests/cases/compiler/breakTarget3.ts
index 9cef599692c..64a9357706f 100644
--- a/tests/cases/compiler/breakTarget3.ts
+++ b/tests/cases/compiler/breakTarget3.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 target1:
 target2:
 while (true) {
diff --git a/tests/cases/compiler/breakTarget4.ts b/tests/cases/compiler/breakTarget4.ts
index 2c3eadca7db..3e00bca659b 100644
--- a/tests/cases/compiler/breakTarget4.ts
+++ b/tests/cases/compiler/breakTarget4.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 target1:
 target2:
 while (true) {
diff --git a/tests/cases/compiler/breakTarget5.ts b/tests/cases/compiler/breakTarget5.ts
index a05ee1cf879..f0bceb5015f 100644
--- a/tests/cases/compiler/breakTarget5.ts
+++ b/tests/cases/compiler/breakTarget5.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 target:
 while (true) {
   function f() {
diff --git a/tests/cases/compiler/commentEmitAtEndOfFile1.ts b/tests/cases/compiler/commentEmitAtEndOfFile1.ts
index b1b863890d5..5713ef006e5 100644
--- a/tests/cases/compiler/commentEmitAtEndOfFile1.ts
+++ b/tests/cases/compiler/commentEmitAtEndOfFile1.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 // test
 var f = ''
 // test #2
diff --git a/tests/cases/compiler/conditionalExpressions2.ts b/tests/cases/compiler/conditionalExpressions2.ts
index 6f2f097f6de..ece002d7778 100644
--- a/tests/cases/compiler/conditionalExpressions2.ts
+++ b/tests/cases/compiler/conditionalExpressions2.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 var a = false ? 1 : null;
 var b = false ? undefined : 0;
 var c = false ? 1 : 0;
diff --git a/tests/cases/compiler/constDeclarations-invalidContexts.ts b/tests/cases/compiler/constDeclarations-invalidContexts.ts
index b5093180990..6d21ee31ec2 100644
--- a/tests/cases/compiler/constDeclarations-invalidContexts.ts
+++ b/tests/cases/compiler/constDeclarations-invalidContexts.ts
@@ -1,3 +1,4 @@
+// @allowUnreachableCode: true
 // @target: ES6
 
 // Errors, const must be defined inside a block
diff --git a/tests/cases/compiler/constDeclarations-validContexts.ts b/tests/cases/compiler/constDeclarations-validContexts.ts
index ffde8e45d6f..63af6d16959 100644
--- a/tests/cases/compiler/constDeclarations-validContexts.ts
+++ b/tests/cases/compiler/constDeclarations-validContexts.ts
@@ -1,3 +1,4 @@
+// @allowUnreachableCode: true
 // @target: ES6
 
 
diff --git a/tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts b/tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts
index a93628e5494..63e0fc30141 100644
--- a/tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts
+++ b/tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 declare module "fs" {
     export class File {
         constructor(filename: string);
diff --git a/tests/cases/compiler/continueNotInIterationStatement4.ts b/tests/cases/compiler/continueNotInIterationStatement4.ts
index 5996eb4323a..218cb151df3 100644
--- a/tests/cases/compiler/continueNotInIterationStatement4.ts
+++ b/tests/cases/compiler/continueNotInIterationStatement4.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 TWO:
 while (true){
   var x = () => {
diff --git a/tests/cases/compiler/continueTarget3.ts b/tests/cases/compiler/continueTarget3.ts
index 26bea241a7a..a7b47ff071b 100644
--- a/tests/cases/compiler/continueTarget3.ts
+++ b/tests/cases/compiler/continueTarget3.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 target1:
 target2:
 while (true) {
diff --git a/tests/cases/compiler/continueTarget4.ts b/tests/cases/compiler/continueTarget4.ts
index e00c222aa9c..5ba2bd69b11 100644
--- a/tests/cases/compiler/continueTarget4.ts
+++ b/tests/cases/compiler/continueTarget4.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 target1:
 target2:
 while (true) {
diff --git a/tests/cases/compiler/continueTarget5.ts b/tests/cases/compiler/continueTarget5.ts
index dd3a806ab2d..5f3d068282b 100644
--- a/tests/cases/compiler/continueTarget5.ts
+++ b/tests/cases/compiler/continueTarget5.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 target:
 while (true) {
   function f() {
diff --git a/tests/cases/compiler/downlevelLetConst16.ts b/tests/cases/compiler/downlevelLetConst16.ts
index 30a27ba61f4..b30f26b4b82 100644
--- a/tests/cases/compiler/downlevelLetConst16.ts
+++ b/tests/cases/compiler/downlevelLetConst16.ts
@@ -1,4 +1,6 @@
 // @target:es5
+// @allowUnreachableCode: true
+
 'use strict'
 
 declare function use(a: any);
diff --git a/tests/cases/compiler/downlevelLetConst17.ts b/tests/cases/compiler/downlevelLetConst17.ts
index b581281f679..7cea2031ac5 100644
--- a/tests/cases/compiler/downlevelLetConst17.ts
+++ b/tests/cases/compiler/downlevelLetConst17.ts
@@ -1,4 +1,5 @@
 // @target:es5
+// @allowUnreachableCode: true
 'use strict'
 
 declare function use(a: any);
diff --git a/tests/cases/compiler/downlevelLetConst18.ts b/tests/cases/compiler/downlevelLetConst18.ts
index 59f2ee7a46e..d40f23e3a37 100644
--- a/tests/cases/compiler/downlevelLetConst18.ts
+++ b/tests/cases/compiler/downlevelLetConst18.ts
@@ -1,4 +1,6 @@
 // @target:es5
+// @allowUnreachableCode: true
+
 'use strict'
 
 for (let x; ;) {
diff --git a/tests/cases/compiler/duplicateLabel1.ts b/tests/cases/compiler/duplicateLabel1.ts
index c588e7b8183..ff248c64548 100644
--- a/tests/cases/compiler/duplicateLabel1.ts
+++ b/tests/cases/compiler/duplicateLabel1.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 target:
 target:
 while (true) {
diff --git a/tests/cases/compiler/duplicateLabel2.ts b/tests/cases/compiler/duplicateLabel2.ts
index bdb0396a246..5ebf273c118 100644
--- a/tests/cases/compiler/duplicateLabel2.ts
+++ b/tests/cases/compiler/duplicateLabel2.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 target:
 while (true) {
   target:
diff --git a/tests/cases/compiler/duplicateLabel3.ts b/tests/cases/compiler/duplicateLabel3.ts
index d4db9399ed2..d6add980447 100644
--- a/tests/cases/compiler/duplicateLabel3.ts
+++ b/tests/cases/compiler/duplicateLabel3.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 target:
 while (true) {
   function f() {
diff --git a/tests/cases/compiler/duplicateLabel4.ts b/tests/cases/compiler/duplicateLabel4.ts
index 2c62180a2ab..bf7ea5c22c6 100644
--- a/tests/cases/compiler/duplicateLabel4.ts
+++ b/tests/cases/compiler/duplicateLabel4.ts
@@ -1,3 +1,6 @@
+// @allowUnusedLabels: true
+// @allowUnreachableCode: true
+
 target:
 while (true) {
 }
diff --git a/tests/cases/compiler/duplicateLocalVariable1.ts b/tests/cases/compiler/duplicateLocalVariable1.ts
index fc20a19c2d9..f6288cfc6ae 100644
--- a/tests/cases/compiler/duplicateLocalVariable1.ts
+++ b/tests/cases/compiler/duplicateLocalVariable1.ts
@@ -1,4 +1,6 @@
-//@module: commonjs
+
+// @allowUnreachableCode: true
+/ /@module: commonjs
 
 //import FileManager = require('filemanager');
 //import App = require('app');
diff --git a/tests/cases/compiler/duplicateVariablesByScope.ts b/tests/cases/compiler/duplicateVariablesByScope.ts
index 481c1bb950e..dc811130d4f 100644
--- a/tests/cases/compiler/duplicateVariablesByScope.ts
+++ b/tests/cases/compiler/duplicateVariablesByScope.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 // duplicate local variables are only reported at global scope
 
 module M {
diff --git a/tests/cases/compiler/es6ClassSuperCodegenBug.ts b/tests/cases/compiler/es6ClassSuperCodegenBug.ts
index 7ab8344c815..2e3f306d5d6 100644
--- a/tests/cases/compiler/es6ClassSuperCodegenBug.ts
+++ b/tests/cases/compiler/es6ClassSuperCodegenBug.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 class A {
 	constructor(str1:string, str2:string) {}
 }
diff --git a/tests/cases/compiler/escapedIdentifiers.ts b/tests/cases/compiler/escapedIdentifiers.ts
index 795aeca2481..c58c59d9b42 100644
--- a/tests/cases/compiler/escapedIdentifiers.ts
+++ b/tests/cases/compiler/escapedIdentifiers.ts
@@ -1,3 +1,6 @@
+// @allowUnusedLabels: true
+// @allowUnreachableCode: true
+
 /*
     0 .. \u0030
     9 .. \u0039
diff --git a/tests/cases/compiler/for.ts b/tests/cases/compiler/for.ts
index e27dab7dbd2..636c7e4a5fc 100644
--- a/tests/cases/compiler/for.ts
+++ b/tests/cases/compiler/for.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 for (var i = 0; i < 10; i++) { // ok
     var x1 = i;
 }
diff --git a/tests/cases/compiler/functionOverloads12.ts b/tests/cases/compiler/functionOverloads12.ts
index 3e8a9882d08..48a8af06cc5 100644
--- a/tests/cases/compiler/functionOverloads12.ts
+++ b/tests/cases/compiler/functionOverloads12.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 function foo():string;
 function foo():number;
 function foo():any { if (true) return ""; else return 0;}
diff --git a/tests/cases/compiler/functionReturn.ts b/tests/cases/compiler/functionReturn.ts
index 8ea0cb8f5a1..897480c64d6 100644
--- a/tests/cases/compiler/functionReturn.ts
+++ b/tests/cases/compiler/functionReturn.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 function f0(): void { }
 function f1() {
     var n: any = f0();
diff --git a/tests/cases/compiler/functionWithNoBestCommonType1.ts b/tests/cases/compiler/functionWithNoBestCommonType1.ts
index 11628812925..2d7a1191770 100644
--- a/tests/cases/compiler/functionWithNoBestCommonType1.ts
+++ b/tests/cases/compiler/functionWithNoBestCommonType1.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 function foo() {
     return true;
     return bar();
diff --git a/tests/cases/compiler/functionWithNoBestCommonType2.ts b/tests/cases/compiler/functionWithNoBestCommonType2.ts
index 974ccdfe035..6bc3878d834 100644
--- a/tests/cases/compiler/functionWithNoBestCommonType2.ts
+++ b/tests/cases/compiler/functionWithNoBestCommonType2.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 var v = function () {
    return true;
    return bar();
diff --git a/tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts b/tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts
index 81259fd7c0c..fde615af41d 100644
--- a/tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts
+++ b/tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 // @target: es5
 
 function f1(): string {
diff --git a/tests/cases/compiler/ifElseWithStatements1.ts b/tests/cases/compiler/ifElseWithStatements1.ts
index a7f337068cb..5ed7f7dd7a3 100644
--- a/tests/cases/compiler/ifElseWithStatements1.ts
+++ b/tests/cases/compiler/ifElseWithStatements1.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 if (true)
     f();
 else
diff --git a/tests/cases/compiler/inferredFunctionReturnTypeIsEmptyType.ts b/tests/cases/compiler/inferredFunctionReturnTypeIsEmptyType.ts
index d150fb1930a..6465e7f1200 100644
--- a/tests/cases/compiler/inferredFunctionReturnTypeIsEmptyType.ts
+++ b/tests/cases/compiler/inferredFunctionReturnTypeIsEmptyType.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 function foo() {
     if (true) {
         return 42;
diff --git a/tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts b/tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts
index 2620e7d88d4..e325ae4582a 100644
--- a/tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts
+++ b/tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 class a {
     static get x(): () => string {
         return null;;
diff --git a/tests/cases/compiler/letAndVarRedeclaration.ts b/tests/cases/compiler/letAndVarRedeclaration.ts
index 1f901ded520..aaf2ce1a68c 100644
--- a/tests/cases/compiler/letAndVarRedeclaration.ts
+++ b/tests/cases/compiler/letAndVarRedeclaration.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 // @target: es6
 
 let e0
diff --git a/tests/cases/compiler/letDeclarations-invalidContexts.ts b/tests/cases/compiler/letDeclarations-invalidContexts.ts
index 4d165ba2cda..cde6c2006bb 100644
--- a/tests/cases/compiler/letDeclarations-invalidContexts.ts
+++ b/tests/cases/compiler/letDeclarations-invalidContexts.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 // @target: ES6
 
 // Errors, let must be defined inside a block
diff --git a/tests/cases/compiler/letDeclarations-scopes.ts b/tests/cases/compiler/letDeclarations-scopes.ts
index 93f4ce5b4ed..b050a5e9bd0 100644
--- a/tests/cases/compiler/letDeclarations-scopes.ts
+++ b/tests/cases/compiler/letDeclarations-scopes.ts
@@ -1,3 +1,6 @@
+// @allowUnusedLabels: true
+// @allowUnreachableCode: true
+
 // @target: ES6
 
 // global
diff --git a/tests/cases/compiler/letDeclarations-validContexts.ts b/tests/cases/compiler/letDeclarations-validContexts.ts
index baedfa2644c..2a4022901c1 100644
--- a/tests/cases/compiler/letDeclarations-validContexts.ts
+++ b/tests/cases/compiler/letDeclarations-validContexts.ts
@@ -1,3 +1,6 @@
+// @allowUnusedLabels: true
+// @allowUnreachableCode: true
+
 // @target: ES6
 
 
diff --git a/tests/cases/compiler/null.ts b/tests/cases/compiler/null.ts
index eb88d387bcc..e8fa9a5d687 100644
--- a/tests/cases/compiler/null.ts
+++ b/tests/cases/compiler/null.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 var x=null; 
 var y=3+x;  
 var z=3+null; 
diff --git a/tests/cases/compiler/overloadOnConstAsTypeAnnotation.ts b/tests/cases/compiler/overloadOnConstAsTypeAnnotation.ts
index 21884031aec..12b99fb29ce 100644
--- a/tests/cases/compiler/overloadOnConstAsTypeAnnotation.ts
+++ b/tests/cases/compiler/overloadOnConstAsTypeAnnotation.ts
@@ -1 +1,3 @@
+// @allowUnreachableCode: true
+
 var f: (x: 'hi') => number = ('hi') => { return 1; };
\ No newline at end of file
diff --git a/tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts b/tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts
index b36f423be21..62311ee75c9 100644
--- a/tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts
+++ b/tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 // expected error for all the LHS of compound assignments (arithmetic and addition)
 var value;
 
diff --git a/tests/cases/conformance/expressions/contextualTyping/generatedContextualTyping.ts b/tests/cases/conformance/expressions/contextualTyping/generatedContextualTyping.ts
index cd0fb64e0d2..d6bfd84fd9a 100644
--- a/tests/cases/conformance/expressions/contextualTyping/generatedContextualTyping.ts
+++ b/tests/cases/conformance/expressions/contextualTyping/generatedContextualTyping.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 class Base { private p; }
 class Derived1 extends Base { private m; }
 class Derived2 extends Base { private n; }
diff --git a/tests/cases/conformance/functions/functionImplementationErrors.ts b/tests/cases/conformance/functions/functionImplementationErrors.ts
index ddd3ba0a2c1..0a7c7812932 100644
--- a/tests/cases/conformance/functions/functionImplementationErrors.ts
+++ b/tests/cases/conformance/functions/functionImplementationErrors.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 // FunctionExpression with no return type annotation with multiple return statements with unrelated types
 var f1 = function () {
     return '';
diff --git a/tests/cases/conformance/functions/functionImplementations.ts b/tests/cases/conformance/functions/functionImplementations.ts
index df36a0b4457..3c5adefd2e4 100644
--- a/tests/cases/conformance/functions/functionImplementations.ts
+++ b/tests/cases/conformance/functions/functionImplementations.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 // FunctionExpression with no return type annotation and no return statement returns void
 var v: void = function () { } ();
 
diff --git a/tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts b/tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts
index 31407b88590..d35002e2f65 100644
--- a/tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts
+++ b/tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 class Foo {
     x: string;
     y() { }
diff --git a/tests/cases/conformance/parser/ecmascript5/Fuzz/parser768531.ts b/tests/cases/conformance/parser/ecmascript5/Fuzz/parser768531.ts
index cad137cc88d..62c0153f224 100644
--- a/tests/cases/conformance/parser/ecmascript5/Fuzz/parser768531.ts
+++ b/tests/cases/conformance/parser/ecmascript5/Fuzz/parser768531.ts
@@ -1,2 +1,4 @@
+// @allowUnusedLabels: true
+
 {a: 3}
 /x/
\ No newline at end of file
diff --git a/tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts b/tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts
index 88476ac4a78..b35204beb48 100644
--- a/tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts
+++ b/tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 /// Copyright (c) 2012 Ecma International.  All rights reserved. 
 /// Ecma International makes this code available under the terms and conditions set
 /// forth on http://hg.ecmascript.org/tests/test262/raw-file/tip/LICENSE (the 
diff --git a/tests/cases/conformance/statements/breakStatements/doWhileBreakStatements.ts b/tests/cases/conformance/statements/breakStatements/doWhileBreakStatements.ts
index 49bfaaca13f..cca94947a5d 100644
--- a/tests/cases/conformance/statements/breakStatements/doWhileBreakStatements.ts
+++ b/tests/cases/conformance/statements/breakStatements/doWhileBreakStatements.ts
@@ -1,3 +1,6 @@
+// @allowUnusedLabels: true
+// @allowUnreachableCode: true
+
 do {
     break;
 } while(true)
diff --git a/tests/cases/conformance/statements/breakStatements/forBreakStatements.ts b/tests/cases/conformance/statements/breakStatements/forBreakStatements.ts
index 20a93db4418..9cf07e1eef7 100644
--- a/tests/cases/conformance/statements/breakStatements/forBreakStatements.ts
+++ b/tests/cases/conformance/statements/breakStatements/forBreakStatements.ts
@@ -1,3 +1,6 @@
+// @allowUnusedLabels: true
+// @allowUnreachableCode: true
+
 for (; ;) {
     break;
 }
diff --git a/tests/cases/conformance/statements/breakStatements/forInBreakStatements.ts b/tests/cases/conformance/statements/breakStatements/forInBreakStatements.ts
index 5810d522182..ffc99ee904b 100644
--- a/tests/cases/conformance/statements/breakStatements/forInBreakStatements.ts
+++ b/tests/cases/conformance/statements/breakStatements/forInBreakStatements.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 for(var x in {}) {
     break;
 }
diff --git a/tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts b/tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts
index 7c93553a726..d164691db68 100644
--- a/tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts
+++ b/tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts
@@ -1,3 +1,6 @@
+// @allowUnusedLabels: true
+// @allowUnreachableCode: true
+
 // All errors
 
 // naked break not allowed
diff --git a/tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts b/tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts
index cc21818b80f..142a8f8b3b5 100644
--- a/tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts
+++ b/tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts
@@ -1,3 +1,6 @@
+// @allowUnusedLabels: true
+// @allowUnreachableCode: true
+
 // All errors
 
 // naked break not allowed
diff --git a/tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts b/tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts
index 9cda003e6f5..db49a13c8f7 100644
--- a/tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts
+++ b/tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts
@@ -1,3 +1,6 @@
+// @allowUnusedLabels: true
+// @allowUnreachableCode: true
+
 // All errors
 
 // naked break not allowed
diff --git a/tests/cases/conformance/statements/breakStatements/whileBreakStatements.ts b/tests/cases/conformance/statements/breakStatements/whileBreakStatements.ts
index c471e6552b9..e2a836b62a3 100644
--- a/tests/cases/conformance/statements/breakStatements/whileBreakStatements.ts
+++ b/tests/cases/conformance/statements/breakStatements/whileBreakStatements.ts
@@ -1,3 +1,6 @@
+// @allowUnusedLabels: true
+// @allowUnreachableCode: true
+
 while(true) {
     break;
 } 
diff --git a/tests/cases/conformance/statements/continueStatements/doWhileContinueStatements.ts b/tests/cases/conformance/statements/continueStatements/doWhileContinueStatements.ts
index d3d999ccb49..4685cc9f046 100644
--- a/tests/cases/conformance/statements/continueStatements/doWhileContinueStatements.ts
+++ b/tests/cases/conformance/statements/continueStatements/doWhileContinueStatements.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 do {
     continue;
 } while(true)
diff --git a/tests/cases/conformance/statements/continueStatements/forContinueStatements.ts b/tests/cases/conformance/statements/continueStatements/forContinueStatements.ts
index 1f8a3fc7b68..9b852df80c7 100644
--- a/tests/cases/conformance/statements/continueStatements/forContinueStatements.ts
+++ b/tests/cases/conformance/statements/continueStatements/forContinueStatements.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 for (; ;) {
     continue;
 }
diff --git a/tests/cases/conformance/statements/continueStatements/forInContinueStatements.ts b/tests/cases/conformance/statements/continueStatements/forInContinueStatements.ts
index 863caec2ccf..b5ccd8189ca 100644
--- a/tests/cases/conformance/statements/continueStatements/forInContinueStatements.ts
+++ b/tests/cases/conformance/statements/continueStatements/forInContinueStatements.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 for(var x in {}) {
     continue;
 }
diff --git a/tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts b/tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts
index 54192212ef7..dcf543ed7e3 100644
--- a/tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts
+++ b/tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts
@@ -1,3 +1,6 @@
+// @allowUnusedLabels: true
+// @allowUnreachableCode: true
+
 // All errors
 
 // naked continue not allowed
diff --git a/tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts b/tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts
index 751cd9477ad..ba367ef87b7 100644
--- a/tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts
+++ b/tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts
@@ -1,3 +1,6 @@
+// @allowUnusedLabels: true
+// @allowUnreachableCode: true
+
 // All errors
 
 // naked continue not allowed
diff --git a/tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts b/tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts
index be274005961..861d7e90629 100644
--- a/tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts
+++ b/tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts
@@ -1,3 +1,6 @@
+// @allowUnusedLabels: true
+// @allowUnreachableCode: true
+
 // All errors
 
 // naked continue not allowed
diff --git a/tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts b/tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts
index cf913671315..ef94466ffba 100644
--- a/tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts
+++ b/tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts
@@ -1,3 +1,6 @@
+// @allowUnusedLabels: true
+// @allowUnreachableCode: true
+
 // All errors
 
 // naked continue not allowed
diff --git a/tests/cases/conformance/statements/forStatements/forStatements.ts b/tests/cases/conformance/statements/forStatements/forStatements.ts
index 567c49c1098..1e65bdc2932 100644
--- a/tests/cases/conformance/statements/forStatements/forStatements.ts
+++ b/tests/cases/conformance/statements/forStatements/forStatements.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 interface I {
     id: number;
 }
diff --git a/tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts b/tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts
index 0c2bb3d40dc..64317b23336 100644
--- a/tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts
+++ b/tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 interface I {
     id: number;
 }
diff --git a/tests/cases/conformance/statements/forStatements/forStatementsMultipleValidDecl.ts b/tests/cases/conformance/statements/forStatements/forStatementsMultipleValidDecl.ts
index 9f5557e7756..af19fd404df 100644
--- a/tests/cases/conformance/statements/forStatements/forStatementsMultipleValidDecl.ts
+++ b/tests/cases/conformance/statements/forStatements/forStatementsMultipleValidDecl.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 // all expected to be valid
 
 for (var x: number; ;) { }
diff --git a/tests/cases/conformance/statements/ifDoWhileStatements/ifDoWhileStatements.ts b/tests/cases/conformance/statements/ifDoWhileStatements/ifDoWhileStatements.ts
index f2cd9aa43ee..03f042401d8 100644
--- a/tests/cases/conformance/statements/ifDoWhileStatements/ifDoWhileStatements.ts
+++ b/tests/cases/conformance/statements/ifDoWhileStatements/ifDoWhileStatements.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 interface I {
     id: number;
 }
diff --git a/tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts b/tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts
index aa382d4ec34..8cc294d01f7 100644
--- a/tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts
+++ b/tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 throw; 
 
 export throw null;
diff --git a/tests/cases/conformance/types/localTypes/localTypes4.ts b/tests/cases/conformance/types/localTypes/localTypes4.ts
index bd31e76a80f..388d5efb637 100644
--- a/tests/cases/conformance/types/localTypes/localTypes4.ts
+++ b/tests/cases/conformance/types/localTypes/localTypes4.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 function f1() {
     // Type parameters are in scope in parameters and return types
     function f<T>(x: T): T {
diff --git a/tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts b/tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts
index c249d2e5671..5cb52588644 100644
--- a/tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts
+++ b/tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 // interfaces do not permit private members, these are errors
 
 interface I {
diff --git a/tests/cases/conformance/types/objectTypeLiteral/callSignatures/callSignatureWithoutReturnTypeAnnotationInference.ts b/tests/cases/conformance/types/objectTypeLiteral/callSignatures/callSignatureWithoutReturnTypeAnnotationInference.ts
index 7ea4f414e15..1cc499c7d6e 100644
--- a/tests/cases/conformance/types/objectTypeLiteral/callSignatures/callSignatureWithoutReturnTypeAnnotationInference.ts
+++ b/tests/cases/conformance/types/objectTypeLiteral/callSignatures/callSignatureWithoutReturnTypeAnnotationInference.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 // Call signatures without a return type should infer one from the function body (if present)
 
 // Simple types
diff --git a/tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts b/tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts
index 9b12363ff08..9864ddab488 100644
--- a/tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts
+++ b/tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 // return type of a function with multiple returns is the BCT of each return statement
 // it is an error if there is no single BCT, these are error cases
 
diff --git a/tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts b/tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts
index 41d4fddfbeb..03021bfdd10 100644
--- a/tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts
+++ b/tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 // return type of a function with multiple returns is the BCT of each return statement
 // no errors expected here