Add quickfix and refactoring to install @types packages

scripts/buildProtocol.ts

@@ -51,22 +51,25 @@ class DeclarationsWalker {
             return this.processType((<any>type).typeArguments[0]);
         }
         else {
-            for (const decl of s.getDeclarations()) {
-                const sourceFile = decl.getSourceFile();
-                if (sourceFile === this.protocolFile || path.basename(sourceFile.fileName) === "lib.d.ts") {
-                    return;
-                }
-                if (decl.kind === ts.SyntaxKind.EnumDeclaration && !isStringEnum(decl as ts.EnumDeclaration)) {
-                    this.removedTypes.push(type);
-                    return;
-                }
-                else {
-                    // splice declaration in final d.ts file
-                    let text = decl.getFullText();
-                    this.text += `${text}\n`;
-                    // recursively pull all dependencies into result dts file
+            const declarations = s.getDeclarations();
+            if (declarations) {
+                for (const decl of declarations) {
+                    const sourceFile = decl.getSourceFile();
+                    if (sourceFile === this.protocolFile || path.basename(sourceFile.fileName) === "lib.d.ts") {
+                        return;
+                    }
+                    if (decl.kind === ts.SyntaxKind.EnumDeclaration && !isStringEnum(decl as ts.EnumDeclaration)) {
+                        this.removedTypes.push(type);
+                        return;
+                    }
+                    else {
+                        // splice declaration in final d.ts file
+                        let text = decl.getFullText();
+                        this.text += `${text}\n`;
+                        // recursively pull all dependencies into result dts file
 
-                    this.visitTypeNodes(decl);
+                        this.visitTypeNodes(decl);
+                    }
                 }
             }
         }

src/compiler/builder.ts

@@ -1,23 +1,6 @@
 /// <reference path="program.ts" />
 
 namespace ts {
-    export interface EmitOutput {
-        outputFiles: OutputFile[];
-        emitSkipped: boolean;
-    }
-
-    export interface EmitOutputDetailed extends EmitOutput {
-        diagnostics: Diagnostic[];
-        sourceMaps: SourceMapData[];
-        emittedSourceFiles: SourceFile[];
-    }
-
-    export interface OutputFile {
-        name: string;
-        writeByteOrderMark: boolean;
-        text: string;
-    }
-
     export function getFileEmitOutput(program: Program, sourceFile: SourceFile, emitOnlyDtsFiles: boolean, isDetailed: boolean,
         cancellationToken?: CancellationToken, customTransformers?: CustomTransformers): EmitOutput | EmitOutputDetailed {
         const outputFiles: OutputFile[] = [];

src/compiler/core.ts

@@ -1829,7 +1829,9 @@ namespace ts {
         return i < 0 ? path : path.substring(i + 1);
     }
 
-    export function combinePaths(path1: string, path2: string) {
+    export function combinePaths(path1: Path, path2: string): Path;
+    export function combinePaths(path1: string, path2: string): string;
+    export function combinePaths(path1: string, path2: string): string {
         if (!(path1 && path1.length)) return path2;
         if (!(path2 && path2.length)) return path1;
         if (getRootLength(path2) !== 0) return path2;

src/compiler/moduleNameResolver.ts

@@ -124,7 +124,11 @@ namespace ts {
         }
     }
 
-    export function getEffectiveTypeRoots(options: CompilerOptions, host: { directoryExists?: (directoryName: string) => boolean, getCurrentDirectory?: () => string }): string[] | undefined {
+    export interface GetEffectiveTypeRootsHost {
+        directoryExists?: (directoryName: string) => boolean;
+        getCurrentDirectory?: () => string;
+    }
+    export function getEffectiveTypeRoots(options: CompilerOptions, host: GetEffectiveTypeRootsHost): string[] | undefined {
         if (options.typeRoots) {
             return options.typeRoots;
         }
@@ -985,7 +989,8 @@ namespace ts {
         return withPackageId(packageId, pathAndExtension);
     }
 
-    function getPackageName(moduleName: string): { packageName: string, rest: string } {
+    /* @internal */
+    export function getPackageName(moduleName: string): { packageName: string, rest: string } {
         let idx = moduleName.indexOf(directorySeparator);
         if (moduleName[0] === "@") {
             idx = moduleName.indexOf(directorySeparator, idx + 1);
@@ -1153,4 +1158,67 @@ namespace ts {
     function toSearchResult<T>(value: T | undefined): SearchResult<T> {
         return value !== undefined ? { value } : undefined;
     }
+
+
+
+    export const enum PackageNameValidationResult {
+        Ok,
+        ScopedPackagesNotSupported,
+        EmptyName,
+        NameTooLong,
+        NameStartsWithDot,
+        NameStartsWithUnderscore,
+        NameContainsNonURISafeCharacters
+    }
+
+    const MaxPackageNameLength = 214;
+
+    /**
+     * Validates package name using rules defined at https://docs.npmjs.com/files/package.json
+     */
+    export function validatePackageName(packageName: string): PackageNameValidationResult {
+        if (!packageName) {
+            return PackageNameValidationResult.EmptyName;
+        }
+        if (packageName.length > MaxPackageNameLength) {
+            return PackageNameValidationResult.NameTooLong;
+        }
+        if (packageName.charCodeAt(0) === CharacterCodes.dot) {
+            return PackageNameValidationResult.NameStartsWithDot;
+        }
+        if (packageName.charCodeAt(0) === CharacterCodes._) {
+            return PackageNameValidationResult.NameStartsWithUnderscore;
+        }
+        // check if name is scope package like: starts with @ and has one '/' in the middle
+        // scoped packages are not currently supported
+        // TODO: when support will be added we'll need to split and check both scope and package name
+        if (/^@[^/]+\/[^/]+$/.test(packageName)) {
+            return PackageNameValidationResult.ScopedPackagesNotSupported;
+        }
+        if (encodeURIComponent(packageName) !== packageName) {
+            return PackageNameValidationResult.NameContainsNonURISafeCharacters;
+        }
+        return PackageNameValidationResult.Ok;
+    }
+
+    export function renderPackageNameValidationFailure(result: PackageNameValidationResult, typing: string): string {
+        switch (result) {
+            case PackageNameValidationResult.EmptyName:
+                return `Package name '${typing}' cannot be empty`;
+            case PackageNameValidationResult.NameTooLong:
+                return `Package name '${typing}' should be less than ${MaxPackageNameLength} characters`;
+            case PackageNameValidationResult.NameStartsWithDot:
+                return `Package name '${typing}' cannot start with '.'`;
+            case PackageNameValidationResult.NameStartsWithUnderscore:
+                return `Package name '${typing}' cannot start with '_'`;
+            case PackageNameValidationResult.ScopedPackagesNotSupported:
+                return `Package '${typing}' is scoped and currently is not supported`;
+            case PackageNameValidationResult.NameContainsNonURISafeCharacters:
+                return `Package name '${typing}' contains non URI safe characters`;
+            case PackageNameValidationResult.Ok:
+                throw Debug.fail(); // Shouldn't have called this.
+            default:
+                Debug.assertNever(result);
+        }
+    }
 }

src/compiler/types.ts

@@ -1,4 +1,21 @@
 namespace ts {
+    export interface EmitOutput {
+        outputFiles: OutputFile[];
+        emitSkipped: boolean;
+    }
+
+    export interface EmitOutputDetailed extends EmitOutput {
+        diagnostics: Diagnostic[];
+        sourceMaps: SourceMapData[];
+        emittedSourceFiles: SourceFile[];
+    }
+
+    export interface OutputFile {
+        name: string;
+        writeByteOrderMark: boolean;
+        text: string;
+    }
+
     /**
      * Type of objects whose values are all of the same type.
      * The `in` and `for-in` operators can *not* be safely used,

src/harness/fourslash.ts

@@ -953,6 +953,10 @@ namespace FourSlash {
             return this.getChecker().getSymbolsInScope(node, ts.SymbolFlags.Value | ts.SymbolFlags.Type | ts.SymbolFlags.Namespace);
         }
 
+        public setTypesRegistry(map: ts.MapLike<void>): void {
+            this.languageServiceAdapterHost.typesRegistry = ts.createMapFromTemplate(map);
+        }
+
         public verifyTypeOfSymbolAtLocation(range: Range, symbol: ts.Symbol, expected: string): void {
             const node = this.goToAndGetNode(range);
             const checker = this.getChecker();
@@ -2750,16 +2754,26 @@ Actual: ${stringify(fullActual)}`);
             }
         }
 
-        public verifyCodeFixAvailable(negative: boolean) {
-            const codeFix = this.getCodeFixActions(this.activeFile.fileName);
+        public verifyCodeFixAvailable(negative: boolean, info: FourSlashInterface.VerifyCodeFixAvailableOptions[] | undefined) {
+            const codeFixes = this.getCodeFixActions(this.activeFile.fileName);
 
-            if (negative && codeFix.length) {
-                this.raiseError(`verifyCodeFixAvailable failed - expected no fixes but found one.`);
+            if (negative) {
+                if (codeFixes.length) {
+                    this.raiseError(`verifyCodeFixAvailable failed - expected no fixes but found one.`);
+                }
+                return;
             }
 
-            if (!(negative || codeFix.length)) {
+            if (!codeFixes.length) {
                 this.raiseError(`verifyCodeFixAvailable failed - expected code fixes but none found.`);
             }
+            if (info) {
+                assert.equal(info.length, codeFixes.length);
+                ts.zipWith(codeFixes, info, (fix, info) => {
+                    assert.equal(fix.description, info.description);
+                    this.assertObjectsEqual(fix.commands, info.commands);
+                });
+            }
         }
 
         public verifyApplicableRefactorAvailableAtMarker(negative: boolean, markerName: string) {
@@ -2803,6 +2817,14 @@ Actual: ${stringify(fullActual)}`);
             }
         }
 
+        public verifyRefactor({ name, actionName, refactors }: FourSlashInterface.VerifyRefactorOptions) {
+            const selection = this.getSelection();
+
+            const actualRefactors = (this.languageService.getApplicableRefactors(this.activeFile.fileName, selection) || ts.emptyArray)
+                .filter(r => r.name === name && r.actions.some(a => a.name === actionName));
+            this.assertObjectsEqual(actualRefactors, refactors);
+        }
+
         public verifyApplicableRefactorAvailableForRange(negative: boolean) {
             const ranges = this.getRanges();
             if (!(ranges && ranges.length === 1)) {
@@ -3577,6 +3599,10 @@ namespace FourSlashInterface {
         public symbolsInScope(range: FourSlash.Range): ts.Symbol[] {
             return this.state.symbolsInScope(range);
         }
+
+        public setTypesRegistry(map: ts.MapLike<void>): void {
+            this.state.setTypesRegistry(map);
+        }
     }
 
     export class GoTo {
@@ -3752,8 +3778,8 @@ namespace FourSlashInterface {
             this.state.verifyCodeFix(options);
         }
 
-        public codeFixAvailable() {
-            this.state.verifyCodeFixAvailable(this.negative);
+        public codeFixAvailable(options?: VerifyCodeFixAvailableOptions[]) {
+            this.state.verifyCodeFixAvailable(this.negative, options);
         }
 
         public applicableRefactorAvailableAtMarker(markerName: string) {
@@ -3764,6 +3790,10 @@ namespace FourSlashInterface {
             this.state.verifyApplicableRefactorAvailableForRange(this.negative);
         }
 
+        public refactor(options: VerifyRefactorOptions) {
+            this.state.verifyRefactor(options);
+        }
+
         public refactorAvailable(name: string, actionName?: string) {
             this.state.verifyRefactorAvailable(this.negative, name, actionName);
         }
@@ -4404,4 +4434,15 @@ namespace FourSlashInterface {
         errorCode?: number;
         index?: number;
     }
+
+    export interface VerifyCodeFixAvailableOptions {
+        description: string;
+        commands?: ts.CodeActionCommand[];
+    }
+
+    export interface VerifyRefactorOptions {
+        name: string;
+        actionName: string;
+        refactors: ts.ApplicableRefactorInfo[];
+    }
 }

src/harness/harnessLanguageService.ts

@@ -123,6 +123,7 @@ namespace Harness.LanguageService {
     }
 
     export class LanguageServiceAdapterHost {
+        public typesRegistry: ts.Map<void> | undefined;
         protected virtualFileSystem: Utils.VirtualFileSystem = new Utils.VirtualFileSystem(virtualFileSystemRoot, /*useCaseSensitiveFilenames*/false);
 
         constructor(protected cancellationToken = DefaultHostCancellationToken.Instance,
@@ -182,6 +183,14 @@ namespace Harness.LanguageService {
 
     /// Native adapter
     class NativeLanguageServiceHost extends LanguageServiceAdapterHost implements ts.LanguageServiceHost {
+        tryGetRegistry(): ts.Map<void> | undefined {
+            if (this.typesRegistry === undefined) {
+                ts.Debug.fail("fourslash test should set types registry.");
+            }
+            return this.typesRegistry;
+        }
+        installPackage = ts.notImplemented;
+
         getCompilationSettings() { return this.settings; }
         getCancellationToken() { return this.cancellationToken; }
         getDirectories(path: string): string[] {
@@ -493,6 +502,7 @@ namespace Harness.LanguageService {
         getCodeFixesAtPosition(): ts.CodeAction[] {
             throw new Error("Not supported on the shim.");
         }
+        applyCodeActionCommand = ts.notImplemented;
         getCodeFixDiagnostics(): ts.Diagnostic[] {
             throw new Error("Not supported on the shim.");
         }

src/harness/unittests/compileOnSave.ts

@@ -12,7 +12,7 @@ namespace ts.projectSystem {
 
     describe("CompileOnSave affected list", () => {
         function sendAffectedFileRequestAndCheckResult(session: server.Session, request: server.protocol.Request, expectedFileList: { projectFileName: string, files: FileOrFolder[] }[]) {
-            const response: server.protocol.CompileOnSaveAffectedFileListSingleProject[] = session.executeCommand(request).response;
+            const response = session.executeCommand(request).response as server.protocol.CompileOnSaveAffectedFileListSingleProject[];
             const actualResult = response.sort((list1, list2) => compareStrings(list1.projectFileName, list2.projectFileName));
             expectedFileList = expectedFileList.sort((list1, list2) => compareStrings(list1.projectFileName, list2.projectFileName));
 

src/harness/unittests/extractTestHelpers.ts

@@ -97,6 +97,14 @@ namespace ts {
         return rulesProvider;
     }
 
+    const notImplementedHost: LanguageServiceHost = {
+        getCompilationSettings: notImplemented,
+        getScriptFileNames: notImplemented,
+        getScriptVersion: notImplemented,
+        getScriptSnapshot: notImplemented,
+        getDefaultLibFileName: notImplemented,
+    };
+
     export function testExtractSymbol(caption: string, text: string, baselineFolder: string, description: DiagnosticMessage) {
         const t = extractTest(text);
         const selectionRange = t.ranges.get("selection");
@@ -125,6 +133,7 @@ namespace ts {
                 file: sourceFile,
                 startPosition: selectionRange.start,
                 endPosition: selectionRange.end,
+                host: notImplementedHost,
                 rulesProvider: getRuleProvider()
             };
             const rangeToExtract = refactor.extractSymbol.getRangeToExtract(sourceFile, createTextSpanFromBounds(selectionRange.start, selectionRange.end));
@@ -188,6 +197,7 @@ namespace ts {
                 file: sourceFile,
                 startPosition: selectionRange.start,
                 endPosition: selectionRange.end,
+                host: notImplementedHost,
                 rulesProvider: getRuleProvider()
             };
             const rangeToExtract = refactor.extractSymbol.getRangeToExtract(sourceFile, createTextSpanFromBounds(selectionRange.start, selectionRange.end));

src/harness/unittests/languageService.ts

@@ -21,6 +21,8 @@ export function Component(x: Config): any;`
         //  to write an alias to a module's default export was referrenced across files and had no default export
         it("should be able to create a language service which can respond to deinition requests without throwing", () => {
             const languageService = ts.createLanguageService({
+                tryGetTypesRegistry: notImplemented,
+                installPackage: notImplemented,
                 getCompilationSettings() {
                     return {};
                 },