Merge branch 'master' into map4

src/server/client.ts

@@ -424,33 +424,39 @@ namespace ts.server {
         }
 
         getSyntacticDiagnostics(fileName: string): Diagnostic[] {
-            const args: protocol.SyntacticDiagnosticsSyncRequestArgs = { file: fileName };
+            const args: protocol.SyntacticDiagnosticsSyncRequestArgs = { file: fileName,  includeLinePosition: true };
 
             const request = this.processRequest<protocol.SyntacticDiagnosticsSyncRequest>(CommandNames.SyntacticDiagnosticsSync, args);
             const response = this.processResponse<protocol.SyntacticDiagnosticsSyncResponse>(request);
 
-            return (<protocol.Diagnostic[]>response.body).map(entry => this.convertDiagnostic(entry, fileName));
+            return (<protocol.DiagnosticWithLinePosition[]>response.body).map(entry => this.convertDiagnostic(entry, fileName));
         }
 
         getSemanticDiagnostics(fileName: string): Diagnostic[] {
-            const args: protocol.SemanticDiagnosticsSyncRequestArgs = { file: fileName };
+            const args: protocol.SemanticDiagnosticsSyncRequestArgs = { file: fileName, includeLinePosition: true };
 
             const request = this.processRequest<protocol.SemanticDiagnosticsSyncRequest>(CommandNames.SemanticDiagnosticsSync, args);
             const response = this.processResponse<protocol.SemanticDiagnosticsSyncResponse>(request);
 
-            return (<protocol.Diagnostic[]>response.body).map(entry => this.convertDiagnostic(entry, fileName));
+            return (<protocol.DiagnosticWithLinePosition[]>response.body).map(entry => this.convertDiagnostic(entry, fileName));
         }
 
-        convertDiagnostic(entry: protocol.Diagnostic, fileName: string): Diagnostic {
-            const start = this.lineOffsetToPosition(fileName, entry.start);
-            const end = this.lineOffsetToPosition(fileName, entry.end);
+        convertDiagnostic(entry: protocol.DiagnosticWithLinePosition, fileName: string): Diagnostic {
+            let category: DiagnosticCategory;
+            for (const id in DiagnosticCategory) {
+                if (typeof id === "string" && entry.category === id.toLowerCase()) {
+                    category = (<any>DiagnosticCategory)[id];
+                }
+            }
+
+            Debug.assert(category !== undefined, "convertDiagnostic: category should not be undefined");
 
             return {
                 file: undefined,
-                start: start,
-                length: end - start,
-                messageText: entry.text,
-                category: undefined,
+                start: entry.start,
+                length: entry.length,
+                messageText: entry.message,
+                category: category,
                 code: entry.code
             };
         }

src/server/editorServices.ts

@@ -17,6 +17,68 @@ namespace ts.server {
         (event: ProjectServiceEvent): void;
     }
 
+    function prepareConvertersForEnumLikeCompilerOptions(commandLineOptions: CommandLineOption[]): Map<string, Map<string, number>> {
+        const map = new StringMap<Map<string, number>>();
+        for (const option of commandLineOptions) {
+            if (typeof option.type === "object") {
+                const optionMap = <Map<string, number>>option.type;
+                // verify that map contains only numbers
+                optionMap.forEach(value => {
+                    Debug.assert(typeof value  === "number");
+                });
+                map.set(option.name, optionMap);
+            }
+        }
+        return map;
+    }
+
+    const compilerOptionConverters = prepareConvertersForEnumLikeCompilerOptions(optionDeclarations);
+    const indentStyle = mapOfMapLike({
+        "none": IndentStyle.None,
+        "block": IndentStyle.Block,
+        "smart": IndentStyle.Smart
+    });
+
+    export function convertFormatOptions(protocolOptions: protocol.FormatCodeSettings): FormatCodeSettings {
+        if (typeof protocolOptions.indentStyle === "string") {
+            protocolOptions.indentStyle = indentStyle.get(protocolOptions.indentStyle.toLowerCase());
+            Debug.assert(protocolOptions.indentStyle !== undefined);
+        }
+        return <any>protocolOptions;
+    }
+
+    export function convertCompilerOptions(protocolOptions: protocol.ExternalProjectCompilerOptions): CompilerOptions & protocol.CompileOnSaveMixin {
+        compilerOptionConverters.forEach((mappedValues, id) => {
+            const propertyValue = protocolOptions[id];
+            if (typeof propertyValue === "string") {
+                const mappedValues = compilerOptionConverters.get(id);
+                protocolOptions[id] = mappedValues.get(propertyValue.toLowerCase());
+            }
+        });
+        return <any>protocolOptions;
+    }
+
+    export function tryConvertScriptKindName(scriptKindName: protocol.ScriptKindName | ScriptKind): ScriptKind {
+        return typeof scriptKindName === "string"
+            ? convertScriptKindName(scriptKindName)
+            : scriptKindName;
+    }
+
+    export function convertScriptKindName(scriptKindName: protocol.ScriptKindName) {
+        switch (scriptKindName) {
+            case "JS":
+                return ScriptKind.JS;
+            case "JSX":
+                return ScriptKind.JSX;
+            case "TS":
+                return ScriptKind.TS;
+            case "TSX":
+                return ScriptKind.TSX;
+            default:
+                return ScriptKind.Unknown;
+        }
+    }
+
     /**
      * This helper function processes a list of projects and return the concatenated, sortd and deduplicated output of processing each project.
      */
@@ -63,7 +125,7 @@ namespace ts.server {
 
     const externalFilePropertyReader: FilePropertyReader<protocol.ExternalFile> = {
         getFileName: x => x.fileName,
-        getScriptKind: x => x.scriptKind,
+        getScriptKind: x => tryConvertScriptKindName(x.scriptKind),
         hasMixedContent: x => x.hasMixedContent
     };
 
@@ -215,6 +277,10 @@ namespace ts.server {
             this.ensureInferredProjectsUpToDate();
         }
 
+        getCompilerOptionsForInferredProjects() {
+            return this.compilerOptionsForInferredProjects;
+        }
+
         updateTypingsForProject(response: SetTypings | InvalidateCachedTypings): void {
             const project = this.findProject(response.projectName);
             if (!project) {
@@ -232,10 +298,10 @@ namespace ts.server {
         }
 
         setCompilerOptionsForInferredProjects(projectCompilerOptions: protocol.ExternalProjectCompilerOptions): void {
-            this.compilerOptionsForInferredProjects = projectCompilerOptions;
+            this.compilerOptionsForInferredProjects = convertCompilerOptions(projectCompilerOptions);
             this.compileOnSaveForInferredProjects = projectCompilerOptions.compileOnSave;
             for (const proj of this.inferredProjects) {
-                proj.setCompilerOptions(projectCompilerOptions);
+                proj.setCompilerOptions(this.compilerOptionsForInferredProjects);
                 proj.compileOnSaveEnabled = projectCompilerOptions.compileOnSave;
             }
             this.updateProjectGraphs(this.inferredProjects);
@@ -745,12 +811,13 @@ namespace ts.server {
         }
 
         private createAndAddExternalProject(projectFileName: string, files: protocol.ExternalFile[], options: protocol.ExternalProjectCompilerOptions, typingOptions: TypingOptions) {
+            const compilerOptions = convertCompilerOptions(options);
             const project = new ExternalProject(
                 projectFileName,
                 this,
                 this.documentRegistry,
-                options,
-                /*languageServiceEnabled*/ !this.exceededTotalSizeLimitForNonTsFiles(options, files, externalFilePropertyReader),
+                compilerOptions,
+                /*languageServiceEnabled*/ !this.exceededTotalSizeLimitForNonTsFiles(compilerOptions, files, externalFilePropertyReader),
                 options.compileOnSave === undefined ? true : options.compileOnSave);
 
             this.addFilesToProjectAndUpdateGraph(project, files, externalFilePropertyReader, /*clientFileName*/ undefined, typingOptions, /*configFileErrors*/ undefined);
@@ -1019,7 +1086,7 @@ namespace ts.server {
             if (args.file) {
                 const info = this.getScriptInfoForNormalizedPath(toNormalizedPath(args.file));
                 if (info) {
-                    info.setFormatOptions(args.formatOptions);
+                    info.setFormatOptions(convertFormatOptions(args.formatOptions));
                     this.logger.info(`Host configuration update for file ${args.file}`);
                 }
             }
@@ -1029,7 +1096,7 @@ namespace ts.server {
                     this.logger.info(`Host information ${args.hostInfo}`);
                 }
                 if (args.formatOptions) {
-                    mergeMapLikes(this.hostConfiguration.formatCodeOptions, args.formatOptions);
+                    mergeMapLikes(this.hostConfiguration.formatCodeOptions, convertFormatOptions(args.formatOptions));
                     this.logger.info("Format host information updated");
                 }
             }
@@ -1143,7 +1210,7 @@ namespace ts.server {
                     const scriptInfo = this.getScriptInfo(file.fileName);
                     Debug.assert(!scriptInfo || !scriptInfo.isOpen);
                     const normalizedPath = scriptInfo ? scriptInfo.fileName : toNormalizedPath(file.fileName);
-                    this.openClientFileWithNormalizedPath(normalizedPath, file.content, file.scriptKind, file.hasMixedContent);
+                    this.openClientFileWithNormalizedPath(normalizedPath, file.content, tryConvertScriptKindName(file.scriptKind), file.hasMixedContent);
                 }
             }
 
@@ -1236,7 +1303,7 @@ namespace ts.server {
             if (externalProject) {
                 if (!tsConfigFiles) {
                     // external project already exists and not config files were added - update the project and return;
-                    this.updateNonInferredProject(externalProject, proj.rootFiles, externalFilePropertyReader, proj.options, proj.typingOptions, proj.options.compileOnSave, /*configFileErrors*/ undefined);
+                    this.updateNonInferredProject(externalProject, proj.rootFiles, externalFilePropertyReader, convertCompilerOptions(proj.options), proj.typingOptions, proj.options.compileOnSave, /*configFileErrors*/ undefined);
                     return;
                 }
                 // some config files were added to external project (that previously were not there)

src/server/project.ts

@@ -437,11 +437,11 @@ namespace ts.server {
             }
         }
 
-        reloadScript(filename: NormalizedPath): boolean {
+        reloadScript(filename: NormalizedPath, tempFileName?: NormalizedPath): boolean {
             const script = this.projectService.getScriptInfoForNormalizedPath(filename);
             if (script) {
                 Debug.assert(script.isAttached(this));
-                script.reloadFromFile();
+                script.reloadFromFile(tempFileName);
                 return true;
             }
             return false;

src/server/protocol.ts

@@ -109,7 +109,7 @@ namespace ts.server.protocol {
         /**
           * One of "request", "response", or "event"
           */
-        type: string;
+        type: "request" | "response" | "event";
     }
 
     /**
@@ -833,7 +833,7 @@ namespace ts.server.protocol {
         /**
          * Script kind of the file
          */
-        scriptKind?: ScriptKind;
+        scriptKind?: ScriptKindName | ts.ScriptKind;
         /**
          * Whether file has mixed content (i.e. .cshtml file that combines html markup with C#/JavaScript)
          */
@@ -866,20 +866,23 @@ namespace ts.server.protocol {
         typingOptions?: TypingOptions;
     }
 
-    /**
-     * For external projects, some of the project settings are sent together with
-     * compiler settings.
-     */
-    export interface ExternalProjectCompilerOptions extends CompilerOptions {
+    export interface CompileOnSaveMixin {
         /**
          * If compile on save is enabled for the project
          */
         compileOnSave?: boolean;
     }
 
+    /**
+     * For external projects, some of the project settings are sent together with
+     * compiler settings.
+     */
+    export type ExternalProjectCompilerOptions = CompilerOptions & CompileOnSaveMixin;
+
     /**
      * Contains information about current project version
      */
+    /* @internal */
     export interface ProjectVersionInfo {
         /**
          * Project name
@@ -896,7 +899,7 @@ namespace ts.server.protocol {
         /**
          * Current set of compiler options for project
          */
-        options: CompilerOptions;
+        options: ts.CompilerOptions;
     }
 
     /**
@@ -920,6 +923,7 @@ namespace ts.server.protocol {
      * if changes is set - then this is the set of changes that should be applied to existing project
      * otherwise - assume that nothing is changed
      */
+    /* @internal */
     export interface ProjectFiles {
         /**
          * Information abount project verison
@@ -938,6 +942,7 @@ namespace ts.server.protocol {
     /**
      * Combines project information with project level errors.
      */
+    /* @internal */
     export interface ProjectFilesWithDiagnostics extends ProjectFiles {
         /**
          * List of errors in project
@@ -1012,9 +1017,11 @@ namespace ts.server.protocol {
          * Used to specify the script kind of the file explicitly. It could be one of the following:
          *      "TS", "JS", "TSX", "JSX"
          */
-        scriptKindName?: "TS" | "JS" | "TSX" | "JSX";
+        scriptKindName?: ScriptKindName;
     }
 
+    export type ScriptKindName = "TS" | "JS" | "TSX" | "JSX";
+
     /**
       * Open request; value of command field is "open". Notify the
       * server that the client has file open.  The server will not
@@ -1109,6 +1116,7 @@ namespace ts.server.protocol {
     /**
      * Arguments to SynchronizeProjectListRequest
      */
+    /* @internal */
     export interface SynchronizeProjectListRequestArgs {
         /**
          * List of last known projects
@@ -2056,4 +2064,141 @@ namespace ts.server.protocol {
     export interface NavTreeResponse extends Response {
         body?: NavigationTree;
     }
+
+    export namespace IndentStyle {
+        export type None = "None";
+        export type Block = "Block";
+        export type Smart = "Smart";
+    }
+
+    export type IndentStyle = IndentStyle.None | IndentStyle.Block | IndentStyle.Smart;
+
+    export interface EditorSettings {
+        baseIndentSize?: number;
+        indentSize?: number;
+        tabSize?: number;
+        newLineCharacter?: string;
+        convertTabsToSpaces?: boolean;
+        indentStyle?: IndentStyle | ts.IndentStyle;
+    }
+
+    export interface FormatCodeSettings extends EditorSettings {
+        insertSpaceAfterCommaDelimiter?: boolean;
+        insertSpaceAfterSemicolonInForStatements?: boolean;
+        insertSpaceBeforeAndAfterBinaryOperators?: boolean;
+        insertSpaceAfterKeywordsInControlFlowStatements?: boolean;
+        insertSpaceAfterFunctionKeywordForAnonymousFunctions?: boolean;
+        insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis?: boolean;
+        insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets?: boolean;
+        insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces?: boolean;
+        insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces?: boolean;
+        placeOpenBraceOnNewLineForFunctions?: boolean;
+        placeOpenBraceOnNewLineForControlBlocks?: boolean;
+    }
+
+    export interface CompilerOptions {
+        allowJs?: boolean;
+        allowSyntheticDefaultImports?: boolean;
+        allowUnreachableCode?: boolean;
+        allowUnusedLabels?: boolean;
+        baseUrl?: string;
+        charset?: string;
+        declaration?: boolean;
+        declarationDir?: string;
+        disableSizeLimit?: boolean;
+        emitBOM?: boolean;
+        emitDecoratorMetadata?: boolean;
+        experimentalDecorators?: boolean;
+        forceConsistentCasingInFileNames?: boolean;
+        inlineSourceMap?: boolean;
+        inlineSources?: boolean;
+        isolatedModules?: boolean;
+        jsx?: JsxEmit | ts.JsxEmit;
+        lib?: string[];
+        locale?: string;
+        mapRoot?: string;
+        maxNodeModuleJsDepth?: number;
+        module?: ModuleKind | ts.ModuleKind;
+        moduleResolution?: ModuleResolutionKind | ts.ModuleResolutionKind;
+        newLine?: NewLineKind | ts.NewLineKind;
+        noEmit?: boolean;
+        noEmitHelpers?: boolean;
+        noEmitOnError?: boolean;
+        noErrorTruncation?: boolean;
+        noFallthroughCasesInSwitch?: boolean;
+        noImplicitAny?: boolean;
+        noImplicitReturns?: boolean;
+        noImplicitThis?: boolean;
+        noUnusedLocals?: boolean;
+        noUnusedParameters?: boolean;
+        noImplicitUseStrict?: boolean;
+        noLib?: boolean;
+        noResolve?: boolean;
+        out?: string;
+        outDir?: string;
+        outFile?: string;
+        paths?: MapLike<string[]>;
+        preserveConstEnums?: boolean;
+        project?: string;
+        reactNamespace?: string;
+        removeComments?: boolean;
+        rootDir?: string;
+        rootDirs?: string[];
+        skipLibCheck?: boolean;
+        skipDefaultLibCheck?: boolean;
+        sourceMap?: boolean;
+        sourceRoot?: string;
+        strictNullChecks?: boolean;
+        suppressExcessPropertyErrors?: boolean;
+        suppressImplicitAnyIndexErrors?: boolean;
+        target?: ScriptTarget | ts.ScriptTarget;
+        traceResolution?: boolean;
+        types?: string[];
+        /** Paths used to used to compute primary types search locations */
+        typeRoots?: string[];
+        [option: string]: CompilerOptionsValue | undefined;
+    }
+
+    export namespace JsxEmit {
+        export type None = "None";
+        export type Preserve = "Preserve";
+        export type React = "React";
+    }
+
+    export type JsxEmit = JsxEmit.None | JsxEmit.Preserve | JsxEmit.React;
+
+    export namespace ModuleKind {
+        export type None = "None";
+        export type CommonJS = "CommonJS";
+        export type AMD = "AMD";
+        export type UMD = "UMD";
+        export type System = "System";
+        export type ES6 = "ES6";
+        export type ES2015 = "ES2015";
+    }
+
+    export type ModuleKind = ModuleKind.None | ModuleKind.CommonJS | ModuleKind.AMD | ModuleKind.UMD | ModuleKind.System | ModuleKind.ES6 | ModuleKind.ES2015;
+
+    export namespace ModuleResolutionKind {
+        export type Classic = "Classic";
+        export type Node = "Node";
+    }
+
+    export type ModuleResolutionKind = ModuleResolutionKind.Classic | ModuleResolutionKind.Node;
+
+    export namespace NewLineKind {
+        export type Crlf = "Crlf";
+        export type Lf = "Lf";
+    }
+
+    export type NewLineKind = NewLineKind.Crlf | NewLineKind.Lf;
+
+    export namespace ScriptTarget {
+        export type ES3 = "ES3";
+        export type ES5 = "ES5";
+        export type ES6 = "ES6";
+        export type ES2015 = "ES2015";
+    }
+
+    export type ScriptTarget = ScriptTarget.ES3 | ScriptTarget.ES5 | ScriptTarget.ES6 | ScriptTarget.ES2015;
 }

src/server/scriptInfo.ts

@@ -87,7 +87,6 @@ namespace ts.server {
             if (this.containingProjects.length === 0) {
                 return Errors.ThrowNoProject();
             }
-            Debug.assert(this.containingProjects.length !== 0);
             return this.containingProjects[0];
         }
 
@@ -126,12 +125,12 @@ namespace ts.server {
             this.host.writeFile(fileName, snap.getText(0, snap.getLength()));
         }
 
-        reloadFromFile() {
+        reloadFromFile(tempFileName?: NormalizedPath) {
             if (this.hasMixedContent) {
                 this.reload("");
             }
             else {
-                this.svc.reloadFromFile(this.fileName);
+                this.svc.reloadFromFile(tempFileName || this.fileName);
                 this.markContainingProjectsAsDirty();
             }
         }

src/server/session.ts

@@ -389,9 +389,9 @@ namespace ts.server {
             });
         }
 
-        private getDiagnosticsWorker(args: protocol.FileRequestArgs, selector: (project: Project, file: string) => Diagnostic[], includeLinePosition: boolean) {
+        private getDiagnosticsWorker(args: protocol.FileRequestArgs, isSemantic: boolean, selector: (project: Project, file: string) => Diagnostic[], includeLinePosition: boolean) {
             const { project, file } = this.getFileAndProject(args);
-            if (shouldSkipSematicCheck(project)) {
+            if (isSemantic && shouldSkipSematicCheck(project)) {
                 return [];
             }
             const scriptInfo = project.getScriptInfoForNormalizedPath(file);
@@ -492,11 +492,11 @@ namespace ts.server {
         }
 
         private getSyntacticDiagnosticsSync(args: protocol.SyntacticDiagnosticsSyncRequestArgs): protocol.Diagnostic[] | protocol.DiagnosticWithLinePosition[] {
-            return this.getDiagnosticsWorker(args, (project, file) => project.getLanguageService().getSyntacticDiagnostics(file), args.includeLinePosition);
+            return this.getDiagnosticsWorker(args, /*isSemantic*/ false, (project, file) => project.getLanguageService().getSyntacticDiagnostics(file), args.includeLinePosition);
         }
 
         private getSemanticDiagnosticsSync(args: protocol.SemanticDiagnosticsSyncRequestArgs): protocol.Diagnostic[] | protocol.DiagnosticWithLinePosition[] {
-            return this.getDiagnosticsWorker(args, (project, file) => project.getLanguageService().getSemanticDiagnostics(file), args.includeLinePosition);
+            return this.getDiagnosticsWorker(args, /*isSemantic*/ true, (project, file) => project.getLanguageService().getSemanticDiagnostics(file), args.includeLinePosition);
         }
 
         private getDocumentHighlights(args: protocol.DocumentHighlightsRequestArgs, simplifiedResult: boolean): protocol.DocumentHighlightsItem[] | DocumentHighlights[] {
@@ -807,7 +807,7 @@ namespace ts.server {
         private getIndentation(args: protocol.IndentationRequestArgs) {
             const { file, project } = this.getFileAndProjectWithoutRefreshingInferredProjects(args);
             const position = this.getPosition(args, project.getScriptInfoForNormalizedPath(file));
-            const options = args.options || this.projectService.getFormatCodeOptions(file);
+            const options = args.options ? convertFormatOptions(args.options) : this.projectService.getFormatCodeOptions(file);
             const indentation = project.getLanguageService(/*ensureSynchronized*/ false).getIndentationAtPosition(file, position, options);
             return { position, indentation };
         }
@@ -874,19 +874,19 @@ namespace ts.server {
 
         private getFormattingEditsForRangeFull(args: protocol.FormatRequestArgs) {
             const { file, project } = this.getFileAndProjectWithoutRefreshingInferredProjects(args);
-            const options = args.options || this.projectService.getFormatCodeOptions(file);
+            const options = args.options ? convertFormatOptions(args.options) : this.projectService.getFormatCodeOptions(file);
             return project.getLanguageService(/*ensureSynchronized*/ false).getFormattingEditsForRange(file, args.position, args.endPosition, options);
         }
 
         private getFormattingEditsForDocumentFull(args: protocol.FormatRequestArgs) {
             const { file, project } = this.getFileAndProjectWithoutRefreshingInferredProjects(args);
-            const options = args.options || this.projectService.getFormatCodeOptions(file);
+            const options = args.options ? convertFormatOptions(args.options) : this.projectService.getFormatCodeOptions(file);
             return project.getLanguageService(/*ensureSynchronized*/ false).getFormattingEditsForDocument(file, options);
         }
 
         private getFormattingEditsAfterKeystrokeFull(args: protocol.FormatOnKeyRequestArgs) {
             const { file, project } = this.getFileAndProjectWithoutRefreshingInferredProjects(args);
-            const options = args.options || this.projectService.getFormatCodeOptions(file);
+            const options = args.options ? convertFormatOptions(args.options) : this.projectService.getFormatCodeOptions(file);
             return project.getLanguageService(/*ensureSynchronized*/ false).getFormattingEditsAfterKeystroke(file, args.position, args.key, options);
         }
 
@@ -1076,11 +1076,12 @@ namespace ts.server {
 
         private reload(args: protocol.ReloadRequestArgs, reqSeq: number) {
             const file = toNormalizedPath(args.file);
+            const tempFileName = args.tmpfile && toNormalizedPath(args.tmpfile);
             const project = this.projectService.getDefaultProjectForFile(file, /*refreshInferredProjects*/ true);
             if (project) {
                 this.changeSeq++;
                 // make sure no changes happen before this one is finished
-                if (project.reloadScript(file)) {
+                if (project.reloadScript(file, tempFileName)) {
                     this.output(undefined, CommandNames.Reload, reqSeq);
                 }
             }
@@ -1426,24 +1427,8 @@ namespace ts.server {
             [CommandNames.RenameInfoFull]: (request: protocol.FileLocationRequest) => {
                 return this.requiredResponse(this.getRenameInfo(request.arguments));
             },
-            [CommandNames.Open]: (request: protocol.Request) => {
-                const openArgs = <protocol.OpenRequestArgs>request.arguments;
-                let scriptKind: ScriptKind;
-                switch (openArgs.scriptKindName) {
-                    case "TS":
-                        scriptKind = ScriptKind.TS;
-                        break;
-                    case "JS":
-                        scriptKind = ScriptKind.JS;
-                        break;
-                    case "TSX":
-                        scriptKind = ScriptKind.TSX;
-                        break;
-                    case "JSX":
-                        scriptKind = ScriptKind.JSX;
-                        break;
-                }
-                this.openClientFile(toNormalizedPath(openArgs.file), openArgs.fileContent, scriptKind);
+            [CommandNames.Open]: (request: protocol.OpenRequest) => {
+                this.openClientFile(toNormalizedPath(request.arguments.file), request.arguments.fileContent, convertScriptKindName(request.arguments.scriptKindName));
                 return this.notRequired();
             },
             [CommandNames.Quickinfo]: (request: protocol.QuickInfoRequest) => {