Merge remote-tracking branch 'origin/master' into faster-interface-check

* origin/master: (140 commits)
  test overriding Session.event
  Update editorServices.ts
  Fix semantic merge conflict (microsoft#20119)
  LEGO: check in for master to temporary branch.
  Moved minified file exclusion
  Fixed internal safelist
  For import completion, if multiple re-exports exist, choose the one with the shortest path (microsoft#20049)
  Bundle fileName with CodeActionCommand (microsoft#19881)
  Simplify documentHighlights (microsoft#20091)
  LEGO: check in for master to temporary branch.
  Support semantic classification of alias (microsoft#20012)
  In `getContextualTypeForBinaryOperand`, only need to look for `=` assignment operator, not e.g. `+=` (microsoft#20037)
  lineAction: Use an enum instead of true | false | undefined (microsoft#20086)
  LEGO: check in for master to temporary branch.
  cleanup NodeTypingsInstaller
  remove comments
  type `event` callback correctly
  update baselines
  defer callback and remove handler object
  Support arbitrary prototype property assignments in navigation bar (microsoft#19923)
  ...

Author: errendir

.gitmodules

@@ -0,0 +1,25 @@
+[submodule "tests/cases/user/TypeScript-React-Starter/TypeScript-React-Starter"]
+	path = tests/cases/user/TypeScript-React-Starter/TypeScript-React-Starter
+	url = https://github.com/Microsoft/TypeScript-React-Starter
+	ignore = all
+	shallow = true
+[submodule "tests/cases/user/TypeScript-Node-Starter/TypeScript-Node-Starter"]
+	path = tests/cases/user/TypeScript-Node-Starter/TypeScript-Node-Starter
+	url = https://github.com/Microsoft/TypeScript-Node-Starter.git
+	ignore = all
+	shallow = true
+[submodule "tests/cases/user/TypeScript-React-Native-Starter/TypeScript-React-Native-Starter"]
+	path = tests/cases/user/TypeScript-React-Native-Starter/TypeScript-React-Native-Starter
+	url = https://github.com/Microsoft/TypeScript-React-Native-Starter.git
+	ignore = all
+	shallow = true
+[submodule "tests/cases/user/TypeScript-Vue-Starter/TypeScript-Vue-Starter"]
+	path = tests/cases/user/TypeScript-Vue-Starter/TypeScript-Vue-Starter
+	url = https://github.com/Microsoft/TypeScript-Vue-Starter.git
+	ignore = all
+	shallow = true
+[submodule "tests/cases/user/TypeScript-WeChat-Starter/TypeScript-WeChat-Starter"]
+	path = tests/cases/user/TypeScript-WeChat-Starter/TypeScript-WeChat-Starter
+	url = https://github.com/Microsoft/TypeScript-WeChat-Starter.git
+	ignore = all
+	shallow = true

src/compiler/binder.ts

@@ -16,52 +16,63 @@ namespace ts {
         referenced: boolean;
     }
 
-    export function getModuleInstanceState(node: Node): ModuleInstanceState {
+    export function getModuleInstanceState(node: ModuleDeclaration): ModuleInstanceState {
+        return node.body ? getModuleInstanceStateWorker(node.body) : ModuleInstanceState.Instantiated;
+    }
+
+    function getModuleInstanceStateWorker(node: Node): ModuleInstanceState {
         // A module is uninstantiated if it contains only
-        // 1. interface declarations, type alias declarations
-        if (node.kind === SyntaxKind.InterfaceDeclaration || node.kind === SyntaxKind.TypeAliasDeclaration) {
-            return ModuleInstanceState.NonInstantiated;
-        }
-        // 2. const enum declarations
-        else if (isConstEnumDeclaration(node)) {
-            return ModuleInstanceState.ConstEnumOnly;
-        }
-        // 3. non-exported import declarations
-        else if ((node.kind === SyntaxKind.ImportDeclaration || node.kind === SyntaxKind.ImportEqualsDeclaration) && !(hasModifier(node, ModifierFlags.Export))) {
-            return ModuleInstanceState.NonInstantiated;
-        }
-        // 4. other uninstantiated module declarations.
-        else if (node.kind === SyntaxKind.ModuleBlock) {
-            let state = ModuleInstanceState.NonInstantiated;
-            forEachChild(node, n => {
-                switch (getModuleInstanceState(n)) {
-                    case ModuleInstanceState.NonInstantiated:
-                        // child is non-instantiated - continue searching
-                        return false;
-                    case ModuleInstanceState.ConstEnumOnly:
-                        // child is const enum only - record state and continue searching
-                        state = ModuleInstanceState.ConstEnumOnly;
-                        return false;
-                    case ModuleInstanceState.Instantiated:
-                        // child is instantiated - record state and stop
-                        state = ModuleInstanceState.Instantiated;
-                        return true;
+        switch (node.kind) {
+            // 1. interface declarations, type alias declarations
+            case SyntaxKind.InterfaceDeclaration:
+            case SyntaxKind.TypeAliasDeclaration:
+                return ModuleInstanceState.NonInstantiated;
+            // 2. const enum declarations
+            case SyntaxKind.EnumDeclaration:
+                if (isConst(node)) {
+                    return ModuleInstanceState.ConstEnumOnly;
+                }
+                break;
+            // 3. non-exported import declarations
+            case SyntaxKind.ImportDeclaration:
+            case SyntaxKind.ImportEqualsDeclaration:
+                if (!(hasModifier(node, ModifierFlags.Export))) {
+                    return ModuleInstanceState.NonInstantiated;
+                }
+                break;
+            // 4. other uninstantiated module declarations.
+            case SyntaxKind.ModuleBlock: {
+                let state = ModuleInstanceState.NonInstantiated;
+                forEachChild(node, n => {
+                    const childState = getModuleInstanceStateWorker(n);
+                    switch (childState) {
+                        case ModuleInstanceState.NonInstantiated:
+                            // child is non-instantiated - continue searching
+                            return;
+                        case ModuleInstanceState.ConstEnumOnly:
+                            // child is const enum only - record state and continue searching
+                            state = ModuleInstanceState.ConstEnumOnly;
+                            return;
+                        case ModuleInstanceState.Instantiated:
+                            // child is instantiated - record state and stop
+                            state = ModuleInstanceState.Instantiated;
+                            return true;
+                        default:
+                            Debug.assertNever(childState);
+                    }
+                });
+                return state;
+            }
+            case SyntaxKind.ModuleDeclaration:
+                return getModuleInstanceState(node as ModuleDeclaration);
+            case SyntaxKind.Identifier:
+                // Only jsdoc typedef definition can exist in jsdoc namespace, and it should
+                // be considered the same as type alias
+                if ((<Identifier>node).isInJSDocNamespace) {
+                    return ModuleInstanceState.NonInstantiated;
                 }
-            });
-            return state;
-        }
-        else if (node.kind === SyntaxKind.ModuleDeclaration) {
-            const body = (<ModuleDeclaration>node).body;
-            return body ? getModuleInstanceState(body) : ModuleInstanceState.Instantiated;
-        }
-        // Only jsdoc typedef definition can exist in jsdoc namespace, and it should
-        // be considered the same as type alias
-        else if (node.kind === SyntaxKind.Identifier && (<Identifier>node).isInJSDocNamespace) {
-            return ModuleInstanceState.NonInstantiated;
-        }
-        else {
-            return ModuleInstanceState.Instantiated;
         }
+        return ModuleInstanceState.Instantiated;
     }
 
     const enum ContainerFlags {
@@ -1680,7 +1691,7 @@ namespace ts {
 
         function bindAnonymousDeclaration(node: Declaration, symbolFlags: SymbolFlags, name: __String) {
             const symbol = createSymbol(symbolFlags, name);
-            if (symbolFlags & SymbolFlags.EnumMember) {
+            if (symbolFlags & (SymbolFlags.EnumMember | SymbolFlags.ClassMember)) {
                 symbol.parent = container.symbol;
             }
             addDeclarationToSymbol(symbol, node, symbolFlags);
@@ -1835,7 +1846,7 @@ namespace ts {
         }
 
         function checkStrictModeNumericLiteral(node: NumericLiteral) {
-            if (inStrictMode && node.numericLiteralFlags & NumericLiteralFlags.Octal) {
+            if (inStrictMode && node.numericLiteralFlags & TokenFlags.Octal) {
                 file.bindDiagnostics.push(createDiagnosticForNode(node, Diagnostics.Octal_literals_are_not_allowed_in_strict_mode));
             }
         }
@@ -3319,7 +3330,7 @@ namespace ts {
                 break;
 
             case SyntaxKind.NumericLiteral:
-                if ((<NumericLiteral>node).numericLiteralFlags & NumericLiteralFlags.BinaryOrOctalSpecifier) {
+                if ((<NumericLiteral>node).numericLiteralFlags & TokenFlags.BinaryOrOctalSpecifier) {
                     transformFlags |= TransformFlags.AssertES2015;
                 }
                 break;

src/compiler/builder.ts

@@ -77,7 +77,7 @@ namespace ts {
     }
 
     export interface BuilderOptions {
-        getCanonicalFileName: (fileName: string) => string;
+        getCanonicalFileName: GetCanonicalFileName;
         computeHash: (data: string) => string;
     }