Have flatMap return a ReadonlyArray by default (#28205)

Andy · web-flow · commit 672b0e3e16ad · 2018-10-29T11:12:51.000-07:00
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -28090,7 +28090,7 @@ namespace ts {
             return ts.typeHasCallOrConstructSignatures(type, checker);
         }
 
-        function getRootSymbols(symbol: Symbol): Symbol[] {
+        function getRootSymbols(symbol: Symbol): ReadonlyArray<Symbol> {
             const roots = getImmediateRootSymbols(symbol);
             return roots ? flatMap(roots, getRootSymbols) : [symbol];
         }
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
@@ -511,12 +511,27 @@ namespace ts {
      * @param array The array to map.
      * @param mapfn The callback used to map the result into one or more values.
      */
-    export function flatMap<T, U>(array: ReadonlyArray<T>, mapfn: (x: T, i: number) => U | ReadonlyArray<U> | undefined): U[];
-    export function flatMap<T, U>(array: ReadonlyArray<T> | undefined, mapfn: (x: T, i: number) => U | ReadonlyArray<U> | undefined): U[] | undefined;
-    export function flatMap<T, U>(array: ReadonlyArray<T> | undefined, mapfn: (x: T, i: number) => U | ReadonlyArray<U> | undefined): U[] | undefined {
+    export function flatMap<T, U>(array: ReadonlyArray<T> | undefined, mapfn: (x: T, i: number) => U | ReadonlyArray<U> | undefined): ReadonlyArray<U> {
         let result: U[] | undefined;
         if (array) {
-            result = [];
+            for (let i = 0; i < array.length; i++) {
+                const v = mapfn(array[i], i);
+                if (v) {
+                    if (isArray(v)) {
+                        result = addRange(result, v);
+                    }
+                    else {
+                        result = append(result, v);
+                    }
+                }
+            }
+        }
+        return result || emptyArray;
+    }
+
+    export function flatMapToMutable<T, U>(array: ReadonlyArray<T> | undefined, mapfn: (x: T, i: number) => U | ReadonlyArray<U> | undefined): U[] {
+        const result: U[] = [];
+        if (array) {
             for (let i = 0; i < array.length; i++) {
                 const v = mapfn(array[i], i);
                 if (v) {
diff --git a/src/compiler/transformers/declarations.ts b/src/compiler/transformers/declarations.ts
@@ -1043,7 +1043,7 @@ namespace ts {
                     const modifiers = createNodeArray(ensureModifiers(input, isPrivate));
                     const typeParameters = ensureTypeParams(input, input.typeParameters);
                     const ctor = getFirstConstructorWithBody(input);
-                    let parameterProperties: PropertyDeclaration[] | undefined;
+                    let parameterProperties: ReadonlyArray<PropertyDeclaration> | undefined;
                     if (ctor) {
                         const oldDiag = getSymbolAccessibilityDiagnostic;
                         parameterProperties = compact(flatMap(ctor.parameters, param => {
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -2793,7 +2793,7 @@ namespace ts {
     export interface ParseConfigHost {
         useCaseSensitiveFileNames: boolean;
 
-        readDirectory(rootDir: string, extensions: ReadonlyArray<string>, excludes: ReadonlyArray<string> | undefined, includes: ReadonlyArray<string>, depth?: number): string[];
+        readDirectory(rootDir: string, extensions: ReadonlyArray<string>, excludes: ReadonlyArray<string> | undefined, includes: ReadonlyArray<string>, depth?: number): ReadonlyArray<string>;
 
         /**
          * Gets a value indicating whether the specified path exists and is a file.
@@ -3079,7 +3079,7 @@ namespace ts {
 
         getFullyQualifiedName(symbol: Symbol): string;
         getAugmentedPropertiesOfType(type: Type): Symbol[];
-        getRootSymbols(symbol: Symbol): Symbol[];
+        getRootSymbols(symbol: Symbol): ReadonlyArray<Symbol>;
         getContextualType(node: Expression): Type | undefined;
         /* @internal */ getContextualTypeForObjectLiteralElement(element: ObjectLiteralElementLike): Type | undefined;
         /* @internal */ getContextualTypeForArgumentAtIndex(call: CallLikeExpression, argIndex: number): Type | undefined;
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
@@ -3038,7 +3038,7 @@ namespace ts {
                 return fileDiagnostics.get(fileName) || [];
             }
 
-            const fileDiags: Diagnostic[] = flatMap(filesWithDiagnostics, f => fileDiagnostics.get(f));
+            const fileDiags: Diagnostic[] = flatMapToMutable(filesWithDiagnostics, f => fileDiagnostics.get(f));
             if (!nonFileDiagnostics.length) {
                 return fileDiags;
             }
@@ -5234,7 +5234,7 @@ namespace ts {
         }
         if (isJSDocTypeAlias(node)) {
             Debug.assert(node.parent.kind === SyntaxKind.JSDocComment);
-            return flatMap(node.parent.tags, tag => isJSDocTemplateTag(tag) ? tag.typeParameters : undefined) as ReadonlyArray<TypeParameterDeclaration>;
+            return flatMap(node.parent.tags, tag => isJSDocTemplateTag(tag) ? tag.typeParameters : undefined);
         }
         if (node.typeParameters) {
             return node.typeParameters;
@@ -7777,7 +7777,7 @@ namespace ts {
         return `^(${pattern})${terminator}`;
     }
 
-    export function getRegularExpressionsForWildcards(specs: ReadonlyArray<string> | undefined, basePath: string, usage: "files" | "directories" | "exclude"): string[] | undefined {
+    export function getRegularExpressionsForWildcards(specs: ReadonlyArray<string> | undefined, basePath: string, usage: "files" | "directories" | "exclude"): ReadonlyArray<string> | undefined {
         if (specs === undefined || specs.length === 0) {
             return undefined;
         }
diff --git a/src/harness/fourslash.ts b/src/harness/fourslash.ts
@@ -491,7 +491,7 @@ namespace FourSlash {
             ];
         }
 
-        private getAllDiagnostics(): ts.Diagnostic[] {
+        private getAllDiagnostics(): ReadonlyArray<ts.Diagnostic> {
             return ts.flatMap(this.languageServiceAdapterHost.getFilenames(), fileName => {
                 if (!ts.isAnySupportedFileExtension(fileName)) {
                     return [];
@@ -532,7 +532,7 @@ namespace FourSlash {
                 predicate(start!, start! + length!, startMarker.position, endMarker === undefined ? undefined : endMarker.position)); // TODO: GH#18217
         }
 
-        private printErrorLog(expectErrors: boolean, errors: ts.Diagnostic[]) {
+        private printErrorLog(expectErrors: boolean, errors: ReadonlyArray<ts.Diagnostic>): void {
             if (expectErrors) {
                 Harness.IO.log("Expected error not found.  Error list is:");
             }
@@ -613,7 +613,7 @@ namespace FourSlash {
             this.verifyGoToX(arg0, endMarkerNames, () => this.getGoToDefinitionAndBoundSpan());
         }
 
-        private getGoToDefinition(): ts.DefinitionInfo[] {
+        private getGoToDefinition(): ReadonlyArray<ts.DefinitionInfo> {
             return this.languageService.getDefinitionAtPosition(this.activeFile.fileName, this.currentCaretPosition)!;
         }
 
@@ -626,7 +626,7 @@ namespace FourSlash {
                 this.languageService.getTypeDefinitionAtPosition(this.activeFile.fileName, this.currentCaretPosition));
         }
 
-        private verifyGoToX(arg0: any, endMarkerNames: ArrayOrSingle<string> | undefined, getDefs: () => ts.DefinitionInfo[] | ts.DefinitionInfoAndBoundSpan | undefined) {
+        private verifyGoToX(arg0: any, endMarkerNames: ArrayOrSingle<string> | undefined, getDefs: () => ReadonlyArray<ts.DefinitionInfo> | ts.DefinitionInfoAndBoundSpan | undefined) {
             if (endMarkerNames) {
                 this.verifyGoToXPlain(arg0, endMarkerNames, getDefs);
             }
@@ -646,7 +646,7 @@ namespace FourSlash {
             }
         }
 
-        private verifyGoToXPlain(startMarkerNames: ArrayOrSingle<string>, endMarkerNames: ArrayOrSingle<string>, getDefs: () => ts.DefinitionInfo[] | ts.DefinitionInfoAndBoundSpan | undefined) {
+        private verifyGoToXPlain(startMarkerNames: ArrayOrSingle<string>, endMarkerNames: ArrayOrSingle<string>, getDefs: () => ReadonlyArray<ts.DefinitionInfo> | ts.DefinitionInfoAndBoundSpan | undefined) {
             for (const start of toArray(startMarkerNames)) {
                 this.verifyGoToXSingle(start, endMarkerNames, getDefs);
             }
@@ -1890,7 +1890,7 @@ Actual: ${stringify(fullActual)}`);
 
         public verifyRangesInImplementationList(markerName: string) {
             this.goToMarker(markerName);
-            const implementations: ImplementationLocationInformation[] = this.languageService.getImplementationAtPosition(this.activeFile.fileName, this.currentCaretPosition)!;
+            const implementations: ReadonlyArray<ImplementationLocationInformation> = this.languageService.getImplementationAtPosition(this.activeFile.fileName, this.currentCaretPosition)!;
             if (!implementations || !implementations.length) {
                 this.raiseError("verifyRangesInImplementationList failed - expected to find at least one implementation location but got 0");
             }
@@ -2383,7 +2383,7 @@ Actual: ${stringify(fullActual)}`);
          * Rerieves a codefix satisfying the parameters, or undefined if no such codefix is found.
          * @param fileName Path to file where error should be retrieved from.
          */
-        private getCodeFixes(fileName: string, errorCode?: number, preferences: ts.UserPreferences = ts.emptyOptions): ts.CodeFixAction[] {
+        private getCodeFixes(fileName: string, errorCode?: number, preferences: ts.UserPreferences = ts.emptyOptions): ReadonlyArray<ts.CodeFixAction> {
             const diagnosticsForCodeFix = this.getDiagnostics(fileName, /*includeSuggestions*/ true).map(diagnostic => ({
                 start: diagnostic.start,
                 length: diagnostic.length,
diff --git a/src/harness/harness.ts b/src/harness/harness.ts
@@ -490,7 +490,7 @@ namespace Harness {
         getExecutingFilePath(): string;
         getWorkspaceRoot(): string;
         exit(exitCode?: number): void;
-        readDirectory(path: string, extension?: ReadonlyArray<string>, exclude?: ReadonlyArray<string>, include?: ReadonlyArray<string>, depth?: number): string[];
+        readDirectory(path: string, extension?: ReadonlyArray<string>, exclude?: ReadonlyArray<string>, include?: ReadonlyArray<string>, depth?: number): ReadonlyArray<string>;
         getAccessibleFileSystemEntries(dirname: string): ts.FileSystemEntries;
         tryEnableSourceMapsForHost?(): void;
         getEnvironmentVariable?(name: string): string;
diff --git a/src/server/project.ts b/src/server/project.ts
@@ -548,7 +548,7 @@ namespace ts.server {
         }
 
         getExternalFiles(): SortedReadonlyArray<string> {
-            return toSortedArray(flatMap(this.plugins, plugin => {
+            return toSortedArray(flatMapToMutable(this.plugins, plugin => {
                 if (typeof plugin.getExternalFiles !== "function") return;
                 try {
                     return plugin.getExternalFiles(this);
diff --git a/src/server/protocol.ts b/src/server/protocol.ts
@@ -1023,7 +1023,7 @@ namespace ts.server.protocol {
         /**
          * The file locations referencing the symbol.
          */
-        refs: ReferencesResponseItem[];
+        refs: ReadonlyArray<ReferencesResponseItem>;
 
         /**
          * The name of the symbol.
diff --git a/src/server/session.ts b/src/server/session.ts
@@ -267,7 +267,7 @@ namespace ts.server {
         projects: Projects,
         action: (project: Project, value: T) => ReadonlyArray<U> | U | undefined,
     ): U[] {
-        const outputs = flatMap(isArray(projects) ? projects : projects.projects, project => action(project, defaultValue));
+        const outputs = flatMapToMutable(isArray(projects) ? projects : projects.projects, project => action(project, defaultValue));
         if (!isArray(projects) && projects.symLinkedProjects) {
             projects.symLinkedProjects.forEach((projects, path) => {
                 const value = getValue(path as Path);
@@ -1230,7 +1230,7 @@ namespace ts.server {
                 const nameSpan = nameInfo && nameInfo.textSpan;
                 const symbolStartOffset = nameSpan ? scriptInfo.positionToLineOffset(nameSpan.start).offset : 0;
                 const symbolName = nameSpan ? scriptInfo.getSnapshot().getText(nameSpan.start, textSpanEnd(nameSpan)) : "";
-                const refs: protocol.ReferencesResponseItem[] = flatMap(references, referencedSymbol =>
+                const refs: ReadonlyArray<protocol.ReferencesResponseItem> = flatMap(references, referencedSymbol =>
                     referencedSymbol.references.map(({ fileName, textSpan, isWriteAccess, isDefinition }): protocol.ReferencesResponseItem => {
                         const scriptInfo = Debug.assertDefined(this.projectService.getScriptInfo(fileName));
                         const start = scriptInfo.positionToLineOffset(textSpan.start);
diff --git a/src/services/codeFixProvider.ts b/src/services/codeFixProvider.ts
@@ -62,7 +62,7 @@ namespace ts {
             return arrayFrom(errorCodeToFixes.keys());
         }
 
-        export function getFixes(context: CodeFixContext): CodeFixAction[] {
+        export function getFixes(context: CodeFixContext): ReadonlyArray<CodeFixAction> {
             return flatMap(errorCodeToFixes.get(String(context.errorCode)) || emptyArray, f => f.getCodeActions(context));
         }
 
diff --git a/src/services/codefixes/importFixes.ts b/src/services/codefixes/importFixes.ts
@@ -289,7 +289,7 @@ namespace ts.codefix {
                 // `position` should only be undefined at a missing jsx namespace, in which case we shouldn't be looking for pure types.
                 exportedSymbolIsTypeOnly && isJs ? { kind: ImportFixKind.ImportType, moduleSpecifier, position: Debug.assertDefined(position) } : { kind: ImportFixKind.AddNew, moduleSpecifier, importKind }));
         // Sort to keep the shortest paths first
-        return choicesForEachExportingModule.sort((a, b) => a.moduleSpecifier.length - b.moduleSpecifier.length);
+        return sort(choicesForEachExportingModule, (a, b) => a.moduleSpecifier.length - b.moduleSpecifier.length);
     }
 
     function getFixesForAddImport(
diff --git a/src/services/codefixes/inferFromUsage.ts b/src/services/codefixes/inferFromUsage.ts
@@ -228,7 +228,7 @@ namespace ts.codefix {
 
     function addJSDocTags(changes: textChanges.ChangeTracker, sourceFile: SourceFile, parent: HasJSDoc, newTags: ReadonlyArray<JSDocTag>): void {
         const comments = mapDefined(parent.jsDoc, j => j.comment);
-        const oldTags = flatMap(parent.jsDoc, j => j.tags);
+        const oldTags = flatMapToMutable(parent.jsDoc, j => j.tags);
         const unmergedNewTags = newTags.filter(newTag => !oldTags || !oldTags.some((tag, i) => {
             const merged = tryMergeJsdocTags(tag, newTag);
             if (merged) oldTags[i] = merged;
diff --git a/src/services/findAllReferences.ts b/src/services/findAllReferences.ts
@@ -1,8 +1,8 @@
 /* @internal */
 namespace ts.FindAllReferences {
     export interface SymbolAndEntries {
-        definition: Definition | undefined;
-        references: Entry[];
+        readonly definition: Definition | undefined;
+        readonly references: ReadonlyArray<Entry>;
     }
 
     export const enum DefinitionKind { Symbol, Label, Keyword, This, String }
@@ -60,7 +60,7 @@ namespace ts.FindAllReferences {
         return map(referenceEntries, entry => toImplementationLocation(entry, checker));
     }
 
-    function getImplementationReferenceEntries(program: Program, cancellationToken: CancellationToken, sourceFiles: ReadonlyArray<SourceFile>, node: Node, position: number): Entry[] | undefined {
+    function getImplementationReferenceEntries(program: Program, cancellationToken: CancellationToken, sourceFiles: ReadonlyArray<SourceFile>, node: Node, position: number): ReadonlyArray<Entry> | undefined {
         if (node.kind === SyntaxKind.SourceFile) {
             return undefined;
         }
@@ -94,11 +94,19 @@ namespace ts.FindAllReferences {
 
     export type ToReferenceOrRenameEntry<T> = (entry: Entry, originalNode: Node) => T;
 
-    export function getReferenceEntriesForNode(position: number, node: Node, program: Program, sourceFiles: ReadonlyArray<SourceFile>, cancellationToken: CancellationToken, options: Options = {}, sourceFilesSet: ReadonlyMap<true> = arrayToSet(sourceFiles, f => f.fileName)): Entry[] | undefined {
+    export function getReferenceEntriesForNode(
+        position: number,
+        node: Node,
+        program: Program,
+        sourceFiles: ReadonlyArray<SourceFile>,
+        cancellationToken: CancellationToken,
+        options: Options = {},
+        sourceFilesSet: ReadonlyMap<true> = arrayToSet(sourceFiles, f => f.fileName),
+    ): ReadonlyArray<Entry> | undefined {
         return flattenEntries(Core.getReferencedSymbolsForNode(position, node, program, sourceFiles, cancellationToken, options, sourceFilesSet));
     }
 
-    function flattenEntries(referenceSymbols: SymbolAndEntries[] | undefined): Entry[] | undefined {
+    function flattenEntries(referenceSymbols: SymbolAndEntries[] | undefined): ReadonlyArray<Entry> | undefined {
         return referenceSymbols && flatMap(referenceSymbols, r => r.references);
     }
 
diff --git a/src/services/goToDefinition.ts b/src/services/goToDefinition.ts
@@ -1,6 +1,6 @@
 /* @internal */
 namespace ts.GoToDefinition {
-    export function getDefinitionAtPosition(program: Program, sourceFile: SourceFile, position: number): DefinitionInfo[] | undefined {
+    export function getDefinitionAtPosition(program: Program, sourceFile: SourceFile, position: number): ReadonlyArray<DefinitionInfo> | undefined {
         const reference = getReferenceAtPosition(sourceFile, position, program);
         if (reference) {
             return [getDefinitionInfoForFileReference(reference.fileName, reference.file.fileName)];
@@ -129,7 +129,7 @@ namespace ts.GoToDefinition {
     }
 
     /// Goto type
-    export function getTypeDefinitionAtPosition(typeChecker: TypeChecker, sourceFile: SourceFile, position: number): DefinitionInfo[] | undefined {
+    export function getTypeDefinitionAtPosition(typeChecker: TypeChecker, sourceFile: SourceFile, position: number): ReadonlyArray<DefinitionInfo> | undefined {
         const node = getTouchingPropertyName(sourceFile, position);
         if (node === sourceFile) {
             return undefined;
@@ -145,7 +145,7 @@ namespace ts.GoToDefinition {
         return fromReturnType && fromReturnType.length !== 0 ? fromReturnType : definitionFromType(typeAtLocation, typeChecker, node);
     }
 
-    function definitionFromType(type: Type, checker: TypeChecker, node: Node): DefinitionInfo[] {
+    function definitionFromType(type: Type, checker: TypeChecker, node: Node): ReadonlyArray<DefinitionInfo> {
         return flatMap(type.isUnion() && !(type.flags & TypeFlags.Enum) ? type.types : [type], t =>
             t.symbol && getDefinitionFromSymbol(checker, t.symbol, node));
     }
diff --git a/src/services/services.ts b/src/services/services.ts
@@ -1496,7 +1496,7 @@ namespace ts {
         }
 
         /// Goto definition
-        function getDefinitionAtPosition(fileName: string, position: number): DefinitionInfo[] | undefined {
+        function getDefinitionAtPosition(fileName: string, position: number): ReadonlyArray<DefinitionInfo> | undefined {
             synchronizeHostData();
             return GoToDefinition.getDefinitionAtPosition(program, getValidSourceFile(fileName), position);
         }
@@ -1506,7 +1506,7 @@ namespace ts {
             return GoToDefinition.getDefinitionAndBoundSpan(program, getValidSourceFile(fileName), position);
         }
 
-        function getTypeDefinitionAtPosition(fileName: string, position: number): DefinitionInfo[] | undefined {
+        function getTypeDefinitionAtPosition(fileName: string, position: number): ReadonlyArray<DefinitionInfo> | undefined {
             synchronizeHostData();
             return GoToDefinition.getTypeDefinitionAtPosition(program.getTypeChecker(), getValidSourceFile(fileName), position);
         }
@@ -1519,7 +1519,7 @@ namespace ts {
         }
 
         /// References and Occurrences
-        function getOccurrencesAtPosition(fileName: string, position: number): ReferenceEntry[] | undefined {
+        function getOccurrencesAtPosition(fileName: string, position: number): ReadonlyArray<ReferenceEntry> | undefined {
             return flatMap(getDocumentHighlights(fileName, position, [fileName]), entry => entry.highlightSpans.map<ReferenceEntry>(highlightSpan => ({
                 fileName: entry.fileName,
                 textSpan: highlightSpan.textSpan,
diff --git a/src/services/types.ts b/src/services/types.ts
diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts
diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts

Original file line number	Diff line number	Diff line change
`@@ -28090,7 +28090,7 @@ namespace ts {`
`28090`	`28090`	`return ts.typeHasCallOrConstructSignatures(type, checker);`
`28091`	`28091`	`}`
`28092`	`28092`
`28093`		`- function getRootSymbols(symbol: Symbol): Symbol[] {`
	`28093`	`+ function getRootSymbols(symbol: Symbol): ReadonlyArray<Symbol> {`
`28094`	`28094`	`const roots = getImmediateRootSymbols(symbol);`
`28095`	`28095`	`return roots ? flatMap(roots, getRootSymbols) : [symbol];`
`28096`	`28096`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3038,7 +3038,7 @@ namespace ts {`
`3038`	`3038`	`return fileDiagnostics.get(fileName) \|\| [];`
`3039`	`3039`	`}`
`3040`	`3040`
`3041`		`- const fileDiags: Diagnostic[] = flatMap(filesWithDiagnostics, f => fileDiagnostics.get(f));`
	`3041`	`+ const fileDiags: Diagnostic[] = flatMapToMutable(filesWithDiagnostics, f => fileDiagnostics.get(f));`
`3042`	`3042`	`if (!nonFileDiagnostics.length) {`
`3043`	`3043`	`return fileDiags;`
`3044`	`3044`	`}`
`@@ -5234,7 +5234,7 @@ namespace ts {`
`5234`	`5234`	`}`
`5235`	`5235`	`if (isJSDocTypeAlias(node)) {`
`5236`	`5236`	`Debug.assert(node.parent.kind === SyntaxKind.JSDocComment);`
`5237`		`- return flatMap(node.parent.tags, tag => isJSDocTemplateTag(tag) ? tag.typeParameters : undefined) as ReadonlyArray<TypeParameterDeclaration>;`
	`5237`	`+ return flatMap(node.parent.tags, tag => isJSDocTemplateTag(tag) ? tag.typeParameters : undefined);`
`5238`	`5238`	`}`
`5239`	`5239`	`if (node.typeParameters) {`
`5240`	`5240`	`return node.typeParameters;`
`@@ -7777,7 +7777,7 @@ namespace ts {`
`7777`	`7777`	return `^(${pattern})${terminator}`;
`7778`	`7778`	`}`
`7779`	`7779`
`7780`		`- export function getRegularExpressionsForWildcards(specs: ReadonlyArray<string> \| undefined, basePath: string, usage: "files" \| "directories" \| "exclude"): string[] \| undefined {`
	`7780`	`+ export function getRegularExpressionsForWildcards(specs: ReadonlyArray<string> \| undefined, basePath: string, usage: "files" \| "directories" \| "exclude"): ReadonlyArray<string> \| undefined {`
`7781`	`7781`	`if (specs === undefined \|\| specs.length === 0) {`
`7782`	`7782`	`return undefined;`
`7783`	`7783`	`}`
Original file line number	Diff line number	Diff line change
`@@ -491,7 +491,7 @@ namespace FourSlash {`
`491`	`491`	`];`
`492`	`492`	`}`
`493`	`493`
`494`		`- private getAllDiagnostics(): ts.Diagnostic[] {`
	`494`	`+ private getAllDiagnostics(): ReadonlyArray<ts.Diagnostic> {`
`495`	`495`	`return ts.flatMap(this.languageServiceAdapterHost.getFilenames(), fileName => {`
`496`	`496`	`if (!ts.isAnySupportedFileExtension(fileName)) {`
`497`	`497`	`return [];`
`@@ -532,7 +532,7 @@ namespace FourSlash {`
`532`	`532`	`predicate(start!, start! + length!, startMarker.position, endMarker === undefined ? undefined : endMarker.position)); // TODO: GH#18217`
`533`	`533`	`}`
`534`	`534`
`535`		`- private printErrorLog(expectErrors: boolean, errors: ts.Diagnostic[]) {`
	`535`	`+ private printErrorLog(expectErrors: boolean, errors: ReadonlyArray<ts.Diagnostic>): void {`
`536`	`536`	`if (expectErrors) {`
`537`	`537`	`Harness.IO.log("Expected error not found. Error list is:");`
`538`	`538`	`}`
`@@ -613,7 +613,7 @@ namespace FourSlash {`
`613`	`613`	`this.verifyGoToX(arg0, endMarkerNames, () => this.getGoToDefinitionAndBoundSpan());`
`614`	`614`	`}`
`615`	`615`
`616`		`- private getGoToDefinition(): ts.DefinitionInfo[] {`
	`616`	`+ private getGoToDefinition(): ReadonlyArray<ts.DefinitionInfo> {`
`617`	`617`	`return this.languageService.getDefinitionAtPosition(this.activeFile.fileName, this.currentCaretPosition)!;`
`618`	`618`	`}`
`619`	`619`
`@@ -626,7 +626,7 @@ namespace FourSlash {`
`626`	`626`	`this.languageService.getTypeDefinitionAtPosition(this.activeFile.fileName, this.currentCaretPosition));`
`627`	`627`	`}`
`628`	`628`
`629`		`- private verifyGoToX(arg0: any, endMarkerNames: ArrayOrSingle<string> \| undefined, getDefs: () => ts.DefinitionInfo[] \| ts.DefinitionInfoAndBoundSpan \| undefined) {`
	`629`	`+ private verifyGoToX(arg0: any, endMarkerNames: ArrayOrSingle<string> \| undefined, getDefs: () => ReadonlyArray<ts.DefinitionInfo> \| ts.DefinitionInfoAndBoundSpan \| undefined) {`
`630`	`630`	`if (endMarkerNames) {`
`631`	`631`	`this.verifyGoToXPlain(arg0, endMarkerNames, getDefs);`
`632`	`632`	`}`
`@@ -646,7 +646,7 @@ namespace FourSlash {`
`646`	`646`	`}`
`647`	`647`	`}`
`648`	`648`
`649`		`- private verifyGoToXPlain(startMarkerNames: ArrayOrSingle<string>, endMarkerNames: ArrayOrSingle<string>, getDefs: () => ts.DefinitionInfo[] \| ts.DefinitionInfoAndBoundSpan \| undefined) {`
	`649`	`+ private verifyGoToXPlain(startMarkerNames: ArrayOrSingle<string>, endMarkerNames: ArrayOrSingle<string>, getDefs: () => ReadonlyArray<ts.DefinitionInfo> \| ts.DefinitionInfoAndBoundSpan \| undefined) {`
`650`	`650`	`for (const start of toArray(startMarkerNames)) {`
`651`	`651`	`this.verifyGoToXSingle(start, endMarkerNames, getDefs);`
`652`	`652`	`}`
@@ -1890,7 +1890,7 @@ Actual: ${stringify(fullActual)}`);
`1890`	`1890`
`1891`	`1891`	`public verifyRangesInImplementationList(markerName: string) {`
`1892`	`1892`	`this.goToMarker(markerName);`
`1893`		`- const implementations: ImplementationLocationInformation[] = this.languageService.getImplementationAtPosition(this.activeFile.fileName, this.currentCaretPosition)!;`
	`1893`	`+ const implementations: ReadonlyArray<ImplementationLocationInformation> = this.languageService.getImplementationAtPosition(this.activeFile.fileName, this.currentCaretPosition)!;`
`1894`	`1894`	`if (!implementations \|\| !implementations.length) {`
`1895`	`1895`	`this.raiseError("verifyRangesInImplementationList failed - expected to find at least one implementation location but got 0");`
`1896`	`1896`	`}`
@@ -2383,7 +2383,7 @@ Actual: ${stringify(fullActual)}`);
`2383`	`2383`	`* Rerieves a codefix satisfying the parameters, or undefined if no such codefix is found.`
`2384`	`2384`	`* @param fileName Path to file where error should be retrieved from.`
`2385`	`2385`	`*/`
`2386`		`- private getCodeFixes(fileName: string, errorCode?: number, preferences: ts.UserPreferences = ts.emptyOptions): ts.CodeFixAction[] {`
	`2386`	`+ private getCodeFixes(fileName: string, errorCode?: number, preferences: ts.UserPreferences = ts.emptyOptions): ReadonlyArray<ts.CodeFixAction> {`
`2387`	`2387`	`const diagnosticsForCodeFix = this.getDiagnostics(fileName, /includeSuggestions/ true).map(diagnostic => ({`
`2388`	`2388`	`start: diagnostic.start,`
`2389`	`2389`	`length: diagnostic.length,`
Original file line number	Diff line number	Diff line change
`@@ -548,7 +548,7 @@ namespace ts.server {`
`548`	`548`	`}`
`549`	`549`
`550`	`550`	`getExternalFiles(): SortedReadonlyArray<string> {`
`551`		`- return toSortedArray(flatMap(this.plugins, plugin => {`
	`551`	`+ return toSortedArray(flatMapToMutable(this.plugins, plugin => {`
`552`	`552`	`if (typeof plugin.getExternalFiles !== "function") return;`
`553`	`553`	`try {`
`554`	`554`	`return plugin.getExternalFiles(this);`