Merge remote-tracking branch 'upstream/master'

* upstream/master:
  Update user baselines
  Fix detecting default project when file is part for more than one project but not part of default configured project (eg because its output of that projet) (microsoft#38429)
  fix(37877): include in NavigationBar default exported child items (microsoft#38255)
  fix: add missing semi-colon to `__exportStar` unnamed function
  Update baselines.
  Add and use the 'intersperse' helper function.
  Don't add duplicates of JSDoc comments.
  Added tests for union types with identical doc comments.
  feat(38225): change diagnostic message for remove braces from arrow function body
  Add outlining spans for object destructuring elements

Author: cangSDARM

src/compiler/core.ts

@@ -129,6 +129,22 @@ namespace ts {
         return map;
     }
 
+    /**
+     * Creates a new array with `element` interspersed in between each element of `input`
+     * if there is more than 1 value in `input`. Otherwise, returns the existing array.
+     */
+    export function intersperse<T>(input: T[], element: T): T[] {
+        if (input.length <= 1) {
+            return input;
+        }
+        const result: T[] = [];
+        for (let i = 0, n = input.length; i < n; i++) {
+            if (i) result.push(element);
+            result.push(input[i]);
+        }
+        return result;
+    }
+
     /**
      * Iterates through `array` by index and performs the callback on each element of array until the callback
      * returns a falsey value, then returns false.

src/compiler/diagnosticMessages.json

@@ -5657,7 +5657,7 @@
         "category": "Message",
         "code": 95111
     },
-    "Remove block body braces": {
+    "Remove braces from arrow function body": {
         "category": "Message",
         "code": 95112
     },
@@ -5669,15 +5669,15 @@
         "category": "Message",
         "code": 95114
     },
-    "Remove all incorrect body block braces": {
+    "Remove braces from all arrow function bodies with relevant issues": {
         "category": "Message",
         "code": 95115
     },
     "Wrap all object literal with parentheses": {
         "category": "Message",
         "code": 95116
     },
-    
+
     "No value exists in scope for the shorthand property '{0}'. Either declare one or provide an initializer.": {
         "category": "Error",
         "code": 18004

src/compiler/transformers/module/module.ts

@@ -1887,7 +1887,7 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
         text: `
             var __exportStar = (this && this.__exportStar) || function(m, exports) {
                 for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
-            }`
+            };`
     };
 
     function createExportStarHelper(context: TransformationContext, module: Expression) {

src/server/editorServices.ts

@@ -1743,7 +1743,9 @@ namespace ts.server {
 
             return project?.isSolution() ?
                 project.getDefaultChildProjectFromSolution(info) :
-                project;
+                project && projectContainsInfoDirectly(project, info) ?
+                    project :
+                    undefined;
         }
 
         /**

src/services/codefixes/returnValueCorrect.ts

@@ -2,7 +2,7 @@
 namespace ts.codefix {
     const fixId = "returnValueCorrect";
     const fixIdAddReturnStatement = "fixAddReturnStatement";
-    const fixIdRemoveBlockBodyBrace = "fixRemoveBlockBodyBrace";
+    const fixRemoveBracesFromArrowFunctionBody = "fixRemoveBracesFromArrowFunctionBody";
     const fixIdWrapTheBlockWithParen = "fixWrapTheBlockWithParen";
     const errorCodes = [
         Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value.code,
@@ -35,7 +35,7 @@ namespace ts.codefix {
 
     registerCodeFix({
         errorCodes,
-        fixIds: [fixIdAddReturnStatement, fixIdRemoveBlockBodyBrace, fixIdWrapTheBlockWithParen],
+        fixIds: [fixIdAddReturnStatement, fixRemoveBracesFromArrowFunctionBody, fixIdWrapTheBlockWithParen],
         getCodeActions: context => {
             const { program, sourceFile, span: { start }, errorCode } = context;
             const info = getInfo(program.getTypeChecker(), sourceFile, start, errorCode);
@@ -44,7 +44,7 @@ namespace ts.codefix {
             if (info.kind === ProblemKind.MissingReturnStatement) {
                 return append(
                     [getActionForfixAddReturnStatement(context, info.expression, info.statement)],
-                    isArrowFunction(info.declaration) ? getActionForfixRemoveBlockBodyBrace(context, info.declaration, info.expression, info.commentSource): undefined);
+                    isArrowFunction(info.declaration) ? getActionForFixRemoveBracesFromArrowFunctionBody(context, info.declaration, info.expression, info.commentSource): undefined);
             }
             else {
                 return [getActionForfixWrapTheBlockWithParen(context, info.declaration, info.expression)];
@@ -58,7 +58,7 @@ namespace ts.codefix {
                 case fixIdAddReturnStatement:
                     addReturnStatement(changes, diag.file, info.expression, info.statement);
                     break;
-                case fixIdRemoveBlockBodyBrace:
+                case fixRemoveBracesFromArrowFunctionBody:
                     if (!isArrowFunction(info.declaration)) return undefined;
                     removeBlockBodyBrace(changes, diag.file, info.declaration, info.expression, info.commentSource, /* withParen */ false);
                     break;
@@ -196,9 +196,9 @@ namespace ts.codefix {
         return createCodeFixAction(fixId, changes, Diagnostics.Add_a_return_statement, fixIdAddReturnStatement, Diagnostics.Add_all_missing_return_statement);
     }
 
-    function getActionForfixRemoveBlockBodyBrace(context: CodeFixContext, declaration: ArrowFunction, expression: Expression, commentSource: Node) {
+    function getActionForFixRemoveBracesFromArrowFunctionBody(context: CodeFixContext, declaration: ArrowFunction, expression: Expression, commentSource: Node) {
         const changes = textChanges.ChangeTracker.with(context, t => removeBlockBodyBrace(t, context.sourceFile, declaration, expression, commentSource, /* withParen */ false));
-        return createCodeFixAction(fixId, changes, Diagnostics.Remove_block_body_braces, fixIdRemoveBlockBodyBrace, Diagnostics.Remove_all_incorrect_body_block_braces);
+        return createCodeFixAction(fixId, changes, Diagnostics.Remove_braces_from_arrow_function_body, fixRemoveBracesFromArrowFunctionBody, Diagnostics.Remove_braces_from_all_arrow_function_bodies_with_relevant_issues);
     }
 
     function getActionForfixWrapTheBlockWithParen(context: CodeFixContext, declaration: ArrowFunction, expression: Expression) {

src/services/jsDoc.ts

@@ -89,17 +89,14 @@ namespace ts.JsDoc {
         // Eg. const a: Array<string> | Array<number>; a.length
         // The property length will have two declarations of property length coming
         // from Array<T> - Array<string> and Array<number>
-        const documentationComment: SymbolDisplayPart[] = [];
+        const documentationComment: string[] = [];
         forEachUnique(declarations, declaration => {
             for (const { comment } of getCommentHavingNodes(declaration)) {
                 if (comment === undefined) continue;
-                if (documentationComment.length) {
-                    documentationComment.push(lineBreakPart());
-                }
-                documentationComment.push(textPart(comment));
+                pushIfUnique(documentationComment, comment);
             }
         });
-        return documentationComment;
+        return intersperse(map(documentationComment, textPart), lineBreakPart());
     }
 
     function getCommentHavingNodes(declaration: Declaration): readonly (JSDoc | JSDocTag)[] {

src/services/navigationBar.ts

@@ -307,7 +307,18 @@ namespace ts.NavigationBar {
                 addNodeWithRecursiveChild(node, getInteriorModule(<ModuleDeclaration>node).body);
                 break;
 
-            case SyntaxKind.ExportAssignment:
+            case SyntaxKind.ExportAssignment: {
+                const expression = (<ExportAssignment>node).expression;
+                if (isObjectLiteralExpression(expression)) {
+                    startNode(node);
+                    addChildrenRecursively(expression);
+                    endNode();
+                }
+                else {
+                    addLeafNode(node);
+                }
+                break;
+            }
             case SyntaxKind.ExportSpecifier:
             case SyntaxKind.ImportEqualsDeclaration:
             case SyntaxKind.IndexSignature:

src/services/outliningElementsCollector.ts

@@ -200,6 +200,7 @@ namespace ts.OutliningElementsCollector {
             case SyntaxKind.EnumDeclaration:
             case SyntaxKind.CaseBlock:
             case SyntaxKind.TypeLiteral:
+            case SyntaxKind.ObjectBindingPattern:
                 return spanForNode(n);
             case SyntaxKind.TupleType:
                 return spanForNode(n, /*autoCollapse*/ false, /*useFullStart*/ !isTupleTypeNode(n.parent), SyntaxKind.OpenBracketToken);

src/testRunner/unittests/tsbuild/watchMode.ts

@@ -15,6 +15,13 @@ namespace ts.tscWatch {
         return ts.createSolutionBuilder(host, rootNames, defaultOptions || {});
     }
 
+    export function ensureErrorFreeBuild(host: WatchedSystem, rootNames: readonly string[]) {
+        // ts build should succeed
+        const solutionBuilder = createSolutionBuilder(host, rootNames, {});
+        solutionBuilder.build();
+        assert.equal(host.getOutput().length, 0, JSON.stringify(host.getOutput(), /*replacer*/ undefined, " "));
+    }
+
     type OutputFileStamp = [string, Date | undefined, boolean];
     function transformOutputToOutputFileStamp(f: string, host: TsBuildWatchSystem): OutputFileStamp {
         return [f, host.getModifiedTime(f), host.writtenFiles.has(host.toFullPath(f))] as OutputFileStamp;

src/testRunner/unittests/tsserver/configuredProjects.ts

@@ -1050,6 +1050,64 @@ declare var console: {
                 });
             });
         });
+
+        it("when default configured project does not contain the file", () => {
+            const barConfig: File = {
+                path: `${tscWatch.projectRoot}/bar/tsconfig.json`,
+                content: "{}"
+            };
+            const barIndex: File = {
+                path: `${tscWatch.projectRoot}/bar/index.ts`,
+                content: `import {foo} from "../foo/lib";
+foo();`
+            };
+            const fooBarConfig: File = {
+                path: `${tscWatch.projectRoot}/foobar/tsconfig.json`,
+                content: barConfig.path
+            };
+            const fooBarIndex: File = {
+                path: `${tscWatch.projectRoot}/foobar/index.ts`,
+                content: barIndex.content
+            };
+            const fooConfig: File = {
+                path: `${tscWatch.projectRoot}/foo/tsconfig.json`,
+                content: JSON.stringify({
+                    include: ["index.ts"],
+                    compilerOptions: {
+                        declaration: true,
+                        outDir: "lib"
+                    }
+                })
+            };
+            const fooIndex: File = {
+                path: `${tscWatch.projectRoot}/foo/index.ts`,
+                content: `export function foo() {}`
+            };
+            const host = createServerHost([barConfig, barIndex, fooBarConfig, fooBarIndex, fooConfig, fooIndex, libFile]);
+            tscWatch.ensureErrorFreeBuild(host, [fooConfig.path]);
+            const fooDts = `${tscWatch.projectRoot}/foo/lib/index.d.ts`;
+            assert.isTrue(host.fileExists(fooDts));
+            const session = createSession(host);
+            const service = session.getProjectService();
+            service.openClientFile(barIndex.path);
+            checkProjectActualFiles(service.configuredProjects.get(barConfig.path)!, [barIndex.path, fooDts, libFile.path, barConfig.path]);
+            service.openClientFile(fooBarIndex.path);
+            checkProjectActualFiles(service.configuredProjects.get(fooBarConfig.path)!, [fooBarIndex.path, fooDts, libFile.path, fooBarConfig.path]);
+            service.openClientFile(fooIndex.path);
+            checkProjectActualFiles(service.configuredProjects.get(fooConfig.path)!, [fooIndex.path, libFile.path, fooConfig.path]);
+            service.openClientFile(fooDts);
+            session.executeCommandSeq<protocol.GetApplicableRefactorsRequest>({
+                command: protocol.CommandTypes.GetApplicableRefactors,
+                arguments: {
+                    file: fooDts,
+                    startLine: 1,
+                    startOffset: 1,
+                    endLine: 1,
+                    endOffset: 1
+                }
+            });
+            assert.equal(service.tryGetDefaultProjectForFile(server.toNormalizedPath(fooDts)), service.configuredProjects.get(barConfig.path));
+        });
     });
 
     describe("unittests:: tsserver:: ConfiguredProjects:: non-existing directories listed in config file input array", () => {