Merge branch 'master' into m-lambda-to-fn

src/services/codefixes/wrapJsxInFragment.ts

@@ -0,0 +1,71 @@
+/* @internal */
+namespace ts.codefix {
+    const fixID = "wrapJsxInFragment";
+    const errorCodes = [Diagnostics.JSX_expressions_must_have_one_parent_element.code];
+    registerCodeFix({
+        errorCodes,
+        getCodeActions: context => {
+            const { jsx } = context.program.getCompilerOptions();
+            if (jsx !== JsxEmit.React && jsx !== JsxEmit.ReactNative) {
+                return undefined;
+            }
+            const { sourceFile, span } = context;
+            const node = findNodeToFix(sourceFile, span.start);
+            if (!node) return undefined;
+            const changes = textChanges.ChangeTracker.with(context, t => doChange(t, sourceFile, node));
+            return [createCodeFixAction(fixID, changes, Diagnostics.Wrap_in_JSX_fragment, fixID, Diagnostics.Wrap_all_unparented_JSX_in_JSX_fragment)];
+        },
+        fixIds: [fixID],
+        getAllCodeActions: context => codeFixAll(context, errorCodes, (changes, diag) => {
+            const node = findNodeToFix(context.sourceFile, diag.start);
+            if (!node) return undefined;
+            doChange(changes, context.sourceFile, node);
+        }),
+    });
+
+    function findNodeToFix(sourceFile: SourceFile, pos: number): BinaryExpression | undefined {
+        // The error always at 1st token that is "<" in "<a /><a />"
+        const lessThanToken = getTokenAtPosition(sourceFile, pos);
+        const firstJsxElementOrOpenElement = lessThanToken.parent;
+        let binaryExpr = firstJsxElementOrOpenElement.parent;
+        if (!isBinaryExpression(binaryExpr)) {
+            // In case the start element is a JsxSelfClosingElement, it the end.
+            // For JsxOpenElement, find one more parent
+            binaryExpr = binaryExpr.parent;
+            if (!isBinaryExpression(binaryExpr)) return undefined;
+        }
+        if (!nodeIsMissing(binaryExpr.operatorToken)) return undefined;
+        return binaryExpr;
+    }
+
+    function doChange(changeTracker: textChanges.ChangeTracker, sf: SourceFile, node: Node) {
+        const jsx = flattenInvalidBinaryExpr(node);
+        if (jsx) changeTracker.replaceNode(sf, node, createJsxFragment(createJsxOpeningFragment(), jsx, createJsxJsxClosingFragment()));
+    }
+    // The invalid syntax is constructed as
+    // InvalidJsxTree :: One of
+    //     JsxElement CommaToken InvalidJsxTree
+    //     JsxElement CommaToken JsxElement
+    function flattenInvalidBinaryExpr(node: Node): JsxChild[] | undefined {
+        const children: JsxChild[] = [];
+        let current = node;
+        while (true) {
+            if (isBinaryExpression(current) && nodeIsMissing(current.operatorToken) && current.operatorToken.kind === SyntaxKind.CommaToken) {
+                children.push(<JsxChild>current.left);
+                if (isJsxChild(current.right)) {
+                    children.push(current.right);
+                    // Indicates the tree has go to the bottom
+                    return children;
+                }
+                else if (isBinaryExpression(current.right)) {
+                    current = current.right;
+                    continue;
+                }
+                // Unreachable case
+                else return undefined;
+            }
+            // Unreachable case
+            else return undefined;
+        }
+    }
+}

src/services/findAllReferences.ts

@@ -399,23 +399,40 @@ namespace ts.FindAllReferences {
     function getPrefixAndSuffixText(entry: Entry, originalNode: Node, checker: TypeChecker): PrefixAndSuffix {
         if (entry.kind !== EntryKind.Span && isIdentifier(originalNode)) {
             const { node, kind } = entry;
+            const parent = node.parent;
             const name = originalNode.text;
-            const isShorthandAssignment = isShorthandPropertyAssignment(node.parent);
-            if (isShorthandAssignment || isObjectBindingElementWithoutPropertyName(node.parent) && node.parent.name === node) {
+            const isShorthandAssignment = isShorthandPropertyAssignment(parent);
+            if (isShorthandAssignment || isObjectBindingElementWithoutPropertyName(parent) && parent.name === node) {
                 const prefixColon: PrefixAndSuffix = { prefixText: name + ": " };
                 const suffixColon: PrefixAndSuffix = { suffixText: ": " + name };
-                return kind === EntryKind.SearchedLocalFoundProperty ? prefixColon
-                    : kind === EntryKind.SearchedPropertyFoundLocal ? suffixColon
-                    // In `const o = { x }; o.x`, symbolAtLocation at `x` in `{ x }` is the property symbol.
-                    // For a binding element `const { x } = o;`, symbolAtLocation at `x` is the property symbol.
-                    : isShorthandAssignment ? suffixColon : prefixColon;
+                if (kind === EntryKind.SearchedLocalFoundProperty) {
+                    return prefixColon;
+                }
+                if (kind === EntryKind.SearchedPropertyFoundLocal) {
+                    return suffixColon;
+                }
+
+                // In `const o = { x }; o.x`, symbolAtLocation at `x` in `{ x }` is the property symbol.
+                // For a binding element `const { x } = o;`, symbolAtLocation at `x` is the property symbol.
+                if (isShorthandAssignment) {
+                    const grandParent = parent.parent;
+                    if (isObjectLiteralExpression(grandParent) &&
+                        isBinaryExpression(grandParent.parent) &&
+                        isModuleExportsAccessExpression(grandParent.parent.left)) {
+                        return prefixColon;
+                    }
+                    return suffixColon;
+                }
+                else {
+                    return prefixColon;
+                }
             }
-            else if (isImportSpecifier(entry.node.parent) && !entry.node.parent.propertyName) {
+            else if (isImportSpecifier(parent) && !parent.propertyName) {
                 // If the original symbol was using this alias, just rename the alias.
                 const originalSymbol = isExportSpecifier(originalNode.parent) ? checker.getExportSpecifierLocalTargetSymbol(originalNode.parent) : checker.getSymbolAtLocation(originalNode);
-                return contains(originalSymbol!.declarations, entry.node.parent) ? { prefixText: name + " as " } : emptyOptions;
+                return contains(originalSymbol!.declarations, parent) ? { prefixText: name + " as " } : emptyOptions;
             }
-            else if (isExportSpecifier(entry.node.parent) && !entry.node.parent.propertyName) {
+            else if (isExportSpecifier(parent) && !parent.propertyName) {
                 // If the symbol for the node is same as declared node symbol use prefix text
                 return originalNode === entry.node || checker.getSymbolAtLocation(originalNode) === checker.getSymbolAtLocation(entry.node) ?
                     { prefixText: name + " as " } :

src/services/formatting/rules.ts

@@ -279,9 +279,9 @@ namespace ts.formatting {
             rule("NoSpaceBetweenEmptyBraceBrackets", SyntaxKind.OpenBraceToken, SyntaxKind.CloseBraceToken, [isOptionDisabled("insertSpaceAfterOpeningAndBeforeClosingEmptyBraces"), isNonJsxSameLineTokenContext], RuleAction.DeleteSpace),
 
             // Insert space after opening and before closing template string braces
-            rule("SpaceAfterTemplateHeadAndMiddle", [SyntaxKind.TemplateHead, SyntaxKind.TemplateMiddle], anyToken, [isOptionEnabled("insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces"), isNonJsxSameLineTokenContext], RuleAction.InsertSpace),
+            rule("SpaceAfterTemplateHeadAndMiddle", [SyntaxKind.TemplateHead, SyntaxKind.TemplateMiddle], anyToken, [isOptionEnabled("insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces"), isNonJsxTextContext], RuleAction.InsertSpace, RuleFlags.CanDeleteNewLines),
             rule("SpaceBeforeTemplateMiddleAndTail", anyToken, [SyntaxKind.TemplateMiddle, SyntaxKind.TemplateTail], [isOptionEnabled("insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces"), isNonJsxSameLineTokenContext], RuleAction.InsertSpace),
-            rule("NoSpaceAfterTemplateHeadAndMiddle", [SyntaxKind.TemplateHead, SyntaxKind.TemplateMiddle], anyToken, [isOptionDisabledOrUndefined("insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces"), isNonJsxSameLineTokenContext], RuleAction.DeleteSpace),
+            rule("NoSpaceAfterTemplateHeadAndMiddle", [SyntaxKind.TemplateHead, SyntaxKind.TemplateMiddle], anyToken, [isOptionDisabledOrUndefined("insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces"), isNonJsxTextContext], RuleAction.DeleteSpace, RuleFlags.CanDeleteNewLines),
             rule("NoSpaceBeforeTemplateMiddleAndTail", anyToken, [SyntaxKind.TemplateMiddle, SyntaxKind.TemplateTail], [isOptionDisabledOrUndefined("insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces"), isNonJsxSameLineTokenContext], RuleAction.DeleteSpace),
 
             // No space after { and before } in JSX expression
@@ -690,6 +690,10 @@ namespace ts.formatting {
         return context.TokensAreOnSameLine() && context.contextNode.kind !== SyntaxKind.JsxText;
     }
 
+    function isNonJsxTextContext(context: FormattingContext): boolean {
+        return context.contextNode.kind !== SyntaxKind.JsxText;
+    }
+
     function isNonJsxElementOrFragmentContext(context: FormattingContext): boolean {
         return context.contextNode.kind !== SyntaxKind.JsxElement && context.contextNode.kind !== SyntaxKind.JsxFragment;
     }

src/services/refactors/extractSymbol.ts

@@ -405,6 +405,20 @@ namespace ts.refactor.extractSymbol {
                             rangeFacts |= RangeFacts.UsesThis;
                         }
                         break;
+                    case SyntaxKind.ArrowFunction:
+                        // check if arrow function uses this
+                        forEachChild(node, function check(n) {
+                            if (isThis(n)) {
+                                rangeFacts |= RangeFacts.UsesThis;
+                            }
+                            else if (isClassLike(n) || (isFunctionLike(n) && !isArrowFunction(n))) {
+                                return false;
+                            }
+                            else {
+                                forEachChild(n, check);
+                            }
+                        });
+                        // falls through
                     case SyntaxKind.ClassDeclaration:
                     case SyntaxKind.FunctionDeclaration:
                         if (isSourceFile(node.parent) && node.parent.externalModuleIndicator === undefined) {
@@ -418,7 +432,7 @@ namespace ts.refactor.extractSymbol {
                     case SyntaxKind.Constructor:
                     case SyntaxKind.GetAccessor:
                     case SyntaxKind.SetAccessor:
-                        // do not dive into functions (except arrow functions) or classes
+                        // do not dive into functions or classes
                         return false;
                 }
 

src/services/symbolDisplay.ts

@@ -159,14 +159,14 @@ namespace ts.SymbolDisplay {
             }
 
             // try get the call/construct signature from the type if it matches
-            let callExpressionLike: CallExpression | NewExpression | JsxOpeningLikeElement | undefined;
+            let callExpressionLike: CallExpression | NewExpression | JsxOpeningLikeElement | TaggedTemplateExpression | undefined;
             if (isCallOrNewExpression(location)) {
                 callExpressionLike = location;
             }
             else if (isCallExpressionTarget(location) || isNewExpressionTarget(location)) {
                 callExpressionLike = <CallExpression | NewExpression>location.parent;
             }
-            else if (location.parent && isJsxOpeningLikeElement(location.parent) && isFunctionLike(symbol.valueDeclaration)) {
+            else if (location.parent && (isJsxOpeningLikeElement(location.parent) || isTaggedTemplateExpression(location.parent)) && isFunctionLike(symbol.valueDeclaration)) {
                 callExpressionLike = location.parent;
             }
 

src/services/tsconfig.json

@@ -97,6 +97,7 @@
         "codefixes/useDefaultImport.ts",
         "codefixes/useBigintLiteral.ts",
         "codefixes/fixAddModuleReferTypeMissingTypeof.ts",
+        "codefixes/wrapJsxInFragment.ts",
         "codefixes/convertToMappedObjectType.ts",
         "codefixes/removeUnnecessaryAwait.ts",
         "codefixes/splitTypeOnlyImport.ts",