Implementing copy/paste

src/harness/client.ts

@@ -49,6 +49,8 @@ import {
     notImplemented,
     OrganizeImportsArgs,
     OutliningSpan,
+    PasteEdits,
+    PasteEditsArgs,
     PatternMatchKind,
     Program,
     QuickInfo,
@@ -1009,6 +1011,25 @@ export class SessionClient implements LanguageService {
         return getSupportedCodeFixes();
     }
 
+    getPasteEdits(
+        { targetFile, pastedText, pasteLocations, copiedFrom }: PasteEditsArgs,
+        _formatOptions: FormatCodeSettings,
+    ): PasteEdits {
+        const args: protocol.GetPasteEditsRequestArgs = {
+            file: targetFile,
+            pastedText,
+            pasteLocations: pasteLocations.map(range => ({ start: this.positionToOneBasedLineOffset(targetFile, range.pos), end: this.positionToOneBasedLineOffset(targetFile, range.end) })),
+            copiedFrom: copiedFrom ? { file: copiedFrom.file, range: copiedFrom.range.map(range => ({ start: this.positionToOneBasedLineOffset(copiedFrom.file, range.pos), end: this.positionToOneBasedLineOffset(copiedFrom.file, range.end) })) } : undefined,
+        };
+        const request = this.processRequest<protocol.GetPasteEditsRequest>(protocol.CommandTypes.GetPasteEdits, args);
+        const response = this.processResponse<protocol.GetPasteEditsResponse>(request);
+        if (!response.body) {
+            return { edits: [] };
+        }
+        const edits: FileTextChanges[] = this.convertCodeEditsToTextChanges(response.body.edits);
+        return { edits, fixId: response.body.fixId };
+    }
+
     getProgram(): Program {
         throw new Error("Program objects are not serializable through the server protocol.");
     }

src/harness/fourslashImpl.ts

@@ -3562,6 +3562,11 @@ export class TestState {
         assert.deepEqual(actualModuleSpecifiers, moduleSpecifiers);
     }
 
+    public verifyPasteEdits(options: FourSlashInterface.PasteEditsOptions): void {
+        const editInfo = this.languageService.getPasteEdits({ targetFile: this.activeFile.fileName, pastedText: options.args.pastedText, pasteLocations: options.args.pasteLocations, copiedFrom: options.args.copiedFrom, preferences: options.args.preferences }, this.formatCodeSettings);
+        (options.fixId === editInfo.fixId) ? this.verifyNewContent({ newFileContent: options.newFileContents }, editInfo.edits) : this.raiseError(`Expected to find a fix ${editInfo.fixId}, but none exists`);
+    }
+
     public verifyDocCommentTemplate(expected: ts.TextInsertion | undefined, options?: ts.DocCommentTemplateOptions) {
         const name = "verifyDocCommentTemplate";
         const actual = this.languageService.getDocCommentTemplateAtPosition(this.activeFile.fileName, this.currentCaretPosition, options || { generateReturnInDocTemplate: true }, this.formatCodeSettings)!;

src/harness/fourslashInterfaceImpl.ts

@@ -620,6 +620,10 @@ export class Verify extends VerifyNegatable {
     public organizeImports(newContent: string, mode?: ts.OrganizeImportsMode, preferences?: ts.UserPreferences): void {
         this.state.verifyOrganizeImports(newContent, mode, preferences);
     }
+
+    public pasteEdits(options: PasteEditsOptions): void {
+        this.state.verifyPasteEdits(options);
+    }
 }
 
 export class Edit {
@@ -1923,6 +1927,12 @@ export interface MoveToFileOptions {
     readonly preferences?: ts.UserPreferences;
 }
 
+export interface PasteEditsOptions {
+    readonly newFileContents: { readonly [fileName: string]: string; };
+    args: ts.PasteEditsArgs;
+    readonly fixId: string;
+}
+
 export type RenameLocationsOptions = readonly RenameLocationOptions[] | {
     readonly findInStrings?: boolean;
     readonly findInComments?: boolean;

src/server/project.ts

@@ -2214,6 +2214,18 @@ export abstract class Project implements LanguageServiceHost, ModuleResolutionHo
         return this.noDtsResolutionProject;
     }
 
+    /** @internal */
+    runWithTemporaryFileUpdate(rootFile: string, updatedText: string, cb: (updatedProgram: Program | undefined, originalProgram: Program | undefined, updatedFile: SourceFile) => void) {
+        const originalProgram = this.program;
+        const originalText = this.program?.getSourceFile(rootFile)?.getText();
+        Debug.assert(this.program && this.program.getSourceFile(rootFile) && originalText);
+
+        this.getScriptInfo(rootFile)?.editContent(0, this.program.getSourceFile(rootFile)!.getText().length, updatedText);
+        this.updateGraph();
+        cb(this.program, originalProgram, (this.program?.getSourceFile(rootFile))!);
+        this.getScriptInfo(rootFile)?.editContent(0, this.program.getSourceFile(rootFile)!.getText().length, originalText);
+    }
+
     /** @internal */
     private getCompilerOptionsForNoDtsResolutionProject() {
         return {

src/server/protocol.ts

@@ -161,6 +161,7 @@ export const enum CommandTypes {
     GetApplicableRefactors = "getApplicableRefactors",
     GetEditsForRefactor = "getEditsForRefactor",
     GetMoveToRefactoringFileSuggestions = "getMoveToRefactoringFileSuggestions",
+    GetPasteEdits = "getPasteEdits",
     /** @internal */
     GetEditsForRefactorFull = "getEditsForRefactor-full",
 
@@ -625,6 +626,28 @@ export interface GetMoveToRefactoringFileSuggestions extends Response {
     };
 }
 
+/**
+ * Request refactorings at a given position post pasting text from some other location.
+ */
+
+export interface GetPasteEditsRequest extends Request {
+    command: CommandTypes.GetPasteEdits;
+    arguments: GetPasteEditsRequestArgs;
+}
+
+export type GetPasteEditsRequestArgs = FileRequestArgs & {
+    pastedText: string[];
+    pasteLocations: TextSpan[];
+    copiedFrom?: { file: string; range: TextSpan[]; };
+};
+export interface GetPasteEditsResponse extends Response {
+    body: PasteEditsAction;
+}
+export interface PasteEditsAction {
+    edits: FileCodeEdits[];
+    fixId?: {};
+}
+
 export interface GetEditsForRefactorRequest extends Request {
     command: CommandTypes.GetEditsForRefactor;
     arguments: GetEditsForRefactorRequestArgs;

src/server/session.ts

@@ -101,6 +101,7 @@ import {
     OperationCanceledException,
     OrganizeImportsMode,
     OutliningSpan,
+    PasteEdits,
     Path,
     perfLogger,
     PerformanceEvent,
@@ -2796,6 +2797,27 @@ export class Session<TMessage = string> implements EventSender {
         return project.getLanguageService().getMoveToRefactoringFileSuggestions(file, this.extractPositionOrRange(args, scriptInfo), this.getPreferences(file));
     }
 
+    private getPasteEdits(args: protocol.GetPasteEditsRequestArgs): protocol.PasteEditsAction | undefined {
+        const { file, project } = this.getFileAndProject(args);
+        const copyFile = args.copiedFrom ? args.copiedFrom.file : undefined;
+        const result = project.getLanguageService().getPasteEdits(
+            {
+                targetFile: file,
+                pastedText: args.pastedText,
+                pasteLocations: args.pasteLocations.map(paste => this.getRange({ file, startLine: paste.start.line, startOffset: paste.start.offset, endLine: paste.end.line, endOffset: paste.end.offset }, project.getScriptInfoForNormalizedPath(file)!)),
+                copiedFrom: args.copiedFrom && copyFile
+                    ? { file: args.copiedFrom.file, range: args.copiedFrom.range.map(copies => this.getRange({ file: copyFile, startLine: copies.start.line, startOffset: copies.start.offset, endLine: copies.end.line, endOffset: copies.end.offset }, project.getScriptInfoForNormalizedPath(toNormalizedPath(copyFile))!)) }
+                    : undefined,
+                preferences: this.getPreferences(file),
+            },
+            this.getFormatOptions(file),
+        );
+        if (result === undefined) {
+            return undefined;
+        }
+        return this.mapPasteEditsAction(result);
+    }
+
     private organizeImports(args: protocol.OrganizeImportsRequestArgs, simplifiedResult: boolean): readonly protocol.FileCodeEdits[] | readonly FileTextChanges[] {
         Debug.assert(args.scope.type === "file");
         const { file, project } = this.getFileAndProject(args.scope.args);
@@ -2928,6 +2950,10 @@ export class Session<TMessage = string> implements EventSender {
         return { fixName, description, changes: this.mapTextChangesToCodeEdits(changes), commands, fixId, fixAllDescription };
     }
 
+    private mapPasteEditsAction({ edits, fixId }: PasteEdits): protocol.PasteEditsAction {
+        return { edits: this.mapTextChangesToCodeEdits(edits), fixId };
+    }
+
     private mapTextChangesToCodeEdits(textChanges: readonly FileTextChanges[]): protocol.FileCodeEdits[] {
         return textChanges.map(change => this.mapTextChangeToCodeEdit(change));
     }
@@ -3521,6 +3547,9 @@ export class Session<TMessage = string> implements EventSender {
         [protocol.CommandTypes.GetMoveToRefactoringFileSuggestions]: (request: protocol.GetMoveToRefactoringFileSuggestionsRequest) => {
             return this.requiredResponse(this.getMoveToRefactoringFileSuggestions(request.arguments));
         },
+        [protocol.CommandTypes.GetPasteEdits]: (request: protocol.GetPasteEditsRequest) => {
+            return this.requiredResponse(this.getPasteEdits(request.arguments));
+        },
         [protocol.CommandTypes.GetEditsForRefactorFull]: (request: protocol.GetEditsForRefactorRequest) => {
             return this.requiredResponse(this.getEditsForRefactor(request.arguments, /*simplifiedResult*/ false));
         },

src/services/_namespaces/ts.PasteEdits.ts

@@ -0,0 +1 @@
+export * from "../pasteEdits";

src/services/_namespaces/ts.ts

@@ -56,3 +56,5 @@ import * as textChanges from "./ts.textChanges";
 export { textChanges };
 import * as formatting from "./ts.formatting";
 export { formatting };
+import * as pasteEdits from "./ts.PasteEdits";
+export { pasteEdits };

src/services/codefixes/helpers.ts

@@ -925,7 +925,7 @@ function replaceFirstIdentifierOfEntityName(name: EntityName, newIdentifier: Ide
 
 /** @internal */
 export function importSymbols(importAdder: ImportAdder, symbols: readonly Symbol[]) {
-    symbols.forEach(s => importAdder.addImportFromExportedSymbol(s, /*isValidTypeOnlyUseSite*/ true));
+    symbols.forEach(s => importAdder.addImportFromSymbol(s, /*isValidTypeOnlyUseSite*/ true));
 }
 
 /** @internal */

src/services/codefixes/importFixes.ts

@@ -131,6 +131,7 @@ import {
     SymbolExportInfo,
     SymbolFlags,
     SymbolId,
+    SymbolInfo,
     SyntaxKind,
     textChanges,
     toPath,
@@ -207,7 +208,8 @@ registerCodeFix({
 export interface ImportAdder {
     hasFixes(): boolean;
     addImportFromDiagnostic: (diagnostic: DiagnosticWithLocation, context: CodeFixContextBase) => void;
-    addImportFromExportedSymbol: (exportedSymbol: Symbol, isValidTypeOnlyUseSite?: boolean) => void;
+    addImportFromSymbol: (exportedSymbol: Symbol, isValidTypeOnlyUseSite?: boolean, targetFilePath?: string) => void;
+    addImportForUnresolvedIdentifier: (context: CodeFixContextBase, symbolToken: Identifier, useAutoImportProvider: boolean) => void;
     writeFixes: (changeTracker: textChanges.ChangeTracker, oldFileQuotePreference?: QuotePreference) => void;
 }
 
@@ -233,24 +235,38 @@ function createImportAdderWorker(sourceFile: SourceFile, program: Program, useAu
     type NewImportsKey = `${0 | 1}|${string}`;
     /** Use `getNewImportEntry` for access */
     const newImports = new Map<NewImportsKey, Mutable<ImportsCollection & { useRequire: boolean; }>>();
-    return { addImportFromDiagnostic, addImportFromExportedSymbol, writeFixes, hasFixes };
+    return { addImportFromDiagnostic, addImportFromSymbol, writeFixes, hasFixes, addImportForUnresolvedIdentifier };
+
+    function addImportForUnresolvedIdentifier(context: CodeFixContextBase, symbolToken: Identifier, useAutoImportProvider: boolean) {
+        const info = getFixInfosWithoutDiagnostic(context, symbolToken, useAutoImportProvider);
+        if (!info || !info.length) return;
+        addImport(first(info));
+    }
 
     function addImportFromDiagnostic(diagnostic: DiagnosticWithLocation, context: CodeFixContextBase) {
         const info = getFixInfos(context, diagnostic.code, diagnostic.start, useAutoImportProvider);
         if (!info || !info.length) return;
         addImport(first(info));
     }
 
-    function addImportFromExportedSymbol(exportedSymbol: Symbol, isValidTypeOnlyUseSite?: boolean) {
-        const moduleSymbol = Debug.checkDefined(exportedSymbol.parent);
-        const symbolName = getNameForExportedSymbol(exportedSymbol, getEmitScriptTarget(compilerOptions));
-        const checker = program.getTypeChecker();
-        const symbol = checker.getMergedSymbol(skipAlias(exportedSymbol, checker));
-        const exportInfo = getAllExportInfoForSymbol(sourceFile, symbol, symbolName, moduleSymbol, /*preferCapitalized*/ false, program, host, preferences, cancellationToken);
-        const useRequire = shouldUseRequire(sourceFile, program);
-        const fix = getImportFixForSymbol(sourceFile, Debug.checkDefined(exportInfo), program, /*position*/ undefined, !!isValidTypeOnlyUseSite, useRequire, host, preferences);
-        if (fix) {
-            addImport({ fix, symbolName, errorIdentifierText: undefined });
+    function addImportFromSymbol(exportedSymbol: Symbol, isValidTypeOnlyUseSite?: boolean, targetFilePath?: string) {
+        if (!exportedSymbol.parent && targetFilePath) {
+            const fix = getImportFixForNonExportedSymbol(sourceFile, exportedSymbol, ImportKind.Named, program, !!isValidTypeOnlyUseSite, targetFilePath);
+            if (fix?.kind === ImportFixKind.AddToExisting) {
+                addImport({ fix, symbolName: exportedSymbol.name, errorIdentifierText: undefined });
+            }
+        }
+        else {
+            const moduleSymbol = Debug.checkDefined(exportedSymbol.parent);
+            const symbolName = getNameForExportedSymbol(exportedSymbol, getEmitScriptTarget(compilerOptions));
+            const checker = program.getTypeChecker();
+            const symbol = checker.getMergedSymbol(skipAlias(exportedSymbol, checker));
+            const exportInfo = getAllExportInfoForSymbol(sourceFile, symbol, symbolName, moduleSymbol, /*preferCapitalized*/ false, program, host, preferences, cancellationToken);
+            const useRequire = shouldUseRequire(sourceFile, program);
+            const fix = getImportFixForSymbol(sourceFile, Debug.checkDefined(exportInfo), program, /*position*/ undefined, !!isValidTypeOnlyUseSite, useRequire, host, preferences);
+            if (fix) {
+                addImport({ fix, symbolName, errorIdentifierText: undefined });
+            }
         }
     }
 
@@ -588,6 +604,14 @@ function getImportFixForSymbol(sourceFile: SourceFile, exportInfos: readonly Sym
     return getBestFix(getImportFixes(exportInfos, position, isValidTypeOnlyUseSite, useRequire, program, sourceFile, host, preferences).fixes, sourceFile, program, packageJsonImportFilter, host);
 }
 
+function getImportFixForNonExportedSymbol(sourceFile: SourceFile, symbol: Symbol, importKind: ImportKind, program: Program, isValidTypeOnlyUseSite: boolean, targetFilePath: string) {
+    const fix = getImportFixesForNonExportedSymbols(sourceFile, symbol, importKind, program, isValidTypeOnlyUseSite, targetFilePath);
+    if (fix.fixes[0] === undefined) return; // Not adding an import to an existing import
+    if (fix.fixes[0].kind === ImportFixKind.AddToExisting) {
+        return fix.fixes[0];
+    }
+}
+
 function codeFixActionToCodeAction({ description, changes, commands }: CodeFixAction): CodeAction {
     return { description, changes, commands };
 }
@@ -623,6 +647,30 @@ function getSingleExportInfoForSymbol(symbol: Symbol, symbolName: string, module
     }
 }
 
+function getImportFixesForNonExportedSymbols(
+    sourceFile: SourceFile,
+    symbol: Symbol,
+    importKind: ImportKind,
+    program: Program,
+    isValidTypeOnlyUseSite: boolean,
+    targetFilePath: string,
+    importMap = createExistingImportMap(program.getTypeChecker(), sourceFile, program.getCompilerOptions()),
+): { computedWithoutCacheCount: number; fixes: readonly ImportFixWithModuleSpecifier[]; } {
+    const checker = program.getTypeChecker();
+    const symbolInfo = [{
+        symbol,
+        targetFlags: SymbolFlags.Value,
+        importKind,
+        targetFilePath,
+    }];
+    const existingImports = flatMap(symbolInfo, importMap.getImportsForNonExportedSymbols);
+    const addToExisting = tryAddToExistingImport(existingImports, isValidTypeOnlyUseSite, checker, program.getCompilerOptions());
+    return {
+        computedWithoutCacheCount: 0,
+        fixes: [addToExisting!],
+    };
+}
+
 function getImportFixes(
     exportInfos: readonly SymbolExportInfo[],
     usagePosition: number | undefined,
@@ -823,6 +871,23 @@ function createExistingImportMap(checker: TypeChecker, importingFile: SourceFile
             const importKind = getImportKind(importingFile, exportKind, compilerOptions);
             return matchingDeclarations.map(declaration => ({ declaration, importKind, symbol, targetFlags }));
         },
+        getImportsForNonExportedSymbols: ({ symbol, importKind, targetFlags, targetFilePath }: SymbolInfo): readonly FixAddToExistingImportInfo[] => {
+            let fix: FixAddToExistingImportInfo[] = [];
+            const values = importMap?.values();
+            Debug.assertIsDefined(values);
+            for (const value of values) {
+                value.forEach(v => {
+                    if (v.kind === SyntaxKind.ImportDeclaration && cast(v.moduleSpecifier, isStringLiteral).text === targetFilePath) {
+                        fix = [{ declaration: v, importKind, targetFlags, symbol }];
+                        return fix;
+                    }
+                    else {
+                        return emptyArray;
+                    }
+                });
+            }
+            return fix;
+        },
     };
 }
 
@@ -1003,6 +1068,12 @@ function sortFixInfo(fixes: readonly (FixInfo & { fix: ImportFixWithModuleSpecif
         compareModuleSpecifiers(a.fix, b.fix, sourceFile, program, packageJsonImportFilter.allowsImportingSpecifier, _toPath));
 }
 
+function getFixInfosWithoutDiagnostic(context: CodeFixContextBase, symbolToken: Identifier, useAutoImportProvider: boolean): readonly FixInfo[] | undefined {
+    const info = getFixesInfoForNonUMDImport(context, symbolToken, useAutoImportProvider);
+    const packageJsonImportFilter = createPackageJsonImportFilter(context.sourceFile, context.preferences, context.host);
+    return info && sortFixInfo(info, context.sourceFile, context.program, packageJsonImportFilter, context.host);
+}
+
 function getBestFix(fixes: readonly ImportFixWithModuleSpecifier[], sourceFile: SourceFile, program: Program, packageJsonImportFilter: PackageJsonImportFilter, host: LanguageServiceHost): ImportFixWithModuleSpecifier | undefined {
     if (!some(fixes)) return;
     // These will always be placed first if available, and are better than other kinds

src/services/codefixes/inferFromUsage.ts

@@ -439,7 +439,7 @@ function tryReplaceImportTypeNodeWithAutoImport(
 ): boolean {
     const importableReference = tryGetAutoImportableReferenceFromTypeNode(typeNode, scriptTarget);
     if (importableReference && changes.tryInsertTypeAnnotation(sourceFile, declaration, importableReference.typeNode)) {
-        forEach(importableReference.symbols, s => importAdder.addImportFromExportedSymbol(s, /*isValidTypeOnlyUseSite*/ true));
+        forEach(importableReference.symbols, s => importAdder.addImportFromSymbol(s, /*isValidTypeOnlyUseSite*/ true));
         return true;
     }
     return false;

src/services/exportInfoMap.ts

@@ -90,6 +90,14 @@ export interface SymbolExportInfo {
     isFromPackageJson: boolean;
 }
 
+/** @internal */
+export interface SymbolInfo {
+    readonly symbol: Symbol;
+    importKind: ImportKind;
+    targetFlags: SymbolFlags;
+    targetFilePath: string;
+}
+
 interface CachedSymbolExportInfo {
     // Used to rehydrate `symbol` and `moduleSymbol` when transient
     id: number;