Merge branch 'master' into optimizeParser

# Conflicts:
#	src/compiler/parser.ts

Author: ahejlsberg

.gitmodules

@@ -0,0 +1,15 @@
+[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
+[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
+[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
+[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
+[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

src/compiler/checker.ts

@@ -6454,7 +6454,10 @@ namespace ts {
                     }
                     for (let i = numTypeArguments; i < numTypeParameters; i++) {
                         const mapper = createTypeMapper(typeParameters, typeArguments);
-                        const defaultType = getDefaultFromTypeParameter(typeParameters[i]);
+                        let defaultType = getDefaultFromTypeParameter(typeParameters[i]);
+                        if (defaultType && isTypeIdenticalTo(defaultType, emptyObjectType) && isJavaScriptImplicitAny) {
+                            defaultType = anyType;
+                        }
                         typeArguments[i] = defaultType ? instantiateType(defaultType, mapper) : getDefaultTypeArgumentType(isJavaScriptImplicitAny);
                     }
                 }
@@ -13469,10 +13472,14 @@ namespace ts {
         }
 
         function isInParameterInitializerBeforeContainingFunction(node: Node) {
+            let inBindingInitializer = false;
             while (node.parent && !isFunctionLike(node.parent)) {
-                if (node.parent.kind === SyntaxKind.Parameter && (<ParameterDeclaration>node.parent).initializer === node) {
+                if (isParameter(node.parent) && (inBindingInitializer || node.parent.initializer === node)) {
                     return true;
                 }
+                if (isBindingElement(node.parent) && node.parent.initializer === node) {
+                    inBindingInitializer = true;
+                }
 
                 node = node.parent;
             }
@@ -14197,7 +14204,7 @@ namespace ts {
             // type with those properties for which the binding pattern specifies a default value.
             if (contextualTypeHasPattern) {
                 for (const prop of getPropertiesOfType(contextualType)) {
-                    if (!propertiesTable.get(prop.escapedName)) {
+                    if (!propertiesTable.get(prop.escapedName) && !(spread && getPropertyOfType(spread, prop.escapedName))) {
                         if (!(prop.flags & SymbolFlags.Optional)) {
                             error(prop.valueDeclaration || (<TransientSymbol>prop).bindingElement,
                                 Diagnostics.Initializer_provides_no_value_for_this_binding_element_and_the_binding_element_has_no_default_value);
@@ -14378,19 +14385,7 @@ namespace ts {
             const parent = openingLikeElement.parent.kind === SyntaxKind.JsxElement ? openingLikeElement.parent as JsxElement : undefined;
             // We have to check that openingElement of the parent is the one we are visiting as this may not be true for selfClosingElement
             if (parent && parent.openingElement === openingLikeElement && parent.children.length > 0) {
-                const childrenTypes: Type[] = [];
-                for (const child of (parent as JsxElement).children) {
-                    // In React, JSX text that contains only whitespaces will be ignored so we don't want to type-check that
-                    // because then type of children property will have constituent of string type.
-                    if (child.kind === SyntaxKind.JsxText) {
-                        if (!child.containsOnlyWhiteSpaces) {
-                            childrenTypes.push(stringType);
-                        }
-                    }
-                    else {
-                        childrenTypes.push(checkExpression(child, checkMode));
-                    }
-                }
+                const childrenTypes: Type[] = checkJsxChildren(parent as JsxElement, checkMode);
 
                 if (!hasSpreadAnyType && jsxChildrenPropertyName && jsxChildrenPropertyName !== "") {
                     // Error if there is a attribute named "children" explicitly specified and children element.
@@ -14430,6 +14425,23 @@ namespace ts {
             }
         }
 
+        function checkJsxChildren(node: JsxElement | JsxFragment, checkMode?: CheckMode) {
+            const childrenTypes: Type[] = [];
+            for (const child of node.children) {
+                // In React, JSX text that contains only whitespaces will be ignored so we don't want to type-check that
+                // because then type of children property will have constituent of string type.
+                if (child.kind === SyntaxKind.JsxText) {
+                    if (!child.containsOnlyWhiteSpaces) {
+                        childrenTypes.push(stringType);
+                    }
+                }
+                else {
+                    childrenTypes.push(checkExpression(child, checkMode));
+                }
+            }
+            return childrenTypes;
+        }
+
         /**
          * Check attributes property of opening-like element. This function is called during chooseOverload to get call signature of a JSX opening-like element.
          * (See "checkApplicableSignatureForJsxOpeningLikeElement" for how the function is used)
@@ -14964,6 +14976,9 @@ namespace ts {
             if (isNodeOpeningLikeElement) {
                 checkJsxAttributesAssignableToTagNameAttributes(<JsxOpeningLikeElement>node);
             }
+            else {
+                checkJsxChildren((node as JsxOpeningFragment).parent);
+            }
         }
 
         /**
@@ -17164,7 +17179,7 @@ namespace ts {
             if (targetDeclarationKind !== SyntaxKind.Unknown) {
                 const decl = getDeclarationOfKind(resolvedRequire, targetDeclarationKind);
                 // function/variable declaration should be ambient
-                return !!(decl.flags & NodeFlags.Ambient);
+                return !!decl && !!(decl.flags & NodeFlags.Ambient);
             }
             return false;
         }

src/compiler/factory.ts

@@ -3709,7 +3709,7 @@ namespace ts {
         while (statementOffset < numStatements) {
             const statement = source[statementOffset];
             if (getEmitFlags(statement) & EmitFlags.CustomPrologue) {
-                target.push(visitor ? visitNode(statement, visitor, isStatement) : statement);
+                append(target, visitor ? visitNode(statement, visitor, isStatement) : statement);
             }
             else {
                 break;

src/compiler/parser.ts

@@ -2274,7 +2274,7 @@ namespace ts {
                 isStartOfType(/*inStartOfParameter*/ true);
         }
 
-        function parseParameter(requireEqualsToken?: boolean): ParameterDeclaration {
+        function parseParameter(): ParameterDeclaration {
             const node = <ParameterDeclaration>createNodeWithJSDoc(SyntaxKind.Parameter);
             if (token() === SyntaxKind.ThisKeyword) {
                 node.name = createIdentifier(/*isIdentifier*/ true);
@@ -2303,15 +2303,11 @@ namespace ts {
 
             node.questionToken = parseOptionalToken(SyntaxKind.QuestionToken);
             node.type = parseParameterType();
-            node.initializer = parseInitializer(/*inParameter*/ true, requireEqualsToken);
+            node.initializer = parseInitializer();
 
             return finishNode(node);
         }
 
-        function parseParameterWithEqualsToken(): ParameterDeclaration {
-            return parseParameter(/*requireEqualsToken*/ true);
-        }
-
         function fillSignature(
             returnToken: SyntaxKind.ColonToken | SyntaxKind.EqualsGreaterThanToken,
             flags: SignatureFlags,
@@ -2364,10 +2360,7 @@ namespace ts {
                 setYieldContext(!!(flags & SignatureFlags.Yield));
                 setAwaitContext(!!(flags & SignatureFlags.Await));
 
-                const result = parseDelimitedList(ParsingContext.Parameters,
-                    flags & SignatureFlags.JSDoc ? parseJSDocParameter :
-                    flags & SignatureFlags.RequireCompleteParameterList ? parseParameterWithEqualsToken :
-                    parseParameter);
+                const result = parseDelimitedList(ParsingContext.Parameters, flags & SignatureFlags.JSDoc ? parseJSDocParameter : parseParameter);
 
                 setYieldContext(savedYieldContext);
                 setAwaitContext(savedAwaitContext);
@@ -2491,7 +2484,7 @@ namespace ts {
                     // Although type literal properties cannot not have initializers, we attempt
                     // to parse an initializer so we can report in the checker that an interface
                     // property or type literal property cannot have an initializer.
-                    (<PropertySignature>node).initializer = parseNonParameterInitializer();
+                    (<PropertySignature>node).initializer = parseInitializer();
                 }
             }
             parseTypeMemberSemicolon();
@@ -3030,34 +3023,8 @@ namespace ts {
             return expr;
         }
 
-        function parseInitializer(inParameter: boolean, requireEqualsToken?: boolean): Expression {
-            if (token() !== SyntaxKind.EqualsToken) {
-                // It's not uncommon during typing for the user to miss writing the '=' token.  Check if
-                // there is no newline after the last token and if we're on an expression.  If so, parse
-                // this as an equals-value clause with a missing equals.
-                // NOTE: There are two places where we allow equals-value clauses.  The first is in a
-                // variable declarator.  The second is with a parameter.  For variable declarators
-                // it's more likely that a { would be a allowed (as an object literal).  While this
-                // is also allowed for parameters, the risk is that we consume the { as an object
-                // literal when it really will be for the block following the parameter.
-                if (scanner.hasPrecedingLineBreak() || (inParameter && token() === SyntaxKind.OpenBraceToken) || !isStartOfExpression()) {
-                    // preceding line break, open brace in a parameter (likely a function body) or current token is not an expression -
-                    // do not try to parse initializer
-                    return undefined;
-                }
-                if (inParameter && requireEqualsToken) {
-                    // = is required when speculatively parsing arrow function parameters,
-                    // so return a fake initializer as a signal that the equals token was missing
-                    const result = createMissingNode(SyntaxKind.Identifier, /*reportAtCurrentPosition*/ true, Diagnostics._0_expected, "=") as Identifier;
-                    result.escapedText = "= not found" as __String;
-                    return result;
-                }
-            }
-
-            // Initializer[In, Yield] :
-            //     = AssignmentExpression[?In, ?Yield]
-            parseExpected(SyntaxKind.EqualsToken);
-            return parseAssignmentExpressionOrHigher();
+        function parseInitializer(): Expression | undefined {
+            return parseOptional(SyntaxKind.EqualsToken) ? parseAssignmentExpressionOrHigher() : undefined;
         }
 
         function parseAssignmentExpressionOrHigher(): Expression {
@@ -5227,7 +5194,7 @@ namespace ts {
             const node = <BindingElement>createNode(SyntaxKind.BindingElement);
             node.dotDotDotToken = parseOptionalToken(SyntaxKind.DotDotDotToken);
             node.name = parseIdentifierOrPattern();
-            node.initializer = parseInitializer(/*inParameter*/ false);
+            node.initializer = parseInitializer();
             return finishNode(node);
         }
 
@@ -5244,7 +5211,7 @@ namespace ts {
                 node.propertyName = propertyName;
                 node.name = parseIdentifierOrPattern();
             }
-            node.initializer = parseInitializer(/*inParameter*/ false);
+            node.initializer = parseInitializer();
             return finishNode(node);
         }
 
@@ -5283,7 +5250,7 @@ namespace ts {
             node.name = parseIdentifierOrPattern();
             node.type = parseTypeAnnotation();
             if (!isInOrOfKeyword(token())) {
-                node.initializer = parseNonParameterInitializer();
+                node.initializer = parseInitializer();
             }
             return finishNode(node);
         }
@@ -5385,8 +5352,8 @@ namespace ts {
             //
             // The checker may still error in the static case to explicitly disallow the yield expression.
             node.initializer = hasModifier(node, ModifierFlags.Static)
-                ? allowInAnd(parseNonParameterInitializer)
-                : doOutsideOfContext(NodeFlags.YieldContext | NodeFlags.DisallowInContext, parseNonParameterInitializer);
+                ? allowInAnd(parseInitializer)
+                : doOutsideOfContext(NodeFlags.YieldContext | NodeFlags.DisallowInContext, parseInitializer);
 
             parseSemicolon();
             return finishNode(node);
@@ -5404,10 +5371,6 @@ namespace ts {
             return parsePropertyDeclaration(<PropertyDeclaration>node);
         }
 
-        function parseNonParameterInitializer() {
-            return parseInitializer(/*inParameter*/ false);
-        }
-
         function parseAccessorDeclaration(node: AccessorDeclaration, kind: AccessorDeclaration["kind"]): AccessorDeclaration {
             node.kind = kind;
             node.name = parsePropertyName();
@@ -5722,7 +5685,7 @@ namespace ts {
         function parseEnumMember(): EnumMember {
             const node = <EnumMember>createNodeWithJSDoc(SyntaxKind.EnumMember);
             node.name = parsePropertyName();
-            node.initializer = allowInAnd(parseNonParameterInitializer);
+            node.initializer = allowInAnd(parseInitializer);
             return finishNode(node);
         }
 

src/compiler/sys.ts

@@ -125,6 +125,8 @@ namespace ts {
     };
 
     export let sys: System = (() => {
+        const utf8ByteOrderMark = "\u00EF\u00BB\u00BF";
+
         function getNodeSystem(): System {
             const _fs = require("fs");
             const _path = require("path");
@@ -348,7 +350,7 @@ namespace ts {
             function writeFile(fileName: string, data: string, writeByteOrderMark?: boolean): void {
                 // If a BOM is required, emit one
                 if (writeByteOrderMark) {
-                    data = "\uFEFF" + data;
+                    data = utf8ByteOrderMark + data;
                 }
 
                 let fd: number;
@@ -549,7 +551,7 @@ namespace ts {
                 writeFile(path: string, data: string, writeByteOrderMark?: boolean) {
                     // If a BOM is required, emit one
                     if (writeByteOrderMark) {
-                        data = "\uFEFF" + data;
+                        data = utf8ByteOrderMark + data;
                     }
 
                     ChakraHost.writeFile(path, data);

src/harness/externalCompileRunner.ts

@@ -9,6 +9,10 @@ interface ExecResult {
     status: number;
 }
 
+interface UserConfig {
+    types: string[];
+}
+
 abstract class ExternalCompileRunnerBase extends RunnerBase {
     abstract testDir: string;
     abstract report(result: ExecResult, cwd: string): string;
@@ -33,18 +37,34 @@ abstract class ExternalCompileRunnerBase extends RunnerBase {
             const cp = require("child_process");
 
             it("should build successfully", () => {
-                const cwd = path.join(__dirname, "../../", this.testDir, directoryName);
+                let cwd = path.join(__dirname, "../../", this.testDir, directoryName);
                 const timeout = 600000; // 600s = 10 minutes
+                const stdio = isWorker ? "pipe" : "inherit";
+                let types: string[];
+                if (fs.existsSync(path.join(cwd, "test.json"))) {
+                    const update = cp.spawnSync("git", ["submodule", "update", "--remote"], { cwd, timeout, shell: true, stdio });
+                    if (update.status !== 0) throw new Error(`git submodule update for ${directoryName} failed!`);
+
+                    const config = JSON.parse(fs.readFileSync(path.join(cwd, "test.json"), { encoding: "utf8" })) as UserConfig;
+                    ts.Debug.assert(!!config.types, "Bad format from test.json: Types field must be present.");
+                    types = config.types;
+
+                    cwd = path.join(cwd, directoryName);
+                }
                 if (fs.existsSync(path.join(cwd, "package.json"))) {
                     if (fs.existsSync(path.join(cwd, "package-lock.json"))) {
                         fs.unlinkSync(path.join(cwd, "package-lock.json"));
                     }
-                    const stdio = isWorker ? "pipe" : "inherit";
                     const install = cp.spawnSync(`npm`, ["i"], { cwd, timeout, shell: true, stdio });
                     if (install.status !== 0) throw new Error(`NPM Install for ${directoryName} failed!`);
                 }
+                const args = [path.join(__dirname, "tsc.js")];
+                if (types) {
+                    args.push("--types", types.join(","));
+                }
+                args.push("--noEmit");
                 Harness.Baseline.runBaseline(`${this.kind()}/${directoryName}.log`, () => {
-                    return this.report(cp.spawnSync(`node`, [path.join(__dirname, "tsc.js")], { cwd, timeout, shell: true }), cwd);
+                    return this.report(cp.spawnSync(`node`, args, { cwd, timeout, shell: true }), cwd);
                 });
             });
         });

src/lib/es5.d.ts

@@ -62,6 +62,18 @@ declare function encodeURI(uri: string): string;
   */
 declare function encodeURIComponent(uriComponent: string): string;
 
+/**
+  * Computes a new string in which certain characters have been replaced by a hexadecimal escape sequence.
+  * @param string A string value
+  */
+declare function escape(string: string): string;
+
+/**
+  * Computes a new string in which hexadecimal escape sequences are replaced with the character that it represents.
+  * @param string A string value
+  */
+declare function unescape(string: string): string;
+
 interface PropertyDescriptor {
     configurable?: boolean;
     enumerable?: boolean;