[Transforms] Merge master 08/09 (#10263)

* Improve error message

* Remove `SupportedExpressionWithTypeArguments` type; just check that the expression of each `ExpressionWithTypeArguments` is an `EntityNameExpression`.

* Fix bug

* Fix #10083 - allowSyntheticDefaultImports alters getExternalModuleMember (#10096)

* Use recursion, and fix error for undefined node

* Rename function

* Fix lint error

* Narrowing type parameter intersects w/narrowed types

This makes sure that a union type that includes a type parameter is
still usable as the actual type that the type guard narrows to.

* Don't allow ".d.ts" extension in an import either.

* Add a helper function `getOrUpdateProperty` to prevent unprotected access to Maps.

* Limit type guards as assertions to incomplete types in loops

* Accept new baselines

* Fix linting error

* Allow JS multiple declarations of ctor properties

When a property is declared in the constructor and on the prototype of
an ES6 class, the property's symbol is discarded in favour of the
method's symbol. That because the usual use for this pattern is to bind
an instance function: `this.m = this.m.bind(this)`. In this case the
type you want really is the method's type.

* Use {} type facts for unconstrained type params

Previously it was using TypeFacts.All. But the constraint of an
unconstrained type parameter is actually {}.

* Fix newline lint

* Test that declares conflicting method first

* [Release-2.0] Fix 9662: Visual Studio 2015 with TS2.0 gives incorrect @types path resolution errors (#9867)

* Change the shape of the shim layer to support getAutomaticTypeDirectives

* Change the key for looking up automatic type-directives

* Update baselines from change look-up name of type-directives

* Add @currentDirectory into the test

* Update baselines

* Fix linting error

* Address PR: fix spelling mistake

* Instead of return path of the type directive names just return type directive names

* Remove unused reference files: these tests produce erros so they will not produce these files (#9233)

* Add string-literal completion test for jsdoc

* Support other (new) literal types in jsdoc

* Don't allow properties inherited from Object to be automatically included in TSX attributes

* Add new test baseline and delete else in binder

The extra `else` caused a ton of test failures!

* Fix lint

* Port PR #10016 to Master (#10100)

* Treat namespaceExportDeclaration as declaration

* Update baselines

* wip - add tests

* Add tests

* Show "export namespace" for quick-info

* Fix more lint

* Try using runtests-parallel for CI (#9970)

* Try using runtests-parallel for CI

* Put worker count setting into .travis.yml

* Reduce worker count to 4 - 8 wasnt much different from 4-6 but had contention issues causing timeouts

* Fix lssl task (#9967)

* Surface noErrorTruncation option

* Stricter check for discriminant properties in type guards

* Add tests

* Emit more efficient/concise "empty" ES6 ctor

When there are property assignments in a the class body of an inheriting
class, tsc current emit the following compilation:

```ts
class Foo extends Bar {
  public foo = 1;
}
```

```js
class Foo extends Bar {
  constructor(…args) {
    super(…args);
    this.foo = 1;
  }
}
```

This introduces an unneeded local variable and might force a reification
of the `arguments` object (or otherwise reify the arguments into an
array).

This is particularly bad when that output is fed into another transpiler
like Babel. In Babel, you get something like this today:


```js
var Foo = (function (_Bar) {
  _inherits(Foo, _Bar);

  function Foo() {
    _classCallCheck(this, Foo);

    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    _Bar.call.apply(_Bar, [this].concat(args));
    this.foo = 1;
  }

  return Foo;
})(Bar);
```

This causes a lot of needless work/allocations and some very strange
code (`.call.apply` o_0).

Admittedly, this is not strictly tsc’s problem; it could have done a
deeper analysis of the code and optimized out the extra dance. However,
tsc could also have emitted this simpler, more concise and semantically
equivalent code in the first place:


```js
class Foo extends Bar {
  constructor() {
    super(…arguments);
    this.foo = 1;
  }
}
```

Which compiles into the following in Babel:

```js
var Foo = (function (_Bar) {
  _inherits(Foo, _Bar);

  function Foo() {
    _classCallCheck(this, Foo);

    _Bar.apply(this, arguments);
    this.foo = 1;
  }

  return Foo;
})(Bar);
```

Which is well-optimized (today) in most engines and much less confusing
to read.

As far as I can tell, the proposed compilation has exactly the same
semantics as before.

Fixes #10175

* Fix instanceof operator narrowing issues

* Accept new baselines

* Add regression test

* Improve naming and documentation from PR

* Update comment

* Add more tests

* Accept new baselines

* Reduce worker count to 3 (#10210)

Since we saw a starvation issue on one of @sandersn's PRs.

* Speed up fourslash tests

* Duh

* Make baselines faster by not writing out unneeded files

* Fix non-strict-compliant test

* Fix 10076: Fix Tuple Destructing with "this" (#10208)

* Call checkExpression eventhough there is no appropriate type from destructuring of array

* Add tests and baselines

* use transpileModule

* Remove use strict

* Improve instanceof for structurally identical types

* Introduce isTypeInstanceOf function

* Add test

* Accept new baselines

* Fix loop over array to use for-of instead of for-in

* Use correct this in tuple type parameter constraints

Instantiate this in tuple types used as type parameter constraints

* Add explanatory comment to resolveTupleTypeMembers

* Ignore null, undefined, void when checking for discriminant property

* Add regression test

* Delay tuple type constraint resolution

Create a new tuple that stores the this-type.

* Always use thisType when generating tuple id

* Optimize format of type list id strings used in maps

* wip - fix error

* Make ReadonlyArray iterable.

* Allow OSX to fail while we investigate (#10255)

The random test timeouts are an issue.

* Fix error from using merging master

* avoid using the global name

* Fix single-quote lint

* Update baselines

* Fix linting

* Optimize performance of maps

* Update API sample

* Fix processDiagnosticMessages script

* 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.

* Add folds to travis log (#10269)

* Optimize filterType to only call getUnionType if necessary

* Add shorthand types declaration for travis-fold (#10293)

* Optimize getTypeWithFacts

* Filter out nullable and primitive types in isDiscriminantProperty

* Fix typo

* Add regression tests

* Optimize core filter function to only allocate when necessary

* Address CR comments + more optimizations

* Faster path for creating union types from filterType

* Allow an @types direcotry to have a package.json which specifies `"typings": null` to disclude it from automatically included typings.

* Lint

* Collect timing information for commands running on travis (#10308)

* Simplifies performance API

* Use 'MapLike' instead of 'Map' in 'preferConstRule.ts'.

* narrow from 'any' in most situations

instanceof and user-defined typeguards narrow from 'any' unless the narrowed-to type is exactly 'Object' or 'Function'. This is a breaking change.

* Update instanceof conformance tests

* accept new baselines

* add tests

* accept new baselines

* Use lowercase names for type reference directives

* Use proper response codes in web tests

* Treat ambient shorthand declarations as explicit uses of the `any` type

* Rename 'find' functions

* Parallel linting (#10313)

* A perilous thing, a parallel lint

* Use work queue rather than scheduling work

* Dont read files for lint on main thread

* Fix style

* Fix the style fix (#10344)

* Aligned mark names with values used by ts-perf.

* Use an enum in checkClassForDuplicateDeclarations to aid readability

* Rename to Accessor

* Migrated more MapLikes to Maps

* Add ES2015 Date constructor signature that accepts another Date (#10353)

* Parameters with no assignments implicitly considered const

* Add tests

* Migrate additional MapLikes to Maps.

* Fix 10625: JSX Not validating when index signature is present  (#10352)

* Check for type of property declaration before using index signature

* Add tests and baselines

* fix linting error

* Adding more comments

* Clean up/move some Map helper functions.

* Revert some formatting changes.

* Improve ReadonlyArray<T>.concat to match Array<T>

The Array-based signature was incorrect and also out-of-date.

* Fix link to blog

* Remove old assertion about when we're allowed to use fileExists

* Set isNewIdentifierLocation to true for JavaScript files

* Update error message for conflicting type definitions

Fixes #10370

* Explain why we lower-case type reference directives

* Correctly merge bindThisPropertyAssignment

Also simply it considerably after noticing that it's *only* called for
Javascript files, so there was a lot of dead code for TS cases that
never happened.

* Fix comment

* Property handle imcomplete control flow types in nested loops

* Update due to CR suggestion

* Add regression test

* Assign and instantiate contextual this type if not present

* Fix 10289: correctly generate tsconfig.json with --lib (#10355)

* Separate generate tsconfig into its own function and implement init with --lib

# Conflicts:
#	src/compiler/tsc.ts

* Add tests and baselines; Update function name

Add unittests and baselines
Add unittests and baselines for generating tsconfig

Move unittest into harness folder

Update harness tsconfig.json

USe correct function name

* Use new MapLike interstead. Update unittest

# Conflicts:
#	src/compiler/commandLineParser.ts

* Update JakeFile

* Add tests for incorrect cases

* Address PR : remove explicity write node_modules

* JSDoc supports null, undefined and never types

* Update baselines in jsDocParsing unit tests

* Restored comments to explain spreading 'arguments' into calls to 'super'.

* Added test.

* Use the non-nullable type of the contextual type for object completions.

* Return non-JsDocComment children
... to make syntactic classification work

* Add more tests for `export = foo.bar`.

* Output test baselines to tests/baselines/local instead of root

* Move supportedTypescriptExtensionsWithDtsFirst next to supportedTypeScriptExtensions and rename

* Fix comment

* Fix RWC Runner (#10420)

* Use /// <reference types

* Don't report an errors if it comes from lib.d.ts

* Treat special property access symbol differently
... when retriving documentation

* Fix tests

* Update shim version to be 2.1 (#10424)

* Check return code paths on getters (#10102)

* Check return paths on getters

* Remove TODO comment

* Remove extraneous arguments from harness's runBaseline (#10419)

* Remove extraneous arguments from runBaseline

* Address comments from @yuit

* Remove needless call to basename

* Refactor baseliners out of compiler runner (#10440)

* CR feedback

* fix broken tests

* Pass in baselineOpts into types baselines so that RWC baselines can be written to internal folder (#10443)

* Add error message

Add error message when trying to relate primitives to the boxed/apparent
backing types.

* fix linting error

* follow advise

* remove extra code

* Add more test for 10426

* fix some errors

* routine update of dom libs

* Add test for jsdoc syntactic classification for function declaration

* Simplify implementation

* Tolerate certain errors in tsconfig.json

* Add test for configFile error tolerance

* Use TS parser to tolerate more errors in tsconfig.json

* Implement tuple types as type references to synthesized generic types

* Add comments + minor changes

* Accept new baselines

* Add .types extension

* Properly guard for undefined in getTypeReferenceArity

* Add jsdoc nullable union test case to fourslash

* Fix class/interface merging issue + lint error

* Allow "typings" in a package.json to be missing its extension (but also allow it to have an extension)

* Contextually type this in getDeclFromSig, not checkThisExpr

* Update parser comment with es7 grammar (#10459)

* Use ES7 term of ExponentiationExpression

* Update timeout for mac OS

* Address PR: add space

* allowSyntheticDefaultImports resolves to modules instead of variables

Fixes #10429 by improving the fix in #10096

* Rename getContextuallyTypedThisParameter to getContextualThisParameter

* Fix 10472: Invalid emitted code for await expression (#10483)

* Properly emit await expression with yield expression

* Add tests and update baselines

* Move parsing await expression into parse unary-expression

* Update incorrect comment

* change error message

* Fix broken build from merging with master

* Fix linting error

src/compiler/binder.ts

@@ -89,9 +89,10 @@ namespace ts {
     const binder = createBinder();
 
     export function bindSourceFile(file: SourceFile, options: CompilerOptions) {
-        const start = performance.mark();
+        performance.mark("beforeBind");
         binder(file, options);
-        performance.measure("Bind", start);
+        performance.mark("afterBind");
+        performance.measure("Bind", "beforeBind", "afterBind");
     }
 
     function createBinder(): (file: SourceFile, options: CompilerOptions) => void {
@@ -139,7 +140,7 @@ namespace ts {
             options = opts;
             languageVersion = getEmitScriptTarget(options);
             inStrictMode = !!file.externalModuleIndicator;
-            classifiableNames = {};
+            classifiableNames = createMap<string>();
             symbolCount = 0;
             skipTransformFlagAggregation = isDeclarationFile(file);
 
@@ -189,11 +190,11 @@ namespace ts {
             symbol.declarations.push(node);
 
             if (symbolFlags & SymbolFlags.HasExports && !symbol.exports) {
-                symbol.exports = {};
+                symbol.exports = createMap<Symbol>();
             }
 
             if (symbolFlags & SymbolFlags.HasMembers && !symbol.members) {
-                symbol.members = {};
+                symbol.members = createMap<Symbol>();
             }
 
             if (symbolFlags & SymbolFlags.Value) {
@@ -304,8 +305,10 @@ namespace ts {
             const name = isDefaultExport && parent ? "default" : getDeclarationName(node);
 
             let symbol: Symbol;
-            if (name !== undefined) {
-
+            if (name === undefined) {
+                symbol = createSymbol(SymbolFlags.None, "__missing");
+            }
+            else {
                 // Check and see if the symbol table already has a symbol with this name.  If not,
                 // create a new symbol with this name and add it to the table.  Note that we don't
                 // give the new symbol any flags *yet*.  This ensures that it will not conflict
@@ -317,6 +320,11 @@ namespace ts {
                 // declaration we have for this symbol, and then create a new symbol for this
                 // declaration.
                 //
+                // Note that when properties declared in Javascript constructors
+                // (marked by isReplaceableByMethod) conflict with another symbol, the property loses.
+                // Always. This allows the common Javascript pattern of overwriting a prototype method
+                // with an bound instance method of the same type: `this.method = this.method.bind(this)`
+                //
                 // If we created a new symbol, either because we didn't have a symbol with this name
                 // in the symbol table, or we conflicted with an existing symbol, then just add this
                 // node as the sole declaration of the new symbol.
@@ -324,42 +332,44 @@ namespace ts {
                 // Otherwise, we'll be merging into a compatible existing symbol (for example when
                 // you have multiple 'vars' with the same name in the same container).  In this case
                 // just add this node into the declarations list of the symbol.
-                symbol = hasProperty(symbolTable, name)
-                    ? symbolTable[name]
-                    : (symbolTable[name] = createSymbol(SymbolFlags.None, name));
+                symbol = symbolTable[name] || (symbolTable[name] = createSymbol(SymbolFlags.None, name));
 
                 if (name && (includes & SymbolFlags.Classifiable)) {
                     classifiableNames[name] = name;
                 }
 
                 if (symbol.flags & excludes) {
-                    if (node.name) {
-                        node.name.parent = node;
+                    if (symbol.isReplaceableByMethod) {
+                        // Javascript constructor-declared symbols can be discarded in favor of
+                        // prototype symbols like methods.
+                        symbol = symbolTable[name] = createSymbol(SymbolFlags.None, name);
                     }
-
-                    // Report errors every position with duplicate declaration
-                    // Report errors on previous encountered declarations
-                    let message = symbol.flags & SymbolFlags.BlockScopedVariable
-                        ? Diagnostics.Cannot_redeclare_block_scoped_variable_0
-                        : Diagnostics.Duplicate_identifier_0;
-
-                    forEach(symbol.declarations, declaration => {
-                        if (hasModifier(declaration, ModifierFlags.Default)) {
-                            message = Diagnostics.A_module_cannot_have_multiple_default_exports;
+                    else {
+                        if (node.name) {
+                            node.name.parent = node;
                         }
-                    });
 
-                    forEach(symbol.declarations, declaration => {
-                        file.bindDiagnostics.push(createDiagnosticForNode(declaration.name || declaration, message, getDisplayName(declaration)));
-                    });
-                    file.bindDiagnostics.push(createDiagnosticForNode(node.name || node, message, getDisplayName(node)));
+                        // Report errors every position with duplicate declaration
+                        // Report errors on previous encountered declarations
+                        let message = symbol.flags & SymbolFlags.BlockScopedVariable
+                            ? Diagnostics.Cannot_redeclare_block_scoped_variable_0
+                            : Diagnostics.Duplicate_identifier_0;
 
-                    symbol = createSymbol(SymbolFlags.None, name);
+                        forEach(symbol.declarations, declaration => {
+                            if (hasModifier(declaration, ModifierFlags.Default)) {
+                                message = Diagnostics.A_module_cannot_have_multiple_default_exports;
+                            }
+                        });
+
+                        forEach(symbol.declarations, declaration => {
+                            file.bindDiagnostics.push(createDiagnosticForNode(declaration.name || declaration, message, getDisplayName(declaration)));
+                        });
+                        file.bindDiagnostics.push(createDiagnosticForNode(node.name || node, message, getDisplayName(node)));
+
+                        symbol = createSymbol(SymbolFlags.None, name);
+                    }
                 }
             }
-            else {
-                symbol = createSymbol(SymbolFlags.None, "__missing");
-            }
 
             addDeclarationToSymbol(symbol, node, includes);
             symbol.parent = parent;
@@ -440,7 +450,7 @@ namespace ts {
             if (containerFlags & ContainerFlags.IsContainer) {
                 container = blockScopeContainer = node;
                 if (containerFlags & ContainerFlags.HasLocals) {
-                    container.locals = {};
+                    container.locals = createMap<Symbol>();
                 }
                 addToContainerChain(container);
             }
@@ -1422,7 +1432,8 @@ namespace ts {
 
             const typeLiteralSymbol = createSymbol(SymbolFlags.TypeLiteral, "__type");
             addDeclarationToSymbol(typeLiteralSymbol, node, SymbolFlags.TypeLiteral);
-            typeLiteralSymbol.members = { [symbol.name]: symbol };
+            typeLiteralSymbol.members = createMap<Symbol>();
+            typeLiteralSymbol.members[symbol.name] = symbol;
         }
 
         function bindObjectLiteralExpression(node: ObjectLiteralExpression) {
@@ -1432,7 +1443,7 @@ namespace ts {
             }
 
             if (inStrictMode) {
-                const seen: Map<ElementKind> = {};
+                const seen = createMap<ElementKind>();
 
                 for (const prop of node.properties) {
                     if (prop.name.kind !== SyntaxKind.Identifier) {
@@ -1488,7 +1499,7 @@ namespace ts {
                 // fall through.
                 default:
                     if (!blockScopeContainer.locals) {
-                        blockScopeContainer.locals = {};
+                        blockScopeContainer.locals = createMap<Symbol>();
                         addToContainerChain(blockScopeContainer);
                     }
                     declareSymbol(blockScopeContainer.locals, undefined, node, symbolFlags, symbolExcludes);
@@ -1913,18 +1924,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);
             }
         }
 
@@ -1951,7 +1961,7 @@ namespace ts {
                 }
             }
 
-            file.symbol.globalExports = file.symbol.globalExports || {};
+            file.symbol.globalExports = file.symbol.globalExports || createMap<Symbol>();
             declareSymbol(file.symbol.globalExports, file.symbol, node, SymbolFlags.Alias, SymbolFlags.AliasExcludes);
         }
 
@@ -1993,20 +2003,25 @@ namespace ts {
         }
 
         function bindThisPropertyAssignment(node: BinaryExpression) {
-            // Declare a 'member' in case it turns out the container was an ES5 class or ES6 constructor
-            let assignee: Node;
+            Debug.assert(isInJavaScriptFile(node));
+            // Declare a 'member' if the container is an ES5 class or ES6 constructor
             if (container.kind === SyntaxKind.FunctionDeclaration || container.kind === SyntaxKind.FunctionExpression) {
-                assignee = container;
+                container.symbol.members = container.symbol.members || createMap<Symbol>();
+                // It's acceptable for multiple 'this' assignments of the same identifier to occur
+                declareSymbol(container.symbol.members, container.symbol, node, SymbolFlags.Property, SymbolFlags.PropertyExcludes & ~SymbolFlags.Property);
             }
             else if (container.kind === SyntaxKind.Constructor) {
-                assignee = container.parent;
+                // this.foo assignment in a JavaScript class
+                // Bind this property to the containing class
+                const saveContainer = container;
+                container = container.parent;
+                const symbol = bindPropertyOrMethodOrAccessor(node, SymbolFlags.Property, SymbolFlags.None);
+                if (symbol) {
+                    // constructor-declared symbols can be overwritten by subsequent method declarations
+                    (symbol as Symbol).isReplaceableByMethod = true;
+                }
+                container = saveContainer;
             }
-            else {
-                return;
-            }
-            assignee.symbol.members = assignee.symbol.members || {};
-            // It's acceptable for multiple 'this' assignments of the same identifier to occur
-            declareSymbol(assignee.symbol.members, assignee.symbol, node, SymbolFlags.Property, SymbolFlags.PropertyExcludes & ~SymbolFlags.Property);
         }
 
         function bindPrototypePropertyAssignment(node: BinaryExpression) {
@@ -2030,7 +2045,7 @@ namespace ts {
 
             // Set up the members collection if it doesn't exist already
             if (!funcSymbol.members) {
-                funcSymbol.members = {};
+                funcSymbol.members = createMap<Symbol>();
             }
 
             // Declare the method/property
@@ -2079,7 +2094,7 @@ namespace ts {
             // module might have an exported variable called 'prototype'.  We can't allow that as
             // that would clash with the built-in 'prototype' for the class.
             const prototypeSymbol = createSymbol(SymbolFlags.Property | SymbolFlags.Prototype, "prototype");
-            if (hasProperty(symbol.exports, prototypeSymbol.name)) {
+            if (symbol.exports[prototypeSymbol.name]) {
                 if (node.name) {
                     node.name.parent = node;
                 }

src/compiler/commandLineParser.ts

@@ -62,10 +62,10 @@ namespace ts {
         },
         {
             name: "jsx",
-            type: {
+            type: createMap({
                 "preserve": JsxEmit.Preserve,
                 "react": JsxEmit.React
-            },
+            }),
             paramType: Diagnostics.KIND,
             description: Diagnostics.Specify_JSX_code_generation_Colon_preserve_or_react,
         },
@@ -92,7 +92,7 @@ namespace ts {
         {
             name: "module",
             shortName: "m",
-            type: {
+            type: createMap({
                 "none": ModuleKind.None,
                 "commonjs": ModuleKind.CommonJS,
                 "amd": ModuleKind.AMD,
@@ -100,16 +100,16 @@ namespace ts {
                 "umd": ModuleKind.UMD,
                 "es6": ModuleKind.ES6,
                 "es2015": ModuleKind.ES2015,
-            },
+            }),
             description: Diagnostics.Specify_module_code_generation_Colon_commonjs_amd_system_umd_or_es2015,
             paramType: Diagnostics.KIND,
         },
         {
             name: "newLine",
-            type: {
+            type: createMap({
                 "crlf": NewLineKind.CarriageReturnLineFeed,
                 "lf": NewLineKind.LineFeed
-            },
+            }),
             description: Diagnostics.Specify_the_end_of_line_sequence_to_be_used_when_emitting_files_Colon_CRLF_dos_or_LF_unix,
             paramType: Diagnostics.NEWLINE,
         },
@@ -127,6 +127,10 @@ namespace ts {
             type: "boolean",
             description: Diagnostics.Do_not_emit_outputs_if_any_errors_were_reported,
         },
+        {
+            name: "noErrorTruncation",
+            type: "boolean"
+        },
         {
             name: "noImplicitAny",
             type: "boolean",
@@ -251,12 +255,12 @@ namespace ts {
         {
             name: "target",
             shortName: "t",
-            type: {
+            type: createMap({
                 "es3": ScriptTarget.ES3,
                 "es5": ScriptTarget.ES5,
                 "es6": ScriptTarget.ES6,
                 "es2015": ScriptTarget.ES2015,
-            },
+            }),
             description: Diagnostics.Specify_ECMAScript_target_version_Colon_ES3_default_ES5_or_ES2015,
             paramType: Diagnostics.VERSION,
         },
@@ -285,10 +289,10 @@ namespace ts {
         },
         {
             name: "moduleResolution",
-            type: {
+            type: createMap({
                 "node": ModuleResolutionKind.NodeJs,
                 "classic": ModuleResolutionKind.Classic,
-            },
+            }),
             description: Diagnostics.Specify_module_resolution_strategy_Colon_node_Node_js_or_classic_TypeScript_pre_1_6,
         },
         {
@@ -393,7 +397,7 @@ namespace ts {
             type: "list",
             element: {
                 name: "lib",
-                type: {
+                type: createMap({
                     // JavaScript only
                     "es5": "lib.es5.d.ts",
                     "es6": "lib.es2015.d.ts",
@@ -418,7 +422,7 @@ namespace ts {
                     "es2016.array.include": "lib.es2016.array.include.d.ts",
                     "es2017.object": "lib.es2017.object.d.ts",
                     "es2017.sharedmemory": "lib.es2017.sharedmemory.d.ts"
-                },
+                }),
             },
             description: Diagnostics.Specify_library_files_to_be_included_in_the_compilation_Colon
         },
@@ -468,6 +472,14 @@ namespace ts {
         shortOptionNames: Map<string>;
     }
 
+    /* @internal */
+    export const defaultInitCompilerOptions: CompilerOptions = {
+        module: ModuleKind.CommonJS,
+        target: ScriptTarget.ES5,
+        noImplicitAny: false,
+        sourceMap: false,
+    };
+
     let optionNameMapCache: OptionNameMap;
 
     /* @internal */
@@ -476,8 +488,8 @@ namespace ts {
             return optionNameMapCache;
         }
 
-        const optionNameMap: Map<CommandLineOption> = {};
-        const shortOptionNames: Map<string> = {};
+        const optionNameMap = createMap<CommandLineOption>();
+        const shortOptionNames = createMap<string>();
         forEach(optionDeclarations, option => {
             optionNameMap[option.name.toLowerCase()] = option;
             if (option.shortName) {
@@ -492,10 +504,9 @@ namespace ts {
     /* @internal */
     export function createCompilerDiagnosticForInvalidCustomType(opt: CommandLineOptionOfCustomType): Diagnostic {
         const namesOfType: string[] = [];
-        forEachKey(opt.type, key => {
+        for (const key in opt.type) {
             namesOfType.push(` '${key}'`);
-        });
-
+        }
         return createCompilerDiagnostic(Diagnostics.Argument_for_0_option_must_be_Colon_1, `--${opt.name}`, namesOfType);
     }
 
@@ -503,7 +514,7 @@ namespace ts {
     export function parseCustomTypeOption(opt: CommandLineOptionOfCustomType, value: string, errors: Diagnostic[]) {
         const key = trimString((value || "")).toLowerCase();
         const map = opt.type;
-        if (hasProperty(map, key)) {
+        if (key in map) {
             return map[key];
         }
         else {
@@ -557,11 +568,11 @@ namespace ts {
                     s = s.slice(s.charCodeAt(1) === CharacterCodes.minus ? 2 : 1).toLowerCase();
 
                     // Try to translate short option names to their full equivalents.
-                    if (hasProperty(shortOptionNames, s)) {
+                    if (s in shortOptionNames) {
                         s = shortOptionNames[s];
                     }
 
-                    if (hasProperty(optionNameMap, s)) {
+                    if (s in optionNameMap) {
                         const opt = optionNameMap[s];
 
                         if (opt.isTSConfigOnly) {
@@ -674,6 +685,94 @@ namespace ts {
         }
     }
 
+    /**
+     * Generate tsconfig configuration when running command line "--init"
+     * @param options commandlineOptions to be generated into tsconfig.json
+     * @param fileNames array of filenames to be generated into tsconfig.json
+     */
+    /* @internal */
+    export function generateTSConfig(options: CompilerOptions, fileNames: string[]): { compilerOptions: Map<CompilerOptionsValue> } {
+        const compilerOptions = extend(options, defaultInitCompilerOptions);
+        const configurations: any = {
+            compilerOptions: serializeCompilerOptions(compilerOptions)
+        };
+        if (fileNames && fileNames.length) {
+            // only set the files property if we have at least one file
+            configurations.files = fileNames;
+        }
+
+        return configurations;
+
+        function getCustomTypeMapOfCommandLineOption(optionDefinition: CommandLineOption): Map<string | number> | undefined {
+            if (optionDefinition.type === "string" || optionDefinition.type === "number" || optionDefinition.type === "boolean") {
+                // this is of a type CommandLineOptionOfPrimitiveType
+                return undefined;
+            }
+            else if (optionDefinition.type === "list") {
+                return getCustomTypeMapOfCommandLineOption((<CommandLineOptionOfListType>optionDefinition).element);
+            }
+            else {
+                return (<CommandLineOptionOfCustomType>optionDefinition).type;
+            }
+        }
+
+        function getNameOfCompilerOptionValue(value: CompilerOptionsValue, customTypeMap: MapLike<string | number>): string | undefined {
+            // There is a typeMap associated with this command-line option so use it to map value back to its name
+            for (const key in customTypeMap) {
+                if (customTypeMap[key] === value) {
+                    return key;
+                }
+            }
+            return undefined;
+        }
+
+        function serializeCompilerOptions(options: CompilerOptions): Map<CompilerOptionsValue> {
+            const result = createMap<CompilerOptionsValue>();
+            const optionsNameMap = getOptionNameMap().optionNameMap;
+
+            for (const name in options) {
+                if (hasProperty(options, name)) {
+                    // tsconfig only options cannot be specified via command line,
+                    // so we can assume that only types that can appear here string | number | boolean
+                    switch (name) {
+                        case "init":
+                        case "watch":
+                        case "version":
+                        case "help":
+                        case "project":
+                            break;
+                        default:
+                            const value = options[name];
+                            let optionDefinition = optionsNameMap[name.toLowerCase()];
+                            if (optionDefinition) {
+                                const customTypeMap = getCustomTypeMapOfCommandLineOption(optionDefinition);
+                                if (!customTypeMap) {
+                                    // There is no map associated with this compiler option then use the value as-is
+                                    // This is the case if the value is expect to be string, number, boolean or list of string
+                                    result[name] = value;
+                                }
+                                else {
+                                    if (optionDefinition.type === "list") {
+                                        const convertedValue: string[] = [];
+                                        for (const element of value as (string | number)[]) {
+                                            convertedValue.push(getNameOfCompilerOptionValue(element, customTypeMap));
+                                        }
+                                        result[name] = convertedValue;
+                                    }
+                                    else {
+                                        // There is a typeMap associated with this command-line option so use it to map value back to its name
+                                        result[name] = getNameOfCompilerOptionValue(value, customTypeMap);
+                                    }
+                                }
+                            }
+                            break;
+                    }
+                }
+            }
+            return result;
+        }
+    }
+
     /**
      * Remove the comments from a json like text.
      * Comments can be single line comments (starting with # or //) or multiline comments using / * * /
@@ -817,7 +916,7 @@ namespace ts {
         const optionNameMap = arrayToMap(optionDeclarations, opt => opt.name);
 
         for (const id in jsonOptions) {
-            if (hasProperty(optionNameMap, id)) {
+            if (id in optionNameMap) {
                 const opt = optionNameMap[id];
                 defaultOptions[opt.name] = convertJsonOption(opt, jsonOptions[id], basePath, errors);
             }
@@ -854,7 +953,7 @@ namespace ts {
 
     function convertJsonOptionOfCustomType(opt: CommandLineOptionOfCustomType, value: string, errors: Diagnostic[]) {
         const key = value.toLowerCase();
-        if (hasProperty(opt.type, key)) {
+        if (key in opt.type) {
             return opt.type[key];
         }
         else {
@@ -964,12 +1063,12 @@ namespace ts {
         // Literal file names (provided via the "files" array in tsconfig.json) are stored in a
         // file map with a possibly case insensitive key. We use this map later when when including
         // wildcard paths.
-        const literalFileMap: Map<string> = {};
+        const literalFileMap = createMap<string>();
 
         // Wildcard paths (provided via the "includes" array in tsconfig.json) are stored in a
         // file map with a possibly case insensitive key. We use this map to store paths matched
         // via wildcard, and to handle extension priority.
-        const wildcardFileMap: Map<string> = {};
+        const wildcardFileMap = createMap<string>();
 
         if (include) {
             include = validateSpecs(include, errors, /*allowTrailingRecursion*/ false);
@@ -1017,7 +1116,7 @@ namespace ts {
                 removeWildcardFilesWithLowerPriorityExtension(file, wildcardFileMap, supportedExtensions, keyMapper);
 
                 const key = keyMapper(file);
-                if (!hasProperty(literalFileMap, key) && !hasProperty(wildcardFileMap, key)) {
+                if (!(key in literalFileMap) && !(key in wildcardFileMap)) {
                     wildcardFileMap[key] = file;
                 }
             }
@@ -1069,7 +1168,7 @@ namespace ts {
         //  /a/b/a?z    - Watch /a/b directly to catch any new file matching a?z
         const rawExcludeRegex = getRegularExpressionForWildcard(exclude, path, "exclude");
         const excludeRegex = rawExcludeRegex && new RegExp(rawExcludeRegex, useCaseSensitiveFileNames ? "" : "i");
-        const wildcardDirectories: Map<WatchDirectoryFlags> = {};
+        const wildcardDirectories = createMap<WatchDirectoryFlags>();
         if (include !== undefined) {
             const recursiveKeys: string[] = [];
             for (const file of include) {
@@ -1082,7 +1181,7 @@ namespace ts {
                 if (match) {
                     const key = useCaseSensitiveFileNames ? match[0] : match[0].toLowerCase();
                     const flags = watchRecursivePattern.test(name) ? WatchDirectoryFlags.Recursive : WatchDirectoryFlags.None;
-                    const existingFlags = getProperty(wildcardDirectories, key);
+                    const existingFlags = wildcardDirectories[key];
                     if (existingFlags === undefined || existingFlags < flags) {
                         wildcardDirectories[key] = flags;
                         if (flags === WatchDirectoryFlags.Recursive) {
@@ -1094,11 +1193,9 @@ namespace ts {
 
             // Remove any subpaths under an existing recursively watched directory.
             for (const key in wildcardDirectories) {
-                if (hasProperty(wildcardDirectories, key)) {
-                    for (const recursiveKey of recursiveKeys) {
-                        if (key !== recursiveKey && containsPath(recursiveKey, key, path, !useCaseSensitiveFileNames)) {
-                            delete wildcardDirectories[key];
-                        }
+                for (const recursiveKey of recursiveKeys) {
+                    if (key !== recursiveKey && containsPath(recursiveKey, key, path, !useCaseSensitiveFileNames)) {
+                        delete wildcardDirectories[key];
                     }
                 }
             }
@@ -1121,7 +1218,7 @@ namespace ts {
         for (let i = ExtensionPriority.Highest; i < adjustedExtensionPriority; i++) {
             const higherPriorityExtension = extensions[i];
             const higherPriorityPath = keyMapper(changeExtension(file, higherPriorityExtension));
-            if (hasProperty(literalFiles, higherPriorityPath) || hasProperty(wildcardFiles, higherPriorityPath)) {
+            if (higherPriorityPath in literalFiles || higherPriorityPath in wildcardFiles) {
                 return true;
             }
         }

src/compiler/comments.ts

@@ -53,9 +53,8 @@ namespace ts {
                     }
                 }
                 else {
-                    let commentStart: number;
                     if (extendedDiagnostics) {
-                        commentStart = performance.mark();
+                        performance.mark("preEmitNodeWithComment");
                     }
 
                     const isEmittedNode = node.kind !== SyntaxKind.NotEmittedStatement;
@@ -88,7 +87,7 @@ namespace ts {
                     }
 
                     if (extendedDiagnostics) {
-                        performance.measure("commentTime", commentStart);
+                        performance.measure("commentTime", "preEmitNodeWithComment");
                     }
 
                     if (emitFlags & NodeEmitFlags.NoNestedComments) {
@@ -99,7 +98,7 @@ namespace ts {
                     }
 
                     if (extendedDiagnostics) {
-                        commentStart = performance.mark();
+                        performance.mark("beginEmitNodeWithComment");
                     }
 
                     // Restore previous container state.
@@ -114,16 +113,15 @@ namespace ts {
                     }
 
                     if (extendedDiagnostics) {
-                        performance.measure("commentTime", commentStart);
+                        performance.measure("commentTime", "beginEmitNodeWithComment");
                     }
                 }
             }
         }
 
         function emitBodyWithDetachedComments(node: Node, detachedRange: TextRange, emitCallback: (node: Node) => void) {
-            let commentStart: number;
             if (extendedDiagnostics) {
-                commentStart = performance.mark();
+                performance.mark("preEmitBodyWithDetachedComments");
             }
 
             const { pos, end } = detachedRange;
@@ -136,7 +134,7 @@ namespace ts {
             }
 
             if (extendedDiagnostics) {
-                performance.measure("commentTime", commentStart);
+                performance.measure("commentTime", "preEmitBodyWithDetachedComments");
             }
 
             if (emitFlags & NodeEmitFlags.NoNestedComments) {
@@ -147,7 +145,7 @@ namespace ts {
             }
 
             if (extendedDiagnostics) {
-                commentStart = performance.mark();
+                performance.mark("beginEmitBodyWithDetachedCommetns");
             }
 
             if (!skipTrailingComments) {
@@ -155,7 +153,7 @@ namespace ts {
             }
 
             if (extendedDiagnostics) {
-                performance.measure("commentTime", commentStart);
+                performance.measure("commentTime", "beginEmitBodyWithDetachedCommetns");
             }
         }
 
@@ -227,15 +225,14 @@ namespace ts {
                 return;
             }
 
-            let commentStart: number;
             if (extendedDiagnostics) {
-                commentStart = performance.mark();
+                performance.mark("beforeEmitTrailingCommentsOfPosition");
             }
 
             forEachTrailingCommentToEmit(pos, emitTrailingCommentOfPosition);
 
             if (extendedDiagnostics) {
-                performance.measure("commentTime", commentStart);
+                performance.measure("commentTime", "beforeEmitTrailingCommentsOfPosition");
             }
         }
 

src/compiler/core.ts

@@ -19,8 +19,28 @@ namespace ts {
         True = -1
     }
 
+    const createObject = Object.create;
+
+    export function createMap<T>(template?: MapLike<T>): Map<T> {
+        const map: Map<T> = createObject(null); // tslint:disable-line:no-null-keyword
+
+        // Using 'delete' on an object causes V8 to put the object in dictionary mode.
+        // This disables creation of hidden classes, which are expensive when an object is
+        // constantly changing shape.
+        map["__"] = undefined;
+        delete map["__"];
+
+        // Copies keys/values from template. Note that for..in will not throw if
+        // template is undefined, and instead will just exit the loop.
+        for (const key in template) if (hasOwnProperty.call(template, key)) {
+            map[key] = template[key];
+        }
+
+        return map;
+    }
+
     export function createFileMap<T>(keyMapper?: (key: string) => string): FileMap<T> {
-        let files: Map<T> = {};
+        let files = createMap<T>();
         return {
             get,
             set,
@@ -46,7 +66,7 @@ namespace ts {
         }
 
         function contains(path: Path) {
-            return hasProperty(files, toKey(path));
+            return toKey(path) in files;
         }
 
         function remove(path: Path) {
@@ -55,7 +75,7 @@ namespace ts {
         }
 
         function clear() {
-            files = {};
+            files = createMap<T>();
         }
 
         function toKey(path: Path): string {
@@ -81,7 +101,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);
@@ -110,6 +130,31 @@ namespace ts {
         return true;
     }
 
+    /** Works like Array.prototype.find, returning `undefined` if no element satisfying the predicate is found. */
+    export function find<T>(array: T[], predicate: (element: T, index: number) => boolean): T | undefined {
+        for (let i = 0, len = array.length; i < len; i++) {
+            const value = array[i];
+            if (predicate(value, i)) {
+                return value;
+            }
+        }
+        return undefined;
+    }
+
+    /**
+     * Returns the first truthy result of `callback`, or else fails.
+     * This is like `forEach`, but never returns undefined.
+     */
+    export function findMap<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) {
@@ -154,20 +199,42 @@ namespace ts {
         return count;
     }
 
-    export function filter<T, U extends T>(array: T[], f: (x: T, i: number) => x is U): U[];
-    export function filter<T>(array: T[], f: (x: T, i: number) => boolean): T[];
-    export function filter<T>(array: T[], f: (x: T, i: number) => boolean): T[] {
-        let result: T[];
+    export function filter<T, U extends T>(array: T[], f: (x: T) => x is U): U[];
+    export function filter<T>(array: T[], f: (x: T) => boolean): T[]
+    export function filter<T>(array: T[], f: (x: T) => boolean): T[] {
         if (array) {
-            result = [];
-            for (let i = 0; i < array.length; i++) {
-                const v = array[i];
-                if (f(v, i)) {
-                    result.push(v);
+            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 removeWhere<T>(array: T[], f: (x: T) => boolean): boolean {
+        let outIndex = 0;
+        for (const item of array) {
+            if (!f(item)) {
+                array[outIndex] = item;
+                outIndex++;
+            }
+        }
+        if (outIndex !== array.length) {
+            array.length = outIndex;
+            return true;
+        }
+        return false;
     }
 
     export function filterMutate<T>(array: T[], f: (x: T) => boolean): void {
@@ -487,82 +554,142 @@ namespace ts {
 
     const hasOwnProperty = Object.prototype.hasOwnProperty;
 
-    export function hasProperty<T>(map: Map<T>, key: string): boolean {
+    /**
+     * Indicates whether a map-like contains an own property with the specified key.
+     *
+     * NOTE: This is intended for use only with MapLike<T> objects. For Map<T> objects, use
+     *       the 'in' operator.
+     *
+     * @param map A map-like.
+     * @param key A property key.
+     */
+    export function hasProperty<T>(map: MapLike<T>, key: string): boolean {
         return hasOwnProperty.call(map, key);
     }
 
-    export function getKeys<T>(map: Map<T>): string[] {
+    /**
+     * Gets the value of an owned property in a map-like.
+     *
+     * NOTE: This is intended for use only with MapLike<T> objects. For Map<T> objects, use
+     *       an indexer.
+     *
+     * @param map A map-like.
+     * @param key A property key.
+     */
+    export function getProperty<T>(map: MapLike<T>, key: string): T | undefined {
+        return hasOwnProperty.call(map, key) ? map[key] : undefined;
+    }
+
+    /**
+     * Gets the owned, enumerable property keys of a map-like.
+     *
+     * NOTE: This is intended for use with MapLike<T> objects. For Map<T> objects, use
+     *       Object.keys instead as it offers better performance.
+     *
+     * @param map A map-like.
+     */
+    export function getOwnKeys<T>(map: MapLike<T>): string[] {
         const keys: string[] = [];
-        for (const key in map) {
+        for (const key in map) if (hasOwnProperty.call(map, key)) {
             keys.push(key);
         }
         return keys;
     }
 
-    export function getProperty<T>(map: Map<T>, key: string): T | undefined {
-        return hasProperty(map, key) ? map[key] : undefined;
+    /**
+     * Enumerates the properties of a Map<T>, invoking a callback and returning the first truthy result.
+     *
+     * @param map A map for which properties should be enumerated.
+     * @param callback A callback to invoke for each property.
+     */
+    export function forEachProperty<T, U>(map: Map<T>, callback: (value: T, key: string) => U): U {
+        let result: U;
+        for (const key in map) {
+            if (result = callback(map[key], key)) break;
+        }
+        return result;
     }
 
-    export function getOrUpdateProperty<T>(map: Map<T>, key: string, makeValue: () => T): T {
-        return hasProperty(map, key) ? map[key] : map[key] = makeValue();
+    /**
+     * Returns true if a Map<T> has some matching property.
+     *
+     * @param map A map whose properties should be tested.
+     * @param predicate An optional callback used to test each property.
+     */
+    export function someProperties<T>(map: Map<T>, predicate?: (value: T, key: string) => boolean) {
+        for (const key in map) {
+            if (!predicate || predicate(map[key], key)) return true;
+        }
+        return false;
     }
 
-    export function isEmpty<T>(map: Map<T>) {
-        for (const id in map) {
-            if (hasProperty(map, id)) {
-                return false;
-            }
+    /**
+     * Performs a shallow copy of the properties from a source Map<T> to a target MapLike<T>
+     *
+     * @param source A map from which properties should be copied.
+     * @param target A map to which properties should be copied.
+     */
+    export function copyProperties<T>(source: Map<T>, target: MapLike<T>): void {
+        for (const key in source) {
+            target[key] = source[key];
+        }
+    }
+
+    /**
+     * Reduce the properties of a map.
+     *
+     * NOTE: This is intended for use with Map<T> objects. For MapLike<T> objects, use
+     *       reduceOwnProperties instead as it offers better runtime safety.
+     *
+     * @param map The map to reduce
+     * @param callback An aggregation function that is called for each entry in the map
+     * @param initial The initial value for the reduction.
+     */
+    export function reduceProperties<T, U>(map: Map<T>, callback: (aggregate: U, value: T, key: string) => U, initial: U): U {
+        let result = initial;
+        for (const key in map) {
+            result = callback(result, map[key], String(key));
+        }
+        return result;
+    }
+
+    /**
+     * Reduce the properties defined on a map-like (but not from its prototype chain).
+     *
+     * NOTE: This is intended for use with MapLike<T> objects. For Map<T> objects, use
+     *       reduceProperties instead as it offers better performance.
+     *
+     * @param map The map-like to reduce
+     * @param callback An aggregation function that is called for each entry in the map
+     * @param initial The initial value for the reduction.
+     */
+    export function reduceOwnProperties<T, U>(map: MapLike<T>, callback: (aggregate: U, value: T, key: string) => U, initial: U): U {
+        let result = initial;
+        for (const key in map) if (hasOwnProperty.call(map, key)) {
+            result = callback(result, map[key], String(key));
+        }
+        return result;
+    }
+
+    /**
+     * Performs a shallow equality comparison of the contents of two map-likes.
+     *
+     * @param left A map-like whose properties should be compared.
+     * @param right A map-like whose properties should be compared.
+     */
+    export function equalOwnProperties<T>(left: MapLike<T>, right: MapLike<T>, equalityComparer?: (left: T, right: T) => boolean) {
+        if (left === right) return true;
+        if (!left || !right) return false;
+        for (const key in left) if (hasOwnProperty.call(left, key)) {
+            if (!hasOwnProperty.call(right, key) === undefined) return false;
+            if (equalityComparer ? !equalityComparer(left[key], right[key]) : left[key] !== right[key]) return false;
+        }
+        for (const key in right) if (hasOwnProperty.call(right, key)) {
+            if (!hasOwnProperty.call(left, key)) return false;
         }
         return true;
     }
 
-    export function clone<T>(object: T): T {
-        const result: any = {};
-        for (const id in object) {
-            result[id] = (<any>object)[id];
-        }
-        return <T>result;
-    }
-
-    export function extend<T1 extends Map<{}>, T2 extends Map<{}>>(first: T1 , second: T2): T1 & T2 {
-        const result: T1 & T2 = <any>{};
-        for (const id in first) {
-            (result as any)[id] = first[id];
-        }
-        for (const id in second) {
-            if (!hasProperty(result, id)) {
-                (result as any)[id] = second[id];
-            }
-        }
-        return result;
-    }
-
-    export function forEachValue<T, U>(map: Map<T>, callback: (value: T) => U): U {
-        let result: U;
-        for (const id in map) {
-            if (result = callback(map[id])) break;
-        }
-        return result;
-    }
-
-    export function forEachKey<T, U>(map: Map<T>, callback: (key: string) => U): U {
-        let result: U;
-        for (const id in map) {
-            if (result = callback(id)) break;
-        }
-        return result;
-    }
-
-    export function lookUp<T>(map: Map<T>, key: string): T {
-        return hasProperty(map, key) ? map[key] : undefined;
-    }
-
-    export function copyMap<T>(source: Map<T>, target: Map<T>): void {
-        for (const p in source) {
-            target[p] = source[p];
-        }
-    }
-
     /**
      * Creates a map from the elements of an array.
      *
@@ -573,33 +700,49 @@ namespace ts {
      * the same key with the given 'makeKey' function, then the element with the higher
      * index in the array will be the one associated with the produced key.
      */
-    export function arrayToMap<T>(array: T[], makeKey: (value: T) => string): Map<T> {
-        const result: Map<T> = {};
-
-        forEach(array, value => {
-            result[makeKey(value)] = value;
-        });
-
+    export function arrayToMap<T>(array: T[], makeKey: (value: T) => string): Map<T>;
+    export function arrayToMap<T, U>(array: T[], makeKey: (value: T) => string, makeValue: (value: T) => U): Map<U>;
+    export function arrayToMap<T, U>(array: T[], makeKey: (value: T) => string, makeValue?: (value: T) => U): Map<T | U> {
+        const result = createMap<T | U>();
+        for (const value of array) {
+            result[makeKey(value)] = makeValue ? makeValue(value) : value;
+        }
         return result;
     }
 
-    /**
-     * Reduce the properties of a map.
-     *
-     * @param map The map to reduce
-     * @param callback An aggregation function that is called for each entry in the map
-     * @param initial The initial value for the reduction.
-     */
-    export function reduceProperties<T, U>(map: Map<T>, callback: (aggregate: U, value: T, key: string) => U, initial: U): U {
-        let result = initial;
-        if (map) {
-            for (const key in map) {
-                if (hasProperty(map, key)) {
-                    result = callback(result, map[key], String(key));
-                }
+    export function isEmpty<T>(map: Map<T>) {
+        for (const id in map) {
+            if (hasProperty(map, id)) {
+                return false;
             }
         }
+        return true;
+    }
 
+    export function cloneMap<T>(map: Map<T>) {
+        const clone = createMap<T>();
+        copyProperties(map, clone);
+        return clone;
+    }
+
+    export function clone<T>(object: T): T {
+        const result: any = {};
+        for (const id in object) {
+            if (hasOwnProperty.call(object, id)) {
+                result[id] = (<any>object)[id];
+            }
+        }
+        return result;
+    }
+
+    export function extend<T1, T2>(first: T1 , second: T2): T1 & T2 {
+        const result: T1 & T2 = <any>{};
+        for (const id in second) if (hasOwnProperty.call(second, id)) {
+            (result as any)[id] = (second as any)[id];
+        }
+        for (const id in first) if (hasOwnProperty.call(first, id)) {
+            (result as any)[id] = (first as any)[id];
+        }
         return result;
     }
 
@@ -630,9 +773,7 @@ namespace ts {
     export let localizedDiagnosticMessages: Map<string> = undefined;
 
     export function getLocaleSpecificMessage(message: DiagnosticMessage) {
-        return localizedDiagnosticMessages && localizedDiagnosticMessages[message.key]
-            ? localizedDiagnosticMessages[message.key]
-            : message.message;
+        return localizedDiagnosticMessages && localizedDiagnosticMessages[message.key] || message.message;
     }
 
     export function createFileDiagnostic(file: SourceFile, start: number, length: number, message: DiagnosticMessage, ...args: any[]): Diagnostic;
@@ -1368,6 +1509,8 @@ namespace ts {
      *  List of supported extensions in order of file resolution precedence.
      */
     export const supportedTypeScriptExtensions = [".ts", ".tsx", ".d.ts"];
+    /** Must have ".d.ts" first because if ".ts" goes first, that will be detected as the extension instead of ".d.ts". */
+    export const supportedTypescriptExtensionsForExtractExtension = [".d.ts", ".ts", ".tsx"];
     export const supportedJavascriptExtensions = [".js", ".jsx"];
     const allSupportedExtensions  = supportedTypeScriptExtensions.concat(supportedJavascriptExtensions);
 
@@ -1450,8 +1593,12 @@ namespace ts {
         return path;
     }
 
-    export function tryRemoveExtension(path: string, extension: string): string {
-        return fileExtensionIs(path, extension) ? path.substring(0, path.length - extension.length) : undefined;
+    export function tryRemoveExtension(path: string, extension: string): string | undefined {
+        return fileExtensionIs(path, extension) ? removeExtension(path, extension) : undefined;
+    }
+
+    export function removeExtension(path: string, extension: string): string {
+        return path.substring(0, path.length - extension.length);
     }
 
     export function isJsxOrTsxExtension(ext: string): boolean {

src/compiler/declarationEmitter.ts

@@ -157,9 +157,7 @@ namespace ts {
 
         if (usedTypeDirectiveReferences) {
             for (const directive in usedTypeDirectiveReferences) {
-                if (hasProperty(usedTypeDirectiveReferences, directive)) {
-                    referencesOutput += `/// <reference types="${directive}" />${newLine}`;
-                }
+                referencesOutput += `/// <reference types="${directive}" />${newLine}`;
             }
         }
 
@@ -269,10 +267,10 @@ namespace ts {
             }
 
             if (!usedTypeDirectiveReferences) {
-                usedTypeDirectiveReferences = {};
+                usedTypeDirectiveReferences = createMap<string>();
             }
             for (const directive of typeReferenceDirectives) {
-                if (!hasProperty(usedTypeDirectiveReferences, directive)) {
+                if (!(directive in usedTypeDirectiveReferences)) {
                     usedTypeDirectiveReferences[directive] = directive;
                 }
             }
@@ -441,7 +439,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);
@@ -452,9 +450,9 @@ 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(<Identifier | PropertyAccessExpression>node.expression);
+                    emitEntityName(node.expression);
                     if (node.typeArguments) {
                         write("<");
                         emitCommaList(node.typeArguments, emitType);
@@ -537,14 +535,14 @@ namespace ts {
         // do not need to keep track of created temp names.
         function getExportDefaultTempVariableName(): string {
             const baseName = "_default";
-            if (!hasProperty(currentIdentifiers, baseName)) {
+            if (!(baseName in currentIdentifiers)) {
                 return baseName;
             }
             let count = 0;
             while (true) {
                 count++;
                 const name = baseName + "_" + count;
-                if (!hasProperty(currentIdentifiers, name)) {
+                if (!(name in currentIdentifiers)) {
                     return name;
                 }
             }
@@ -1020,7 +1018,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) {

src/compiler/diagnosticMessages.json

@@ -1947,6 +1947,14 @@
         "category": "Error",
         "code": 2690
     },
+    "An import path cannot end with a '{0}' extension. Consider importing '{1}' instead.": {
+        "category": "Error",
+        "code": 2691
+    },
+    "'{0}' is a primitive, but '{1}' is a wrapper object. Prefer using '{0}' when possible.": {
+        "category": "Error",
+        "code": 2692
+    },
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",
         "code": 4000
@@ -2227,7 +2235,7 @@
         "category": "Error",
         "code": 4082
     },
-    "Conflicting library definitions for '{0}' found at '{1}' and '{2}'. Copy the correct file to the 'typings' folder to resolve this conflict.": {
+    "Conflicting definitions for '{0}' found at '{1}' and '{2}'. Consider installing a specific version of this library to resolve the conflict.": {
         "category": "Message",
         "code": 4090
     },
@@ -2824,9 +2832,13 @@
         "category": "Message",
         "code": 6137
     },
+    "Property '{0}' is declared but never used.": {
+        "category": "Error",
+        "code": 6138
+    },
     "Import emit helpers from 'tslib'.": {
         "category": "Message",
-        "code": 6138
+        "code": 6139
     },
     "Variable '{0}' implicitly has an '{1}' type.": {
         "category": "Error",

src/compiler/emitter.ts

@@ -182,8 +182,7 @@ const _super = (function (geti, seti) {
         let isOwnFileEmit: boolean;
         let emitSkipped = false;
 
-        performance.emit("beforeTransform");
-        const transformStart = performance.mark();
+        performance.mark("beforeTransform");
 
         // Transform the source files
         const transformed = transformFiles(
@@ -192,8 +191,7 @@ const _super = (function (geti, seti) {
             getSourceFilesToEmit(host, targetSourceFile),
             transformers);
 
-        performance.measure("transformTime", transformStart);
-        performance.emit("afterTransform");
+        performance.measure("transformTime", "beforeTransform");
 
         // Extract helpers from the result
         const {
@@ -204,8 +202,7 @@ const _super = (function (geti, seti) {
             onEmitNode
         } = transformed;
 
-        performance.emit("beforePrint");
-        const printStart = performance.mark();
+        performance.mark("beforePrint");
 
         // Emit each output file
         forEachTransformedEmitFile(host, transformed.getSourceFiles(), emitFile);
@@ -213,8 +210,7 @@ const _super = (function (geti, seti) {
         // Clean up after transformation
         transformed.dispose();
 
-        performance.measure("printTime", printStart);
-        performance.emit("afterPrint");
+        performance.measure("printTime", "beforePrint");
 
         return {
             emitSkipped,
@@ -251,7 +247,7 @@ const _super = (function (geti, seti) {
             sourceMap.initialize(jsFilePath, sourceMapFilePath, sourceFiles, isBundledEmit);
             nodeIdToGeneratedName = [];
             autoGeneratedIdToGeneratedName = [];
-            generatedNameSet = {};
+            generatedNameSet = createMap<string>();
             isOwnFileEmit = !isBundledEmit;
 
             // Emit helpers from all the files
@@ -2609,7 +2605,7 @@ const _super = (function (geti, seti) {
 
         function getTextOfNode(node: Node, includeTrivia?: boolean): string {
             if (isGeneratedIdentifier(node)) {
-                return getGeneratedIdentifier(node);
+                return getGeneratedIdentifier(<Identifier>node);
             }
             else if (isIdentifier(node) && (nodeIsSynthesized(node) || !node.parent)) {
                 return unescapeIdentifier(node.text);

src/compiler/parser.ts

@@ -420,14 +420,16 @@ namespace ts {
                     visitNode(cbNode, (<JSDocPropertyTag>node).name);
             case SyntaxKind.PartiallyEmittedExpression:
                 return visitNode(cbNode, (<PartiallyEmittedExpression>node).expression);
+            case SyntaxKind.JSDocLiteralType:
+                    return visitNode(cbNode, (<JSDocLiteralType>node).literal);
         }
     }
 
     export function createSourceFile(fileName: string, sourceText: string, languageVersion: ScriptTarget, setParentNodes = false, scriptKind?: ScriptKind): SourceFile {
-        const start = performance.mark();
+        performance.mark("beforeParse");
         const result = Parser.parseSourceFile(fileName, sourceText, languageVersion, /*syntaxCursor*/ undefined, setParentNodes, scriptKind);
-
-        performance.measure("Parse", start);
+        performance.mark("afterParse");
+        performance.measure("Parse", "beforeParse", "afterParse");
         return result;
     }
 
@@ -598,7 +600,7 @@ namespace ts {
 
             parseDiagnostics = [];
             parsingContext = 0;
-            identifiers = {};
+            identifiers = createMap<string>();
             identifierCount = 0;
             nodeCount = 0;
 
@@ -913,7 +915,7 @@ namespace ts {
             // Note: it is not actually necessary to save/restore the context flags here.  That's
             // because the saving/restoring of these flags happens naturally through the recursive
             // descent nature of our parser.  However, we still store this here just so we can
-            // assert that that invariant holds.
+            // assert that invariant holds.
             const saveContextFlags = contextFlags;
 
             // If we're only looking ahead, then tell the scanner to only lookahead as well.
@@ -1097,7 +1099,7 @@ namespace ts {
 
         function internIdentifier(text: string): string {
             text = escapeIdentifier(text);
-            return hasProperty(identifiers, text) ? identifiers[text] : (identifiers[text] = text);
+            return identifiers[text] || (identifiers[text] = text);
         }
 
         // An identifier that starts with two underscores has an extra underscore character prepended to it to avoid issues
@@ -2761,7 +2763,7 @@ namespace ts {
             // Note: for ease of implementation we treat productions '2' and '3' as the same thing.
             // (i.e. they're both BinaryExpressions with an assignment operator in it).
 
-            // First, do the simple check if we have a YieldExpression (production '5').
+            // First, do the simple check if we have a YieldExpression (production '6').
             if (isYieldExpression()) {
                 return parseYieldExpression();
             }
@@ -3368,24 +3370,40 @@ namespace ts {
         }
 
         /**
-         * Parse ES7 unary expression and await expression
+         * Parse ES7 exponential expression and await expression
+         *
+         * ES7 ExponentiationExpression:
+         *      1) UnaryExpression[?Yield]
+         *      2) UpdateExpression[?Yield] ** ExponentiationExpression[?Yield]
          *
-         * ES7 UnaryExpression:
-         *      1) SimpleUnaryExpression[?yield]
-         *      2) IncrementExpression[?yield] ** UnaryExpression[?yield]
          */
         function parseUnaryExpressionOrHigher(): UnaryExpression | BinaryExpression {
-            if (isAwaitExpression()) {
-                return parseAwaitExpression();
-            }
-
-            if (isIncrementExpression()) {
+            /**
+             * ES7 UpdateExpression:
+             *      1) LeftHandSideExpression[?Yield]
+             *      2) LeftHandSideExpression[?Yield][no LineTerminator here]++
+             *      3) LeftHandSideExpression[?Yield][no LineTerminator here]--
+             *      4) ++UnaryExpression[?Yield]
+             *      5) --UnaryExpression[?Yield]
+             */
+            if (isUpdateExpression()) {
                 const incrementExpression = parseIncrementExpression();
                 return token() === SyntaxKind.AsteriskAsteriskToken ?
                     <BinaryExpression>parseBinaryExpressionRest(getBinaryOperatorPrecedence(), incrementExpression) :
                     incrementExpression;
             }
 
+            /**
+             * ES7 UnaryExpression:
+             *      1) UpdateExpression[?yield]
+             *      2) delete UpdateExpression[?yield]
+             *      3) void UpdateExpression[?yield]
+             *      4) typeof UpdateExpression[?yield]
+             *      5) + UpdateExpression[?yield]
+             *      6) - UpdateExpression[?yield]
+             *      7) ~ UpdateExpression[?yield]
+             *      8) ! UpdateExpression[?yield]
+             */
             const unaryOperator = token();
             const simpleUnaryExpression = parseSimpleUnaryExpression();
             if (token() === SyntaxKind.AsteriskAsteriskToken) {
@@ -3403,8 +3421,8 @@ namespace ts {
         /**
          * Parse ES7 simple-unary expression or higher:
          *
-         * ES7 SimpleUnaryExpression:
-         *      1) IncrementExpression[?yield]
+         * ES7 UnaryExpression:
+         *      1) UpdateExpression[?yield]
          *      2) delete UnaryExpression[?yield]
          *      3) void UnaryExpression[?yield]
          *      4) typeof UnaryExpression[?yield]
@@ -3412,6 +3430,7 @@ namespace ts {
          *      6) - UnaryExpression[?yield]
          *      7) ~ UnaryExpression[?yield]
          *      8) ! UnaryExpression[?yield]
+         *      9) [+Await] await UnaryExpression[?yield]
          */
         function parseSimpleUnaryExpression(): UnaryExpression {
             switch (token()) {
@@ -3431,6 +3450,10 @@ namespace ts {
                     //  UnaryExpression (modified):
                     //      < type > UnaryExpression
                     return parseTypeAssertion();
+                case SyntaxKind.AwaitKeyword:
+                    if (isAwaitExpression()) {
+                        return parseAwaitExpression();
+                    }
                 default:
                     return parseIncrementExpression();
             }
@@ -3439,14 +3462,14 @@ namespace ts {
         /**
          * Check if the current token can possibly be an ES7 increment expression.
          *
-         * ES7 IncrementExpression:
+         * ES7 UpdateExpression:
          *      LeftHandSideExpression[?Yield]
          *      LeftHandSideExpression[?Yield][no LineTerminator here]++
          *      LeftHandSideExpression[?Yield][no LineTerminator here]--
          *      ++LeftHandSideExpression[?Yield]
          *      --LeftHandSideExpression[?Yield]
          */
-        function isIncrementExpression(): boolean {
+        function isUpdateExpression(): boolean {
             // This function is called inside parseUnaryExpression to decide
             // whether to call parseSimpleUnaryExpression or call parseIncrementExpression directly
             switch (token()) {
@@ -3457,6 +3480,7 @@ namespace ts {
                 case SyntaxKind.DeleteKeyword:
                 case SyntaxKind.TypeOfKeyword:
                 case SyntaxKind.VoidKeyword:
+                case SyntaxKind.AwaitKeyword:
                     return false;
                 case SyntaxKind.LessThanToken:
                     // If we are not in JSX context, we are parsing TypeAssertion which is an UnaryExpression
@@ -5883,10 +5907,17 @@ namespace ts {
                     case SyntaxKind.BooleanKeyword:
                     case SyntaxKind.SymbolKeyword:
                     case SyntaxKind.VoidKeyword:
+                    case SyntaxKind.NullKeyword:
+                    case SyntaxKind.UndefinedKeyword:
+                    case SyntaxKind.NeverKeyword:
                         return parseTokenNode<JSDocType>();
+                    case SyntaxKind.StringLiteral:
+                    case SyntaxKind.NumericLiteral:
+                    case SyntaxKind.TrueKeyword:
+                    case SyntaxKind.FalseKeyword:
+                        return parseJSDocLiteralType();
                 }
 
-                // TODO (drosen): Parse string literal types in JSDoc as well.
                 return parseJSDocTypeReference();
             }
 
@@ -6063,6 +6094,12 @@ namespace ts {
                 return finishNode(result);
             }
 
+            function parseJSDocLiteralType(): JSDocLiteralType {
+                const result = <JSDocLiteralType>createNode(SyntaxKind.JSDocLiteralType);
+                result.literal = parseLiteralTypeNode();
+                return finishNode(result);
+            }
+
             function parseJSDocUnknownOrNullableType(): JSDocUnknownType | JSDocNullableType {
                 const pos = scanner.getStartPos();
                 // skip the ?

src/compiler/performance.ts

@@ -6,71 +6,57 @@ namespace ts {
 }
 
 /*@internal*/
+/** Performance measurements for the compiler. */
 namespace ts.performance {
-    /** Performance measurements for the compiler. */
     declare const onProfilerEvent: { (markName: string): void; profiler: boolean; };
-    let profilerEvent: (markName: string) => void;
-    let counters: Map<number>;
+
+    const profilerEvent = typeof onProfilerEvent === "function" && onProfilerEvent.profiler === true
+            ? onProfilerEvent
+            : (markName: string) => { };
+
+    let enabled = false;
+    let profilerStart = 0;
+    let counts: Map<number>;
+    let marks: Map<number>;
     let measures: Map<number>;
 
     /**
-     * Emit a performance event if ts-profiler is connected. This is primarily used
-     * to generate heap snapshots.
+     * Marks a performance event.
      *
-     * @param eventName A name for the event.
+     * @param markName The name of the mark.
      */
-    export function emit(eventName: string) {
-        if (profilerEvent) {
-            profilerEvent(eventName);
+    export function mark(markName: string) {
+        if (enabled) {
+            marks[markName] = timestamp();
+            counts[markName] = (counts[markName] || 0) + 1;
+            profilerEvent(markName);
         }
     }
 
-    /**
-     * Increments a counter with the specified name.
-     *
-     * @param counterName The name of the counter.
-     */
-    export function increment(counterName: string) {
-        if (counters) {
-            counters[counterName] = (getProperty(counters, counterName) || 0) + 1;
-        }
-    }
-
-    /**
-     * Gets the value of the counter with the specified name.
-     *
-     * @param counterName The name of the counter.
-     */
-    export function getCount(counterName: string) {
-        return counters && getProperty(counters, counterName) || 0;
-    }
-
-    /**
-     * Marks the start of a performance measurement.
-     */
-    export function mark() {
-        return measures ? timestamp() : 0;
-    }
-
     /**
      * Adds a performance measurement with the specified name.
      *
      * @param measureName The name of the performance measurement.
-     * @param marker The timestamp of the starting mark.
+     * @param startMarkName The name of the starting mark. If not supplied, the point at which the
+     *      profiler was enabled is used.
+     * @param endMarkName The name of the ending mark. If not supplied, the current timestamp is
+     *      used.
      */
-    export function measure(measureName: string, marker: number) {
-        if (measures) {
-            measures[measureName] = (getProperty(measures, measureName) || 0) + (timestamp() - marker);
+    export function measure(measureName: string, startMarkName?: string, endMarkName?: string) {
+        if (enabled) {
+            const end = endMarkName && marks[endMarkName] || timestamp();
+            const start = startMarkName && marks[startMarkName] || profilerStart;
+            measures[measureName] = (measures[measureName] || 0) + (end - start);
         }
     }
 
     /**
-     * Iterate over each measure, performing some action
-     * 
-     * @param cb The action to perform for each measure
+     * Gets the number of times a marker was encountered.
+     *
+     * @param markName The name of the mark.
      */
-    export function forEachMeasure(cb: (measureName: string, duration: number) => void) {
-        return forEachKey(measures, key => cb(key, measures[key]));
+    export function getCount(markName: string) {
+        return counts && counts[markName] || 0;
     }
 
     /**
@@ -79,31 +65,31 @@ namespace ts.performance {
      * @param measureName The name of the measure whose durations should be accumulated.
      */
     export function getDuration(measureName: string) {
-        return measures && getProperty(measures, measureName) || 0;
+        return measures && measures[measureName] || 0;
+    }
+
+    /**
+     * Iterate over each measure, performing some action
+     *
+     * @param cb The action to perform for each measure
+     */
+    export function forEachMeasure(cb: (measureName: string, duration: number) => void) {
+        for (const key in measures) {
+            cb(key, measures[key]);
+        }
     }
 
     /** Enables (and resets) performance measurements for the compiler. */
     export function enable() {
-        counters = { };
-        measures = {
-            "I/O Read": 0,
-            "I/O Write": 0,
-            "Program": 0,
-            "Parse": 0,
-            "Bind": 0,
-            "Check": 0,
-            "Emit": 0,
-        };
-
-        profilerEvent = typeof onProfilerEvent === "function" && onProfilerEvent.profiler === true
-            ? onProfilerEvent
-            : undefined;
+        counts = createMap<number>();
+        marks = createMap<number>();
+        measures = createMap<number>();
+        enabled = true;
+        profilerStart = timestamp();
     }
 
-    /** Disables (and clears) performance measurements for the compiler. */
+    /** Disables performance measurements for the compiler. */
     export function disable() {
-        counters = undefined;
-        measures = undefined;
-        profilerEvent = undefined;
+        enabled = false;
     }
 }

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) {
@@ -508,7 +501,7 @@ namespace ts {
             if (state.traceEnabled) {
                 trace(state.host, Diagnostics.paths_option_is_specified_looking_for_a_pattern_to_match_module_name_0, moduleName);
             }
-            matchedPattern = matchPatternOrExact(getKeys(state.compilerOptions.paths), moduleName);
+            matchedPattern = matchPatternOrExact(getOwnKeys(state.compilerOptions.paths), moduleName);
         }
 
         if (matchedPattern) {
@@ -668,24 +661,27 @@ namespace ts {
      * @param {boolean} onlyRecordFailures - if true then function won't try to actually load files but instead record all attempts as failures. This flag is necessary
      * in cases when we know upfront that all load attempts will fail (because containing folder does not exists) however we still need to record all failed lookup locations.
      */
-    function loadModuleFromFile(candidate: string, extensions: string[], failedLookupLocation: string[], onlyRecordFailures: boolean, state: ModuleResolutionState): string {
-        // First try to keep/add an extension: importing "./foo.ts" can be matched by a file "./foo.ts", and "./foo" by "./foo.d.ts"
-        const resolvedByAddingOrKeepingExtension = loadModuleFromFileWorker(candidate, extensions, failedLookupLocation, onlyRecordFailures, state);
-        if (resolvedByAddingOrKeepingExtension) {
-            return resolvedByAddingOrKeepingExtension;
+    function loadModuleFromFile(candidate: string, extensions: string[], failedLookupLocation: string[], onlyRecordFailures: boolean, state: ModuleResolutionState): string | undefined {
+        // First, try adding an extension. An import of "foo" could be matched by a file "foo.ts", or "foo.js" by "foo.js.ts"
+        const resolvedByAddingExtension = tryAddingExtensions(candidate, extensions, failedLookupLocation, onlyRecordFailures, state);
+        if (resolvedByAddingExtension) {
+            return resolvedByAddingExtension;
         }
-        // Then try stripping a ".js" or ".jsx" extension and replacing it with a TypeScript one, e.g. "./foo.js" can be matched by "./foo.ts" or "./foo.d.ts"
+
+        // If that didn't work, try stripping a ".js" or ".jsx" extension and replacing it with a TypeScript one;
+        // e.g. "./foo.js" can be matched by "./foo.ts" or "./foo.d.ts"
         if (hasJavaScriptFileExtension(candidate)) {
             const extensionless = removeFileExtension(candidate);
             if (state.traceEnabled) {
                 const extension = candidate.substring(extensionless.length);
                 trace(state.host, Diagnostics.File_name_0_has_a_1_extension_stripping_it, candidate, extension);
             }
-            return loadModuleFromFileWorker(extensionless, extensions, failedLookupLocation, onlyRecordFailures, state);
+            return tryAddingExtensions(extensionless, extensions, failedLookupLocation, onlyRecordFailures, state);
         }
     }
 
-    function loadModuleFromFileWorker(candidate: string, extensions: string[], failedLookupLocation: string[], onlyRecordFailures: boolean, state: ModuleResolutionState): string {
+    /** Try to return an existing file that adds one of the `extensions` to `candidate`. */
+    function tryAddingExtensions(candidate: string, extensions: string[], failedLookupLocation: string[], onlyRecordFailures: boolean, state: ModuleResolutionState): string | undefined {
         if (!onlyRecordFailures) {
             // check if containing folder exists - if it doesn't then just record failures for all supported extensions without disk probing
             const directory = getDirectoryPath(candidate);
@@ -693,31 +689,29 @@ namespace ts {
                 onlyRecordFailures = !directoryProbablyExists(directory, state.host);
             }
         }
-        return forEach(extensions, tryLoad);
+        return forEach(extensions, ext =>
+            !(state.skipTsx && isJsxOrTsxExtension(ext)) && tryFile(candidate + ext, failedLookupLocation, onlyRecordFailures, state));
+    }
 
-        function tryLoad(ext: string): string {
-            if (state.skipTsx && isJsxOrTsxExtension(ext)) {
-                return undefined;
+    /** Return the file if it exists. */
+    function tryFile(fileName: string, failedLookupLocation: string[], onlyRecordFailures: boolean, state: ModuleResolutionState): string | undefined {
+        if (!onlyRecordFailures && state.host.fileExists(fileName)) {
+            if (state.traceEnabled) {
+                trace(state.host, Diagnostics.File_0_exist_use_it_as_a_name_resolution_result, fileName);
             }
-            const fileName = fileExtensionIs(candidate, ext) ? candidate : candidate + ext;
-            if (!onlyRecordFailures && state.host.fileExists(fileName)) {
-                if (state.traceEnabled) {
-                    trace(state.host, Diagnostics.File_0_exist_use_it_as_a_name_resolution_result, fileName);
-                }
-                return fileName;
-            }
-            else {
-                if (state.traceEnabled) {
-                    trace(state.host, Diagnostics.File_0_does_not_exist, fileName);
-                }
-                failedLookupLocation.push(fileName);
-                return undefined;
+            return fileName;
+        }
+        else {
+            if (state.traceEnabled) {
+                trace(state.host, Diagnostics.File_0_does_not_exist, fileName);
             }
+            failedLookupLocation.push(fileName);
+            return undefined;
         }
     }
 
     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) {
@@ -725,7 +719,10 @@ namespace ts {
             }
             const typesFile = tryReadTypesSection(packageJsonPath, candidate, state);
             if (typesFile) {
-                const result = loadModuleFromFile(typesFile, extensions, failedLookupLocation, !directoryProbablyExists(getDirectoryPath(typesFile), state.host), state);
+                const onlyRecordFailures = !directoryProbablyExists(getDirectoryPath(typesFile), state.host);
+                // A package.json "typings" may specify an exact filename, or may choose to omit an extension.
+                const result = tryFile(typesFile, failedLookupLocation, onlyRecordFailures, state) ||
+                    tryAddingExtensions(typesFile, extensions, failedLookupLocation, onlyRecordFailures, state);
                 if (result) {
                     return result;
                 }
@@ -747,6 +744,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);
@@ -831,14 +832,6 @@ namespace ts {
             : { resolvedModule: undefined, failedLookupLocations };
     }
 
-    /* @internal */
-    export const defaultInitCompilerOptions: CompilerOptions = {
-        module: ModuleKind.CommonJS,
-        target: ScriptTarget.ES5,
-        noImplicitAny: false,
-        sourceMap: false,
-    };
-
     interface OutputFingerprint {
         hash: string;
         byteOrderMark: boolean;
@@ -846,7 +839,7 @@ namespace ts {
     }
 
     export function createCompilerHost(options: CompilerOptions, setParentNodes?: boolean): CompilerHost {
-        const existingDirectories: Map<boolean> = {};
+        const existingDirectories = createMap<boolean>();
 
         function getCanonicalFileName(fileName: string): string {
             // if underlying system can distinguish between two files whose names differs only in cases then file name already in canonical form.
@@ -860,9 +853,10 @@ namespace ts {
         function getSourceFile(fileName: string, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile {
             let text: string;
             try {
-                const start = performance.mark();
+                performance.mark("beforeIORead");
                 text = sys.readFile(fileName, options.charset);
-                performance.measure("I/O Read", start);
+                performance.mark("afterIORead");
+                performance.measure("I/O Read", "beforeIORead", "afterIORead");
             }
             catch (e) {
                 if (onError) {
@@ -877,7 +871,7 @@ namespace ts {
         }
 
         function directoryExists(directoryPath: string): boolean {
-            if (hasProperty(existingDirectories, directoryPath)) {
+            if (directoryPath in existingDirectories) {
                 return true;
             }
             if (sys.directoryExists(directoryPath)) {
@@ -899,13 +893,13 @@ namespace ts {
 
         function writeFileIfUpdated(fileName: string, data: string, writeByteOrderMark: boolean): void {
             if (!outputFingerprints) {
-                outputFingerprints = {};
+                outputFingerprints = createMap<OutputFingerprint>();
             }
 
             const hash = sys.createHash(data);
             const mtimeBefore = sys.getModifiedTime(fileName);
 
-            if (mtimeBefore && hasProperty(outputFingerprints, fileName)) {
+            if (mtimeBefore && fileName in outputFingerprints) {
                 const fingerprint = outputFingerprints[fileName];
 
                 // If output has not been changed, and the file has no external modification
@@ -929,7 +923,7 @@ namespace ts {
 
         function writeFile(fileName: string, data: string, writeByteOrderMark: boolean, onError?: (message: string) => void) {
             try {
-                const start = performance.mark();
+                performance.mark("beforeIOWrite");
                 ensureDirectoriesExist(getDirectoryPath(normalizePath(fileName)));
 
                 if (isWatchSet(options) && sys.createHash && sys.getModifiedTime) {
@@ -939,7 +933,8 @@ namespace ts {
                     sys.writeFile(fileName, data, writeByteOrderMark);
                 }
 
-                performance.measure("I/O Write", start);
+                performance.mark("afterIOWrite");
+                performance.measure("I/O Write", "beforeIOWrite", "afterIOWrite");
             }
             catch (e) {
                 if (onError) {
@@ -1041,16 +1036,11 @@ namespace ts {
             return [];
         }
         const resolutions: T[] = [];
-        const cache: Map<T> = {};
+        const cache = createMap<T>();
         for (const name of names) {
-            let result: T;
-            if (hasProperty(cache, name)) {
-                result = cache[name];
-            }
-            else {
-                result = loader(name, containingFile);
-                cache[name] = result;
-            }
+            const result = name in cache
+                ? cache[name]
+                : cache[name] = loader(name, containingFile);
             resolutions.push(result);
         }
         return resolutions;
@@ -1071,15 +1061,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));
+                            }
                         }
                     }
                 }
@@ -1096,7 +1092,7 @@ namespace ts {
         let noDiagnosticsTypeChecker: TypeChecker;
         let classifiableNames: Map<string>;
 
-        let resolvedTypeReferenceDirectives: Map<ResolvedTypeReferenceDirective> = {};
+        let resolvedTypeReferenceDirectives = createMap<ResolvedTypeReferenceDirective>();
         let fileProcessingDiagnostics = createDiagnosticCollection();
 
         // The below settings are to track if a .js file should be add to the program if loaded via searching under node_modules.
@@ -1111,12 +1107,12 @@ namespace ts {
 
         // If a module has some of its imports skipped due to being at the depth limit under node_modules, then track
         // this, as it may be imported at a shallower depth later, and then it will need its skipped imports processed.
-        const modulesWithElidedImports: Map<boolean> = {};
+        const modulesWithElidedImports = createMap<boolean>();
 
         // Track source files that are source files found by searching under node_modules, as these shouldn't be compiled.
-        const sourceFilesFoundSearchingNodeModules: Map<boolean> = {};
+        const sourceFilesFoundSearchingNodeModules = createMap<boolean>();
 
-        const start = performance.mark();
+        performance.mark("beforeProgram");
 
         host = host || createCompilerHost(options);
 
@@ -1214,8 +1210,8 @@ namespace ts {
         };
 
         verifyCompilerOptions();
-
-        performance.measure("Program", start);
+        performance.mark("afterProgram");
+        performance.measure("Program", "beforeProgram", "afterProgram");
 
         return program;
 
@@ -1242,10 +1238,10 @@ namespace ts {
             if (!classifiableNames) {
                 // Initialize a checker so that all our files are bound.
                 getTypeChecker();
-                classifiableNames = {};
+                classifiableNames = createMap<string>();
 
                 for (const sourceFile of files) {
-                    copyMap(sourceFile.classifiableNames, classifiableNames);
+                    copyProperties(sourceFile.classifiableNames, classifiableNames);
                 }
             }
 
@@ -1273,7 +1269,7 @@ namespace ts {
                 (oldOptions.maxNodeModuleJsDepth !== options.maxNodeModuleJsDepth) ||
                 !arrayIsEqualTo(oldOptions.typeRoots, oldOptions.typeRoots) ||
                 !arrayIsEqualTo(oldOptions.rootDirs, options.rootDirs) ||
-                !mapIsEqualTo(oldOptions.paths, options.paths)) {
+                !equalOwnProperties(oldOptions.paths, options.paths)) {
                 return false;
             }
 
@@ -1395,7 +1391,7 @@ namespace ts {
                 getSourceFile: program.getSourceFile,
                 getSourceFileByPath: program.getSourceFileByPath,
                 getSourceFiles: program.getSourceFiles,
-                isSourceFileFromExternalLibrary: (file: SourceFile) => !!lookUp(sourceFilesFoundSearchingNodeModules, file.path),
+                isSourceFileFromExternalLibrary: (file: SourceFile) => !!sourceFilesFoundSearchingNodeModules[file.path],
                 writeFile: writeFileCallback || (
                     (fileName, data, writeByteOrderMark, onError, sourceFiles) => host.writeFile(fileName, data, writeByteOrderMark, onError, sourceFiles)),
                 isEmitBlocked,
@@ -1458,17 +1454,15 @@ namespace ts {
             // checked is to not pass the file to getEmitResolver.
             const emitResolver = getDiagnosticsProducingTypeChecker().getEmitResolver((options.outFile || options.out) ? undefined : sourceFile);
 
-            performance.emit("beforeEmit");
-            const start = performance.mark();
+            performance.mark("beforeEmit");
 
             const emitResult = emitFiles(
                 emitResolver,
                 getEmitHost(writeFileCallback),
                 sourceFile);
 
-            performance.measure("Emit", start);
-            performance.emit("afterEmit");
-
+            performance.mark("afterEmit");
+            performance.measure("Emit", "beforeEmit", "afterEmit");
             return emitResult;
         }
 
@@ -1946,7 +1940,7 @@ namespace ts {
 
                 // If the file was previously found via a node_modules search, but is now being processed as a root file,
                 // then everything it sucks in may also be marked incorrectly, and needs to be checked again.
-                if (file && lookUp(sourceFilesFoundSearchingNodeModules, file.path) && currentNodeModulesDepth == 0) {
+                if (file && sourceFilesFoundSearchingNodeModules[file.path] && currentNodeModulesDepth == 0) {
                     sourceFilesFoundSearchingNodeModules[file.path] = false;
                     if (!options.noResolve) {
                         processReferencedFiles(file, getDirectoryPath(fileName), isDefaultLib);
@@ -1957,7 +1951,7 @@ namespace ts {
                     processImportedModules(file, getDirectoryPath(fileName));
                 }
                 // See if we need to reprocess the imports due to prior skipped imports
-                else if (file && lookUp(modulesWithElidedImports, file.path)) {
+                else if (file && modulesWithElidedImports[file.path]) {
                     if (currentNodeModulesDepth < maxNodeModulesJsDepth) {
                         modulesWithElidedImports[file.path] = false;
                         processImportedModules(file, getDirectoryPath(fileName));
@@ -2024,15 +2018,17 @@ namespace ts {
         }
 
         function processTypeReferenceDirectives(file: SourceFile) {
-            const typeDirectives = map(file.typeReferenceDirectives, l => l.fileName);
+            // We lower-case all type references because npm automatically lowercases all packages. See GH#9824.
+            const typeDirectives = map(file.typeReferenceDirectives, ref => ref.fileName.toLocaleLowerCase());
             const resolutions = resolveTypeReferenceDirectiveNamesWorker(typeDirectives, file.fileName);
 
             for (let i = 0; i < typeDirectives.length; i++) {
                 const ref = file.typeReferenceDirectives[i];
                 const resolvedTypeReferenceDirective = resolutions[i];
                 // store resolved type directive on the file
-                setResolvedTypeReferenceDirective(file, ref.fileName, resolvedTypeReferenceDirective);
-                processTypeReferenceDirective(ref.fileName, resolvedTypeReferenceDirective, file, ref.pos, ref.end);
+                const fileName = ref.fileName.toLocaleLowerCase();
+                setResolvedTypeReferenceDirective(file, fileName, resolvedTypeReferenceDirective);
+                processTypeReferenceDirective(fileName, resolvedTypeReferenceDirective, file, ref.pos, ref.end);
             }
         }
 
@@ -2057,7 +2053,7 @@ namespace ts {
                         const otherFileText = host.readFile(resolvedTypeReferenceDirective.resolvedFileName);
                         if (otherFileText !== getSourceFile(previousResolution.resolvedFileName).text) {
                             fileProcessingDiagnostics.add(createDiagnostic(refFile, refPos, refEnd,
-                                Diagnostics.Conflicting_library_definitions_for_0_found_at_1_and_2_Copy_the_correct_file_to_the_typings_folder_to_resolve_this_conflict,
+                                Diagnostics.Conflicting_definitions_for_0_found_at_1_and_2_Consider_installing_a_specific_version_of_this_library_to_resolve_the_conflict,
                                 typeReferenceDirective,
                                 resolvedTypeReferenceDirective.resolvedFileName,
                                 previousResolution.resolvedFileName
@@ -2097,7 +2093,7 @@ namespace ts {
         function processImportedModules(file: SourceFile, basePath: string) {
             collectExternalModuleReferences(file);
             if (file.imports.length || file.moduleAugmentations.length) {
-                file.resolvedModules = {};
+                file.resolvedModules = createMap<ResolvedModule>();
                 const moduleNames = map(concatenate(file.imports, file.moduleAugmentations), getTextOfLiteral);
                 const resolutions = resolveModuleNamesWorker(moduleNames, getNormalizedAbsolutePath(file.fileName, currentDirectory));
                 for (let i = 0; i < moduleNames.length; i++) {

src/compiler/scanner.ts

@@ -55,7 +55,7 @@ namespace ts {
         tryScan<T>(callback: () => T): T;
     }
 
-    const textToToken: Map<SyntaxKind> = {
+    const textToToken = createMap({
         "abstract": SyntaxKind.AbstractKeyword,
         "any": SyntaxKind.AnyKeyword,
         "as": SyntaxKind.AsKeyword,
@@ -179,7 +179,7 @@ namespace ts {
         "|=": SyntaxKind.BarEqualsToken,
         "^=": SyntaxKind.CaretEqualsToken,
         "@": SyntaxKind.AtToken,
-    };
+    });
 
     /*
         As per ECMAScript Language Specification 3th Edition, Section 7.6: Identifiers
@@ -274,9 +274,7 @@ namespace ts {
     function makeReverseMap(source: Map<number>): string[] {
         const result: string[] = [];
         for (const name in source) {
-            if (source.hasOwnProperty(name)) {
-                result[source[name]] = name;
-            }
+            result[source[name]] = name;
         }
         return result;
     }

src/compiler/sourcemap.ts

@@ -219,6 +219,7 @@ namespace ts {
 
     function createSourceMapWriterWorker(host: EmitHost, writer: EmitTextWriter): SourceMapWriter {
         const compilerOptions = host.getCompilerOptions();
+        const extendedDiagnostics = compilerOptions.extendedDiagnostics;
         let currentSourceFile: SourceFile;
         let currentSourceText: string;
         let sourceMapDir: string; // The directory in which sourcemap will be
@@ -462,7 +463,9 @@ namespace ts {
                 return;
             }
 
-            const start = performance.mark();
+            if (extendedDiagnostics) {
+                performance.mark("beforeSourcemap");
+            }
 
             const sourceLinePos = getLineAndCharacterOfPosition(currentSourceFile, pos);
 
@@ -504,7 +507,10 @@ namespace ts {
 
             updateLastEncodedAndRecordedSpans();
 
-            performance.measure("Source Map", start);
+            if (extendedDiagnostics) {
+                performance.mark("afterSourcemap");
+                performance.measure("Source Map", "beforeSourcemap", "afterSourcemap");
+            }
         }
 
         function getStartPosPastDecorators(range: TextRange) {
@@ -782,30 +788,30 @@ namespace ts {
             getSourceMapData,
             setSourceFile,
             emitPos(pos: number): void {
-                const sourcemapStart = performance.mark();
+                 performance.mark("sourcemapStart");
                 emitPos(pos);
-                performance.measure("sourceMapTime", sourcemapStart);
+                performance.measure("sourceMapTime", "sourcemapStart");
             },
             emitStart(range: TextRange, contextNode?: Node, ignoreNodeCallback?: (node: Node) => boolean, ignoreChildrenCallback?: (node: Node) => boolean, getTextRangeCallback?: (node: Node) => TextRange): void {
-                const sourcemapStart = performance.mark();
+                performance.mark("emitSourcemap:emitStart");
                 emitStart(range, contextNode, ignoreNodeCallback, ignoreChildrenCallback, getTextRangeCallback);
-                performance.measure("sourceMapTime", sourcemapStart);
+                performance.measure("sourceMapTime", "emitSourcemap:emitStart");
             },
             emitEnd(range: TextRange, contextNode?: Node, ignoreNodeCallback?: (node: Node) => boolean, ignoreChildrenCallback?: (node: Node) => boolean, getTextRangeCallback?: (node: Node) => TextRange): void {
-                const sourcemapStart = performance.mark();
+                performance.mark("emitSourcemap:emitEnd");
                 emitEnd(range, contextNode, ignoreNodeCallback, ignoreChildrenCallback, getTextRangeCallback);
-                performance.measure("sourceMapTime", sourcemapStart);
+                performance.measure("sourceMapTime", "emitSourcemap:emitEnd");
             },
             emitTokenStart(token: SyntaxKind, tokenStartPos: number, contextNode?: Node, ignoreTokenCallback?: (node: Node) => boolean, getTokenTextRangeCallback?: (node: Node, token: SyntaxKind) => TextRange): number {
-                const sourcemapStart = performance.mark();
+                performance.mark("emitSourcemap:emitTokenStart");
                 tokenStartPos = emitTokenStart(token, tokenStartPos, contextNode, ignoreTokenCallback, getTokenTextRangeCallback);
-                performance.measure("sourceMapTime", sourcemapStart);
+                performance.measure("sourceMapTime", "emitSourcemap:emitTokenStart");
                 return tokenStartPos;
             },
             emitTokenEnd(token: SyntaxKind, tokenEndPos: number, contextNode?: Node, ignoreTokenCallback?: (node: Node) => boolean, getTokenTextRangeCallback?: (node: Node, token: SyntaxKind) => TextRange): number {
-                const sourcemapStart = performance.mark();
+                performance.mark("emitSourcemap:emitTokenEnd");
                 tokenEndPos = emitTokenEnd(token, tokenEndPos, contextNode, ignoreTokenCallback, getTokenTextRangeCallback);
-                performance.measure("sourceMapTime", sourcemapStart);
+                performance.measure("sourceMapTime", "emitSourcemap:emitTokenEnd");
                 return tokenEndPos;
             },
             changeEmitSourcePos,

src/compiler/sys.ts

@@ -239,15 +239,15 @@ namespace ts {
             const useNonPollingWatchers = process.env["TSC_NONPOLLING_WATCHER"];
 
             function createWatchedFileSet() {
-                const dirWatchers: Map<DirectoryWatcher> = {};
+                const dirWatchers = createMap<DirectoryWatcher>();
                 // One file can have multiple watchers
-                const fileWatcherCallbacks: Map<FileWatcherCallback[]> = {};
+                const fileWatcherCallbacks = createMap<FileWatcherCallback[]>();
                 return { addFile, removeFile };
 
                 function reduceDirWatcherRefCountForFile(fileName: string) {
                     const dirName = getDirectoryPath(fileName);
-                    if (hasProperty(dirWatchers, dirName)) {
-                        const watcher = dirWatchers[dirName];
+                    const watcher = dirWatchers[dirName];
+                    if (watcher) {
                         watcher.referenceCount -= 1;
                         if (watcher.referenceCount <= 0) {
                             watcher.close();
@@ -257,13 +257,12 @@ namespace ts {
                 }
 
                 function addDirWatcher(dirPath: string): void {
-                    if (hasProperty(dirWatchers, dirPath)) {
-                        const watcher = dirWatchers[dirPath];
+                    let watcher = dirWatchers[dirPath];
+                    if (watcher) {
                         watcher.referenceCount += 1;
                         return;
                     }
-
-                    const watcher: DirectoryWatcher = _fs.watch(
+                    watcher = _fs.watch(
                         dirPath,
                         { persistent: true },
                         (eventName: string, relativeFileName: string) => fileEventHandler(eventName, relativeFileName, dirPath)
@@ -274,12 +273,7 @@ namespace ts {
                 }
 
                 function addFileWatcherCallback(filePath: string, callback: FileWatcherCallback): void {
-                    if (hasProperty(fileWatcherCallbacks, filePath)) {
-                        fileWatcherCallbacks[filePath].push(callback);
-                    }
-                    else {
-                        fileWatcherCallbacks[filePath] = [callback];
-                    }
+                    (fileWatcherCallbacks[filePath] || (fileWatcherCallbacks[filePath] = [])).push(callback);
                 }
 
                 function addFile(fileName: string, callback: FileWatcherCallback): WatchedFile {
@@ -295,8 +289,9 @@ namespace ts {
                 }
 
                 function removeFileWatcherCallback(filePath: string, callback: FileWatcherCallback) {
-                    if (hasProperty(fileWatcherCallbacks, filePath)) {
-                        const newCallbacks = copyListRemovingItem(callback, fileWatcherCallbacks[filePath]);
+                    const callbacks = fileWatcherCallbacks[filePath];
+                    if (callbacks) {
+                        const newCallbacks = copyListRemovingItem(callback, callbacks);
                         if (newCallbacks.length === 0) {
                             delete fileWatcherCallbacks[filePath];
                         }
@@ -312,7 +307,7 @@ namespace ts {
                         ? undefined
                         : ts.getNormalizedAbsolutePath(relativeFileName, baseDirPath);
                     // Some applications save a working file via rename operations
-                    if ((eventName === "change" || eventName === "rename") && hasProperty(fileWatcherCallbacks, fileName)) {
+                    if ((eventName === "change" || eventName === "rename") && fileWatcherCallbacks[fileName]) {
                         for (const fileCallback of fileWatcherCallbacks[fileName]) {
                             fileCallback(fileName);
                         }
@@ -443,7 +438,7 @@ namespace ts {
             }
 
             function getDirectories(path: string): string[] {
-                return filter<string>(_fs.readdirSync(path), p => fileSystemEntryExists(combinePaths(path, p), FileSystemEntryKind.Directory));
+                return filter<string>(_fs.readdirSync(path), dir => fileSystemEntryExists(combinePaths(path, dir), FileSystemEntryKind.Directory));
             }
 
             const nodeSystem: System = {

src/compiler/transformer.ts

@@ -10,14 +10,14 @@
 
 /* @internal */
 namespace ts {
-    const moduleTransformerMap: Map<Transformer> = {
+    const moduleTransformerMap = createMap<Transformer>({
         [ModuleKind.ES6]: transformES6Module,
         [ModuleKind.System]: transformSystemModule,
         [ModuleKind.AMD]: transformModule,
         [ModuleKind.CommonJS]: transformModule,
         [ModuleKind.UMD]: transformModule,
         [ModuleKind.None]: transformModule,
-    };
+    });
 
     const enum SyntaxKindFeatureFlags {
         Substitution = 1 << 0,
@@ -206,7 +206,7 @@ namespace ts {
         const transformId = nextTransformId;
         nextTransformId++;
 
-        const tokenSourceMapRanges: Map<TextRange> = { };
+        const tokenSourceMapRanges = createMap<TextRange>();
         const lexicalEnvironmentVariableDeclarationsStack: VariableDeclaration[][] = [];
         const lexicalEnvironmentFunctionDeclarationsStack: FunctionDeclaration[][] = [];
         const enabledSyntaxKindFeatures = new Array<SyntaxKindFeatureFlags>(SyntaxKind.Count);

src/compiler/transformers/es6.ts

@@ -1663,7 +1663,7 @@ namespace ts {
         function visitLabeledStatement(node: LabeledStatement): VisitResult<Statement> {
             if (convertedLoopState) {
                 if (!convertedLoopState.labels) {
-                    convertedLoopState.labels = {};
+                    convertedLoopState.labels = createMap<string>();
                 }
                 convertedLoopState.labels[node.label.text] = node.label.text;
             }
@@ -1815,7 +1815,9 @@ namespace ts {
                     );
                 }
                 else {
-                    assignment.end = initializer.end;
+                    // Currently there is not way to check that assignment is binary expression of destructing assignment
+                    // so we have to cast never type to binaryExpression
+                    (<BinaryExpression>assignment).end = initializer.end;
                     statements.push(createStatement(assignment, /*location*/ moveRangeEnd(initializer, -1)));
                 }
             }
@@ -2249,13 +2251,13 @@ namespace ts {
         function setLabeledJump(state: ConvertedLoopState, isBreak: boolean, labelText: string, labelMarker: string): void {
             if (isBreak) {
                 if (!state.labeledNonLocalBreaks) {
-                    state.labeledNonLocalBreaks = {};
+                    state.labeledNonLocalBreaks = createMap<string>();
                 }
                 state.labeledNonLocalBreaks[labelText] = labelMarker;
             }
             else {
                 if (!state.labeledNonLocalContinues) {
-                    state.labeledNonLocalContinues = {};
+                    state.labeledNonLocalContinues = createMap<string>();
                 }
                 state.labeledNonLocalContinues[labelText] = labelMarker;
             }

src/compiler/transformers/generators.ts

@@ -216,13 +216,13 @@ namespace ts {
         Endfinally = 7,
     }
 
-    const instructionNames: Map<string> = {
+    const instructionNames = createMap<string>({
         [Instruction.Return]: "return",
         [Instruction.Break]: "break",
         [Instruction.Yield]: "yield",
         [Instruction.YieldStar]: "yield*",
         [Instruction.Endfinally]: "endfinally",
-    };
+    });
 
     export function transformGenerators(context: TransformationContext) {
         const {
@@ -1912,7 +1912,7 @@ namespace ts {
         function cacheExpression(node: Expression): Identifier {
             let temp: Identifier;
             if (isGeneratedIdentifier(node)) {
-                return node;
+                return <Identifier>node;
             }
 
             temp = createTempVariable(hoistVariableDeclaration);
@@ -2060,8 +2060,8 @@ namespace ts {
             const name = declareLocal(text);
 
             if (!renamedCatchVariables) {
-                renamedCatchVariables = {};
-                renamedCatchVariableDeclarations = {};
+                renamedCatchVariables = createMap<boolean>();
+                renamedCatchVariableDeclarations = createMap<Identifier>();
                 context.enableSubstitution(SyntaxKind.Identifier);
             }
 

src/compiler/transformers/jsx.ts

@@ -259,7 +259,7 @@ namespace ts {
     }
 
     function createEntitiesMap(): Map<number> {
-        return {
+        return createMap<number>({
             "quot": 0x0022,
             "amp": 0x0026,
             "apos": 0x0027,
@@ -513,6 +513,6 @@ namespace ts {
             "clubs": 0x2663,
             "hearts": 0x2665,
             "diams": 0x2666
-        };
+        });
     }
 }

src/compiler/transformers/module/module.ts

@@ -4,12 +4,12 @@
 /*@internal*/
 namespace ts {
     export function transformModule(context: TransformationContext) {
-        const transformModuleDelegates: Map<(node: SourceFile) => SourceFile> = {
+        const transformModuleDelegates = createMap<(node: SourceFile) => SourceFile>({
             [ModuleKind.None]: transformCommonJSModule,
             [ModuleKind.CommonJS]: transformCommonJSModule,
             [ModuleKind.AMD]: transformAMDModule,
             [ModuleKind.UMD]: transformUMDModule,
-        };
+        });
 
         const {
             startLexicalEnvironment,
@@ -43,7 +43,7 @@ namespace ts {
         let bindingNameExportSpecifiersMap: Map<ExportSpecifier[]>;
         // Subset of exportSpecifiers that is a binding-name.
         // This is to reduce amount of memory we have to keep around even after we done with module-transformer
-        const bindingNameExportSpecifiersForFileMap: Map<Map<ExportSpecifier[]>> = {};
+        const bindingNameExportSpecifiersForFileMap = createMap<Map<ExportSpecifier[]>>();
         let hasExportStarsToExportValues: boolean;
 
         return transformSourceFile;
@@ -667,7 +667,7 @@ namespace ts {
                 if (!exportEquals && exportSpecifiers && hasProperty(exportSpecifiers, name.text)) {
                     const sourceFileId = getOriginalNodeId(currentSourceFile);
                     if (!bindingNameExportSpecifiersForFileMap[sourceFileId]) {
-                        bindingNameExportSpecifiersForFileMap[sourceFileId] = {};
+                        bindingNameExportSpecifiersForFileMap[sourceFileId] = createMap<ExportSpecifier[]>();
                     }
                     bindingNameExportSpecifiersForFileMap[sourceFileId][name.text] = exportSpecifiers[name.text];
                     addExportMemberAssignments(resultStatements, name);

src/compiler/transformers/module/system.ts

@@ -1324,7 +1324,7 @@ namespace ts {
         }
 
         function collectDependencyGroups(externalImports: (ImportDeclaration | ImportEqualsDeclaration | ExportDeclaration)[]) {
-            const groupIndices: Map<number> = {};
+            const groupIndices = createMap<number>();
             const dependencyGroups: DependencyGroup[] = [];
             for (let i = 0; i < externalImports.length; i++) {
                 const externalImport = externalImports[i];

src/compiler/transformers/ts.ts

@@ -3152,7 +3152,7 @@ namespace ts {
                 context.enableSubstitution(SyntaxKind.Identifier);
 
                 // Keep track of class aliases.
-                classAliases = {};
+                classAliases = createMap<Identifier>();
             }
         }
 

src/compiler/tsc.ts

@@ -127,11 +127,11 @@ namespace ts {
     const gutterSeparator = " ";
     const resetEscapeSequence = "\u001b[0m";
     const ellipsis = "...";
-    const categoryFormatMap: Map<string> = {
+    const categoryFormatMap = createMap<string>({
         [DiagnosticCategory.Warning]: yellowForegroundEscapeSequence,
         [DiagnosticCategory.Error]: redForegroundEscapeSequence,
         [DiagnosticCategory.Message]: blueForegroundEscapeSequence,
-    };
+    });
 
     function formatAndReset(text: string, formatStyle: string) {
         return formatStyle + text + resetEscapeSequence;
@@ -425,7 +425,7 @@ namespace ts {
             }
 
             // reset the cache of existing files
-            cachedExistingFiles = {};
+            cachedExistingFiles = createMap<boolean>();
 
             const compileResult = compile(rootFileNames, compilerOptions, compilerHost);
 
@@ -438,10 +438,9 @@ namespace ts {
         }
 
         function cachedFileExists(fileName: string): boolean {
-            if (hasProperty(cachedExistingFiles, fileName)) {
-                return cachedExistingFiles[fileName];
-            }
-            return cachedExistingFiles[fileName] = hostFileExists(fileName);
+            return fileName in cachedExistingFiles
+                ? cachedExistingFiles[fileName]
+                : cachedExistingFiles[fileName] = hostFileExists(fileName);
         }
 
         function getSourceFile(fileName: string, languageVersion: ScriptTarget, onError?: (message: string) => void) {
@@ -704,7 +703,7 @@ namespace ts {
         const usageColumn: string[] = []; // Things like "-d, --declaration" go in here.
         const descriptionColumn: string[] = [];
 
-        const optionsDescriptionMap: Map<string[]> = {};  // Map between option.description and list of option.type if it is a kind
+        const optionsDescriptionMap = createMap<string[]>();  // Map between option.description and list of option.type if it is a kind
 
         for (let i = 0; i < optsList.length; i++) {
             const option = optsList[i];
@@ -732,9 +731,10 @@ namespace ts {
                 description = getDiagnosticText(option.description);
                 const options: string[] = [];
                 const element = (<CommandLineOptionOfListType>option).element;
-                forEachKey(<Map<number | string>>element.type, key => {
+                const typeMap = <Map<number | string>>element.type;
+                for (const key in typeMap) {
                     options.push(`'${key}'`);
-                });
+                }
                 optionsDescriptionMap[description] = options;
             }
             else {
@@ -791,68 +791,11 @@ namespace ts {
             reportDiagnostic(createCompilerDiagnostic(Diagnostics.A_tsconfig_json_file_is_already_defined_at_Colon_0, file), /* host */ undefined);
         }
         else {
-            const compilerOptions = extend(options, defaultInitCompilerOptions);
-            const configurations: any = {
-                compilerOptions: serializeCompilerOptions(compilerOptions)
-            };
-
-            if (fileNames && fileNames.length) {
-                // only set the files property if we have at least one file
-                configurations.files = fileNames;
-            }
-            else {
-                configurations.exclude = ["node_modules"];
-                if (compilerOptions.outDir) {
-                    configurations.exclude.push(compilerOptions.outDir);
-                }
-            }
-
-            sys.writeFile(file, JSON.stringify(configurations, undefined, 4));
+            sys.writeFile(file, JSON.stringify(generateTSConfig(options, fileNames), undefined, 4));
             reportDiagnostic(createCompilerDiagnostic(Diagnostics.Successfully_created_a_tsconfig_json_file), /* host */ undefined);
         }
 
         return;
-
-        function serializeCompilerOptions(options: CompilerOptions): Map<string | number | boolean> {
-            const result: Map<string | number | boolean> = {};
-            const optionsNameMap = getOptionNameMap().optionNameMap;
-
-            for (const name in options) {
-                if (hasProperty(options, name)) {
-                    // tsconfig only options cannot be specified via command line,
-                    // so we can assume that only types that can appear here string | number | boolean
-                    const value = <string | number | boolean>options[name];
-                    switch (name) {
-                        case "init":
-                        case "watch":
-                        case "version":
-                        case "help":
-                        case "project":
-                            break;
-                        default:
-                            let optionDefinition = optionsNameMap[name.toLowerCase()];
-                            if (optionDefinition) {
-                                if (typeof optionDefinition.type === "string") {
-                                    // string, number or boolean
-                                    result[name] = value;
-                                }
-                                else {
-                                    // Enum
-                                    const typeMap = <Map<number>>optionDefinition.type;
-                                    for (const key in typeMap) {
-                                        if (hasProperty(typeMap, key)) {
-                                            if (typeMap[key] === value)
-                                                result[name] = key;
-                                        }
-                                    }
-                                }
-                            }
-                            break;
-                    }
-                }
-            }
-            return result;
-        }
     }
 }
 

src/compiler/types.ts

@@ -1,9 +1,13 @@
-
 namespace ts {
-    export interface Map<T> {
+
+    export interface MapLike<T> {
         [index: string]: T;
     }
 
+    export interface Map<T> extends MapLike<T> {
+        __mapBrand: any;
+    }
+
     // branded string type used to store absolute, normalized and canonicalized paths
     // arbitrary file name can be converted to Path via toPath function
     export type Path = string & { __pathBrand: any };
@@ -346,6 +350,10 @@ namespace ts {
         JSDocTypedefTag,
         JSDocPropertyTag,
         JSDocTypeLiteral,
+        JSDocLiteralType,
+        JSDocNullKeyword,
+        JSDocUndefinedKeyword,
+        JSDocNeverKeyword,
 
         // Synthesized list
         SyntaxList,
@@ -383,9 +391,9 @@ namespace ts {
         LastBinaryOperator = CaretEqualsToken,
         FirstNode = QualifiedName,
         FirstJSDocNode = JSDocTypeExpression,
-        LastJSDocNode = JSDocTypeLiteral,
+        LastJSDocNode = JSDocLiteralType,
         FirstJSDocTagNode = JSDocComment,
-        LastJSDocTagNode = JSDocTypeLiteral
+        LastJSDocTagNode = JSDocNeverKeyword
     }
 
     export const enum NodeFlags {
@@ -585,7 +593,7 @@ namespace ts {
     // @kind(SyntaxKind.ConstructSignature)
     export interface ConstructSignatureDeclaration extends SignatureDeclaration, TypeElement { }
 
-    export type BindingName = Identifier | ObjectBindingPattern | ArrayBindingPattern;
+    export type BindingName = Identifier | BindingPattern;
 
     // @kind(SyntaxKind.VariableDeclaration)
     export interface VariableDeclaration extends Declaration {
@@ -1038,13 +1046,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 {
@@ -1566,6 +1580,10 @@ namespace ts {
         type: JSDocType;
     }
 
+    export interface JSDocLiteralType extends JSDocType {
+        literal: LiteralTypeNode;
+    }
+
     export type JSDocTypeReferencingNode = JSDocThisType | JSDocConstructorType | JSDocVariadicType | JSDocOptionalType | JSDocNullableType | JSDocNonNullableType;
 
     // @kind(SyntaxKind.JSDocRecordMember)
@@ -2108,7 +2126,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;
@@ -2117,7 +2135,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[];
     }
 
@@ -2224,6 +2242,8 @@ namespace ts {
         /* @internal */ exportSymbol?: Symbol;  // Exported symbol associated with this symbol
         /* @internal */ constEnumOnlyModule?: boolean; // True if module contains only const enums or other modules with only const enums
         /* @internal */ isReferenced?: boolean; // True if the symbol is referenced elsewhere
+        /* @internal */ isReplaceableByMethod?: boolean; // Can this Javascript class property be replaced by a method symbol?
+        /* @internal */ isAssigned?: boolean;   // True if the symbol is a parameter with assignments
     }
 
     /* @internal */
@@ -2237,6 +2257,8 @@ namespace ts {
         mapper?: TypeMapper;                // Type mapper for instantiation alias
         referenced?: boolean;               // True if alias symbol has been referenced as a value
         containingType?: UnionOrIntersectionType; // Containing union or intersection type for synthetic property
+        hasCommonType?: boolean;            // True if constituents of synthetic property all have same type
+        isDiscriminantProperty?: boolean;   // True if discriminant synthetic property
         resolvedExports?: SymbolTable;      // Resolved exports of module
         exportsChecked?: boolean;           // True if exports of external module have been checked
         isDeclarationWithCollidingName?: boolean;    // True if symbol is block scoped redeclaration
@@ -2247,9 +2269,7 @@ namespace ts {
     /* @internal */
     export interface TransientSymbol extends Symbol, SymbolLinks { }
 
-    export interface SymbolTable {
-        [index: string]: Symbol;
-    }
+    export type SymbolTable = Map<Symbol>;
 
     /** Represents a "prefix*suffix" pattern. */
     /* @internal */
@@ -2276,23 +2296,26 @@ namespace ts {
         AsyncMethodWithSuper                = 0x00000800,  // An async method that reads a value from a member of 'super'.
         AsyncMethodWithSuperBinding         = 0x00001000,  // An async method that assigns a value to a member of 'super'.
         CaptureArguments                    = 0x00002000,  // Lexical 'arguments' used in body (for async functions)
-        EnumValuesComputed                  = 0x00004000, // Values for enum members have been computed, and any errors have been reported for them.
-        LexicalModuleMergesWithClass        = 0x00008000, // Instantiated lexical module declaration is merged with a previous class declaration.
-        LoopWithCapturedBlockScopedBinding  = 0x00010000, // Loop that contains block scoped variable captured in closure
-        CapturedBlockScopedBinding          = 0x00020000, // Block-scoped binding that is captured in some function
-        BlockScopedBindingInLoop            = 0x00040000, // Block-scoped binding with declaration nested inside iteration statement
-        ClassWithConstructorReference       = 0x00080000, // Class that contains a binding to its constructor inside of the class body.
-        ConstructorReferenceInClass         = 0x00100000, // Binding to a class constructor inside of the class's body.
-        NeedsLoopOutParameter               = 0x00200000, // Block scoped binding whose value should be explicitly copied outside of the converted loop
+        EnumValuesComputed                  = 0x00004000,  // Values for enum members have been computed, and any errors have been reported for them.
+        LexicalModuleMergesWithClass        = 0x00008000,  // Instantiated lexical module declaration is merged with a previous class declaration.
+        LoopWithCapturedBlockScopedBinding  = 0x00010000,  // Loop that contains block scoped variable captured in closure
+        CapturedBlockScopedBinding          = 0x00020000,  // Block-scoped binding that is captured in some function
+        BlockScopedBindingInLoop            = 0x00040000,  // Block-scoped binding with declaration nested inside iteration statement
+        ClassWithBodyScopedClassBinding     = 0x00080000,  // Decorated class that contains a binding to itself inside of the class body.
+        BodyScopedClassBinding              = 0x00100000,  // Binding to a decorated class inside of the class's body.
+        NeedsLoopOutParameter               = 0x00200000,  // Block scoped binding whose value should be explicitly copied outside of the converted loop
+        AssignmentsMarked                   = 0x00400000,  // Parameter assignments have been marked
+        ClassWithConstructorReference       = 0x00800000,  // Class that contains a binding to its constructor inside of the class body.
+        ConstructorReferenceInClass         = 0x01000000,  // Binding to a class constructor inside of the class's body.
     }
 
     /* @internal */
     export interface NodeLinks {
+        flags?: NodeCheckFlags;           // Set of flags specific to Node
         resolvedType?: Type;              // Cached type of type node
         resolvedSignature?: Signature;    // Cached signature of signature node or call expression
         resolvedSymbol?: Symbol;          // Cached name resolution result
         resolvedIndexInfo?: IndexInfo;    // Cached indexing info resolution result
-        flags?: NodeCheckFlags;           // Set of flags specific to Node
         enumMemberValue?: number;         // Constant value of enum member
         isVisible?: boolean;              // Is this node visible
         hasReportedStatementInAmbientContext?: boolean;  // Cache boolean if we report statements in ambient context
@@ -2322,7 +2345,7 @@ namespace ts {
         Class                   = 1 << 15,  // Class
         Interface               = 1 << 16,  // Interface
         Reference               = 1 << 17,  // Generic type reference
-        Tuple                   = 1 << 18,  // Tuple
+        Tuple                   = 1 << 18,  // Synthesized generic tuple type
         Union                   = 1 << 19,  // Union (T | U)
         Intersection            = 1 << 20,  // Intersection (T & U)
         Anonymous               = 1 << 21,  // Anonymous
@@ -2444,10 +2467,6 @@ namespace ts {
         instantiations: Map<TypeReference>;   // Generic instantiation cache
     }
 
-    export interface TupleType extends ObjectType {
-        elementTypes: Type[];  // Element types
-    }
-
     export interface UnionOrIntersectionType extends Type {
         types: Type[];                    // Constituent types
         /* @internal */
@@ -2632,7 +2651,7 @@ namespace ts {
     }
 
     export type RootPaths = string[];
-    export type PathSubstitutions = Map<string[]>;
+    export type PathSubstitutions = MapLike<string[]>;
     export type TsConfigOnlyOptions = RootPaths | PathSubstitutions;
 
     export type CompilerOptionsValue = string | number | boolean | (string | number)[] | TsConfigOnlyOptions;
@@ -2793,7 +2812,7 @@ namespace ts {
         fileNames: string[];
         raw?: any;
         errors: Diagnostic[];
-        wildcardDirectories?: Map<WatchDirectoryFlags>;
+        wildcardDirectories?: MapLike<WatchDirectoryFlags>;
     }
 
     export const enum WatchDirectoryFlags {
@@ -2803,7 +2822,7 @@ namespace ts {
 
     export interface ExpandResult {
         fileNames: string[];
-        wildcardDirectories: Map<WatchDirectoryFlags>;
+        wildcardDirectories: MapLike<WatchDirectoryFlags>;
     }
 
     /* @internal */
@@ -2825,7 +2844,7 @@ namespace ts {
 
     /* @internal */
     export interface CommandLineOptionOfCustomType extends CommandLineOptionBase {
-        type: Map<number | string>;             // an object literal mapping named values to actual values
+        type: Map<number | string>;  // an object literal mapping named values to actual values
     }
 
     /* @internal */

src/compiler/utilities.ts

@@ -83,25 +83,6 @@ namespace ts {
         return node.end - node.pos;
     }
 
-    export function mapIsEqualTo<T>(map1: Map<T>, map2: Map<T>): boolean {
-        if (!map1 || !map2) {
-            return map1 === map2;
-        }
-        return containsAll(map1, map2) && containsAll(map2, map1);
-    }
-
-    function containsAll<T>(map: Map<T>, other: Map<T>): boolean {
-        for (const key in map) {
-            if (!hasProperty(map, key)) {
-                continue;
-            }
-            if (!hasProperty(other, key) || map[key] !== other[key]) {
-                return false;
-            }
-        }
-        return true;
-    }
-
     export function arrayIsEqualTo<T>(array1: T[], array2: T[], equaler?: (a: T, b: T) => boolean): boolean {
         if (!array1 || !array2) {
             return array1 === array2;
@@ -122,7 +103,7 @@ namespace ts {
     }
 
     export function hasResolvedModule(sourceFile: SourceFile, moduleNameText: string): boolean {
-        return sourceFile && sourceFile.resolvedModules && hasProperty(sourceFile.resolvedModules, moduleNameText);
+        return !!(sourceFile && sourceFile.resolvedModules && sourceFile.resolvedModules[moduleNameText]);
     }
 
     export function getResolvedModule(sourceFile: SourceFile, moduleNameText: string): ResolvedModule {
@@ -131,7 +112,7 @@ namespace ts {
 
     export function setResolvedModule(sourceFile: SourceFile, moduleNameText: string, resolvedModule: ResolvedModule): void {
         if (!sourceFile.resolvedModules) {
-            sourceFile.resolvedModules = {};
+            sourceFile.resolvedModules = createMap<ResolvedModule>();
         }
 
         sourceFile.resolvedModules[moduleNameText] = resolvedModule;
@@ -139,7 +120,7 @@ namespace ts {
 
     export function setResolvedTypeReferenceDirective(sourceFile: SourceFile, typeReferenceDirectiveName: string, resolvedTypeReferenceDirective: ResolvedTypeReferenceDirective): void {
         if (!sourceFile.resolvedTypeReferenceDirectiveNames) {
-            sourceFile.resolvedTypeReferenceDirectiveNames = {};
+            sourceFile.resolvedTypeReferenceDirectiveNames = createMap<ResolvedTypeReferenceDirective>();
         }
 
         sourceFile.resolvedTypeReferenceDirectiveNames[typeReferenceDirectiveName] = resolvedTypeReferenceDirective;
@@ -162,7 +143,7 @@ namespace ts {
         }
         for (let i = 0; i < names.length; i++) {
             const newResolution = newResolutions[i];
-            const oldResolution = oldResolutions && hasProperty(oldResolutions, names[i]) ? oldResolutions[names[i]] : undefined;
+            const oldResolution = oldResolutions && oldResolutions[names[i]];
             const changed =
                 oldResolution
                     ? !newResolution || !comparer(oldResolution, newResolution)
@@ -320,6 +301,10 @@ namespace ts {
         return node.kind >= SyntaxKind.FirstJSDocNode && node.kind <= SyntaxKind.LastJSDocNode;
     }
 
+    export function isJSDocTag(node: Node) {
+        return node.kind >= SyntaxKind.FirstJSDocTagNode && node.kind <= SyntaxKind.LastJSDocTagNode;
+    }
+
     export function getNonDecoratorTokenPosOfNode(node: Node, sourceFile?: SourceFile): number {
         if (nodeIsMissing(node) || !node.decorators) {
             return getTokenPosOfNode(node, sourceFile);
@@ -1118,23 +1103,14 @@ namespace ts {
             && (<PropertyAccessExpression | ElementAccessExpression>node).expression.kind === SyntaxKind.SuperKeyword;
     }
 
-    export function isSuperPropertyCall(node: Node): node is CallExpression {
-        return node.kind === SyntaxKind.CallExpression
-            && <boolean>isSuperProperty((<CallExpression>node).expression);
-    }
-
-    export function isSuperCall(node: Node): node is CallExpression {
-        return node.kind === SyntaxKind.CallExpression
-            && (<CallExpression>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(isEntityNameExpression((<ExpressionWithTypeArguments>node).expression));
+                    return <EntityNameExpression>(<ExpressionWithTypeArguments>node).expression;
                 case SyntaxKind.Identifier:
                 case SyntaxKind.QualifiedName:
                     return (<EntityName><Node>node);
@@ -1716,8 +1692,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 ||
@@ -1725,7 +1701,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) {
@@ -2043,7 +2023,6 @@ namespace ts {
                         return Associativity.Right;
                 }
         }
-
         return Associativity.Left;
     }
 
@@ -2198,7 +2177,7 @@ namespace ts {
 
     export function createDiagnosticCollection(): DiagnosticCollection {
         let nonFileDiagnostics: Diagnostic[] = [];
-        const fileDiagnostics: Map<Diagnostic[]> = {};
+        const fileDiagnostics = createMap<Diagnostic[]>();
 
         let diagnosticsModified = false;
         let modificationCount = 0;
@@ -2262,9 +2241,7 @@ namespace ts {
             forEach(nonFileDiagnostics, pushDiagnostic);
 
             for (const key in fileDiagnostics) {
-                if (hasProperty(fileDiagnostics, key)) {
-                    forEach(fileDiagnostics[key], pushDiagnostic);
-                }
+                forEach(fileDiagnostics[key], pushDiagnostic);
             }
 
             return sortAndDeduplicateDiagnostics(allDiagnostics);
@@ -2279,9 +2256,7 @@ namespace ts {
             nonFileDiagnostics = sortAndDeduplicateDiagnostics(nonFileDiagnostics);
 
             for (const key in fileDiagnostics) {
-                if (hasProperty(fileDiagnostics, key)) {
-                    fileDiagnostics[key] = sortAndDeduplicateDiagnostics(fileDiagnostics[key]);
-                }
+                fileDiagnostics[key] = sortAndDeduplicateDiagnostics(fileDiagnostics[key]);
             }
         }
     }
@@ -2292,7 +2267,7 @@ namespace ts {
     // the map below must be updated. Note that this regexp *does not* include the 'delete' character.
     // There is no reason for this other than that JSON.stringify does not handle it either.
     const escapedCharsRegExp = /[\\\"\u0000-\u001f\t\v\f\b\r\n\u2028\u2029\u0085]/g;
-    const escapedCharsMap: Map<string> = {
+    const escapedCharsMap = createMap({
         "\0": "\\0",
         "\t": "\\t",
         "\v": "\\v",
@@ -2305,7 +2280,7 @@ namespace ts {
         "\u2028": "\\u2028", // lineSeparator
         "\u2029": "\\u2029", // paragraphSeparator
         "\u0085": "\\u0085"  // nextLine
-    };
+    });
 
 
     /**
@@ -3083,6 +3058,11 @@ namespace ts {
         }
     }
 
+    export function isEntityNameExpression(node: Expression): node is EntityNameExpression {
+        return node.kind === SyntaxKind.Identifier ||
+            node.kind === SyntaxKind.PropertyAccessExpression && isEntityNameExpression((<PropertyAccessExpression>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);
@@ -3111,6 +3091,11 @@ namespace ts {
         return forEach(supportedTypeScriptExtensions, extension => fileExtensionIs(fileName, extension));
     }
 
+    /** Return ".ts", ".d.ts", or ".tsx", if that is the extension. */
+    export function tryExtractTypeScriptExtension(fileName: string): string | undefined {
+        return find(supportedTypescriptExtensionsForExtractExtension, extension => fileExtensionIs(fileName, extension));
+    }
+
     /**
      * Replace each instance of non-ascii characters by one, two, three, or four escape sequences
      * representing the UTF-8 encoding of the character, and return the expanded char code list.
@@ -3190,7 +3175,7 @@ namespace ts {
     }
 
     function stringifyObject(value: any) {
-        return `{${reduceProperties(value, stringifyProperty, "")}}`;
+        return `{${reduceOwnProperties(value, stringifyProperty, "")}}`;
     }
 
     function stringifyProperty(memo: string, value: any, key: string) {
@@ -3332,7 +3317,7 @@ namespace ts {
         return false;
     }
 
-    const syntaxKindCache: Map<string> = {};
+    const syntaxKindCache = createMap<string>();
 
     export function formatSyntaxKind(kind: SyntaxKind): string {
         const syntaxKindEnum = (<any>ts).SyntaxKind;
@@ -3480,7 +3465,7 @@ namespace ts {
 
     export function collectExternalModuleInfo(sourceFile: SourceFile, resolver: EmitResolver) {
         const externalImports: (ImportDeclaration | ImportEqualsDeclaration | ExportDeclaration)[] = [];
-        const exportSpecifiers: Map<ExportSpecifier[]> = {};
+        const exportSpecifiers = createMap<ExportSpecifier[]>();
         let exportEquals: ExportAssignment = undefined;
         let hasExportStarsToExportValues = false;
         for (const node of sourceFile.statements) {
@@ -3521,7 +3506,7 @@ namespace ts {
                         // export { x, y }
                         for (const specifier of (<ExportDeclaration>node).exportClause.elements) {
                             const name = (specifier.propertyName || specifier.name).text;
-                            getOrUpdateProperty(exportSpecifiers, name, () => []).push(specifier);
+                            (exportSpecifiers[name] || (exportSpecifiers[name] = [])).push(specifier);
                         }
                     }
                     break;
@@ -3623,7 +3608,7 @@ namespace ts {
         return node.kind === SyntaxKind.Identifier;
     }
 
-    export function isGeneratedIdentifier(node: Node): node is Identifier {
+    export function isGeneratedIdentifier(node: Node): boolean {
         // Using `>` here catches both `GeneratedIdentifierKind.None` and `undefined`.
         return isIdentifier(node) && node.autoGenerateKind > GeneratedIdentifierKind.None;
     }

src/compiler/visitor.ts

@@ -46,7 +46,7 @@ namespace ts {
      *       supplant the existing `forEachChild` implementation if performance is not
      *       significantly impacted.
      */
-    const nodeEdgeTraversalMap: Map<NodeTraversalPath> = {
+    const nodeEdgeTraversalMap = createMap<NodeTraversalPath>({
         [SyntaxKind.QualifiedName]: [
             { name: "left", test: isEntityName },
             { name: "right", test: isIdentifier }
@@ -93,7 +93,7 @@ namespace ts {
             { name: "name", test: isPropertyName },
             { name: "initializer", test: isExpression, optional: true, parenthesize: parenthesizeExpressionForList }
         ]
-    };
+    });
 
     function reduceNode<T>(node: Node, f: (memo: T, node: Node) => T, initial: T) {
         return node ? f(initial, node) : initial;
@@ -523,7 +523,7 @@ namespace ts {
                 const edgeTraversalPath = nodeEdgeTraversalMap[kind];
                 if (edgeTraversalPath) {
                     for (const edge of edgeTraversalPath) {
-                        const value = (<Map<any>>node)[edge.name];
+                        const value = (<MapLike<any>>node)[edge.name];
                         if (value !== undefined) {
                             result = isArray(value)
                                 ? reduceLeft(<NodeArray<Node>>value, f, result)
@@ -1140,7 +1140,7 @@ namespace ts {
                     visitNode((<PartiallyEmittedExpression>node).expression, visitor, isExpression));
 
             default:
-                let updated: Node & Map<any>;
+                let updated: Node & MapLike<any>;
                 const edgeTraversalPath = nodeEdgeTraversalMap[kind];
                 if (edgeTraversalPath) {
                     for (const edge of edgeTraversalPath) {