Implementing copy/paste

src/harness/client.ts

@@ -1,5 +1,6 @@
 import {
     ApplicableRefactorInfo,
+    arrayFrom,
     CallHierarchyIncomingCall,
     CallHierarchyItem,
     CallHierarchyOutgoingCall,
@@ -13,6 +14,7 @@ import {
     computeLineAndCharacterOfPosition,
     computeLineStarts,
     computePositionOfLineAndCharacter,
+    CopyRange,
     createQueue,
     createTextSpanFromBounds,
     Debug,
@@ -50,6 +52,7 @@ import {
     OrganizeImportsArgs,
     OutliningSpan,
     PatternMatchKind,
+    PostPasteImportFixes,
     Program,
     QuickInfo,
     RefactorEditInfo,
@@ -1009,6 +1012,22 @@ export class SessionClient implements LanguageService {
         return getSupportedCodeFixes();
     }
 
+    getPostPasteImportFixes(targetFile: string, pastes: Array<{text: string; range: TextRange}>, _preferences: UserPreferences, _formatOptions: FormatCodeSettings, originalFile?: string, copyRange?: CopyRange): PostPasteImportFixes{    
+        const args = this.createFileLocationOrRangeRequestArgs(pastes[0].range, targetFile) as protocol.GetPostPasteImportFixesRequestArgs;
+        args.targetFile = targetFile;
+        args.pastes = arrayFrom(pastes.map(paste => ({text: paste.text, range: this.createFileRangeRequestArgs(targetFile, paste.range.pos, paste.range.end)})));
+        args.originalFile = originalFile;
+        args.copyRange = copyRange;
+
+        const request = this.processRequest<protocol.GetPostPasteImportFixesRequest>(protocol.CommandTypes.GetPostPasteImportFixes, args);
+        const response = this.processResponse<protocol.GetPostPasteImportFixesResponse>(request);
+        if (!response.body) {
+            return { edits: []};
+        }
+        const edits: FileTextChanges[] = this.convertCodeEditsToTextChanges(response.body.edits);
+        return { edits: edits };
+    }
+
     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 verifyPostPasteImportFixes(options: FourSlashInterface.PostPasteImportFixOptions): void{
+        const editInfo =  this.languageService.getPostPasteImportFixes(this.activeFile.fileName, options.pastes, options.preferences, this.formatCodeSettings, options.originalFile, options.copyRange);
+        this.verifyNewContent({ newFileContent: options.newFileContents }, editInfo.edits);
+    }
+
     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 postPasteImportFix(options: PostPasteImportFixOptions): void {
+        this.state.verifyPostPasteImportFixes(options);
+    }
 }
 
 export class Edit {
@@ -1879,6 +1883,14 @@ export interface VerifyCodeFixAllOptions {
     preferences?: ts.UserPreferences;
 }
 
+export interface verifyPostPasteImportFix {
+    targetFile: string;
+    pastes: Array<{text: string; range: ts.TextRange}>;
+    preferences: ts.UserPreferences;
+    originalFile?: string;
+    copyRange?: ts.CopyRange
+}
+
 export interface VerifyRefactorOptions {
     name: string;
     actionName: string;
@@ -1919,6 +1931,14 @@ export interface MoveToFileOptions {
     readonly preferences?: ts.UserPreferences;
 }
 
+export interface PostPasteImportFixOptions {
+    readonly newFileContents: { readonly [fileName: string]: string; };
+    readonly pastes: Array<{text: string; range: ts.TextRange}>,//{ pos, end }: ts.TextRange
+    readonly preferences: ts.UserPreferences,
+    readonly originalFile?: string,
+    readonly copyRange?: ts.CopyRange
+}
+
 export type RenameLocationsOptions = readonly RenameLocationOptions[] | {
     readonly findInStrings?: boolean;
     readonly findInComments?: boolean;

src/server/project.ts

@@ -1,3 +1,6 @@
+import { info } from "console";
+import { FormatContext } from "../services/_namespaces/ts.formatting";
+import { FixInfo, ImportFixWithModuleSpecifier, sortFixInfo } from "../services/codefixes/importFixes";
 import * as ts from "./_namespaces/ts";
 import {
     addRange,
@@ -20,6 +23,7 @@ import {
     containsPath,
     createCacheableExportInfoMap,
     createLanguageService,
+    createPackageJsonImportFilter,
     createResolutionCache,
     createSymlinkCache,
     Debug,
@@ -65,6 +69,7 @@ import {
     HasInvalidatedLibResolutions,
     HasInvalidatedResolutions,
     HostCancellationToken,
+    ImportClause,
     inferredTypesContainingFile,
     InstallPackageOptions,
     IScriptSnapshot,
@@ -120,6 +125,7 @@ import {
     StringLiteralLike,
     stripQuotes,
     StructureIsReused,
+    SymbolExportInfo,
     SymlinkCache,
     ThrottledCancellationToken,
     timestamp,
@@ -2212,6 +2218,20 @@ export abstract class Project implements LanguageServiceHost, ModuleResolutionHo
         return this.noDtsResolutionProject;
     }
 
+    /** @internal */
+    updateTargetFile(rootFile: string, targetFileText: string, pastedText: string): {updatedFile: SourceFile | undefined, updatedProgram: Program | undefined, originalProgram: ts.Program | undefined} {
+        const originalProgram = this.program;
+        this.getScriptInfo(rootFile)?.editContent(0, targetFileText.length-1, pastedText);
+        this.updateGraph();
+        return { updatedFile: (this.program?.getSourceFile(rootFile)), updatedProgram: this.program, originalProgram };
+    }
+
+    /** @internal */
+    revertUpdatedFile(rootFile: string, updatedText: string, originalText: string) {
+        this.getScriptInfo(rootFile)?.editContent(0, updatedText.length-1, originalText);
+        this.updateGraph();
+    }
+
     /** @internal */
     private getCompilerOptionsForNoDtsResolutionProject() {
         return {

src/server/protocol.ts

@@ -144,6 +144,7 @@ export const enum CommandTypes {
     GetApplicableRefactors = "getApplicableRefactors",
     GetEditsForRefactor = "getEditsForRefactor",
     GetMoveToRefactoringFileSuggestions = "getMoveToRefactoringFileSuggestions",
+    GetPostPasteImportFixes = "getPostPasteImportFixes",
     /** @internal */
     GetEditsForRefactorFull = "getEditsForRefactor-full",
 
@@ -630,6 +631,32 @@ export interface GetMoveToRefactoringFileSuggestions extends Response {
     };
 }
 
+/**
+ * Request refactorings at a given position post pasting text from some other location.
+ */
+
+export interface GetPostPasteImportFixesRequest extends Request {
+    command: CommandTypes.GetPostPasteImportFixes;
+    arguments: GetPostPasteImportFixesRequestArgs;
+}
+export type DocumentRange = FileRangeRequestArgs;
+export type CopyRange  = {
+    start: Location;
+    end: Location;
+}
+export type GetPostPasteImportFixesRequestArgs = FileLocationOrRangeRequestArgs & {
+    targetFile: string, 
+    pastes: Array<{text: string; range: DocumentRange}>,
+    originalFile?: string,
+    copyRange?: CopyRange
+}
+export interface GetPostPasteImportFixesResponse extends Response {
+    body: PostPasteImportAction;
+}
+export interface PostPasteImportAction {
+    edits: FileCodeEdits[];
+}
+
 /**
  * A set of one or more available refactoring actions, grouped under a parent refactoring.
  */

src/server/session.ts

@@ -106,6 +106,7 @@ import {
     perfLogger,
     PerformanceEvent,
     PossibleProgramFileInfo,
+    PostPasteImportFixes,
     Program,
     QuickInfo,
     RefactorEditInfo,
@@ -2796,6 +2797,16 @@ export class Session<TMessage = string> implements EventSender {
         return project.getLanguageService().getMoveToRefactoringFileSuggestions(file, this.extractPositionOrRange(args, scriptInfo), this.getPreferences(file));
     }
 
+    private getPostPasteImportFixes(args: protocol.GetPostPasteImportFixesRequestArgs): protocol.PostPasteImportAction | undefined {
+        const { file, project } = this.getFileAndProject(args);
+        const result = project.getLanguageService().getPostPasteImportFixes(args.targetFile, arrayFrom(args.pastes).map(paste => ({text: paste.text, range: this.getRange(paste.range, project.getScriptInfoForNormalizedPath(file)!)})), this.getPreferences(file), this.getFormatOptions(file), args.originalFile, args.copyRange);
+        if (result === undefined) {
+            return undefined;
+        }
+        const allResults = this.mapPostPasteAction(result);
+        return allResults;
+    }
+
     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 +2939,10 @@ export class Session<TMessage = string> implements EventSender {
         return { fixName, description, changes: this.mapTextChangesToCodeEdits(changes), commands, fixId, fixAllDescription };
     }
 
+    private mapPostPasteAction({ edits }: PostPasteImportFixes): protocol.PostPasteImportAction {
+        return { edits: this.mapTextChangesToCodeEdits(edits)};
+    }
+
     private mapTextChangesToCodeEdits(textChanges: readonly FileTextChanges[]): protocol.FileCodeEdits[] {
         return textChanges.map(change => this.mapTextChangeToCodeEdit(change));
     }
@@ -3521,6 +3536,9 @@ export class Session<TMessage = string> implements EventSender {
         [protocol.CommandTypes.GetMoveToRefactoringFileSuggestions]: (request: protocol.GetMoveToRefactoringFileSuggestionsRequest) => {
             return this.requiredResponse(this.getMoveToRefactoringFileSuggestions(request.arguments));
         },
+        [protocol.CommandTypes.GetPostPasteImportFixes]: (request: protocol.GetPostPasteImportFixesRequest) => {
+            return this.requiredResponse(this.getPostPasteImportFixes(request.arguments));
+        },
         [protocol.CommandTypes.GetEditsForRefactorFull]: (request: protocol.GetEditsForRefactorRequest) => {
             return this.requiredResponse(this.getEditsForRefactor(request.arguments, /*simplifiedResult*/ false));
         },

src/services/_namespaces/ts.postPasteImportFixes.ts

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

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 postPasteImportFixes from "./ts.postPasteImportFixes";
+export { postPasteImportFixes };

src/services/codefixes/importFixes.ts

@@ -212,6 +212,7 @@ export interface ImportAdder {
     addImportFromDiagnostic: (diagnostic: DiagnosticWithLocation, context: CodeFixContextBase) => void;
     addImportFromExportedSymbol: (exportedSymbol: Symbol, isValidTypeOnlyUseSite?: boolean) => void;
     writeFixes: (changeTracker: textChanges.ChangeTracker, oldFileQuotePreference?: QuotePreference) => void;
+    addImportsForUnknownSymbols: (context: CodeFixContextBase, symbolToken: Identifier, useAutoImportProvider: boolean) => void;
 }
 
 /** @internal */
@@ -236,8 +237,14 @@ 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, addImportFromExportedSymbol, writeFixes, hasFixes, addImportsForUnknownSymbols };
 
+    function addImportsForUnknownSymbols(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;
@@ -474,7 +481,7 @@ const enum AddAsTypeOnly {
     NotAllowed = 1 << 2,
 }
 type ImportFix = FixUseNamespaceImport | FixAddJsdocTypeImport | FixAddToExistingImport | FixAddNewImport | FixPromoteTypeOnlyImport;
-type ImportFixWithModuleSpecifier = FixUseNamespaceImport | FixAddJsdocTypeImport | FixAddToExistingImport | FixAddNewImport;
+export type ImportFixWithModuleSpecifier = FixUseNamespaceImport | FixAddJsdocTypeImport | FixAddToExistingImport | FixAddNewImport;
 
 // Properties are be undefined if fix is derived from an existing import
 interface ImportFixBase {
@@ -626,7 +633,7 @@ function getSingleExportInfoForSymbol(symbol: Symbol, symbolName: string, module
     }
 }
 
-function getImportFixes(
+export function getImportFixes(
     exportInfos: readonly SymbolExportInfo[],
     usagePosition: number | undefined,
     isValidTypeOnlyUseSite: boolean,
@@ -833,7 +840,7 @@ function createExistingImportMap(checker: TypeChecker, importingFile: SourceFile
     };
 }
 
-function shouldUseRequire(sourceFile: SourceFile, program: Program): boolean {
+export function shouldUseRequire(sourceFile: SourceFile, program: Program): boolean {
     // 1. TypeScript files don't use require variable declarations
     if (!isSourceFileJS(sourceFile)) {
         return false;
@@ -974,7 +981,7 @@ function newImportInfoFromExistingSpecifier(
     }
 }
 
-interface FixInfo {
+export interface FixInfo {
     readonly fix: ImportFix;
     readonly symbolName: string;
     readonly errorIdentifierText: string | undefined;
@@ -1002,14 +1009,20 @@ function getFixInfos(context: CodeFixContextBase, errorCode: number, pos: number
     return info && sortFixInfo(info, context.sourceFile, context.program, packageJsonImportFilter, context.host);
 }
 
-function sortFixInfo(fixes: readonly (FixInfo & { fix: ImportFixWithModuleSpecifier; })[], sourceFile: SourceFile, program: Program, packageJsonImportFilter: PackageJsonImportFilter, host: LanguageServiceHost): readonly (FixInfo & { fix: ImportFixWithModuleSpecifier; })[] {
+export function sortFixInfo(fixes: readonly (FixInfo & { fix: ImportFixWithModuleSpecifier; })[], sourceFile: SourceFile, program: Program, packageJsonImportFilter: PackageJsonImportFilter, host: LanguageServiceHost): readonly (FixInfo & { fix: ImportFixWithModuleSpecifier; })[] {
     const _toPath = (fileName: string) => toPath(fileName, host.getCurrentDirectory(), hostGetCanonicalFileName(host));
     return sort(fixes, (a, b) =>
         compareBooleans(!!a.isJsxNamespaceFix, !!b.isJsxNamespaceFix) ||
         compareValues(a.fix.kind, b.fix.kind) ||
         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