From 97bbbd729e049ee644e954f4dff0c3756a0677db Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Thu, 28 Jul 2016 07:20:51 -0700
Subject: [PATCH 01/29] Introduce the `EntityNameExpression` type

---
 src/compiler/checker.ts                       | 102 ++++++++++--------
 src/compiler/declarationEmitter.ts            |   4 +-
 src/compiler/types.ts                         |  18 +++-
 src/compiler/utilities.ts                     |  36 ++++---
 .../reference/exportDefaultProperty.js        |   8 ++
 .../reference/exportDefaultProperty.symbols   |   5 +
 .../reference/exportDefaultProperty.types     |   6 ++
 tests/cases/compiler/exportDefaultProperty.ts |   1 +
 8 files changed, 113 insertions(+), 67 deletions(-)
 create mode 100644 tests/baselines/reference/exportDefaultProperty.js
 create mode 100644 tests/baselines/reference/exportDefaultProperty.symbols
 create mode 100644 tests/baselines/reference/exportDefaultProperty.types
 create mode 100644 tests/cases/compiler/exportDefaultProperty.ts

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 04c12eb613..6d670c7054 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -968,28 +968,39 @@ namespace ts {
 
 
         function checkAndReportErrorForExtendingInterface(errorLocation: Node): boolean {
-            let parentClassExpression = errorLocation;
-            while (parentClassExpression) {
-                const kind = parentClassExpression.kind;
-                if (kind === SyntaxKind.Identifier || kind === SyntaxKind.PropertyAccessExpression) {
-                    parentClassExpression = parentClassExpression.parent;
-                    continue;
-                }
-                if (kind === SyntaxKind.ExpressionWithTypeArguments) {
-                    break;
-                }
+            const parentExpression = climbToSupportedExpressionWithTypeArguments(errorLocation);
+            if (!parentExpression) {
                 return false;
             }
-            if (!parentClassExpression) {
-                return false;
-            }
-            const expression = (<ExpressionWithTypeArguments>parentClassExpression).expression;
+            const expression = parentExpression.expression;
+
             if (resolveEntityName(expression, SymbolFlags.Interface, /*ignoreErrors*/ true)) {
                 error(errorLocation, Diagnostics.Cannot_extend_an_interface_0_Did_you_mean_implements, getTextOfNode(expression));
                 return true;
             }
             return false;
         }
+        /**
+         * Climbs up parents to a SupportedExpressionWIthTypeArguments.
+         * Does *not* just climb to an ExpressionWithTypeArguments; instead, ensures that this really is supported.
+         */
+        function climbToSupportedExpressionWithTypeArguments(node: Node): SupportedExpressionWithTypeArguments | undefined {
+            while (node) {
+                switch (node.kind) {
+                    case SyntaxKind.Identifier:
+                    case SyntaxKind.PropertyAccessExpression:
+                        node = node.parent;
+                        break;
+                    case SyntaxKind.ExpressionWithTypeArguments:
+                        Debug.assert(isSupportedExpressionWithTypeArguments(<ExpressionWithTypeArguments>node));
+                        return <SupportedExpressionWithTypeArguments>node;
+                    default:
+                        return undefined;
+                }
+            }
+            return undefined;
+        }
+
 
         function checkResolvedBlockScopedVariable(result: Symbol, errorLocation: Node): void {
             Debug.assert((result.flags & SymbolFlags.BlockScopedVariable) !== 0);
@@ -1274,7 +1285,7 @@ namespace ts {
         }
 
         // Resolves a qualified name and any involved aliases
-        function resolveEntityName(name: EntityName | Expression, meaning: SymbolFlags, ignoreErrors?: boolean, dontResolveAlias?: boolean): Symbol {
+        function resolveEntityName(name: EntityNameOrEntityNameExpression, meaning: SymbolFlags, ignoreErrors?: boolean, dontResolveAlias?: boolean): Symbol | undefined {
             if (nodeIsMissing(name)) {
                 return undefined;
             }
@@ -1289,7 +1300,7 @@ namespace ts {
                 }
             }
             else if (name.kind === SyntaxKind.QualifiedName || name.kind === SyntaxKind.PropertyAccessExpression) {
-                const left = name.kind === SyntaxKind.QualifiedName ? (<QualifiedName>name).left : (<PropertyAccessExpression>name).expression;
+                const left = name.kind === SyntaxKind.QualifiedName ? (<QualifiedName>name).left : (<PropertyAccessEntityNameExpression>name).expression;
                 const right = name.kind === SyntaxKind.QualifiedName ? (<QualifiedName>name).right : (<PropertyAccessExpression>name).name;
 
                 const namespace = resolveEntityName(left, SymbolFlags.Namespace, ignoreErrors);
@@ -1845,7 +1856,7 @@ namespace ts {
             }
         }
 
-        function isEntityNameVisible(entityName: EntityName | Expression, enclosingDeclaration: Node): SymbolVisibilityResult {
+        function isEntityNameVisible(entityName: EntityNameOrEntityNameExpression, enclosingDeclaration: Node): SymbolVisibilityResult {
             // get symbol of the first identifier of the entityName
             let meaning: SymbolFlags;
             if (entityName.parent.kind === SyntaxKind.TypeQuery || isExpressionWithTypeArgumentsInClassExtendsClause(entityName.parent)) {
@@ -5022,7 +5033,7 @@ namespace ts {
             return getDeclaredTypeOfSymbol(symbol);
         }
 
-        function getTypeReferenceName(node: TypeReferenceNode | ExpressionWithTypeArguments | JSDocTypeReference): LeftHandSideExpression | EntityName {
+        function getTypeReferenceName(node: TypeReferenceNode | ExpressionWithTypeArguments | JSDocTypeReference): EntityNameOrEntityNameExpression | undefined {
             switch (node.kind) {
                 case SyntaxKind.TypeReference:
                     return (<TypeReferenceNode>node).typeName;
@@ -5031,8 +5042,9 @@ namespace ts {
                 case SyntaxKind.ExpressionWithTypeArguments:
                     // We only support expressions that are simple qualified names. For other
                     // expressions this produces undefined.
-                    if (isSupportedExpressionWithTypeArguments(<ExpressionWithTypeArguments>node)) {
-                        return (<ExpressionWithTypeArguments>node).expression;
+                    const expr = <ExpressionWithTypeArguments>node;
+                    if (isSupportedExpressionWithTypeArguments(expr)) {
+                        return expr.expression;
                     }
 
                 // fall through;
@@ -5043,7 +5055,7 @@ namespace ts {
 
         function resolveTypeReferenceName(
             node: TypeReferenceNode | ExpressionWithTypeArguments | JSDocTypeReference,
-            typeReferenceName: LeftHandSideExpression | EntityName) {
+            typeReferenceName: EntityNameExpression | EntityName) {
 
             if (!typeReferenceName) {
                 return unknownSymbol;
@@ -5084,15 +5096,14 @@ namespace ts {
                     const typeReferenceName = getTypeReferenceName(node);
                     symbol = resolveTypeReferenceName(node, typeReferenceName);
                     type = getTypeReferenceType(node, symbol);
-
-                    links.resolvedSymbol = symbol;
-                    links.resolvedType = type;
                 }
                 else {
                     // We only support expressions that are simple qualified names. For other expressions this produces undefined.
-                    const typeNameOrExpression = node.kind === SyntaxKind.TypeReference ? (<TypeReferenceNode>node).typeName :
-                        isSupportedExpressionWithTypeArguments(<ExpressionWithTypeArguments>node) ? (<ExpressionWithTypeArguments>node).expression :
-                            undefined;
+                    const typeNameOrExpression: EntityNameOrEntityNameExpression = node.kind === SyntaxKind.TypeReference
+                        ? (<TypeReferenceNode>node).typeName
+                        : isSupportedExpressionWithTypeArguments(<ExpressionWithTypeArguments>node)
+                            ? (<SupportedExpressionWithTypeArguments>node).expression
+                            : undefined;
                     symbol = typeNameOrExpression && resolveEntityName(typeNameOrExpression, SymbolFlags.Type) || unknownSymbol;
                     type = symbol === unknownSymbol ? unknownType :
                         symbol.flags & (SymbolFlags.Class | SymbolFlags.Interface) ? getTypeFromClassOrInterfaceReference(node, symbol) :
@@ -16951,20 +16962,21 @@ namespace ts {
             }
         }
 
-        function getFirstIdentifier(node: EntityName | Expression): Identifier {
-            while (true) {
-                if (node.kind === SyntaxKind.QualifiedName) {
-                    node = (<QualifiedName>node).left;
-                }
-                else if (node.kind === SyntaxKind.PropertyAccessExpression) {
-                    node = (<PropertyAccessExpression>node).expression;
-                }
-                else {
-                    break;
-                }
+        function getFirstIdentifier(node: EntityNameOrEntityNameExpression): Identifier {
+            switch (node.kind) {
+                case SyntaxKind.Identifier:
+                    return <Identifier>node;
+                case SyntaxKind.QualifiedName:
+                    do {
+                        node = (<QualifiedName>node).left;
+                    } while (node.kind !== SyntaxKind.Identifier);
+                    return <Identifier>node;
+                case SyntaxKind.PropertyAccessExpression:
+                    do {
+                        node = (<PropertyAccessEntityNameExpression>node).expression;
+                    } while (node.kind !== SyntaxKind.Identifier);
+                    return <Identifier>node;
             }
-            Debug.assert(node.kind === SyntaxKind.Identifier);
-            return <Identifier>node;
         }
 
         function checkExternalImportOrExportDeclaration(node: ImportDeclaration | ImportEqualsDeclaration | ExportDeclaration): boolean {
@@ -17663,7 +17675,7 @@ namespace ts {
             return getLeftSideOfImportEqualsOrExportAssignment(node) !== undefined;
         }
 
-        function getSymbolOfEntityNameOrPropertyAccessExpression(entityName: EntityName | PropertyAccessExpression): Symbol {
+        function getSymbolOfEntityNameOrPropertyAccessExpression(entityName: EntityName | PropertyAccessExpression): Symbol | undefined {
             if (isDeclarationName(entityName)) {
                 return getSymbolOfNode(entityName.parent);
             }
@@ -17682,8 +17694,8 @@ namespace ts {
                 }
             }
 
-            if (entityName.parent.kind === SyntaxKind.ExportAssignment) {
-                return resolveEntityName(<Identifier>entityName,
+            if (entityName.parent.kind === SyntaxKind.ExportAssignment && isEntityNameExpression(<Identifier | PropertyAccessExpression>entityName)) {
+                return resolveEntityName(<EntityNameExpression>entityName,
                     /*all meanings*/ SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace | SymbolFlags.Alias);
             }
 
@@ -17697,7 +17709,7 @@ namespace ts {
             }
 
             if (isRightSideOfQualifiedNameOrPropertyAccess(entityName)) {
-                entityName = <QualifiedName | PropertyAccessExpression>entityName.parent;
+                entityName = <QualifiedName | PropertyAccessEntityNameExpression>entityName.parent;
             }
 
             if (isHeritageClauseElementIdentifier(<EntityName>entityName)) {
@@ -18410,7 +18422,7 @@ namespace ts {
             };
 
             // defined here to avoid outer scope pollution
-            function getTypeReferenceDirectivesForEntityName(node: EntityName | PropertyAccessExpression): string[] {
+            function getTypeReferenceDirectivesForEntityName(node: EntityNameOrEntityNameExpression): string[] {
                 // program does not have any files with type reference directives - bail out
                 if (!fileToDirective) {
                     return undefined;
diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index d93a8a0aed..220244c55a 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -441,7 +441,7 @@ namespace ts {
                 }
             }
 
-            function emitEntityName(entityName: EntityName | PropertyAccessExpression) {
+            function emitEntityName(entityName: EntityNameOrEntityNameExpression) {
                 const visibilityResult = resolver.isEntityNameVisible(entityName,
                     // Aliases can be written asynchronously so use correct enclosing declaration
                     entityName.parent.kind === SyntaxKind.ImportEqualsDeclaration ? entityName.parent : enclosingDeclaration);
@@ -454,7 +454,7 @@ namespace ts {
             function emitExpressionWithTypeArguments(node: ExpressionWithTypeArguments) {
                 if (isSupportedExpressionWithTypeArguments(node)) {
                     Debug.assert(node.expression.kind === SyntaxKind.Identifier || node.expression.kind === SyntaxKind.PropertyAccessExpression);
-                    emitEntityName(<Identifier | PropertyAccessExpression>node.expression);
+                    emitEntityName(node.expression);
                     if (node.typeArguments) {
                         write("<");
                         emitCommaList(node.typeArguments, emitType);
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 072209aa49..983ed25c84 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -982,13 +982,19 @@ namespace ts {
         multiLine?: boolean;
     }
 
+    export type EntityNameExpression = Identifier | PropertyAccessEntityNameExpression;
+    export type EntityNameOrEntityNameExpression = EntityName | EntityNameExpression;
+
     // @kind(SyntaxKind.PropertyAccessExpression)
     export interface PropertyAccessExpression extends MemberExpression, Declaration {
         expression: LeftHandSideExpression;
         name: Identifier;
     }
-
-    export type IdentifierOrPropertyAccess = Identifier | PropertyAccessExpression;
+    /** Brand for a PropertyAccessExpression which, like a QualifiedName, consists of a sequence of identifiers separated by dots. */
+    export interface PropertyAccessEntityNameExpression extends PropertyAccessExpression {
+        _propertyAccessExpressionLikeQualifiedNameBrand?: any;
+        expression: EntityNameExpression;
+    }
 
     // @kind(SyntaxKind.ElementAccessExpression)
     export interface ElementAccessExpression extends MemberExpression {
@@ -1008,6 +1014,10 @@ namespace ts {
         expression: LeftHandSideExpression;
         typeArguments?: NodeArray<TypeNode>;
     }
+    export interface SupportedExpressionWithTypeArguments extends ExpressionWithTypeArguments {
+        _supportedExpressionWithTypeArgumentsBrand?: any;
+        expression: EntityNameExpression;
+    }
 
     // @kind(SyntaxKind.NewExpression)
     export interface NewExpression extends CallExpression, PrimaryExpression { }
@@ -2021,7 +2031,7 @@ namespace ts {
         writeTypeOfExpression(expr: Expression, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
         writeBaseConstructorTypeOfClass(node: ClassLikeDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
         isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessibilityResult;
-        isEntityNameVisible(entityName: EntityName | Expression, enclosingDeclaration: Node): SymbolVisibilityResult;
+        isEntityNameVisible(entityName: EntityNameOrEntityNameExpression, enclosingDeclaration: Node): SymbolVisibilityResult;
         // Returns the constant value this property access resolves to, or 'undefined' for a non-constant
         getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number;
         getReferencedValueDeclaration(reference: Identifier): Declaration;
@@ -2030,7 +2040,7 @@ namespace ts {
         moduleExportsSomeValue(moduleReferenceExpression: Expression): boolean;
         isArgumentsLocalBinding(node: Identifier): boolean;
         getExternalModuleFileFromDeclaration(declaration: ImportEqualsDeclaration | ImportDeclaration | ExportDeclaration | ModuleDeclaration): SourceFile;
-        getTypeReferenceDirectivesForEntityName(name: EntityName | PropertyAccessExpression): string[];
+        getTypeReferenceDirectivesForEntityName(name: EntityNameOrEntityNameExpression): string[];
         getTypeReferenceDirectivesForSymbol(symbol: Symbol, meaning?: SymbolFlags): string[];
     }
 
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index 4ae0005e9c..acace78396 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -1033,14 +1033,14 @@ namespace ts {
             && (<PropertyAccessExpression | ElementAccessExpression>node).expression.kind === SyntaxKind.SuperKeyword;
     }
 
-
-    export function getEntityNameFromTypeNode(node: TypeNode): EntityName | Expression {
+    export function getEntityNameFromTypeNode(node: TypeNode): EntityNameOrEntityNameExpression {
         if (node) {
             switch (node.kind) {
                 case SyntaxKind.TypeReference:
                     return (<TypeReferenceNode>node).typeName;
                 case SyntaxKind.ExpressionWithTypeArguments:
-                    return (<ExpressionWithTypeArguments>node).expression;
+                    Debug.assert(isSupportedExpressionWithTypeArguments(<ExpressionWithTypeArguments>node));
+                    return (<SupportedExpressionWithTypeArguments>node).expression;
                 case SyntaxKind.Identifier:
                 case SyntaxKind.QualifiedName:
                     return (<EntityName><Node>node);
@@ -2680,24 +2680,28 @@ namespace ts {
             isClassLike(node.parent.parent);
     }
 
-    // Returns false if this heritage clause element's expression contains something unsupported
-    // (i.e. not a name or dotted name).
-    export function isSupportedExpressionWithTypeArguments(node: ExpressionWithTypeArguments): boolean {
-        return isSupportedExpressionWithTypeArgumentsRest(node.expression);
+    export function isSupportedExpressionWithTypeArguments(node: ExpressionWithTypeArguments): node is SupportedExpressionWithTypeArguments {
+        return isEntityNameExpression(node.expression);
     }
 
-    function isSupportedExpressionWithTypeArgumentsRest(node: Expression): boolean {
-        if (node.kind === SyntaxKind.Identifier) {
-            return true;
-        }
-        else if (isPropertyAccessExpression(node)) {
-            return isSupportedExpressionWithTypeArgumentsRest(node.expression);
-        }
-        else {
-            return false;
+    export function isEntityNameExpression(node: Expression): node is EntityNameExpression {
+        for (; ; ) {
+            switch (node.kind) {
+                case SyntaxKind.Identifier:
+                    return true;
+                case SyntaxKind.PropertyAccessExpression:
+                    node = (<PropertyAccessExpression>node).expression;
+                    break;
+                default:
+                    return false;
+            }
         }
     }
 
+    export function isPropertyAccessAnEntityNameExpression(node: PropertyAccessExpression): node is PropertyAccessEntityNameExpression {
+        return isEntityNameExpression(node.expression);
+    }
+
     export function isRightSideOfQualifiedNameOrPropertyAccess(node: Node) {
         return (node.parent.kind === SyntaxKind.QualifiedName && (<QualifiedName>node.parent).right === node) ||
             (node.parent.kind === SyntaxKind.PropertyAccessExpression && (<PropertyAccessExpression>node.parent).name === node);
diff --git a/tests/baselines/reference/exportDefaultProperty.js b/tests/baselines/reference/exportDefaultProperty.js
new file mode 100644
index 0000000000..efb4ee8bff
--- /dev/null
+++ b/tests/baselines/reference/exportDefaultProperty.js
@@ -0,0 +1,8 @@
+//// [exportDefaultProperty.ts]
+export default "".length
+
+
+//// [exportDefaultProperty.js]
+"use strict";
+exports.__esModule = true;
+exports["default"] = "".length;
diff --git a/tests/baselines/reference/exportDefaultProperty.symbols b/tests/baselines/reference/exportDefaultProperty.symbols
new file mode 100644
index 0000000000..2bc00e48fe
--- /dev/null
+++ b/tests/baselines/reference/exportDefaultProperty.symbols
@@ -0,0 +1,5 @@
+=== tests/cases/compiler/exportDefaultProperty.ts ===
+export default "".length
+>"".length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
+
diff --git a/tests/baselines/reference/exportDefaultProperty.types b/tests/baselines/reference/exportDefaultProperty.types
new file mode 100644
index 0000000000..82e6277b29
--- /dev/null
+++ b/tests/baselines/reference/exportDefaultProperty.types
@@ -0,0 +1,6 @@
+=== tests/cases/compiler/exportDefaultProperty.ts ===
+export default "".length
+>"".length : number
+>"" : string
+>length : number
+
diff --git a/tests/cases/compiler/exportDefaultProperty.ts b/tests/cases/compiler/exportDefaultProperty.ts
new file mode 100644
index 0000000000..4df2eb692a
--- /dev/null
+++ b/tests/cases/compiler/exportDefaultProperty.ts
@@ -0,0 +1 @@
+export default "".length

From f9fd4967af519473bdf32395df677b2bc966c64e Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Fri, 29 Jul 2016 08:06:04 -0700
Subject: [PATCH 02/29] Allow `export =` and `export default` to alias any
 EntityNameExpression, not just identifiers.

---
 src/compiler/binder.ts                        | 13 ++-
 src/compiler/checker.ts                       |  4 +-
 src/compiler/core.ts                          | 15 ++-
 src/compiler/utilities.ts                     | 10 +-
 .../reference/exportDefaultProperty.js        | 76 +++++++++++++-
 .../reference/exportDefaultProperty.symbols   | 93 ++++++++++++++++-
 .../reference/exportDefaultProperty.types     | 99 ++++++++++++++++++-
 .../reference/exportEqualsProperty.js         | 72 ++++++++++++++
 .../reference/exportEqualsProperty.symbols    | 87 ++++++++++++++++
 .../reference/exportEqualsProperty.types      | 92 +++++++++++++++++
 tests/cases/compiler/exportDefaultProperty.ts | 40 +++++++-
 tests/cases/compiler/exportEqualsProperty.ts  | 38 +++++++
 12 files changed, 613 insertions(+), 26 deletions(-)
 create mode 100644 tests/baselines/reference/exportEqualsProperty.js
 create mode 100644 tests/baselines/reference/exportEqualsProperty.symbols
 create mode 100644 tests/baselines/reference/exportEqualsProperty.types
 create mode 100644 tests/cases/compiler/exportEqualsProperty.ts

diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts
index 8d8666a67a..502cb39e8f 100644
--- a/src/compiler/binder.ts
+++ b/src/compiler/binder.ts
@@ -1887,18 +1887,17 @@ namespace ts {
         }
 
         function bindExportAssignment(node: ExportAssignment | BinaryExpression) {
-            const boundExpression = node.kind === SyntaxKind.ExportAssignment ? (<ExportAssignment>node).expression : (<BinaryExpression>node).right;
             if (!container.symbol || !container.symbol.exports) {
                 // Export assignment in some sort of block construct
                 bindAnonymousDeclaration(node, SymbolFlags.Alias, getDeclarationName(node));
             }
-            else if (boundExpression.kind === SyntaxKind.Identifier && node.kind === SyntaxKind.ExportAssignment) {
-                // An export default clause with an identifier exports all meanings of that identifier
-                declareSymbol(container.symbol.exports, container.symbol, node, SymbolFlags.Alias, SymbolFlags.PropertyExcludes | SymbolFlags.AliasExcludes);
-            }
             else {
-                // An export default clause with an expression exports a value
-                declareSymbol(container.symbol.exports, container.symbol, node, SymbolFlags.Property, SymbolFlags.PropertyExcludes | SymbolFlags.AliasExcludes);
+                const flags = node.kind === SyntaxKind.ExportAssignment && exportAssignmentIsAlias(<ExportAssignment>node)
+                    // An export default clause with an EntityNameExpression exports all meanings of that identifier
+                    ? SymbolFlags.Alias
+                    // An export default clause with any other expression exports a value
+                    : SymbolFlags.Property;
+                declareSymbol(container.symbol.exports, container.symbol, node, flags, SymbolFlags.PropertyExcludes | SymbolFlags.AliasExcludes);
             }
         }
 
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 6d670c7054..21d74bb24b 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -1044,7 +1044,7 @@ namespace ts {
         }
 
         function getDeclarationOfAliasSymbol(symbol: Symbol): Declaration {
-            return forEach(symbol.declarations, d => isAliasSymbolDeclaration(d) ? d : undefined);
+            return find(symbol.declarations, d => isAliasSymbolDeclaration(d) ? d : undefined);
         }
 
         function getTargetOfImportEqualsDeclaration(node: ImportEqualsDeclaration): Symbol {
@@ -1175,7 +1175,7 @@ namespace ts {
         }
 
         function getTargetOfExportAssignment(node: ExportAssignment): Symbol {
-            return resolveEntityName(<Identifier>node.expression, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace);
+            return resolveEntityName(<EntityNameExpression>node.expression, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace);
         }
 
         function getTargetOfAliasDeclaration(node: Declaration): Symbol {
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index 709a331e02..cd332b6bef 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -81,7 +81,7 @@ namespace ts {
      * returns a truthy value, then returns that value.
      * If no such value is found, the callback is applied to each element of array and undefined is returned.
      */
-    export function forEach<T, U>(array: T[], callback: (element: T, index: number) => U): U {
+    export function forEach<T, U>(array: T[] | undefined, callback: (element: T, index: number) => U | undefined): U | undefined {
         if (array) {
             for (let i = 0, len = array.length; i < len; i++) {
                 const result = callback(array[i], i);
@@ -93,6 +93,17 @@ namespace ts {
         return undefined;
     }
 
+    /** Like `forEach`, but assumes existence of array and fails if no truthy value is found. */
+    export function find<T, U>(array: T[], callback: (element: T, index: number) => U | undefined): U {
+        for (let i = 0, len = array.length; i < len; i++) {
+            const result = callback(array[i], i);
+            if (result) {
+                return result;
+            }
+        }
+        Debug.fail();
+    }
+
     export function contains<T>(array: T[], value: T): boolean {
         if (array) {
             for (const v of array) {
@@ -941,7 +952,7 @@ namespace ts {
      *  [^./]                   # matches everything up to the first . character (excluding directory seperators)
      *  (\\.(?!min\\.js$))?     # matches . characters but not if they are part of the .min.js file extension
      */
-    const singleAsteriskRegexFragmentFiles = "([^./]|(\\.(?!min\\.js$))?)*";
+    const singleAsteriskRegexFragmentFiles = "([^./]|(\\.(?!min\\.js$))?)*";
     const singleAsteriskRegexFragmentOther = "[^/]*";
 
     export function getRegularExpressionForWildcard(specs: string[], basePath: string, usage: "files" | "directories" | "exclude") {
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index acace78396..466cf8c2b7 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -1693,8 +1693,8 @@ namespace ts {
     // import * as <symbol> from ...
     // import { x as <symbol> } from ...
     // export { x as <symbol> } from ...
-    // export = ...
-    // export default ...
+    // export = <EntityNameExpression>
+    // export default <EntityNameExpression>
     export function isAliasSymbolDeclaration(node: Node): boolean {
         return node.kind === SyntaxKind.ImportEqualsDeclaration ||
             node.kind === SyntaxKind.NamespaceExportDeclaration ||
@@ -1702,7 +1702,11 @@ namespace ts {
             node.kind === SyntaxKind.NamespaceImport ||
             node.kind === SyntaxKind.ImportSpecifier ||
             node.kind === SyntaxKind.ExportSpecifier ||
-            node.kind === SyntaxKind.ExportAssignment && (<ExportAssignment>node).expression.kind === SyntaxKind.Identifier;
+            node.kind === SyntaxKind.ExportAssignment && exportAssignmentIsAlias(<ExportAssignment>node);
+    }
+
+    export function exportAssignmentIsAlias(node: ExportAssignment): boolean {
+        return isEntityNameExpression(node.expression);
     }
 
     export function getClassExtendsHeritageClauseElement(node: ClassLikeDeclaration | InterfaceDeclaration) {
diff --git a/tests/baselines/reference/exportDefaultProperty.js b/tests/baselines/reference/exportDefaultProperty.js
index efb4ee8bff..10ba6d6419 100644
--- a/tests/baselines/reference/exportDefaultProperty.js
+++ b/tests/baselines/reference/exportDefaultProperty.js
@@ -1,8 +1,76 @@
-//// [exportDefaultProperty.ts]
-export default "".length
+//// [tests/cases/compiler/exportDefaultProperty.ts] ////
+
+//// [declarations.d.ts]
+// This test is just like exportEqualsProperty, but with `export default`.
+
+declare namespace foo.bar {
+    export type X = number;
+    export const X: number;
+}
+
+declare module "foobar" {
+    export default foo.bar;
+}
+
+declare module "foobarx" {
+    export default foo.bar.X;
+}
+
+//// [a.ts]
+namespace A {
+    export class B { constructor(b: number) {} }
+    export namespace B { export const b: number = 0; }
+}
+export default A.B;
+
+//// [b.ts]
+export default "foo".length;
+
+//// [index.ts]
+/// <reference path="declarations.d.ts" />
+import fooBar from "foobar";
+import X = fooBar.X;
+import X2 from "foobarx";
+const x: X = X;
+const x2: X2 = X2;
+
+import B from "./a";
+const b: B = new B(B.b);
+
+import fooLength from "./b";
+fooLength + 1;
 
 
-//// [exportDefaultProperty.js]
+//// [a.js]
+"use strict";
+var A;
+(function (A) {
+    var B = (function () {
+        function B(b) {
+        }
+        return B;
+    }());
+    A.B = B;
+    var B;
+    (function (B) {
+        B.b = 0;
+    })(B = A.B || (A.B = {}));
+})(A || (A = {}));
+exports.__esModule = true;
+exports["default"] = A.B;
+//// [b.js]
 "use strict";
 exports.__esModule = true;
-exports["default"] = "".length;
+exports["default"] = "foo".length;
+//// [index.js]
+"use strict";
+/// <reference path="declarations.d.ts" />
+var foobar_1 = require("foobar");
+var X = foobar_1["default"].X;
+var foobarx_1 = require("foobarx");
+var x = X;
+var x2 = foobarx_1["default"];
+var a_1 = require("./a");
+var b = new a_1["default"](a_1["default"].b);
+var b_1 = require("./b");
+b_1["default"] + 1;
diff --git a/tests/baselines/reference/exportDefaultProperty.symbols b/tests/baselines/reference/exportDefaultProperty.symbols
index 2bc00e48fe..f9edcd154c 100644
--- a/tests/baselines/reference/exportDefaultProperty.symbols
+++ b/tests/baselines/reference/exportDefaultProperty.symbols
@@ -1,5 +1,92 @@
-=== tests/cases/compiler/exportDefaultProperty.ts ===
-export default "".length
->"".length : Symbol(String.length, Decl(lib.d.ts, --, --))
+=== tests/cases/compiler/index.ts ===
+/// <reference path="declarations.d.ts" />
+import fooBar from "foobar";
+>fooBar : Symbol(fooBar, Decl(index.ts, 1, 6))
+
+import X = fooBar.X;
+>X : Symbol(X, Decl(index.ts, 1, 28))
+>fooBar : Symbol(fooBar, Decl(index.ts, 1, 6))
+>X : Symbol(fooBar.X, Decl(declarations.d.ts, 2, 27), Decl(declarations.d.ts, 4, 16))
+
+import X2 from "foobarx";
+>X2 : Symbol(X2, Decl(index.ts, 3, 6))
+
+const x: X = X;
+>x : Symbol(x, Decl(index.ts, 4, 5))
+>X : Symbol(X, Decl(index.ts, 1, 28))
+>X : Symbol(X, Decl(index.ts, 1, 28))
+
+const x2: X2 = X2;
+>x2 : Symbol(x2, Decl(index.ts, 5, 5))
+>X2 : Symbol(X2, Decl(index.ts, 3, 6))
+>X2 : Symbol(X2, Decl(index.ts, 3, 6))
+
+import B from "./a";
+>B : Symbol(B, Decl(index.ts, 7, 6))
+
+const b: B = new B(B.b);
+>b : Symbol(b, Decl(index.ts, 8, 5))
+>B : Symbol(B, Decl(index.ts, 7, 6))
+>B : Symbol(B, Decl(index.ts, 7, 6))
+>B.b : Symbol(B.b, Decl(a.ts, 2, 37))
+>B : Symbol(B, Decl(index.ts, 7, 6))
+>b : Symbol(B.b, Decl(a.ts, 2, 37))
+
+import fooLength from "./b";
+>fooLength : Symbol(fooLength, Decl(index.ts, 10, 6))
+
+fooLength + 1;
+>fooLength : Symbol(fooLength, Decl(index.ts, 10, 6))
+
+=== tests/cases/compiler/declarations.d.ts ===
+// This test is just like exportEqualsProperty, but with `export default`.
+
+declare namespace foo.bar {
+>foo : Symbol(foo, Decl(declarations.d.ts, 0, 0))
+>bar : Symbol(bar, Decl(declarations.d.ts, 2, 22))
+
+    export type X = number;
+>X : Symbol(X, Decl(declarations.d.ts, 2, 27), Decl(declarations.d.ts, 4, 16))
+
+    export const X: number;
+>X : Symbol(X, Decl(declarations.d.ts, 2, 27), Decl(declarations.d.ts, 4, 16))
+}
+
+declare module "foobar" {
+    export default foo.bar;
+>foo.bar : Symbol(default, Decl(declarations.d.ts, 2, 22))
+>foo : Symbol(foo, Decl(declarations.d.ts, 0, 0))
+>bar : Symbol(default, Decl(declarations.d.ts, 2, 22))
+}
+
+declare module "foobarx" {
+    export default foo.bar.X;
+>foo.bar.X : Symbol(default, Decl(declarations.d.ts, 2, 27), Decl(declarations.d.ts, 4, 16))
+>foo.bar : Symbol(foo.bar, Decl(declarations.d.ts, 2, 22))
+>foo : Symbol(foo, Decl(declarations.d.ts, 0, 0))
+>bar : Symbol(foo.bar, Decl(declarations.d.ts, 2, 22))
+>X : Symbol(default, Decl(declarations.d.ts, 2, 27), Decl(declarations.d.ts, 4, 16))
+}
+
+=== tests/cases/compiler/a.ts ===
+namespace A {
+>A : Symbol(A, Decl(a.ts, 0, 0))
+
+    export class B { constructor(b: number) {} }
+>B : Symbol(B, Decl(a.ts, 0, 13), Decl(a.ts, 1, 48))
+>b : Symbol(b, Decl(a.ts, 1, 33))
+
+    export namespace B { export const b: number = 0; }
+>B : Symbol(B, Decl(a.ts, 0, 13), Decl(a.ts, 1, 48))
+>b : Symbol(b, Decl(a.ts, 2, 37))
+}
+export default A.B;
+>A.B : Symbol(default, Decl(a.ts, 0, 13), Decl(a.ts, 1, 48))
+>A : Symbol(A, Decl(a.ts, 0, 0))
+>B : Symbol(default, Decl(a.ts, 0, 13), Decl(a.ts, 1, 48))
+
+=== tests/cases/compiler/b.ts ===
+export default "foo".length;
+>"foo".length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/exportDefaultProperty.types b/tests/baselines/reference/exportDefaultProperty.types
index 82e6277b29..47cfabfbc1 100644
--- a/tests/baselines/reference/exportDefaultProperty.types
+++ b/tests/baselines/reference/exportDefaultProperty.types
@@ -1,6 +1,97 @@
-=== tests/cases/compiler/exportDefaultProperty.ts ===
-export default "".length
->"".length : number
->"" : string
+=== tests/cases/compiler/index.ts ===
+/// <reference path="declarations.d.ts" />
+import fooBar from "foobar";
+>fooBar : typeof fooBar
+
+import X = fooBar.X;
+>X : number
+>fooBar : typeof fooBar
+>X : number
+
+import X2 from "foobarx";
+>X2 : number
+
+const x: X = X;
+>x : number
+>X : number
+>X : number
+
+const x2: X2 = X2;
+>x2 : number
+>X2 : number
+>X2 : number
+
+import B from "./a";
+>B : typeof B
+
+const b: B = new B(B.b);
+>b : B
+>B : B
+>new B(B.b) : B
+>B : typeof B
+>B.b : number
+>B : typeof B
+>b : number
+
+import fooLength from "./b";
+>fooLength : number
+
+fooLength + 1;
+>fooLength + 1 : number
+>fooLength : number
+>1 : number
+
+=== tests/cases/compiler/declarations.d.ts ===
+// This test is just like exportEqualsProperty, but with `export default`.
+
+declare namespace foo.bar {
+>foo : typeof foo
+>bar : typeof bar
+
+    export type X = number;
+>X : number
+
+    export const X: number;
+>X : number
+}
+
+declare module "foobar" {
+    export default foo.bar;
+>foo.bar : typeof default
+>foo : typeof foo
+>bar : typeof default
+}
+
+declare module "foobarx" {
+    export default foo.bar.X;
+>foo.bar.X : number
+>foo.bar : typeof foo.bar
+>foo : typeof foo
+>bar : typeof foo.bar
+>X : number
+}
+
+=== tests/cases/compiler/a.ts ===
+namespace A {
+>A : typeof A
+
+    export class B { constructor(b: number) {} }
+>B : B
+>b : number
+
+    export namespace B { export const b: number = 0; }
+>B : typeof B
+>b : number
+>0 : number
+}
+export default A.B;
+>A.B : typeof default
+>A : typeof A
+>B : typeof default
+
+=== tests/cases/compiler/b.ts ===
+export default "foo".length;
+>"foo".length : number
+>"foo" : string
 >length : number
 
diff --git a/tests/baselines/reference/exportEqualsProperty.js b/tests/baselines/reference/exportEqualsProperty.js
new file mode 100644
index 0000000000..2fd8a8c851
--- /dev/null
+++ b/tests/baselines/reference/exportEqualsProperty.js
@@ -0,0 +1,72 @@
+//// [tests/cases/compiler/exportEqualsProperty.ts] ////
+
+//// [declarations.d.ts]
+// This test is just like exportDefaultProperty, but with `export =`.
+
+declare namespace foo.bar {
+    export type X = number;
+    export const X: number;
+}
+
+declare module "foobar" {
+    export = foo.bar;
+}
+
+declare module "foobarx" {
+    export = foo.bar.X;
+}
+
+//// [a.ts]
+namespace A {
+    export class B { constructor(b: number) {} }
+    export namespace B { export const b: number = 0; }
+}
+export = A.B;
+
+//// [b.ts]
+export = "foo".length;
+
+//// [index.ts]
+/// <reference path="declarations.d.ts" />
+import { X } from "foobar";
+import X2 = require("foobarx");
+const x: X = X;
+const x2: X2 = X2;
+
+import B = require("./a");
+const b: B = new B(B.b);
+
+import fooLength = require("./b");
+fooLength + 1;
+
+
+//// [a.js]
+"use strict";
+var A;
+(function (A) {
+    var B = (function () {
+        function B(b) {
+        }
+        return B;
+    }());
+    A.B = B;
+    var B;
+    (function (B) {
+        B.b = 0;
+    })(B = A.B || (A.B = {}));
+})(A || (A = {}));
+module.exports = A.B;
+//// [b.js]
+"use strict";
+module.exports = "foo".length;
+//// [index.js]
+"use strict";
+/// <reference path="declarations.d.ts" />
+var foobar_1 = require("foobar");
+var X2 = require("foobarx");
+var x = foobar_1.X;
+var x2 = X2;
+var B = require("./a");
+var b = new B(B.b);
+var fooLength = require("./b");
+fooLength + 1;
diff --git a/tests/baselines/reference/exportEqualsProperty.symbols b/tests/baselines/reference/exportEqualsProperty.symbols
new file mode 100644
index 0000000000..43c9ed3251
--- /dev/null
+++ b/tests/baselines/reference/exportEqualsProperty.symbols
@@ -0,0 +1,87 @@
+=== tests/cases/compiler/index.ts ===
+/// <reference path="declarations.d.ts" />
+import { X } from "foobar";
+>X : Symbol(X, Decl(index.ts, 1, 8))
+
+import X2 = require("foobarx");
+>X2 : Symbol(X2, Decl(index.ts, 1, 27))
+
+const x: X = X;
+>x : Symbol(x, Decl(index.ts, 3, 5))
+>X : Symbol(X, Decl(index.ts, 1, 8))
+>X : Symbol(X, Decl(index.ts, 1, 8))
+
+const x2: X2 = X2;
+>x2 : Symbol(x2, Decl(index.ts, 4, 5))
+>X2 : Symbol(X2, Decl(index.ts, 1, 27))
+>X2 : Symbol(X2, Decl(index.ts, 1, 27))
+
+import B = require("./a");
+>B : Symbol(B, Decl(index.ts, 4, 18))
+
+const b: B = new B(B.b);
+>b : Symbol(b, Decl(index.ts, 7, 5))
+>B : Symbol(B, Decl(index.ts, 4, 18))
+>B : Symbol(B, Decl(index.ts, 4, 18))
+>B.b : Symbol(B.b, Decl(a.ts, 2, 37))
+>B : Symbol(B, Decl(index.ts, 4, 18))
+>b : Symbol(B.b, Decl(a.ts, 2, 37))
+
+import fooLength = require("./b");
+>fooLength : Symbol(fooLength, Decl(index.ts, 7, 24))
+
+fooLength + 1;
+>fooLength : Symbol(fooLength, Decl(index.ts, 7, 24))
+
+=== tests/cases/compiler/declarations.d.ts ===
+// This test is just like exportDefaultProperty, but with `export =`.
+
+declare namespace foo.bar {
+>foo : Symbol(foo, Decl(declarations.d.ts, 0, 0))
+>bar : Symbol(bar, Decl(declarations.d.ts, 2, 22))
+
+    export type X = number;
+>X : Symbol(X, Decl(declarations.d.ts, 2, 27), Decl(declarations.d.ts, 4, 16))
+
+    export const X: number;
+>X : Symbol(X, Decl(declarations.d.ts, 2, 27), Decl(declarations.d.ts, 4, 16))
+}
+
+declare module "foobar" {
+    export = foo.bar;
+>foo.bar : Symbol(foo.bar, Decl(declarations.d.ts, 2, 22))
+>foo : Symbol(foo, Decl(declarations.d.ts, 0, 0))
+>bar : Symbol(foo.bar, Decl(declarations.d.ts, 2, 22))
+}
+
+declare module "foobarx" {
+    export = foo.bar.X;
+>foo.bar.X : Symbol(foo.bar.X, Decl(declarations.d.ts, 2, 27), Decl(declarations.d.ts, 4, 16))
+>foo.bar : Symbol(foo.bar, Decl(declarations.d.ts, 2, 22))
+>foo : Symbol(foo, Decl(declarations.d.ts, 0, 0))
+>bar : Symbol(foo.bar, Decl(declarations.d.ts, 2, 22))
+>X : Symbol(foo.bar.X, Decl(declarations.d.ts, 2, 27), Decl(declarations.d.ts, 4, 16))
+}
+
+=== tests/cases/compiler/a.ts ===
+namespace A {
+>A : Symbol(A, Decl(a.ts, 0, 0))
+
+    export class B { constructor(b: number) {} }
+>B : Symbol(B, Decl(a.ts, 0, 13), Decl(a.ts, 1, 48))
+>b : Symbol(b, Decl(a.ts, 1, 33))
+
+    export namespace B { export const b: number = 0; }
+>B : Symbol(B, Decl(a.ts, 0, 13), Decl(a.ts, 1, 48))
+>b : Symbol(b, Decl(a.ts, 2, 37))
+}
+export = A.B;
+>A.B : Symbol(A.B, Decl(a.ts, 0, 13), Decl(a.ts, 1, 48))
+>A : Symbol(A, Decl(a.ts, 0, 0))
+>B : Symbol(A.B, Decl(a.ts, 0, 13), Decl(a.ts, 1, 48))
+
+=== tests/cases/compiler/b.ts ===
+export = "foo".length;
+>"foo".length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
+
diff --git a/tests/baselines/reference/exportEqualsProperty.types b/tests/baselines/reference/exportEqualsProperty.types
new file mode 100644
index 0000000000..a92af53b12
--- /dev/null
+++ b/tests/baselines/reference/exportEqualsProperty.types
@@ -0,0 +1,92 @@
+=== tests/cases/compiler/index.ts ===
+/// <reference path="declarations.d.ts" />
+import { X } from "foobar";
+>X : number
+
+import X2 = require("foobarx");
+>X2 : number
+
+const x: X = X;
+>x : number
+>X : number
+>X : number
+
+const x2: X2 = X2;
+>x2 : number
+>X2 : number
+>X2 : number
+
+import B = require("./a");
+>B : typeof B
+
+const b: B = new B(B.b);
+>b : B
+>B : B
+>new B(B.b) : B
+>B : typeof B
+>B.b : number
+>B : typeof B
+>b : number
+
+import fooLength = require("./b");
+>fooLength : number
+
+fooLength + 1;
+>fooLength + 1 : number
+>fooLength : number
+>1 : number
+
+=== tests/cases/compiler/declarations.d.ts ===
+// This test is just like exportDefaultProperty, but with `export =`.
+
+declare namespace foo.bar {
+>foo : typeof foo
+>bar : typeof bar
+
+    export type X = number;
+>X : number
+
+    export const X: number;
+>X : number
+}
+
+declare module "foobar" {
+    export = foo.bar;
+>foo.bar : typeof foo.bar
+>foo : typeof foo
+>bar : typeof foo.bar
+}
+
+declare module "foobarx" {
+    export = foo.bar.X;
+>foo.bar.X : number
+>foo.bar : typeof foo.bar
+>foo : typeof foo
+>bar : typeof foo.bar
+>X : number
+}
+
+=== tests/cases/compiler/a.ts ===
+namespace A {
+>A : typeof A
+
+    export class B { constructor(b: number) {} }
+>B : B
+>b : number
+
+    export namespace B { export const b: number = 0; }
+>B : typeof B
+>b : number
+>0 : number
+}
+export = A.B;
+>A.B : typeof A.B
+>A : typeof A
+>B : typeof A.B
+
+=== tests/cases/compiler/b.ts ===
+export = "foo".length;
+>"foo".length : number
+>"foo" : string
+>length : number
+
diff --git a/tests/cases/compiler/exportDefaultProperty.ts b/tests/cases/compiler/exportDefaultProperty.ts
index 4df2eb692a..4a4b413902 100644
--- a/tests/cases/compiler/exportDefaultProperty.ts
+++ b/tests/cases/compiler/exportDefaultProperty.ts
@@ -1 +1,39 @@
-export default "".length
+// This test is just like exportEqualsProperty, but with `export default`.
+
+// @Filename: declarations.d.ts
+declare namespace foo.bar {
+    export type X = number;
+    export const X: number;
+}
+
+declare module "foobar" {
+    export default foo.bar;
+}
+
+declare module "foobarx" {
+    export default foo.bar.X;
+}
+
+// @Filename: a.ts
+namespace A {
+    export class B { constructor(b: number) {} }
+    export namespace B { export const b: number = 0; }
+}
+export default A.B;
+
+// @Filename: b.ts
+export default "foo".length;
+
+// @Filename: index.ts
+/// <reference path="declarations.d.ts" />
+import fooBar from "foobar";
+import X = fooBar.X;
+import X2 from "foobarx";
+const x: X = X;
+const x2: X2 = X2;
+
+import B from "./a";
+const b: B = new B(B.b);
+
+import fooLength from "./b";
+fooLength + 1;
diff --git a/tests/cases/compiler/exportEqualsProperty.ts b/tests/cases/compiler/exportEqualsProperty.ts
new file mode 100644
index 0000000000..0d14815a5b
--- /dev/null
+++ b/tests/cases/compiler/exportEqualsProperty.ts
@@ -0,0 +1,38 @@
+// This test is just like exportDefaultProperty, but with `export =`.
+
+// @Filename: declarations.d.ts
+declare namespace foo.bar {
+    export type X = number;
+    export const X: number;
+}
+
+declare module "foobar" {
+    export = foo.bar;
+}
+
+declare module "foobarx" {
+    export = foo.bar.X;
+}
+
+// @Filename: a.ts
+namespace A {
+    export class B { constructor(b: number) {} }
+    export namespace B { export const b: number = 0; }
+}
+export = A.B;
+
+// @Filename: b.ts
+export = "foo".length;
+
+// @Filename: index.ts
+/// <reference path="declarations.d.ts" />
+import { X } from "foobar";
+import X2 = require("foobarx");
+const x: X = X;
+const x2: X2 = X2;
+
+import B = require("./a");
+const b: B = new B(B.b);
+
+import fooLength = require("./b");
+fooLength + 1;

From c50ccbf9616bbb06e7f73203a7e0134ab852f0d6 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Fri, 29 Jul 2016 12:31:02 -0700
Subject: [PATCH 03/29] Simplify some code

---
 src/compiler/checker.ts | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 21d74bb24b..ca66534603 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -17699,13 +17699,11 @@ namespace ts {
                     /*all meanings*/ SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace | SymbolFlags.Alias);
             }
 
-            if (entityName.kind !== SyntaxKind.PropertyAccessExpression) {
-                if (isInRightSideOfImportOrExportAssignment(<EntityName>entityName)) {
-                    // Since we already checked for ExportAssignment, this really could only be an Import
-                    const importEqualsDeclaration = <ImportEqualsDeclaration>getAncestor(entityName, SyntaxKind.ImportEqualsDeclaration);
-                    Debug.assert(importEqualsDeclaration !== undefined);
-                    return getSymbolOfPartOfRightHandSideOfImportEquals(<EntityName>entityName, importEqualsDeclaration, /*dontResolveAlias*/ true);
-                }
+            if (entityName.kind !== SyntaxKind.PropertyAccessExpression && isInRightSideOfImportOrExportAssignment(<EntityName>entityName)) {
+                // Since we already checked for ExportAssignment, this really could only be an Import
+                const importEqualsDeclaration = <ImportEqualsDeclaration>getAncestor(entityName, SyntaxKind.ImportEqualsDeclaration);
+                Debug.assert(importEqualsDeclaration !== undefined);
+                return getSymbolOfPartOfRightHandSideOfImportEquals(<EntityName>entityName, importEqualsDeclaration, /*dontResolveAlias*/ true);
             }
 
             if (isRightSideOfQualifiedNameOrPropertyAccess(entityName)) {

From 91c9d76f09c173c0480d7faa9fc19624e6ff8bcc Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Tue, 2 Aug 2016 10:32:42 -0700
Subject: [PATCH 04/29] Remove `SupportedExpressionWithTypeArguments` type;
 just check that the expression of each `ExpressionWithTypeArguments` is an
 `EntityNameExpression`.

---
 src/compiler/checker.ts            | 59 ++++++++++++++----------------
 src/compiler/declarationEmitter.ts |  4 +-
 src/compiler/types.ts              |  4 --
 src/compiler/utilities.ts          | 12 +-----
 4 files changed, 32 insertions(+), 47 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index ca66534603..d8b3785a89 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -968,37 +968,34 @@ namespace ts {
 
 
         function checkAndReportErrorForExtendingInterface(errorLocation: Node): boolean {
-            const parentExpression = climbToSupportedExpressionWithTypeArguments(errorLocation);
-            if (!parentExpression) {
-                return false;
-            }
-            const expression = parentExpression.expression;
-
-            if (resolveEntityName(expression, SymbolFlags.Interface, /*ignoreErrors*/ true)) {
+            const expression = climbToEntityNameOfExpressionWithTypeArguments(errorLocation);
+            const isError = !!(expression && resolveEntityName(expression, SymbolFlags.Interface, /*ignoreErrors*/ true));
+            if (isError) {
                 error(errorLocation, Diagnostics.Cannot_extend_an_interface_0_Did_you_mean_implements, getTextOfNode(expression));
-                return true;
             }
-            return false;
+            return isError;
         }
         /**
-         * Climbs up parents to a SupportedExpressionWIthTypeArguments.
-         * Does *not* just climb to an ExpressionWithTypeArguments; instead, ensures that this really is supported.
+         * Climbs up parents to an ExpressionWithTypeArguments, and returns its expression,
+         * but returns undefined if that expression is not an EntityNameExpression.
          */
-        function climbToSupportedExpressionWithTypeArguments(node: Node): SupportedExpressionWithTypeArguments | undefined {
-            while (node) {
-                switch (node.kind) {
-                    case SyntaxKind.Identifier:
-                    case SyntaxKind.PropertyAccessExpression:
+        function climbToEntityNameOfExpressionWithTypeArguments(node: Node): EntityNameExpression | undefined {
+            switch (node.kind) {
+                case SyntaxKind.Identifier:
+                case SyntaxKind.PropertyAccessExpression:
+                    if (node.parent) {
                         node = node.parent;
-                        break;
-                    case SyntaxKind.ExpressionWithTypeArguments:
-                        Debug.assert(isSupportedExpressionWithTypeArguments(<ExpressionWithTypeArguments>node));
-                        return <SupportedExpressionWithTypeArguments>node;
-                    default:
+                    }
+                    else {
                         return undefined;
-                }
+                    }
+                    break;
+                case SyntaxKind.ExpressionWithTypeArguments:
+                    Debug.assert(isEntityNameExpression((<ExpressionWithTypeArguments>node).expression));
+                    return <EntityNameExpression>(<ExpressionWithTypeArguments>node).expression;
+                default:
+                    return undefined;
             }
-            return undefined;
         }
 
 
@@ -3686,7 +3683,7 @@ namespace ts {
                     const baseTypeNodes = getInterfaceBaseTypeNodes(<InterfaceDeclaration>declaration);
                     if (baseTypeNodes) {
                         for (const node of baseTypeNodes) {
-                            if (isSupportedExpressionWithTypeArguments(node)) {
+                            if (isEntityNameExpression(node.expression)) {
                                 const baseSymbol = resolveEntityName(node.expression, SymbolFlags.Type, /*ignoreErrors*/ true);
                                 if (!baseSymbol || !(baseSymbol.flags & SymbolFlags.Interface) || getDeclaredTypeOfClassOrInterface(baseSymbol).thisType) {
                                     return false;
@@ -5042,9 +5039,9 @@ namespace ts {
                 case SyntaxKind.ExpressionWithTypeArguments:
                     // We only support expressions that are simple qualified names. For other
                     // expressions this produces undefined.
-                    const expr = <ExpressionWithTypeArguments>node;
-                    if (isSupportedExpressionWithTypeArguments(expr)) {
-                        return expr.expression;
+                    const expr = (<ExpressionWithTypeArguments>node).expression;
+                    if (isEntityNameExpression(expr)) {
+                        return expr;
                     }
 
                 // fall through;
@@ -5101,8 +5098,8 @@ namespace ts {
                     // We only support expressions that are simple qualified names. For other expressions this produces undefined.
                     const typeNameOrExpression: EntityNameOrEntityNameExpression = node.kind === SyntaxKind.TypeReference
                         ? (<TypeReferenceNode>node).typeName
-                        : isSupportedExpressionWithTypeArguments(<ExpressionWithTypeArguments>node)
-                            ? (<SupportedExpressionWithTypeArguments>node).expression
+                        : isEntityNameExpression((<ExpressionWithTypeArguments>node).expression)
+                            ? <EntityNameExpression>(<ExpressionWithTypeArguments>node).expression
                             : undefined;
                     symbol = typeNameOrExpression && resolveEntityName(typeNameOrExpression, SymbolFlags.Type) || unknownSymbol;
                     type = symbol === unknownSymbol ? unknownType :
@@ -16255,7 +16252,7 @@ namespace ts {
             const implementedTypeNodes = getClassImplementsHeritageClauseElements(node);
             if (implementedTypeNodes) {
                 for (const typeRefNode of implementedTypeNodes) {
-                    if (!isSupportedExpressionWithTypeArguments(typeRefNode)) {
+                    if (!isEntityNameExpression(typeRefNode.expression)) {
                         error(typeRefNode.expression, Diagnostics.A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments);
                     }
                     checkTypeReferenceNode(typeRefNode);
@@ -16497,7 +16494,7 @@ namespace ts {
                 checkObjectTypeForDuplicateDeclarations(node);
             }
             forEach(getInterfaceBaseTypeNodes(node), heritageElement => {
-                if (!isSupportedExpressionWithTypeArguments(heritageElement)) {
+                if (!isEntityNameExpression(heritageElement.expression)) {
                     error(heritageElement.expression, Diagnostics.An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments);
                 }
                 checkTypeReferenceNode(heritageElement);
diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index 220244c55a..c93784cd9e 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -452,7 +452,7 @@ namespace ts {
             }
 
             function emitExpressionWithTypeArguments(node: ExpressionWithTypeArguments) {
-                if (isSupportedExpressionWithTypeArguments(node)) {
+                if (isEntityNameExpression(node.expression)) {
                     Debug.assert(node.expression.kind === SyntaxKind.Identifier || node.expression.kind === SyntaxKind.PropertyAccessExpression);
                     emitEntityName(node.expression);
                     if (node.typeArguments) {
@@ -1019,7 +1019,7 @@ namespace ts {
             }
 
             function emitTypeOfTypeReference(node: ExpressionWithTypeArguments) {
-                if (isSupportedExpressionWithTypeArguments(node)) {
+                if (isEntityNameExpression(node.expression)) {
                     emitTypeWithNewGetSymbolAccessibilityDiagnostic(node, getHeritageClauseVisibilityError);
                 }
                 else if (!isImplementsList && node.expression.kind === SyntaxKind.NullKeyword) {
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 983ed25c84..804989570d 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -1014,10 +1014,6 @@ namespace ts {
         expression: LeftHandSideExpression;
         typeArguments?: NodeArray<TypeNode>;
     }
-    export interface SupportedExpressionWithTypeArguments extends ExpressionWithTypeArguments {
-        _supportedExpressionWithTypeArgumentsBrand?: any;
-        expression: EntityNameExpression;
-    }
 
     // @kind(SyntaxKind.NewExpression)
     export interface NewExpression extends CallExpression, PrimaryExpression { }
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index 466cf8c2b7..f946e4b614 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -1039,8 +1039,8 @@ namespace ts {
                 case SyntaxKind.TypeReference:
                     return (<TypeReferenceNode>node).typeName;
                 case SyntaxKind.ExpressionWithTypeArguments:
-                    Debug.assert(isSupportedExpressionWithTypeArguments(<ExpressionWithTypeArguments>node));
-                    return (<SupportedExpressionWithTypeArguments>node).expression;
+                    Debug.assert(isEntityNameExpression((<ExpressionWithTypeArguments>node).expression));
+                    return <EntityNameExpression>(<ExpressionWithTypeArguments>node).expression;
                 case SyntaxKind.Identifier:
                 case SyntaxKind.QualifiedName:
                     return (<EntityName><Node>node);
@@ -2684,10 +2684,6 @@ namespace ts {
             isClassLike(node.parent.parent);
     }
 
-    export function isSupportedExpressionWithTypeArguments(node: ExpressionWithTypeArguments): node is SupportedExpressionWithTypeArguments {
-        return isEntityNameExpression(node.expression);
-    }
-
     export function isEntityNameExpression(node: Expression): node is EntityNameExpression {
         for (; ; ) {
             switch (node.kind) {
@@ -2702,10 +2698,6 @@ namespace ts {
         }
     }
 
-    export function isPropertyAccessAnEntityNameExpression(node: PropertyAccessExpression): node is PropertyAccessEntityNameExpression {
-        return isEntityNameExpression(node.expression);
-    }
-
     export function isRightSideOfQualifiedNameOrPropertyAccess(node: Node) {
         return (node.parent.kind === SyntaxKind.QualifiedName && (<QualifiedName>node.parent).right === node) ||
             (node.parent.kind === SyntaxKind.PropertyAccessExpression && (<PropertyAccessExpression>node.parent).name === node);

From db44a710058b2340184de90127aed3182ed1c251 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Tue, 2 Aug 2016 10:47:06 -0700
Subject: [PATCH 05/29] Fix bug

---
 src/compiler/checker.ts | 30 ++++++++++++++++--------------
 1 file changed, 16 insertions(+), 14 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index d8b3785a89..dc0c8a6a41 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -980,21 +980,23 @@ namespace ts {
          * but returns undefined if that expression is not an EntityNameExpression.
          */
         function climbToEntityNameOfExpressionWithTypeArguments(node: Node): EntityNameExpression | undefined {
-            switch (node.kind) {
-                case SyntaxKind.Identifier:
-                case SyntaxKind.PropertyAccessExpression:
-                    if (node.parent) {
-                        node = node.parent;
-                    }
-                    else {
+            for (; ; ) {
+                switch (node.kind) {
+                    case SyntaxKind.Identifier:
+                    case SyntaxKind.PropertyAccessExpression:
+                        if (node.parent) {
+                            node = node.parent;
+                        }
+                        else {
+                            return undefined;
+                        }
+                        break;
+                    case SyntaxKind.ExpressionWithTypeArguments:
+                        Debug.assert(isEntityNameExpression((<ExpressionWithTypeArguments>node).expression));
+                        return <EntityNameExpression>(<ExpressionWithTypeArguments>node).expression;
+                    default:
                         return undefined;
-                    }
-                    break;
-                case SyntaxKind.ExpressionWithTypeArguments:
-                    Debug.assert(isEntityNameExpression((<ExpressionWithTypeArguments>node).expression));
-                    return <EntityNameExpression>(<ExpressionWithTypeArguments>node).expression;
-                default:
-                    return undefined;
+                }
             }
         }
 

From dc192238cca65da38eb321c9e3ed6f7ced643f9a Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Tue, 2 Aug 2016 12:37:30 -0700
Subject: [PATCH 06/29] Use recursion, and fix error for undefined node

---
 src/compiler/checker.ts   | 33 +++++++++++++--------------------
 src/compiler/utilities.ts | 13 ++-----------
 2 files changed, 15 insertions(+), 31 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index dc0c8a6a41..ca85a85e27 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -664,7 +664,7 @@ namespace ts {
         // Resolve a given name for a given meaning at a given location. An error is reported if the name was not found and
         // the nameNotFoundMessage argument is not undefined. Returns the resolved symbol, or undefined if no symbol with
         // the given name can be found.
-        function resolveName(location: Node, name: string, meaning: SymbolFlags, nameNotFoundMessage: DiagnosticMessage, nameArg: string | Identifier): Symbol {
+        function resolveName(location: Node | undefined, name: string, meaning: SymbolFlags, nameNotFoundMessage: DiagnosticMessage, nameArg: string | Identifier): Symbol {
             let result: Symbol;
             let lastLocation: Node;
             let propertyWithInvalidInitializer: Node;
@@ -881,7 +881,8 @@ namespace ts {
 
             if (!result) {
                 if (nameNotFoundMessage) {
-                    if (!checkAndReportErrorForMissingPrefix(errorLocation, name, nameArg) &&
+                    if (!errorLocation ||
+                        !checkAndReportErrorForMissingPrefix(errorLocation, name, nameArg) &&
                         !checkAndReportErrorForExtendingInterface(errorLocation)) {
                         error(errorLocation, nameNotFoundMessage, typeof nameArg === "string" ? nameArg : declarationNameToString(nameArg));
                     }
@@ -930,7 +931,7 @@ namespace ts {
         }
 
         function checkAndReportErrorForMissingPrefix(errorLocation: Node, name: string, nameArg: string | Identifier): boolean {
-            if (!errorLocation || (errorLocation.kind === SyntaxKind.Identifier && (isTypeReferenceIdentifier(<Identifier>errorLocation)) || isInTypeQuery(errorLocation))) {
+            if ((errorLocation.kind === SyntaxKind.Identifier && (isTypeReferenceIdentifier(<Identifier>errorLocation)) || isInTypeQuery(errorLocation))) {
                 return false;
             }
 
@@ -980,23 +981,15 @@ namespace ts {
          * but returns undefined if that expression is not an EntityNameExpression.
          */
         function climbToEntityNameOfExpressionWithTypeArguments(node: Node): EntityNameExpression | undefined {
-            for (; ; ) {
-                switch (node.kind) {
-                    case SyntaxKind.Identifier:
-                    case SyntaxKind.PropertyAccessExpression:
-                        if (node.parent) {
-                            node = node.parent;
-                        }
-                        else {
-                            return undefined;
-                        }
-                        break;
-                    case SyntaxKind.ExpressionWithTypeArguments:
-                        Debug.assert(isEntityNameExpression((<ExpressionWithTypeArguments>node).expression));
-                        return <EntityNameExpression>(<ExpressionWithTypeArguments>node).expression;
-                    default:
-                        return undefined;
-                }
+            switch (node.kind) {
+                case SyntaxKind.Identifier:
+                case SyntaxKind.PropertyAccessExpression:
+                    return node.parent ? climbToEntityNameOfExpressionWithTypeArguments(node.parent) : undefined;
+                case SyntaxKind.ExpressionWithTypeArguments:
+                    Debug.assert(isEntityNameExpression((<ExpressionWithTypeArguments>node).expression));
+                    return <EntityNameExpression>(<ExpressionWithTypeArguments>node).expression
+                default:
+                    return undefined;
             }
         }
 
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index f946e4b614..affbcbe7a9 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -2685,17 +2685,8 @@ namespace ts {
     }
 
     export function isEntityNameExpression(node: Expression): node is EntityNameExpression {
-        for (; ; ) {
-            switch (node.kind) {
-                case SyntaxKind.Identifier:
-                    return true;
-                case SyntaxKind.PropertyAccessExpression:
-                    node = (<PropertyAccessExpression>node).expression;
-                    break;
-                default:
-                    return false;
-            }
-        }
+        return node.kind === SyntaxKind.Identifier ||
+            node.kind === SyntaxKind.PropertyAccessExpression && isEntityNameExpression((<PropertyAccessExpression>node).expression);
     }
 
     export function isRightSideOfQualifiedNameOrPropertyAccess(node: Node) {

From 6814a9fac6a218c8a51fd283b1cfd3144cf3d67b Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Tue, 2 Aug 2016 12:41:22 -0700
Subject: [PATCH 07/29] Rename function

---
 src/compiler/checker.ts | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index ca85a85e27..dd9b56a5b5 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -969,7 +969,7 @@ namespace ts {
 
 
         function checkAndReportErrorForExtendingInterface(errorLocation: Node): boolean {
-            const expression = climbToEntityNameOfExpressionWithTypeArguments(errorLocation);
+            const expression = getEntityNameForExtendingInterface(errorLocation);
             const isError = !!(expression && resolveEntityName(expression, SymbolFlags.Interface, /*ignoreErrors*/ true));
             if (isError) {
                 error(errorLocation, Diagnostics.Cannot_extend_an_interface_0_Did_you_mean_implements, getTextOfNode(expression));
@@ -980,11 +980,11 @@ namespace ts {
          * Climbs up parents to an ExpressionWithTypeArguments, and returns its expression,
          * but returns undefined if that expression is not an EntityNameExpression.
          */
-        function climbToEntityNameOfExpressionWithTypeArguments(node: Node): EntityNameExpression | undefined {
+        function getEntityNameForExtendingInterface(node: Node): EntityNameExpression | undefined {
             switch (node.kind) {
                 case SyntaxKind.Identifier:
                 case SyntaxKind.PropertyAccessExpression:
-                    return node.parent ? climbToEntityNameOfExpressionWithTypeArguments(node.parent) : undefined;
+                    return node.parent ? getEntityNameForExtendingInterface(node.parent) : undefined;
                 case SyntaxKind.ExpressionWithTypeArguments:
                     Debug.assert(isEntityNameExpression((<ExpressionWithTypeArguments>node).expression));
                     return <EntityNameExpression>(<ExpressionWithTypeArguments>node).expression

From 7908257ab7b59b4760e7012c03fcc700e31e7fa2 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Tue, 2 Aug 2016 13:18:46 -0700
Subject: [PATCH 08/29] Fix lint error

---
 src/compiler/checker.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index dd9b56a5b5..0c65050a32 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -987,7 +987,7 @@ namespace ts {
                     return node.parent ? getEntityNameForExtendingInterface(node.parent) : undefined;
                 case SyntaxKind.ExpressionWithTypeArguments:
                     Debug.assert(isEntityNameExpression((<ExpressionWithTypeArguments>node).expression));
-                    return <EntityNameExpression>(<ExpressionWithTypeArguments>node).expression
+                    return <EntityNameExpression>(<ExpressionWithTypeArguments>node).expression;
                 default:
                     return undefined;
             }

From 7e115bbbef0e6e9cfe71ca63373d0881dd48e3be Mon Sep 17 00:00:00 2001
From: Nathan Shively-Sanders <nathansa@microsoft.com>
Date: Tue, 9 Aug 2016 12:44:08 -0700
Subject: [PATCH 09/29] Use correct this in tuple type parameter constraints

Instantiate this in tuple types used as type parameter constraints
---
 src/compiler/checker.ts                       |  8 ++-
 .../thisInTupleTypeParameterConstraints.js    | 29 ++++++++
 ...hisInTupleTypeParameterConstraints.symbols | 66 ++++++++++++++++++
 .../thisInTupleTypeParameterConstraints.types | 67 +++++++++++++++++++
 .../thisInTupleTypeParameterConstraints.ts    | 22 ++++++
 5 files changed, 190 insertions(+), 2 deletions(-)
 create mode 100644 tests/baselines/reference/thisInTupleTypeParameterConstraints.js
 create mode 100644 tests/baselines/reference/thisInTupleTypeParameterConstraints.symbols
 create mode 100644 tests/baselines/reference/thisInTupleTypeParameterConstraints.types
 create mode 100644 tests/cases/compiler/thisInTupleTypeParameterConstraints.ts

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 1f2eaea833..8b31ef9193 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -4000,6 +4000,10 @@ namespace ts {
                 return createTypeReference((<TypeReference>type).target,
                     concatenate((<TypeReference>type).typeArguments, [thisArgument || (<TypeReference>type).target.thisType]));
             }
+            if (type.flags & TypeFlags.Tuple) {
+                resolveTupleTypeMembers(type as TupleType, thisArgument);
+                return type;
+            }
             return type;
         }
 
@@ -4100,10 +4104,10 @@ namespace ts {
             return members;
         }
 
-        function resolveTupleTypeMembers(type: TupleType) {
+        function resolveTupleTypeMembers(type: TupleType, thisArgument?: Type) {
             const arrayElementType = getUnionType(type.elementTypes);
             // Make the tuple type itself the 'this' type by including an extra type argument
-            const arrayType = resolveStructuredTypeMembers(createTypeFromGenericGlobalType(globalArrayType, [arrayElementType, type]));
+            const arrayType = resolveStructuredTypeMembers(createTypeFromGenericGlobalType(globalArrayType, [arrayElementType, thisArgument || type]));
             const members = createTupleTypeMemberSymbols(type.elementTypes);
             addInheritedMembers(members, arrayType.properties);
             setObjectTypeMembers(type, members, arrayType.callSignatures, arrayType.constructSignatures, arrayType.stringIndexInfo, arrayType.numberIndexInfo);
diff --git a/tests/baselines/reference/thisInTupleTypeParameterConstraints.js b/tests/baselines/reference/thisInTupleTypeParameterConstraints.js
new file mode 100644
index 0000000000..c63fbf6199
--- /dev/null
+++ b/tests/baselines/reference/thisInTupleTypeParameterConstraints.js
@@ -0,0 +1,29 @@
+//// [thisInTupleTypeParameterConstraints.ts]
+/// <reference no-default-lib="true"/>
+
+interface Boolean {}
+interface IArguments {}
+interface Function {}
+interface Number {}
+interface RegExp {}
+interface Object {}
+interface String {}
+
+interface Array<T> {
+    // 4 methods will run out of memory if this-types are not instantiated
+    // correctly for tuple types that are type parameter constraints
+    map<U>(arg: this): void;
+    reduceRight<U>(arg: this): void;
+    reduce<U>(arg: this): void;
+    reduce2<U>(arg: this): void;
+}
+
+declare function f<T extends [(x: number) => number]>(a: T): void;
+let x: [(x: number) => number];
+f(x);
+
+
+//// [thisInTupleTypeParameterConstraints.js]
+/// <reference no-default-lib="true"/>
+var x;
+f(x);
diff --git a/tests/baselines/reference/thisInTupleTypeParameterConstraints.symbols b/tests/baselines/reference/thisInTupleTypeParameterConstraints.symbols
new file mode 100644
index 0000000000..4d2bef22c5
--- /dev/null
+++ b/tests/baselines/reference/thisInTupleTypeParameterConstraints.symbols
@@ -0,0 +1,66 @@
+=== tests/cases/compiler/thisInTupleTypeParameterConstraints.ts ===
+/// <reference no-default-lib="true"/>
+
+interface Boolean {}
+>Boolean : Symbol(Boolean, Decl(thisInTupleTypeParameterConstraints.ts, 0, 0))
+
+interface IArguments {}
+>IArguments : Symbol(IArguments, Decl(thisInTupleTypeParameterConstraints.ts, 2, 20))
+
+interface Function {}
+>Function : Symbol(Function, Decl(thisInTupleTypeParameterConstraints.ts, 3, 23))
+
+interface Number {}
+>Number : Symbol(Number, Decl(thisInTupleTypeParameterConstraints.ts, 4, 21))
+
+interface RegExp {}
+>RegExp : Symbol(RegExp, Decl(thisInTupleTypeParameterConstraints.ts, 5, 19))
+
+interface Object {}
+>Object : Symbol(Object, Decl(thisInTupleTypeParameterConstraints.ts, 6, 19))
+
+interface String {}
+>String : Symbol(String, Decl(thisInTupleTypeParameterConstraints.ts, 7, 19))
+
+interface Array<T> {
+>Array : Symbol(Array, Decl(thisInTupleTypeParameterConstraints.ts, 8, 19))
+>T : Symbol(T, Decl(thisInTupleTypeParameterConstraints.ts, 10, 16))
+
+    // 4 methods will run out of memory if this-types are not instantiated
+    // correctly for tuple types that are type parameter constraints
+    map<U>(arg: this): void;
+>map : Symbol(Array.map, Decl(thisInTupleTypeParameterConstraints.ts, 10, 20))
+>U : Symbol(U, Decl(thisInTupleTypeParameterConstraints.ts, 13, 8))
+>arg : Symbol(arg, Decl(thisInTupleTypeParameterConstraints.ts, 13, 11))
+
+    reduceRight<U>(arg: this): void;
+>reduceRight : Symbol(Array.reduceRight, Decl(thisInTupleTypeParameterConstraints.ts, 13, 28))
+>U : Symbol(U, Decl(thisInTupleTypeParameterConstraints.ts, 14, 16))
+>arg : Symbol(arg, Decl(thisInTupleTypeParameterConstraints.ts, 14, 19))
+
+    reduce<U>(arg: this): void;
+>reduce : Symbol(Array.reduce, Decl(thisInTupleTypeParameterConstraints.ts, 14, 36))
+>U : Symbol(U, Decl(thisInTupleTypeParameterConstraints.ts, 15, 11))
+>arg : Symbol(arg, Decl(thisInTupleTypeParameterConstraints.ts, 15, 14))
+
+    reduce2<U>(arg: this): void;
+>reduce2 : Symbol(Array.reduce2, Decl(thisInTupleTypeParameterConstraints.ts, 15, 31))
+>U : Symbol(U, Decl(thisInTupleTypeParameterConstraints.ts, 16, 12))
+>arg : Symbol(arg, Decl(thisInTupleTypeParameterConstraints.ts, 16, 15))
+}
+
+declare function f<T extends [(x: number) => number]>(a: T): void;
+>f : Symbol(f, Decl(thisInTupleTypeParameterConstraints.ts, 17, 1))
+>T : Symbol(T, Decl(thisInTupleTypeParameterConstraints.ts, 19, 19))
+>x : Symbol(x, Decl(thisInTupleTypeParameterConstraints.ts, 19, 31))
+>a : Symbol(a, Decl(thisInTupleTypeParameterConstraints.ts, 19, 54))
+>T : Symbol(T, Decl(thisInTupleTypeParameterConstraints.ts, 19, 19))
+
+let x: [(x: number) => number];
+>x : Symbol(x, Decl(thisInTupleTypeParameterConstraints.ts, 20, 3))
+>x : Symbol(x, Decl(thisInTupleTypeParameterConstraints.ts, 20, 9))
+
+f(x);
+>f : Symbol(f, Decl(thisInTupleTypeParameterConstraints.ts, 17, 1))
+>x : Symbol(x, Decl(thisInTupleTypeParameterConstraints.ts, 20, 3))
+
diff --git a/tests/baselines/reference/thisInTupleTypeParameterConstraints.types b/tests/baselines/reference/thisInTupleTypeParameterConstraints.types
new file mode 100644
index 0000000000..7daafe02bf
--- /dev/null
+++ b/tests/baselines/reference/thisInTupleTypeParameterConstraints.types
@@ -0,0 +1,67 @@
+=== tests/cases/compiler/thisInTupleTypeParameterConstraints.ts ===
+/// <reference no-default-lib="true"/>
+
+interface Boolean {}
+>Boolean : Boolean
+
+interface IArguments {}
+>IArguments : IArguments
+
+interface Function {}
+>Function : Function
+
+interface Number {}
+>Number : Number
+
+interface RegExp {}
+>RegExp : RegExp
+
+interface Object {}
+>Object : Object
+
+interface String {}
+>String : String
+
+interface Array<T> {
+>Array : T[]
+>T : T
+
+    // 4 methods will run out of memory if this-types are not instantiated
+    // correctly for tuple types that are type parameter constraints
+    map<U>(arg: this): void;
+>map : <U>(arg: this) => void
+>U : U
+>arg : this
+
+    reduceRight<U>(arg: this): void;
+>reduceRight : <U>(arg: this) => void
+>U : U
+>arg : this
+
+    reduce<U>(arg: this): void;
+>reduce : <U>(arg: this) => void
+>U : U
+>arg : this
+
+    reduce2<U>(arg: this): void;
+>reduce2 : <U>(arg: this) => void
+>U : U
+>arg : this
+}
+
+declare function f<T extends [(x: number) => number]>(a: T): void;
+>f : <T extends [(x: number) => number]>(a: T) => void
+>T : T
+>x : number
+>a : T
+>T : T
+
+let x: [(x: number) => number];
+>x : [(x: number) => number]
+>x : number
+
+f(x);
+>f(x) : void
+>f : <T extends [(x: number) => number]>(a: T) => void
+>x : [(x: number) => number]
+
diff --git a/tests/cases/compiler/thisInTupleTypeParameterConstraints.ts b/tests/cases/compiler/thisInTupleTypeParameterConstraints.ts
new file mode 100644
index 0000000000..b6d0d338d8
--- /dev/null
+++ b/tests/cases/compiler/thisInTupleTypeParameterConstraints.ts
@@ -0,0 +1,22 @@
+/// <reference no-default-lib="true"/>
+
+interface Boolean {}
+interface IArguments {}
+interface Function {}
+interface Number {}
+interface RegExp {}
+interface Object {}
+interface String {}
+
+interface Array<T> {
+    // 4 methods will run out of memory if this-types are not instantiated
+    // correctly for tuple types that are type parameter constraints
+    map<U>(arg: this): void;
+    reduceRight<U>(arg: this): void;
+    reduce<U>(arg: this): void;
+    reduce2<U>(arg: this): void;
+}
+
+declare function f<T extends [(x: number) => number]>(a: T): void;
+let x: [(x: number) => number];
+f(x);

From d34bbe5f5880170066a55301a576f6372634d47c Mon Sep 17 00:00:00 2001
From: Nathan Shively-Sanders <nathansa@microsoft.com>
Date: Tue, 9 Aug 2016 12:47:43 -0700
Subject: [PATCH 10/29] Add explanatory comment to resolveTupleTypeMembers

---
 src/compiler/checker.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 8b31ef9193..546d8412c9 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -4107,6 +4107,7 @@ namespace ts {
         function resolveTupleTypeMembers(type: TupleType, thisArgument?: Type) {
             const arrayElementType = getUnionType(type.elementTypes);
             // Make the tuple type itself the 'this' type by including an extra type argument
+            // (Unless it's provided in the case that the tuple is a type parameter constraint)
             const arrayType = resolveStructuredTypeMembers(createTypeFromGenericGlobalType(globalArrayType, [arrayElementType, thisArgument || type]));
             const members = createTupleTypeMemberSymbols(type.elementTypes);
             addInheritedMembers(members, arrayType.properties);

From 6a8f4cb676f0df1ce6fd84c0766643b8ca42f98b Mon Sep 17 00:00:00 2001
From: Nathan Shively-Sanders <nathansa@microsoft.com>
Date: Tue, 9 Aug 2016 14:48:11 -0700
Subject: [PATCH 11/29] Delay tuple type constraint resolution

Create a new tuple that stores the this-type.
---
 src/compiler/checker.ts | 20 ++++++++++++--------
 src/compiler/types.ts   |  1 +
 2 files changed, 13 insertions(+), 8 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 546d8412c9..1ed8cb8c6e 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -4001,8 +4001,7 @@ namespace ts {
                     concatenate((<TypeReference>type).typeArguments, [thisArgument || (<TypeReference>type).target.thisType]));
             }
             if (type.flags & TypeFlags.Tuple) {
-                resolveTupleTypeMembers(type as TupleType, thisArgument);
-                return type;
+                return createTupleType((type as TupleType).elementTypes, thisArgument);
             }
             return type;
         }
@@ -4104,11 +4103,11 @@ namespace ts {
             return members;
         }
 
-        function resolveTupleTypeMembers(type: TupleType, thisArgument?: Type) {
+        function resolveTupleTypeMembers(type: TupleType) {
             const arrayElementType = getUnionType(type.elementTypes);
             // Make the tuple type itself the 'this' type by including an extra type argument
             // (Unless it's provided in the case that the tuple is a type parameter constraint)
-            const arrayType = resolveStructuredTypeMembers(createTypeFromGenericGlobalType(globalArrayType, [arrayElementType, thisArgument || type]));
+            const arrayType = resolveStructuredTypeMembers(createTypeFromGenericGlobalType(globalArrayType, [arrayElementType, type.thisType || type]));
             const members = createTupleTypeMemberSymbols(type.elementTypes);
             addInheritedMembers(members, arrayType.properties);
             setObjectTypeMembers(type, members, arrayType.callSignatures, arrayType.constructSignatures, arrayType.stringIndexInfo, arrayType.numberIndexInfo);
@@ -5235,15 +5234,20 @@ namespace ts {
             return links.resolvedType;
         }
 
-        function createTupleType(elementTypes: Type[]) {
-            const id = getTypeListId(elementTypes);
-            return tupleTypes[id] || (tupleTypes[id] = createNewTupleType(elementTypes));
+        function createTupleType(elementTypes: Type[], thisType?: Type) {
+            let id = getTypeListId(elementTypes);
+            if (thisType) {
+                id += ',' + thisType.id;
+            }
+
+            return tupleTypes[id] || (tupleTypes[id] = createNewTupleType(elementTypes, thisType));
         }
 
-        function createNewTupleType(elementTypes: Type[]) {
+        function createNewTupleType(elementTypes: Type[], thisType?: Type) {
             const propagatedFlags = getPropagatingFlagsOfTypes(elementTypes, /*excludeKinds*/ 0);
             const type = <TupleType>createObjectType(TypeFlags.Tuple | propagatedFlags);
             type.elementTypes = elementTypes;
+            type.thisType = thisType;
             return type;
         }
 
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index a6e860450c..25630059bf 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -2371,6 +2371,7 @@ namespace ts {
 
     export interface TupleType extends ObjectType {
         elementTypes: Type[];  // Element types
+        thisType?: Type;       // This-type of tuple (only needed for tuples that are constraints of type parameters)
     }
 
     export interface UnionOrIntersectionType extends Type {

From 80963baf509fd7f22b81f13da3aa6b3840312c97 Mon Sep 17 00:00:00 2001
From: Nathan Shively-Sanders <nathansa@microsoft.com>
Date: Tue, 9 Aug 2016 15:37:15 -0700
Subject: [PATCH 12/29] Always use thisType when generating tuple id

---
 src/compiler/checker.ts | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 1ed8cb8c6e..8fcd22f0ff 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -1538,8 +1538,8 @@ namespace ts {
 
         function createType(flags: TypeFlags): Type {
             const result = new Type(checker, flags);
-            result.id = typeCount;
             typeCount++;
+            result.id = typeCount;
             return result;
         }
 
@@ -5235,11 +5235,7 @@ namespace ts {
         }
 
         function createTupleType(elementTypes: Type[], thisType?: Type) {
-            let id = getTypeListId(elementTypes);
-            if (thisType) {
-                id += ',' + thisType.id;
-            }
-
+            const id = getTypeListId(elementTypes) + ',' + (thisType ? thisType.id : 0);
             return tupleTypes[id] || (tupleTypes[id] = createNewTupleType(elementTypes, thisType));
         }
 

From 9d4547c5d08430a87304caac6a8fe164baed4c19 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Tue, 9 Aug 2016 16:33:45 -0700
Subject: [PATCH 13/29] Optimize format of type list id strings used in maps

---
 src/compiler/checker.ts | 33 ++++++++++++++++++---------------
 1 file changed, 18 insertions(+), 15 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 1f2eaea833..ac4ac3d506 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -4941,24 +4941,27 @@ namespace ts {
         }
 
         function getTypeListId(types: Type[]) {
+            let result = "";
             if (types) {
-                switch (types.length) {
-                    case 1:
-                        return "" + types[0].id;
-                    case 2:
-                        return types[0].id + "," + types[1].id;
-                    default:
-                        let result = "";
-                        for (let i = 0; i < types.length; i++) {
-                            if (i > 0) {
-                                result += ",";
-                            }
-                            result += types[i].id;
-                        }
-                        return result;
+                const length = types.length;
+                let i = 0;
+                while (i < length) {
+                    const startId = types[i].id;
+                    let count = 1;
+                    while (i + count < length && types[i + count].id === startId + count) {
+                        count++;
+                    }
+                    if (result.length) {
+                        result += ",";
+                    }
+                    result += startId;
+                    if (count > 1) {
+                        result += ":" + count;
+                    }
+                    i += count;
                 }
             }
-            return "";
+            return result;
         }
 
         // This function is used to propagate certain flags when creating new object type references and union types.

From 8975cd7024dc1057794af93fcb74f36844f8e1a5 Mon Sep 17 00:00:00 2001
From: joshaber <joshaber@gmail.com>
Date: Tue, 9 Aug 2016 23:00:47 -0400
Subject: [PATCH 14/29] Make ReadonlyArray iterable.

---
 src/lib/es2015.iterable.d.ts | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/src/lib/es2015.iterable.d.ts b/src/lib/es2015.iterable.d.ts
index e1b9d99762..de339e2bf2 100644
--- a/src/lib/es2015.iterable.d.ts
+++ b/src/lib/es2015.iterable.d.ts
@@ -63,6 +63,26 @@ interface ArrayConstructor {
     from<T>(iterable: Iterable<T>): Array<T>;
 }
 
+interface ReadonlyArray<T> {
+    /** Iterator */
+    [Symbol.iterator](): IterableIterator<T>;
+
+    /** 
+      * Returns an array of key, value pairs for every entry in the array
+      */
+    entries(): IterableIterator<[number, T]>;
+
+    /** 
+      * Returns an list of keys in the array
+      */
+    keys(): IterableIterator<number>;
+
+    /** 
+      * Returns an list of values in the array
+      */
+    values(): IterableIterator<T>;
+}
+
 interface IArguments {
     /** Iterator */
     [Symbol.iterator](): IterableIterator<any>;

From ecc51af1ec712447be88fa97c4ba38612bd98f42 Mon Sep 17 00:00:00 2001
From: Wesley Wigham <wwigham@gmail.com>
Date: Wed, 10 Aug 2016 10:01:16 -0700
Subject: [PATCH 15/29] Allow OSX to fail while we investigate (#10255)

The random test timeouts are an issue.
---
 .travis.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.travis.yml b/.travis.yml
index 4126683eb6..97c772f45a 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -17,6 +17,8 @@ matrix:
     node_js: stable
     osx_image: xcode7.3
     env: workerCount=2
+  allow_failures:
+  - os: osx
 
 branches:
   only:

From 56cb07ae919372d96e98d9195375b7264555380e Mon Sep 17 00:00:00 2001
From: zhengbli <zhengli@microsoft.com>
Date: Wed, 10 Aug 2016 12:34:27 -0700
Subject: [PATCH 16/29] avoid using the global name

---
 src/harness/unittests/session.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/harness/unittests/session.ts b/src/harness/unittests/session.ts
index c528554432..d5e6daa5d6 100644
--- a/src/harness/unittests/session.ts
+++ b/src/harness/unittests/session.ts
@@ -106,7 +106,7 @@ namespace ts.server {
         describe("onMessage", () => {
             it("should not throw when commands are executed with invalid arguments", () => {
                 let i = 0;
-                for (name in CommandNames) {
+                for (const name in CommandNames) {
                     if (!Object.prototype.hasOwnProperty.call(CommandNames, name)) {
                         continue;
                     }

From 408780864c1199899ed5277aa0ed893a95528671 Mon Sep 17 00:00:00 2001
From: Nathan Shively-Sanders <nathansa@microsoft.com>
Date: Wed, 10 Aug 2016 14:09:52 -0700
Subject: [PATCH 17/29] Fix single-quote lint

---
 src/compiler/checker.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 8fcd22f0ff..b8d7146efb 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -5235,7 +5235,7 @@ namespace ts {
         }
 
         function createTupleType(elementTypes: Type[], thisType?: Type) {
-            const id = getTypeListId(elementTypes) + ',' + (thisType ? thisType.id : 0);
+            const id = getTypeListId(elementTypes) + "," + (thisType ? thisType.id : 0);
             return tupleTypes[id] || (tupleTypes[id] = createNewTupleType(elementTypes, thisType));
         }
 

From fa991b51750d7b6951733bf521d0f18ef888fc9e Mon Sep 17 00:00:00 2001
From: Wesley Wigham <wwigham@gmail.com>
Date: Wed, 10 Aug 2016 23:45:24 -0700
Subject: [PATCH 18/29] Have travis take shallow clones of the repo (#10275)

Just cloning TS on travis takes 23 seconds on linux (68 seconds on mac), hopefully having it do a shallow clone will help.

We don't rely on any tagging/artifacts from the travis servers which clone depth could impact, so this shouldn't impact anything other than build speed.
---
 .travis.yml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.travis.yml b/.travis.yml
index 97c772f45a..bfc07e2b51 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -34,3 +34,6 @@ install:
 cache:
   directories:
     - node_modules
+
+git:
+  depth: 1

From c9f62f33d4d87dbb4a40ba5a28bb1085c683def2 Mon Sep 17 00:00:00 2001
From: Wesley Wigham <wwigham@gmail.com>
Date: Thu, 11 Aug 2016 09:53:38 -0700
Subject: [PATCH 19/29] Add folds to travis log (#10269)

---
 Gulpfile.ts  |  3 +++
 Jakefile.js  | 27 +++++++++++++++++++++++++--
 package.json |  3 ++-
 3 files changed, 30 insertions(+), 3 deletions(-)

diff --git a/Gulpfile.ts b/Gulpfile.ts
index b9b5d2068b..d677b04225 100644
--- a/Gulpfile.ts
+++ b/Gulpfile.ts
@@ -35,6 +35,7 @@ import merge2 = require("merge2");
 import intoStream = require("into-stream");
 import * as os from "os";
 import Linter = require("tslint");
+import fold = require("travis-fold");
 const gulp = helpMaker(originalGulp);
 const mochaParallel = require("./scripts/mocha-parallel.js");
 const {runTestsInParallel} = mochaParallel;
@@ -964,6 +965,7 @@ gulp.task("lint", "Runs tslint on the compiler sources. Optional arguments are:
     const fileMatcher = RegExp(cmdLineOptions["files"]);
     const lintOptions = getLinterOptions();
     let failed = 0;
+    if (fold.isTravis()) console.log(fold.start("lint"));
     return gulp.src(lintTargets)
         .pipe(insert.transform((contents, file) => {
             if (!fileMatcher.test(file.path)) return contents;
@@ -975,6 +977,7 @@ gulp.task("lint", "Runs tslint on the compiler sources. Optional arguments are:
             return contents; // TODO (weswig): Automatically apply fixes? :3
         }))
         .on("end", () => {
+            if (fold.isTravis()) console.log(fold.end("lint"));
             if (failed > 0) {
                 console.error("Linter errors.");
                 process.exit(1);
diff --git a/Jakefile.js b/Jakefile.js
index a5650a56b1..0624c92f16 100644
--- a/Jakefile.js
+++ b/Jakefile.js
@@ -5,6 +5,7 @@ var os = require("os");
 var path = require("path");
 var child_process = require("child_process");
 var Linter = require("tslint");
+var fold = require("travis-fold");
 var runTestsInParallel = require("./scripts/mocha-parallel").runTestsInParallel;
 
 // Variables
@@ -560,9 +561,19 @@ compileFile(
 desc("Builds language service server library");
 task("lssl", [tsserverLibraryFile, tsserverLibraryDefinitionFile]);
 
+desc("Emit the start of the build fold");
+task("build-fold-start", [] , function() {
+    if (fold.isTravis()) console.log(fold.start("build"));
+});
+
+desc("Emit the end of the build fold");
+task("build-fold-end", [] , function() {
+    if (fold.isTravis()) console.log(fold.end("build"));
+});
+
 // Local target to build the compiler and services
 desc("Builds the full compiler and services");
-task("local", ["generate-diagnostics", "lib", tscFile, servicesFile, nodeDefinitionsFile, serverFile, builtGeneratedDiagnosticMessagesJSON, "lssl"]);
+task("local", ["build-fold-start", "generate-diagnostics", "lib", tscFile, servicesFile, nodeDefinitionsFile, serverFile, builtGeneratedDiagnosticMessagesJSON, "lssl", "build-fold-end"]);
 
 // Local target to build only tsc.js
 desc("Builds only the compiler");
@@ -998,12 +1009,22 @@ var tslintRulesOutFiles = tslintRules.map(function(p) {
     return path.join(builtLocalDirectory, "tslint", p + ".js");
 });
 desc("Compiles tslint rules to js");
-task("build-rules", tslintRulesOutFiles);
+task("build-rules", ["build-rules-start"].concat(tslintRulesOutFiles).concat(["build-rules-end"]));
 tslintRulesFiles.forEach(function(ruleFile, i) {
     compileFile(tslintRulesOutFiles[i], [ruleFile], [ruleFile], [], /*useBuiltCompiler*/ false,
     { noOutFile: true, generateDeclarations: false, outDir: path.join(builtLocalDirectory, "tslint")});
 });
 
+desc("Emit the start of the build-rules fold");
+task("build-rules-start", [] , function() {
+    if (fold.isTravis()) console.log(fold.start("build-rules"));
+});
+
+desc("Emit the end of the build-rules fold");
+task("build-rules-end", [] , function() {
+    if (fold.isTravis()) console.log(fold.end("build-rules"));
+});
+
 function getLinterOptions() {
     return {
         configuration: require("./tslint.json"),
@@ -1047,6 +1068,7 @@ var lintTargets = compilerSources
 
 desc("Runs tslint on the compiler sources. Optional arguments are: f[iles]=regex");
 task("lint", ["build-rules"], function() {
+    if (fold.isTravis()) console.log(fold.start("lint"));
     var lintOptions = getLinterOptions();
     var failed = 0;
     var fileMatcher = RegExp(process.env.f || process.env.file || process.env.files || "");
@@ -1062,6 +1084,7 @@ task("lint", ["build-rules"], function() {
             done[target] = true;
         }
     }
+    if (fold.isTravis()) console.log(fold.end("lint"));
     if (failed > 0) {
         fail('Linter errors.', failed);
     }
diff --git a/package.json b/package.json
index 9f3122c337..25d8f0c42e 100644
--- a/package.json
+++ b/package.json
@@ -30,8 +30,8 @@
     },
     "devDependencies": {
         "@types/browserify": "latest",
-        "@types/convert-source-map": "latest",
         "@types/chai": "latest",
+        "@types/convert-source-map": "latest",
         "@types/del": "latest",
         "@types/glob": "latest",
         "@types/gulp": "latest",
@@ -72,6 +72,7 @@
         "run-sequence": "latest",
         "sorcery": "latest",
         "through2": "latest",
+        "travis-fold": "latest",
         "ts-node": "latest",
         "tslint": "next",
         "typescript": "next"

From 24d8d848f1b85b627482e8a56e50f398b1520cfd Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Thu, 11 Aug 2016 10:23:27 -0700
Subject: [PATCH 20/29] Optimize filterType to only call getUnionType if
 necessary

---
 src/compiler/checker.ts | 23 ++++++++++++++++++++---
 1 file changed, 20 insertions(+), 3 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 43ec22df40..2ae238b917 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -8172,9 +8172,26 @@ namespace ts {
         }
 
         function filterType(type: Type, f: (t: Type) => boolean): Type {
-            return type.flags & TypeFlags.Union ?
-                getUnionType(filter((<UnionType>type).types, f)) :
-                f(type) ? type : neverType;
+            if (!(type.flags & TypeFlags.Union)) {
+                return f(type) ? type : neverType;
+            }
+            let types = (<UnionType>type).types;
+            let length = types.length;
+            let i = 0;
+            while (i < length && f(types[i])) i++;
+            if (i === length) {
+                return type;
+            }
+            let filtered = types.slice(0, i);
+            i++;
+            while (i < length) {
+                const t = types[i];
+                if (f(t)) {
+                    filtered.push(t);
+                }
+                i++;
+            }
+            return getUnionType(filtered);
         }
 
         function isIncomplete(flowType: FlowType) {

From 9ac13abfd196f662ce606d8d99cb8791c2ad61fe Mon Sep 17 00:00:00 2001
From: Andy <anhans@microsoft.com>
Date: Thu, 11 Aug 2016 11:58:23 -0700
Subject: [PATCH 21/29] Add shorthand types declaration for travis-fold
 (#10293)

---
 scripts/types/ambient.d.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/scripts/types/ambient.d.ts b/scripts/types/ambient.d.ts
index e77e3fe8c5..e83489801d 100644
--- a/scripts/types/ambient.d.ts
+++ b/scripts/types/ambient.d.ts
@@ -22,3 +22,4 @@ declare module "into-stream" {
 }
 
 declare module "sorcery";
+declare module "travis-fold";

From a3845a95d56cd190fcc0a3fa359aaad37cbb4c74 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Thu, 11 Aug 2016 13:44:51 -0700
Subject: [PATCH 22/29] Optimize getTypeWithFacts

---
 src/compiler/checker.ts | 49 +++++++++++++++++++++++------------------
 1 file changed, 28 insertions(+), 21 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 2ae238b917..e4f650691d 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -7924,6 +7924,14 @@ namespace ts {
             return result;
         }
 
+        function isFunctionObjectType(type: ObjectType): boolean {
+            // We do a quick check for a "bind" property before performing the more expensive subtype
+            // check. This gives us a quicker out in the common case where an object type is not a function.
+            const resolved = resolveStructuredTypeMembers(type);
+            return !!(resolved.callSignatures.length || resolved.constructSignatures.length ||
+                hasProperty(resolved.members, "bind") && isTypeSubtypeOf(type, globalFunctionType));
+        }
+
         function getTypeFacts(type: Type): TypeFacts {
             const flags = type.flags;
             if (flags & TypeFlags.String) {
@@ -7952,8 +7960,7 @@ namespace ts {
                     type === falseType ? TypeFacts.FalseFacts : TypeFacts.TrueFacts;
             }
             if (flags & TypeFlags.ObjectType) {
-                const resolved = resolveStructuredTypeMembers(type);
-                return resolved.callSignatures.length || resolved.constructSignatures.length || isTypeSubtypeOf(type, globalFunctionType) ?
+                return isFunctionObjectType(<ObjectType>type) ?
                     strictNullChecks ? TypeFacts.FunctionStrictFacts : TypeFacts.FunctionFacts :
                     strictNullChecks ? TypeFacts.ObjectStrictFacts : TypeFacts.ObjectFacts;
             }
@@ -7980,23 +7987,23 @@ namespace ts {
             if (!(type.flags & TypeFlags.Union)) {
                 return getTypeFacts(type) & include ? type : neverType;
             }
-            let firstType: Type;
-            let types: Type[];
-            for (const t of (type as UnionType).types) {
-                if (getTypeFacts(t) & include) {
-                    if (!firstType) {
-                        firstType = t;
-                    }
-                    else {
-                        if (!types) {
-                            types = [firstType];
-                        }
-                        types.push(t);
-                    }
-                }
+            const types = (<UnionType>type).types;
+            const length = types.length;
+            let i = 0;
+            while (i < length && getTypeFacts(types[i]) & include) i++;
+            if (i === length) {
+                return type;
             }
-            return types ? getUnionType(types) :
-                firstType ? firstType : neverType;
+            const filtered = types.slice(0, i);
+            i++;
+            while (i < length) {
+                const t = types[i];
+                if (getTypeFacts(t) & include) {
+                    filtered.push(t);
+                }
+                i++;
+            }
+            return getUnionType(filtered);
         }
 
         function getTypeWithDefault(type: Type, defaultExpression: Expression) {
@@ -8175,14 +8182,14 @@ namespace ts {
             if (!(type.flags & TypeFlags.Union)) {
                 return f(type) ? type : neverType;
             }
-            let types = (<UnionType>type).types;
-            let length = types.length;
+            const types = (<UnionType>type).types;
+            const length = types.length;
             let i = 0;
             while (i < length && f(types[i])) i++;
             if (i === length) {
                 return type;
             }
-            let filtered = types.slice(0, i);
+            const filtered = types.slice(0, i);
             i++;
             while (i < length) {
                 const t = types[i];

From c22a54fb9507d25ca0b81f1ff82de4b26154cb9a Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Thu, 11 Aug 2016 13:46:06 -0700
Subject: [PATCH 23/29] Filter out nullable and primitive types in
 isDiscriminantProperty

---
 src/compiler/checker.ts | 34 +++++++++++++++++++++-------------
 1 file changed, 21 insertions(+), 13 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index e4f650691d..0ba44b34f8 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -245,7 +245,8 @@ namespace ts {
             NEUndefinedOrNull = 1 << 19,  // x != undefined / x != null
             Truthy = 1 << 20,             // x
             Falsy = 1 << 21,              // !x
-            All = (1 << 22) - 1,
+            Discriminatable = 1 << 22,    // May have discriminant property
+            All = (1 << 23) - 1,
             // The following members encode facts about particular kinds of types for use in the getTypeFacts function.
             // The presence of a particular fact means that the given test is true for some (and possibly all) values
             // of that kind of type.
@@ -275,9 +276,9 @@ namespace ts {
             TrueFacts = BaseBooleanFacts | Truthy,
             SymbolStrictFacts = TypeofEQSymbol | TypeofNEString | TypeofNENumber | TypeofNEBoolean | TypeofNEObject | TypeofNEFunction | TypeofNEHostObject | NEUndefined | NENull | NEUndefinedOrNull | Truthy,
             SymbolFacts = SymbolStrictFacts | EQUndefined | EQNull | EQUndefinedOrNull | Falsy,
-            ObjectStrictFacts = TypeofEQObject | TypeofEQHostObject | TypeofNEString | TypeofNENumber | TypeofNEBoolean | TypeofNESymbol | TypeofNEFunction | NEUndefined | NENull | NEUndefinedOrNull | Truthy,
+            ObjectStrictFacts = TypeofEQObject | TypeofEQHostObject | TypeofNEString | TypeofNENumber | TypeofNEBoolean | TypeofNESymbol | TypeofNEFunction | NEUndefined | NENull | NEUndefinedOrNull | Truthy | Discriminatable,
             ObjectFacts = ObjectStrictFacts | EQUndefined | EQNull | EQUndefinedOrNull | Falsy,
-            FunctionStrictFacts = TypeofEQFunction | TypeofEQHostObject | TypeofNEString | TypeofNENumber | TypeofNEBoolean | TypeofNESymbol | TypeofNEObject | NEUndefined | NENull | NEUndefinedOrNull | Truthy,
+            FunctionStrictFacts = TypeofEQFunction | TypeofEQHostObject | TypeofNEString | TypeofNENumber | TypeofNEBoolean | TypeofNESymbol | TypeofNEObject | NEUndefined | NENull | NEUndefinedOrNull | Truthy | Discriminatable,
             FunctionFacts = FunctionStrictFacts | EQUndefined | EQNull | EQUndefinedOrNull | Falsy,
             UndefinedFacts = TypeofNEString | TypeofNENumber | TypeofNEBoolean | TypeofNESymbol | TypeofNEObject | TypeofNEFunction | TypeofNEHostObject | EQUndefined | EQUndefinedOrNull | NENull | Falsy,
             NullFacts = TypeofEQObject | TypeofNEString | TypeofNENumber | TypeofNEBoolean | TypeofNESymbol | TypeofNEFunction | TypeofNEHostObject | EQNull | EQUndefinedOrNull | NEUndefined | Falsy,
@@ -7848,18 +7849,25 @@ namespace ts {
         }
 
         function isDiscriminantProperty(type: Type, name: string) {
-            if (type) {
-                const nonNullType = getNonNullableType(type);
-                if (nonNullType.flags & TypeFlags.Union) {
-                    const prop = getPropertyOfType(nonNullType, name);
-                    if (prop && prop.flags & SymbolFlags.SyntheticProperty) {
-                        if ((<TransientSymbol>prop).isDiscriminantProperty === undefined) {
-                            (<TransientSymbol>prop).isDiscriminantProperty = !(<TransientSymbol>prop).hasCommonType &&
-                                isUnitUnionType(getTypeOfSymbol(prop));
-                        }
-                        return (<TransientSymbol>prop).isDiscriminantProperty;
+            if (type && type.flags & TypeFlags.Union) {
+                let prop = getPropertyOfType(type, name);
+                if (!prop) {
+                    // The type may be a union that includes nullable or primtive types. If filtering
+                    // those out produces a different type, get the property from that type instead.
+                    // Effectively, we're checking if this *could* be a discriminant property once nullable
+                    // and primitive types are removed by other type guards.
+                    const filteredType = getTypeWithFacts(type, TypeFacts.Discriminatable);
+                    if (filteredType !== type && filteredType.flags & TypeFlags.Union) {
+                        prop = getPropertyOfType(type, name);
                     }
                 }
+                if (prop && prop.flags & SymbolFlags.SyntheticProperty) {
+                    if ((<TransientSymbol>prop).isDiscriminantProperty === undefined) {
+                        (<TransientSymbol>prop).isDiscriminantProperty = !(<TransientSymbol>prop).hasCommonType &&
+                            isUnitUnionType(getTypeOfSymbol(prop));
+                    }
+                    return (<TransientSymbol>prop).isDiscriminantProperty;
+                }
             }
             return false;
         }

From b336c693eed9745efdabb0c7736a81080d481eb0 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Thu, 11 Aug 2016 14:38:01 -0700
Subject: [PATCH 24/29] Fix typo

---
 src/compiler/checker.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 0ba44b34f8..b6d0373781 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -7858,7 +7858,7 @@ namespace ts {
                     // and primitive types are removed by other type guards.
                     const filteredType = getTypeWithFacts(type, TypeFacts.Discriminatable);
                     if (filteredType !== type && filteredType.flags & TypeFlags.Union) {
-                        prop = getPropertyOfType(type, name);
+                        prop = getPropertyOfType(filteredType, name);
                     }
                 }
                 if (prop && prop.flags & SymbolFlags.SyntheticProperty) {

From 29ae2b2cf153ef7d28a50053c85e637ea2d02915 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Thu, 11 Aug 2016 14:38:17 -0700
Subject: [PATCH 25/29] Add regression tests

---
 .../reference/discriminantsAndPrimitives.js   |  84 +++++++++++
 .../discriminantsAndPrimitives.symbols        | 117 +++++++++++++++
 .../discriminantsAndPrimitives.types          | 141 ++++++++++++++++++
 .../compiler/discriminantsAndPrimitives.ts    |  49 ++++++
 4 files changed, 391 insertions(+)
 create mode 100644 tests/baselines/reference/discriminantsAndPrimitives.js
 create mode 100644 tests/baselines/reference/discriminantsAndPrimitives.symbols
 create mode 100644 tests/baselines/reference/discriminantsAndPrimitives.types
 create mode 100644 tests/cases/compiler/discriminantsAndPrimitives.ts

diff --git a/tests/baselines/reference/discriminantsAndPrimitives.js b/tests/baselines/reference/discriminantsAndPrimitives.js
new file mode 100644
index 0000000000..1d11781a70
--- /dev/null
+++ b/tests/baselines/reference/discriminantsAndPrimitives.js
@@ -0,0 +1,84 @@
+//// [discriminantsAndPrimitives.ts]
+
+// Repro from #10257 plus other tests
+
+interface Foo {
+    kind: "foo";
+    name: string;
+}
+
+interface Bar {
+    kind: "bar";
+    length: string;
+}
+
+function f1(x: Foo | Bar | string) {
+    if (typeof x !== 'string') {
+        switch(x.kind) {
+            case 'foo':
+                x.name;
+        }
+    }
+}
+
+function f2(x: Foo | Bar | string | undefined) {
+    if (typeof x === "object") {
+        switch(x.kind) {
+            case 'foo':
+                x.name;
+        }
+    }
+}
+
+function f3(x: Foo | Bar | string | null) {
+    if (x && typeof x !== "string") {
+        switch(x.kind) {
+            case 'foo':
+                x.name;
+        }
+    }
+}
+
+function f4(x: Foo | Bar | string | number | null) {
+    if (x && typeof x === "object") {
+        switch(x.kind) {
+            case 'foo':
+                x.name;
+        }
+    }
+}
+
+//// [discriminantsAndPrimitives.js]
+// Repro from #10257 plus other tests
+function f1(x) {
+    if (typeof x !== 'string') {
+        switch (x.kind) {
+            case 'foo':
+                x.name;
+        }
+    }
+}
+function f2(x) {
+    if (typeof x === "object") {
+        switch (x.kind) {
+            case 'foo':
+                x.name;
+        }
+    }
+}
+function f3(x) {
+    if (x && typeof x !== "string") {
+        switch (x.kind) {
+            case 'foo':
+                x.name;
+        }
+    }
+}
+function f4(x) {
+    if (x && typeof x === "object") {
+        switch (x.kind) {
+            case 'foo':
+                x.name;
+        }
+    }
+}
diff --git a/tests/baselines/reference/discriminantsAndPrimitives.symbols b/tests/baselines/reference/discriminantsAndPrimitives.symbols
new file mode 100644
index 0000000000..c84f32cd99
--- /dev/null
+++ b/tests/baselines/reference/discriminantsAndPrimitives.symbols
@@ -0,0 +1,117 @@
+=== tests/cases/compiler/discriminantsAndPrimitives.ts ===
+
+// Repro from #10257 plus other tests
+
+interface Foo {
+>Foo : Symbol(Foo, Decl(discriminantsAndPrimitives.ts, 0, 0))
+
+    kind: "foo";
+>kind : Symbol(Foo.kind, Decl(discriminantsAndPrimitives.ts, 3, 15))
+
+    name: string;
+>name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16))
+}
+
+interface Bar {
+>Bar : Symbol(Bar, Decl(discriminantsAndPrimitives.ts, 6, 1))
+
+    kind: "bar";
+>kind : Symbol(Bar.kind, Decl(discriminantsAndPrimitives.ts, 8, 15))
+
+    length: string;
+>length : Symbol(Bar.length, Decl(discriminantsAndPrimitives.ts, 9, 16))
+}
+
+function f1(x: Foo | Bar | string) {
+>f1 : Symbol(f1, Decl(discriminantsAndPrimitives.ts, 11, 1))
+>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 13, 12))
+>Foo : Symbol(Foo, Decl(discriminantsAndPrimitives.ts, 0, 0))
+>Bar : Symbol(Bar, Decl(discriminantsAndPrimitives.ts, 6, 1))
+
+    if (typeof x !== 'string') {
+>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 13, 12))
+
+        switch(x.kind) {
+>x.kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15))
+>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 13, 12))
+>kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15))
+
+            case 'foo':
+                x.name;
+>x.name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16))
+>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 13, 12))
+>name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16))
+        }
+    }
+}
+
+function f2(x: Foo | Bar | string | undefined) {
+>f2 : Symbol(f2, Decl(discriminantsAndPrimitives.ts, 20, 1))
+>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 22, 12))
+>Foo : Symbol(Foo, Decl(discriminantsAndPrimitives.ts, 0, 0))
+>Bar : Symbol(Bar, Decl(discriminantsAndPrimitives.ts, 6, 1))
+
+    if (typeof x === "object") {
+>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 22, 12))
+
+        switch(x.kind) {
+>x.kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15))
+>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 22, 12))
+>kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15))
+
+            case 'foo':
+                x.name;
+>x.name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16))
+>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 22, 12))
+>name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16))
+        }
+    }
+}
+
+function f3(x: Foo | Bar | string | null) {
+>f3 : Symbol(f3, Decl(discriminantsAndPrimitives.ts, 29, 1))
+>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 31, 12))
+>Foo : Symbol(Foo, Decl(discriminantsAndPrimitives.ts, 0, 0))
+>Bar : Symbol(Bar, Decl(discriminantsAndPrimitives.ts, 6, 1))
+
+    if (x && typeof x !== "string") {
+>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 31, 12))
+>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 31, 12))
+
+        switch(x.kind) {
+>x.kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15))
+>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 31, 12))
+>kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15))
+
+            case 'foo':
+                x.name;
+>x.name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16))
+>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 31, 12))
+>name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16))
+        }
+    }
+}
+
+function f4(x: Foo | Bar | string | number | null) {
+>f4 : Symbol(f4, Decl(discriminantsAndPrimitives.ts, 38, 1))
+>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 40, 12))
+>Foo : Symbol(Foo, Decl(discriminantsAndPrimitives.ts, 0, 0))
+>Bar : Symbol(Bar, Decl(discriminantsAndPrimitives.ts, 6, 1))
+
+    if (x && typeof x === "object") {
+>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 40, 12))
+>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 40, 12))
+
+        switch(x.kind) {
+>x.kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15))
+>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 40, 12))
+>kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15))
+
+            case 'foo':
+                x.name;
+>x.name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16))
+>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 40, 12))
+>name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16))
+        }
+    }
+}
diff --git a/tests/baselines/reference/discriminantsAndPrimitives.types b/tests/baselines/reference/discriminantsAndPrimitives.types
new file mode 100644
index 0000000000..d3e1b70e59
--- /dev/null
+++ b/tests/baselines/reference/discriminantsAndPrimitives.types
@@ -0,0 +1,141 @@
+=== tests/cases/compiler/discriminantsAndPrimitives.ts ===
+
+// Repro from #10257 plus other tests
+
+interface Foo {
+>Foo : Foo
+
+    kind: "foo";
+>kind : "foo"
+
+    name: string;
+>name : string
+}
+
+interface Bar {
+>Bar : Bar
+
+    kind: "bar";
+>kind : "bar"
+
+    length: string;
+>length : string
+}
+
+function f1(x: Foo | Bar | string) {
+>f1 : (x: string | Foo | Bar) => void
+>x : string | Foo | Bar
+>Foo : Foo
+>Bar : Bar
+
+    if (typeof x !== 'string') {
+>typeof x !== 'string' : boolean
+>typeof x : string
+>x : string | Foo | Bar
+>'string' : "string"
+
+        switch(x.kind) {
+>x.kind : "foo" | "bar"
+>x : Foo | Bar
+>kind : "foo" | "bar"
+
+            case 'foo':
+>'foo' : "foo"
+
+                x.name;
+>x.name : string
+>x : Foo
+>name : string
+        }
+    }
+}
+
+function f2(x: Foo | Bar | string | undefined) {
+>f2 : (x: string | Foo | Bar | undefined) => void
+>x : string | Foo | Bar | undefined
+>Foo : Foo
+>Bar : Bar
+
+    if (typeof x === "object") {
+>typeof x === "object" : boolean
+>typeof x : string
+>x : string | Foo | Bar | undefined
+>"object" : "object"
+
+        switch(x.kind) {
+>x.kind : "foo" | "bar"
+>x : Foo | Bar
+>kind : "foo" | "bar"
+
+            case 'foo':
+>'foo' : "foo"
+
+                x.name;
+>x.name : string
+>x : Foo
+>name : string
+        }
+    }
+}
+
+function f3(x: Foo | Bar | string | null) {
+>f3 : (x: string | Foo | Bar | null) => void
+>x : string | Foo | Bar | null
+>Foo : Foo
+>Bar : Bar
+>null : null
+
+    if (x && typeof x !== "string") {
+>x && typeof x !== "string" : boolean | "" | null
+>x : string | Foo | Bar | null
+>typeof x !== "string" : boolean
+>typeof x : string
+>x : string | Foo | Bar
+>"string" : "string"
+
+        switch(x.kind) {
+>x.kind : "foo" | "bar"
+>x : Foo | Bar
+>kind : "foo" | "bar"
+
+            case 'foo':
+>'foo' : "foo"
+
+                x.name;
+>x.name : string
+>x : Foo
+>name : string
+        }
+    }
+}
+
+function f4(x: Foo | Bar | string | number | null) {
+>f4 : (x: string | number | Foo | Bar | null) => void
+>x : string | number | Foo | Bar | null
+>Foo : Foo
+>Bar : Bar
+>null : null
+
+    if (x && typeof x === "object") {
+>x && typeof x === "object" : boolean | "" | 0 | null
+>x : string | number | Foo | Bar | null
+>typeof x === "object" : boolean
+>typeof x : string
+>x : string | number | Foo | Bar
+>"object" : "object"
+
+        switch(x.kind) {
+>x.kind : "foo" | "bar"
+>x : Foo | Bar
+>kind : "foo" | "bar"
+
+            case 'foo':
+>'foo' : "foo"
+
+                x.name;
+>x.name : string
+>x : Foo
+>name : string
+        }
+    }
+}
diff --git a/tests/cases/compiler/discriminantsAndPrimitives.ts b/tests/cases/compiler/discriminantsAndPrimitives.ts
new file mode 100644
index 0000000000..6352d74180
--- /dev/null
+++ b/tests/cases/compiler/discriminantsAndPrimitives.ts
@@ -0,0 +1,49 @@
+// @strictNullChecks: true
+
+// Repro from #10257 plus other tests
+
+interface Foo {
+    kind: "foo";
+    name: string;
+}
+
+interface Bar {
+    kind: "bar";
+    length: string;
+}
+
+function f1(x: Foo | Bar | string) {
+    if (typeof x !== 'string') {
+        switch(x.kind) {
+            case 'foo':
+                x.name;
+        }
+    }
+}
+
+function f2(x: Foo | Bar | string | undefined) {
+    if (typeof x === "object") {
+        switch(x.kind) {
+            case 'foo':
+                x.name;
+        }
+    }
+}
+
+function f3(x: Foo | Bar | string | null) {
+    if (x && typeof x !== "string") {
+        switch(x.kind) {
+            case 'foo':
+                x.name;
+        }
+    }
+}
+
+function f4(x: Foo | Bar | string | number | null) {
+    if (x && typeof x === "object") {
+        switch(x.kind) {
+            case 'foo':
+                x.name;
+        }
+    }
+}
\ No newline at end of file

From 644d6554fb3d4d9d2afb3ea494d695a303ae7712 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Thu, 11 Aug 2016 16:04:46 -0700
Subject: [PATCH 26/29] Optimize core filter function to only allocate when
 necessary

---
 src/compiler/core.ts | 24 ++++++++++++++++++------
 1 file changed, 18 insertions(+), 6 deletions(-)

diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index 549410159b..1d89d0092f 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -147,17 +147,29 @@ namespace ts {
         return count;
     }
 
+    /**
+     * Filters an array by a predicate function. Returns the same array instance if the predicate is
+     * true for all elements, otherwise returns a new array instance containing the filtered subset.
+     */
     export function filter<T>(array: T[], f: (x: T) => boolean): T[] {
-        let result: T[];
         if (array) {
-            result = [];
-            for (const item of array) {
-                if (f(item)) {
-                    result.push(item);
+            const len = array.length;
+            let i = 0;
+            while (i < len && f(array[i])) i++;
+            if (i < len) {
+                const result = array.slice(0, i);
+                i++;
+                while (i < len) {
+                    const item = array[i];
+                    if (f(item)) {
+                        result.push(item);
+                    }
+                    i++;
                 }
+                return result;
             }
         }
-        return result;
+        return array;
     }
 
     export function filterMutate<T>(array: T[], f: (x: T) => boolean): void {

From f1ea145e052cea7af3a9cbdf42f07d4f2728cb45 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Thu, 11 Aug 2016 16:06:03 -0700
Subject: [PATCH 27/29] Address CR comments + more optimizations

---
 src/compiler/checker.ts | 57 +++++++++--------------------------------
 1 file changed, 12 insertions(+), 45 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index b6d0373781..0fb626e628 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -7852,7 +7852,7 @@ namespace ts {
             if (type && type.flags & TypeFlags.Union) {
                 let prop = getPropertyOfType(type, name);
                 if (!prop) {
-                    // The type may be a union that includes nullable or primtive types. If filtering
+                    // The type may be a union that includes nullable or primitive types. If filtering
                     // those out produces a different type, get the property from that type instead.
                     // Effectively, we're checking if this *could* be a discriminant property once nullable
                     // and primitive types are removed by other type guards.
@@ -7915,10 +7915,10 @@ namespace ts {
         // For example, when a variable of type number | string | boolean is assigned a value of type number | boolean,
         // we remove type string.
         function getAssignmentReducedType(declaredType: UnionType, assignedType: Type) {
-            if (declaredType !== assignedType && declaredType.flags & TypeFlags.Union) {
-                const reducedTypes = filter(declaredType.types, t => typeMaybeAssignableTo(assignedType, t));
-                if (reducedTypes.length) {
-                    return reducedTypes.length === 1 ? reducedTypes[0] : getUnionType(reducedTypes);
+            if (declaredType !== assignedType) {
+                const reducedType = filterType(declaredType, t => typeMaybeAssignableTo(assignedType, t));
+                if (reducedType !== neverType) {
+                    return reducedType;
                 }
             }
             return declaredType;
@@ -7992,26 +7992,7 @@ namespace ts {
         }
 
         function getTypeWithFacts(type: Type, include: TypeFacts) {
-            if (!(type.flags & TypeFlags.Union)) {
-                return getTypeFacts(type) & include ? type : neverType;
-            }
-            const types = (<UnionType>type).types;
-            const length = types.length;
-            let i = 0;
-            while (i < length && getTypeFacts(types[i]) & include) i++;
-            if (i === length) {
-                return type;
-            }
-            const filtered = types.slice(0, i);
-            i++;
-            while (i < length) {
-                const t = types[i];
-                if (getTypeFacts(t) & include) {
-                    filtered.push(t);
-                }
-                i++;
-            }
-            return getUnionType(filtered);
+            return filterType(type, t => (getTypeFacts(t) & include) !== 0);
         }
 
         function getTypeWithDefault(type: Type, defaultExpression: Expression) {
@@ -8191,22 +8172,8 @@ namespace ts {
                 return f(type) ? type : neverType;
             }
             const types = (<UnionType>type).types;
-            const length = types.length;
-            let i = 0;
-            while (i < length && f(types[i])) i++;
-            if (i === length) {
-                return type;
-            }
-            const filtered = types.slice(0, i);
-            i++;
-            while (i < length) {
-                const t = types[i];
-                if (f(t)) {
-                    filtered.push(t);
-                }
-                i++;
-            }
-            return getUnionType(filtered);
+            const filtered = filter(types, f);
+            return filtered === types ? type : getUnionType(filtered);
         }
 
         function isIncomplete(flowType: FlowType) {
@@ -8544,7 +8511,7 @@ namespace ts {
                 }
                 if (assumeTrue && !(type.flags & TypeFlags.Union)) {
                     // We narrow a non-union type to an exact primitive type if the non-union type
-                    // is a supertype of that primtive type. For example, type 'any' can be narrowed
+                    // is a supertype of that primitive type. For example, type 'any' can be narrowed
                     // to one of the primitive types.
                     const targetType = getProperty(typeofTypesByName, literal.text);
                     if (targetType && isTypeSubtypeOf(targetType, type)) {
@@ -8633,9 +8600,9 @@ namespace ts {
                 // If the current type is a union type, remove all constituents that couldn't be instances of
                 // the candidate type. If one or more constituents remain, return a union of those.
                 if (type.flags & TypeFlags.Union) {
-                    const assignableConstituents = filter((<UnionType>type).types, t => isTypeInstanceOf(t, candidate));
-                    if (assignableConstituents.length) {
-                        return getUnionType(assignableConstituents);
+                    const assignableType = filterType(type, t => isTypeInstanceOf(t, candidate));
+                    if (assignableType !== neverType) {
+                        return assignableType;
                     }
                 }
                 // If the candidate type is a subtype of the target type, narrow to the candidate type.

From e64675eb85ad9bf346e0cd7495cb98e258be221d Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Fri, 12 Aug 2016 06:54:51 -0700
Subject: [PATCH 28/29] Faster path for creating union types from filterType

---
 src/compiler/checker.ts | 36 ++++++++++++++++++++++--------------
 1 file changed, 22 insertions(+), 14 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 0fb626e628..4e04c5fc11 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -5352,12 +5352,12 @@ namespace ts {
             }
         }
 
-        // We deduplicate the constituent types based on object identity. If the subtypeReduction flag is
-        // specified we also reduce the constituent type set to only include types that aren't subtypes of
-        // other types. Subtype reduction is expensive for large union types and is possible only when union
+        // We sort and deduplicate the constituent types based on object identity. If the subtypeReduction
+        // flag is specified we also reduce the constituent type set to only include types that aren't subtypes
+        // of other types. Subtype reduction is expensive for large union types and is possible only when union
         // types are known not to circularly reference themselves (as is the case with union types created by
         // expression constructs such as array literals and the || and ?: operators). Named types can
-        // circularly reference themselves and therefore cannot be deduplicated during their declaration.
+        // circularly reference themselves and therefore cannot be subtype reduced during their declaration.
         // For example, "type Item = string | (() => Item" is a named type that circularly references itself.
         function getUnionType(types: Type[], subtypeReduction?: boolean, aliasSymbol?: Symbol, aliasTypeArguments?: Type[]): Type {
             if (types.length === 0) {
@@ -5379,15 +5379,23 @@ namespace ts {
                     typeSet.containsUndefined ? typeSet.containsNonWideningType ? undefinedType : undefinedWideningType :
                         neverType;
             }
-            else if (typeSet.length === 1) {
-                return typeSet[0];
+            return getUnionTypeFromSortedList(typeSet, aliasSymbol, aliasTypeArguments);
+        }
+
+        // This function assumes the constituent type list is sorted and deduplicated.
+        function getUnionTypeFromSortedList(types: Type[], aliasSymbol?: Symbol, aliasTypeArguments?: Type[]): Type {
+            if (types.length === 0) {
+                return neverType;
             }
-            const id = getTypeListId(typeSet);
+            if (types.length === 1) {
+                return types[0];
+            }
+            const id = getTypeListId(types);
             let type = unionTypes[id];
             if (!type) {
-                const propagatedFlags = getPropagatingFlagsOfTypes(typeSet, /*excludeKinds*/ TypeFlags.Nullable);
+                const propagatedFlags = getPropagatingFlagsOfTypes(types, /*excludeKinds*/ TypeFlags.Nullable);
                 type = unionTypes[id] = <UnionType>createObjectType(TypeFlags.Union | propagatedFlags);
-                type.types = typeSet;
+                type.types = types;
                 type.aliasSymbol = aliasSymbol;
                 type.aliasTypeArguments = aliasTypeArguments;
             }
@@ -8168,12 +8176,12 @@ namespace ts {
         }
 
         function filterType(type: Type, f: (t: Type) => boolean): Type {
-            if (!(type.flags & TypeFlags.Union)) {
-                return f(type) ? type : neverType;
+            if (type.flags & TypeFlags.Union) {
+                const types = (<UnionType>type).types;
+                const filtered = filter(types, f);
+                return filtered === types ? type : getUnionTypeFromSortedList(filtered);
             }
-            const types = (<UnionType>type).types;
-            const filtered = filter(types, f);
-            return filtered === types ? type : getUnionType(filtered);
+            return f(type) ? type : neverType;
         }
 
         function isIncomplete(flowType: FlowType) {

From df739fdd50b3ea3fcd8a5bd04614fe2093a4aa39 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Thu, 11 Aug 2016 12:26:22 -0700
Subject: [PATCH 29/29] Allow an @types direcotry to have a package.json which
 specifies `"typings": null` to disclude it from automatically included
 typings.

---
 src/compiler/program.ts                       | 89 ++++++++++---------
 src/harness/compilerRunner.ts                 |  2 +-
 src/harness/fourslash.ts                      | 19 ++--
 tests/baselines/reference/typingsLookup2.js   |  9 ++
 .../reference/typingsLookup2.symbols          |  3 +
 .../reference/typingsLookup2.trace.json       |  1 +
 .../baselines/reference/typingsLookup2.types  |  3 +
 .../conformance/typings/typingsLookup2.ts     | 13 +++
 8 files changed, 86 insertions(+), 53 deletions(-)
 create mode 100644 tests/baselines/reference/typingsLookup2.js
 create mode 100644 tests/baselines/reference/typingsLookup2.symbols
 create mode 100644 tests/baselines/reference/typingsLookup2.trace.json
 create mode 100644 tests/baselines/reference/typingsLookup2.types
 create mode 100644 tests/cases/conformance/typings/typingsLookup2.ts

diff --git a/src/compiler/program.ts b/src/compiler/program.ts
index 7d40b2f321..67a93606cc 100644
--- a/src/compiler/program.ts
+++ b/src/compiler/program.ts
@@ -119,49 +119,31 @@ namespace ts {
     }
 
     function tryReadTypesSection(packageJsonPath: string, baseDirectory: string, state: ModuleResolutionState): string {
-        let jsonContent: { typings?: string, types?: string, main?: string };
-        try {
-            const jsonText = state.host.readFile(packageJsonPath);
-            jsonContent = jsonText ? <{ typings?: string, types?: string, main?: string }>JSON.parse(jsonText) : {};
-        }
-        catch (e) {
-            // gracefully handle if readFile fails or returns not JSON
-            jsonContent = {};
+        const jsonContent = readJson(packageJsonPath, state.host);
+
+        function tryReadFromField(fieldName: string) {
+            if (hasProperty(jsonContent, fieldName)) {
+                const typesFile = (<any>jsonContent)[fieldName];
+                if (typeof typesFile === "string") {
+                    const typesFilePath = normalizePath(combinePaths(baseDirectory, typesFile));
+                    if (state.traceEnabled) {
+                        trace(state.host, Diagnostics.package_json_has_0_field_1_that_references_2, fieldName, typesFile, typesFilePath);
+                    }
+                    return typesFilePath;
+                }
+                else {
+                    if (state.traceEnabled) {
+                        trace(state.host, Diagnostics.Expected_type_of_0_field_in_package_json_to_be_string_got_1, fieldName, typeof typesFile);
+                    }
+                }
+            }
         }
 
-        let typesFile: string;
-        let fieldName: string;
-        // first try to read content of 'typings' section (backward compatibility)
-        if (jsonContent.typings) {
-            if (typeof jsonContent.typings === "string") {
-                fieldName = "typings";
-                typesFile = jsonContent.typings;
-            }
-            else {
-                if (state.traceEnabled) {
-                    trace(state.host, Diagnostics.Expected_type_of_0_field_in_package_json_to_be_string_got_1, "typings", typeof jsonContent.typings);
-                }
-            }
-        }
-        // then read 'types'
-        if (!typesFile && jsonContent.types) {
-            if (typeof jsonContent.types === "string") {
-                fieldName = "types";
-                typesFile = jsonContent.types;
-            }
-            else {
-                if (state.traceEnabled) {
-                    trace(state.host, Diagnostics.Expected_type_of_0_field_in_package_json_to_be_string_got_1, "types", typeof jsonContent.types);
-                }
-            }
-        }
-        if (typesFile) {
-            const typesFilePath = normalizePath(combinePaths(baseDirectory, typesFile));
-            if (state.traceEnabled) {
-                trace(state.host, Diagnostics.package_json_has_0_field_1_that_references_2, fieldName, typesFile, typesFilePath);
-            }
+        const typesFilePath = tryReadFromField("typings") || tryReadFromField("types");
+        if (typesFilePath) {
             return typesFilePath;
         }
+
         // Use the main module for inferring types if no types package specified and the allowJs is set
         if (state.compilerOptions.allowJs && jsonContent.main && typeof jsonContent.main === "string") {
             if (state.traceEnabled) {
@@ -173,6 +155,17 @@ namespace ts {
         return undefined;
     }
 
+    function readJson(path: string, host: ModuleResolutionHost): { typings?: string, types?: string, main?: string } {
+        try {
+            const jsonText = host.readFile(path);
+            return jsonText ? JSON.parse(jsonText) : {};
+        }
+        catch (e) {
+            // gracefully handle if readFile fails or returns not JSON
+            return {};
+        }
+    }
+
     const typeReferenceExtensions = [".d.ts"];
 
     function getEffectiveTypeRoots(options: CompilerOptions, host: ModuleResolutionHost) {
@@ -717,7 +710,7 @@ namespace ts {
     }
 
     function loadNodeModuleFromDirectory(extensions: string[], candidate: string, failedLookupLocation: string[], onlyRecordFailures: boolean, state: ModuleResolutionState): string {
-        const packageJsonPath = combinePaths(candidate, "package.json");
+        const packageJsonPath = pathToPackageJson(candidate);
         const directoryExists = !onlyRecordFailures && directoryProbablyExists(candidate, state.host);
         if (directoryExists && state.host.fileExists(packageJsonPath)) {
             if (state.traceEnabled) {
@@ -747,6 +740,10 @@ namespace ts {
         return loadModuleFromFile(combinePaths(candidate, "index"), extensions, failedLookupLocation, !directoryExists, state);
     }
 
+    function pathToPackageJson(directory: string): string {
+        return combinePaths(directory, "package.json");
+    }
+
     function loadModuleFromNodeModulesFolder(moduleName: string, directory: string, failedLookupLocations: string[], state: ModuleResolutionState): string {
         const nodeModulesFolder = combinePaths(directory, "node_modules");
         const nodeModulesFolderExists = directoryProbablyExists(nodeModulesFolder, state.host);
@@ -1070,15 +1067,21 @@ namespace ts {
         }
 
         // Walk the primary type lookup locations
-        let result: string[] = [];
+        const result: string[] = [];
         if (host.directoryExists && host.getDirectories) {
             const typeRoots = getEffectiveTypeRoots(options, host);
             if (typeRoots) {
                 for (const root of typeRoots) {
                     if (host.directoryExists(root)) {
                         for (const typeDirectivePath of host.getDirectories(root)) {
-                            // Return just the type directive names
-                            result = result.concat(getBaseFileName(normalizePath(typeDirectivePath)));
+                            const normalized = normalizePath(typeDirectivePath);
+                            const packageJsonPath = pathToPackageJson(combinePaths(root, normalized));
+                            // tslint:disable-next-line:no-null-keyword
+                            const isNotNeededPackage = host.fileExists(packageJsonPath) && readJson(packageJsonPath, host).typings === null;
+                            if (!isNotNeededPackage) {
+                                // Return just the type directive names
+                                result.push(getBaseFileName(normalized));
+                            }
                         }
                     }
                 }
diff --git a/src/harness/compilerRunner.ts b/src/harness/compilerRunner.ts
index ecdc18394b..35e09c9c0d 100644
--- a/src/harness/compilerRunner.ts
+++ b/src/harness/compilerRunner.ts
@@ -52,7 +52,7 @@ class CompilerBaselineRunner extends RunnerBase {
     private makeUnitName(name: string, root: string) {
         const path = ts.toPath(name, root, (fileName) => Harness.Compiler.getCanonicalFileName(fileName));
         const pathStart = ts.toPath(Harness.IO.getCurrentDirectory(), "", (fileName) => Harness.Compiler.getCanonicalFileName(fileName));
-        return path.replace(pathStart, "/");
+        return pathStart ? path.replace(pathStart, "/") : path;
     };
 
     public checkTestCodeOutput(fileName: string) {
diff --git a/src/harness/fourslash.ts b/src/harness/fourslash.ts
index a42abbbc60..620eee584e 100644
--- a/src/harness/fourslash.ts
+++ b/src/harness/fourslash.ts
@@ -2395,13 +2395,14 @@ ${code}
                 // Comment line, check for global/file @options and record them
                 const match = optionRegex.exec(line.substr(2));
                 if (match) {
-                    const fileMetadataNamesIndex = fileMetadataNames.indexOf(match[1]);
+                    const [key, value] = match.slice(1);
+                    const fileMetadataNamesIndex = fileMetadataNames.indexOf(key);
                     if (fileMetadataNamesIndex === -1) {
                         // Check if the match is already existed in the global options
-                        if (globalOptions[match[1]] !== undefined) {
-                            throw new Error("Global Option : '" + match[1] + "' is already existed");
+                        if (globalOptions[key] !== undefined) {
+                            throw new Error(`Global option '${key}' already exists`);
                         }
-                        globalOptions[match[1]] = match[2];
+                        globalOptions[key] = value;
                     }
                     else {
                         if (fileMetadataNamesIndex === fileMetadataNames.indexOf(metadataOptionNames.fileName)) {
@@ -2416,12 +2417,12 @@ ${code}
                                 resetLocalData();
                             }
 
-                            currentFileName = basePath + "/" + match[2];
-                            currentFileOptions[match[1]] = match[2];
+                            currentFileName = basePath + "/" + value;
+                            currentFileOptions[key] = value;
                         }
                         else {
                             // Add other fileMetadata flag
-                            currentFileOptions[match[1]] = match[2];
+                            currentFileOptions[key] = value;
                         }
                     }
                 }
@@ -2509,7 +2510,7 @@ ${code}
         }
 
         const marker: Marker = {
-            fileName: fileName,
+            fileName,
             position: location.position,
             data: markerValue
         };
@@ -2526,7 +2527,7 @@ ${code}
 
     function recordMarker(fileName: string, location: LocationInformation, name: string, markerMap: MarkerMap, markers: Marker[]): Marker {
         const marker: Marker = {
-            fileName: fileName,
+            fileName,
             position: location.position
         };
 
diff --git a/tests/baselines/reference/typingsLookup2.js b/tests/baselines/reference/typingsLookup2.js
new file mode 100644
index 0000000000..3e816526af
--- /dev/null
+++ b/tests/baselines/reference/typingsLookup2.js
@@ -0,0 +1,9 @@
+//// [tests/cases/conformance/typings/typingsLookup2.ts] ////
+
+//// [package.json]
+{ "typings": null }
+
+//// [a.ts]
+
+
+//// [a.js]
diff --git a/tests/baselines/reference/typingsLookup2.symbols b/tests/baselines/reference/typingsLookup2.symbols
new file mode 100644
index 0000000000..7223c8589a
--- /dev/null
+++ b/tests/baselines/reference/typingsLookup2.symbols
@@ -0,0 +1,3 @@
+=== /a.ts ===
+
+No type information for this code.
\ No newline at end of file
diff --git a/tests/baselines/reference/typingsLookup2.trace.json b/tests/baselines/reference/typingsLookup2.trace.json
new file mode 100644
index 0000000000..0637a088a0
--- /dev/null
+++ b/tests/baselines/reference/typingsLookup2.trace.json
@@ -0,0 +1 @@
+[]
\ No newline at end of file
diff --git a/tests/baselines/reference/typingsLookup2.types b/tests/baselines/reference/typingsLookup2.types
new file mode 100644
index 0000000000..7223c8589a
--- /dev/null
+++ b/tests/baselines/reference/typingsLookup2.types
@@ -0,0 +1,3 @@
+=== /a.ts ===
+
+No type information for this code.
\ No newline at end of file
diff --git a/tests/cases/conformance/typings/typingsLookup2.ts b/tests/cases/conformance/typings/typingsLookup2.ts
new file mode 100644
index 0000000000..90e1e463f0
--- /dev/null
+++ b/tests/cases/conformance/typings/typingsLookup2.ts
@@ -0,0 +1,13 @@
+// @traceResolution: true
+// @noImplicitReferences: true
+// @currentDirectory: /
+// This tests that an @types package with `"typings": null` is not automatically included.
+// (If it were, this test would break because there are no typings to be found.)
+
+// @filename: /tsconfig.json
+{}
+
+// @filename: /node_modules/@types/angular2/package.json
+{ "typings": null }
+
+// @filename: /a.ts