Expose compiler API needed for vue

src/harness/harnessLanguageService.ts

@@ -785,6 +785,75 @@ namespace Harness.LanguageService {
                         }),
                         error: undefined
                     };
+                case "mock-vue":
+                    return {
+                        module: () => ({
+                            create(info: ts.server.PluginCreateInfo) {
+                                const compilerOptions: ts.CompilerOptions = {
+                                    allowNonTsExtensions: true,
+                                    allowJs: true,
+                                    lib: ["lib.dom.d.ts", "lib.es2017.d.ts"],
+                                    target: ts.ScriptTarget.Latest,
+                                    moduleResolution: ts.ModuleResolutionKind.NodeJs,
+                                    module: ts.ModuleKind.CommonJS,
+                                    allowSyntheticDefaultImports: true
+                                };
+                                info.languageServiceHost.resolveModuleNames = (moduleNames, containingFile) =>
+                                    bifilterMap(moduleNames, importInterested,
+                                                name => ({
+                                                    resolvedFileName: containingFile.slice(0, containingFile.lastIndexOf("/")) + "/" + name,
+                                                    extension: ts.Extension.Ts
+                                                }),
+                                                name => ts.resolveModuleName(name, containingFile, compilerOptions, ts.sys).resolvedModule);
+                                const clssf = ts.createLanguageServiceSourceFile;
+                                const ulssf = ts.updateLanguageServiceSourceFile;
+                                ts.overrideCreateupdateLanguageServiceSourceFile(
+                                    (fileName, scriptSnapshot, scriptTarget, version, setNodeParents, scriptKind?) => {
+                                        if (interested(fileName)) {
+                                            const wrapped = scriptSnapshot;
+                                            scriptSnapshot = {
+                                                getChangeRange: old => wrapped.getChangeRange(old),
+                                                getLength: () => wrapped.getLength(),
+                                                getText: (start, end) => parse(wrapped.getText(0, wrapped.getLength())).slice(start, end),
+                                            };
+                                        }
+                                        return clssf(fileName, scriptSnapshot, scriptTarget, version, setNodeParents, scriptKind);
+                                    },
+                                    (sourceFile, scriptSnapshot, version, textChangeRange, aggressiveChecks?) => {
+                                        if (interested(sourceFile.fileName)) {
+                                            const wrapped = scriptSnapshot;
+                                            scriptSnapshot = {
+                                                getChangeRange: old => wrapped.getChangeRange(old),
+                                                getLength: () => wrapped.getLength(),
+                                                getText: (start, end) => parse(wrapped.getText(0, wrapped.getLength())).slice(start, end),
+                                            };
+                                        }
+                                        return ulssf(sourceFile, scriptSnapshot, version, textChangeRange, aggressiveChecks);
+                                    });
+                                return makeDefaultProxy(info);
+
+                                function bifilterMap<T, U>(l: T[], predicate: (t: T) => boolean, yes: (t: T) => U, no: (t: T) => U): U[] {
+                                    const result = [];
+                                    for (const x of l) {
+                                        result.push(predicate(x) ? yes(x) : no(x));
+                                    }
+                                    return result;
+                                }
+                                function interested(fileName: string) {
+                                    return fileName.slice(-4) === ".vue";
+                                }
+                                function parse(text: string) {
+                                    const start = text.indexOf("<script>") + "<script>".length;
+                                    const end = text.indexOf("</script>");
+                                    return text.slice(0, start).replace(/./g, " ") + text.slice(start, end) + text.slice(end).replace(/./g, " ");
+                                }
+                                function importInterested(fileName: string) {
+                                    return fileName.charAt(0) === "." && fileName.slice(-4) === ".vue";
+                                }
+                            }
+                        }),
+                        error: undefined
+                    };
 
                 default:
                     return {

src/server/lsHost.ts

@@ -237,4 +237,4 @@ namespace ts.server {
             this.compilationSettings = opt;
         }
     }
-}
+}

src/server/project.ts

@@ -1083,4 +1083,4 @@ namespace ts.server {
             this.typeAcquisition = newTypeAcquisition;
         }
     }
-}
+}

src/services/services.ts

@@ -899,6 +899,13 @@ namespace ts {
         sourceFile.scriptSnapshot = scriptSnapshot;
     }
 
+    export function overrideCreateupdateLanguageServiceSourceFile(
+        create: (fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean, scriptKind?: ScriptKind, cheat?: string) => SourceFile,
+        update: (sourceFile: SourceFile, scriptSnapshot: IScriptSnapshot, version: string, textChangeRange: TextChangeRange, aggressiveChecks?: boolean, cheat?: string) => SourceFile) {
+        ts.createLanguageServiceSourceFile = create;
+        ts.updateLanguageServiceSourceFile = update;
+    }
+
     export function createLanguageServiceSourceFile(fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean, scriptKind?: ScriptKind): SourceFile {
         const text = scriptSnapshot.getText(0, scriptSnapshot.getLength());
         const sourceFile = createSourceFile(fileName, text, scriptTarget, setNodeParents, scriptKind);

tests/cases/fourslash/server/vueProxy1.ts

@@ -0,0 +1,44 @@
+/// <reference path="../fourslash.ts"/>
+
+// @Filename: tsconfig.json
+//// {
+////     "compilerOptions": {
+////         "allowNonTsExtensions": true,
+////         "plugins": [
+////             { "name": "mock-vue" }
+////         ]
+////     },
+////     "files": ["a.vue"]
+//// }
+
+// Note: This test does *not* implement the correct vue transformation.
+// So it's other.data.property, not other.property or other.$data.property
+// @Filename: other.vue
+////<template>
+////</template>
+////<script>
+////export default {
+////    data: { property: "Example" }
+////}
+////</script>
+////<style>
+////</style>
+
+
+// @Filename: a.vue
+////<template>
+////</template>
+////<script>
+////import other from './other.vue'
+//// other.data.property/**/
+////export default {
+////    data: { greeting: "Hello" }
+////}
+////</script>
+////<style>
+////</style>
+
+// LS shouldn't crash/fail if a plugin fails to init correctly
+goTo.marker();
+verify.quickInfoIs('(property) property: string');
+verify.numberOfErrorsInCurrentFile(0);