manually re-apply commits for TypeStrong#250 and TypeStrong#260

This reverts commit 9db85d7.

Author: phryneas

src/index.ts

@@ -53,6 +53,8 @@ interface Options {
   vue: boolean;
   useTypescriptIncrementalApi: boolean;
   measureCompilationTime: boolean;
+  resolveModuleNameModule: string;
+  resolveTypeReferenceDirectiveModule: string;
 }
 
 /**
@@ -99,6 +101,8 @@ class ForkTsCheckerWebpackPlugin {
   private colors: Chalk;
   private formatter: Formatter;
   private useTypescriptIncrementalApi: boolean;
+  private resolveModuleNameModule: string | undefined;
+  private resolveTypeReferenceDirectiveModule: string | undefined;
 
   private tsconfigPath?: string;
   private tslintPath?: string;
@@ -158,6 +162,9 @@ class ForkTsCheckerWebpackPlugin {
     this.silent = options.silent === true; // default false
     this.async = options.async !== false; // default true
     this.checkSyntacticErrors = options.checkSyntacticErrors === true; // default false
+    this.resolveModuleNameModule = options.resolveModuleNameModule;
+    this.resolveTypeReferenceDirectiveModule =
+      options.resolveTypeReferenceDirectiveModule;
     this.workersNumber = options.workers || ForkTsCheckerWebpackPlugin.ONE_CPU;
     this.memoryLimit =
       options.memoryLimit || ForkTsCheckerWebpackPlugin.DEFAULT_MEMORY_LIMIT;
@@ -569,35 +576,50 @@ class ForkTsCheckerWebpackPlugin {
   }
 
   private spawnService() {
+    const env: { [key: string]: string | undefined } = {
+      ...process.env,
+      TYPESCRIPT_PATH: this.typescriptPath,
+      TSCONFIG: this.tsconfigPath,
+      COMPILER_OPTIONS: JSON.stringify(this.compilerOptions),
+      TSLINT: this.tslintPath || (this.tslint ? 'true' : ''),
+      CONTEXT: this.compiler.options.context,
+      TSLINTAUTOFIX: String(this.tslintAutoFix),
+      WATCH: this.isWatching ? this.watchPaths.join('|') : '',
+      WORK_DIVISION: String(Math.max(1, this.workersNumber)),
+      MEMORY_LIMIT: String(this.memoryLimit),
+      CHECK_SYNTACTIC_ERRORS: String(this.checkSyntacticErrors),
+      USE_INCREMENTAL_API: String(this.useTypescriptIncrementalApi === true),
+      VUE: String(this.vue)
+    };
+
+    if (typeof this.resolveModuleNameModule !== 'undefined') {
+      env.RESOLVE_MODULE_NAME = this.resolveModuleNameModule;
+    } else {
+      delete env.RESOLVE_MODULE_NAME;
+    }
+
+    if (typeof this.resolveTypeReferenceDirectiveModule !== 'undefined') {
+      env.RESOLVE_TYPE_REFERENCE_DIRECTIVE = this.resolveTypeReferenceDirectiveModule;
+    } else {
+      delete env.RESOLVE_TYPE_REFERENCE_DIRECTIVE;
+    }
+
     this.service = childProcess.fork(
       path.resolve(
         __dirname,
         this.workersNumber > 1 ? './cluster.js' : './service.js'
       ),
       [],
       {
+        env,
         execArgv: (this.workersNumber > 1
           ? []
           : ['--max-old-space-size=' + this.memoryLimit]
         ).concat(this.nodeArgs),
-        env: {
-          ...process.env,
-          TYPESCRIPT_PATH: this.typescriptPath,
-          TSCONFIG: this.tsconfigPath,
-          COMPILER_OPTIONS: JSON.stringify(this.compilerOptions),
-          TSLINT: this.tslintPath || (this.tslint ? 'true' : ''),
-          CONTEXT: this.compiler.options.context,
-          TSLINTAUTOFIX: this.tslintAutoFix,
-          WATCH: this.isWatching ? this.watchPaths.join('|') : '',
-          WORK_DIVISION: Math.max(1, this.workersNumber),
-          MEMORY_LIMIT: this.memoryLimit,
-          CHECK_SYNTACTIC_ERRORS: this.checkSyntacticErrors,
-          USE_INCREMENTAL_API: this.useTypescriptIncrementalApi === true,
-          VUE: this.vue
-        },
         stdio: ['inherit', 'inherit', 'inherit', 'ipc']
       }
     );
+
     this.serviceRpc = new RpcProvider(message => this.service!.send(message));
     this.service.on('message', message => this.serviceRpc!.dispatch(message));
 

src/resolution.ts

@@ -0,0 +1,59 @@
+// tslint:disable-next-line:no-implicit-dependencies
+import * as ts from 'typescript'; // Imported for types alone
+
+export type ResolveModuleName = (
+  typescript: typeof ts,
+  moduleName: string,
+  containingFile: string,
+  compilerOptions: ts.CompilerOptions,
+  moduleResolutionHost: ts.ModuleResolutionHost
+) => ts.ResolvedModuleWithFailedLookupLocations;
+
+export type ResolveTypeReferenceDirective = (
+  typescript: typeof ts,
+  typeDirectiveName: string,
+  containingFile: string,
+  compilerOptions: ts.CompilerOptions,
+  moduleResolutionHost: ts.ModuleResolutionHost
+) => ts.ResolvedTypeReferenceDirectiveWithFailedLookupLocations;
+
+export function makeResolutionFunctions(
+  resolveModuleName: ResolveModuleName | undefined,
+  resolveTypeReferenceDirective: ResolveTypeReferenceDirective | undefined
+) {
+  resolveModuleName =
+    resolveModuleName ||
+    ((
+      typescript,
+      moduleName,
+      containingFile,
+      compilerOptions,
+      moduleResolutionHost
+    ) => {
+      return typescript.resolveModuleName(
+        moduleName,
+        containingFile,
+        compilerOptions,
+        moduleResolutionHost
+      );
+    });
+
+  resolveTypeReferenceDirective =
+    resolveTypeReferenceDirective ||
+    ((
+      typescript,
+      typeDirectiveName,
+      containingFile,
+      compilerOptions,
+      moduleResolutionHost
+    ) => {
+      return typescript.resolveTypeReferenceDirective(
+        typeDirectiveName,
+        containingFile,
+        compilerOptions,
+        moduleResolutionHost
+      );
+    });
+
+  return { resolveModuleName, resolveTypeReferenceDirective };
+}

src/service.ts

@@ -35,8 +35,21 @@ const rpc = new RpcProvider(message => {
 });
 process.on('message', message => rpc.dispatch(message));
 
-const wrapperConfig: TypeScriptWrapperConfig =
-  process.env.VUE === 'true' ? wrapperConfigWithVue : emptyWrapperConfig;
+const resolveModuleName = process.env.RESOLVE_MODULE_NAME
+  ? require(process.env.RESOLVE_MODULE_NAME!).resolveModuleName
+  : undefined;
+const resolveTypeReferenceDirective = process.env
+  .RESOLVE_TYPE_REFERENCE_DIRECTIVE
+  ? require(process.env.RESOLVE_TYPE_REFERENCE_DIRECTIVE!)
+      .resolveTypeReferenceDirective
+  : undefined;
+
+const wrapperConfig: TypeScriptWrapperConfig = {
+  ...emptyWrapperConfig,
+  resolveModuleName,
+  resolveTypeReferenceDirective,
+  ...(process.env.VUE === 'true' ? wrapperConfigWithVue : {})
+};
 
 const typescript: typeof ts = patchTypescript(
   require(process.env.TYPESCRIPT_PATH!),

src/wrapCompilerHost.ts

@@ -2,6 +2,7 @@
 // tslint:disable-next-line:no-implicit-dependencies
 import * as ts from 'typescript'; // Imported for types alone
 import { TypeScriptWrapperConfig } from './wrapperUtils';
+import { makeResolutionFunctions } from './resolution';
 
 type HostType = ts.CompilerHost | ts.WatchCompilerHostOfConfigFile<any>;
 // @ts-ignore
@@ -21,16 +22,24 @@ export function wrapCompilerHost<T extends HostType>(
   origHost: T,
   compilerOptions: ts.CompilerOptions,
   typescript: typeof ts,
-  _config: TypeScriptWrapperConfig
+  config: TypeScriptWrapperConfig
 ) {
   let wrappedCompilerHost: T;
 
+  const {
+    resolveModuleName,
+    resolveTypeReferenceDirective
+  } = makeResolutionFunctions(
+    config.resolveModuleName,
+    config.resolveTypeReferenceDirective
+  );
+
   const compilerHostWrappers: Partial<ts.CompilerHost> = {
     resolveModuleNames(
       moduleNames,
       containingFile,
-      _reusedNames, // no idea what this is for
-      redirectedReference
+      _reusedNames,
+      _redirectedReference
     ) {
       return moduleNames.map(moduleName => {
         for (const suffix of wrapSuffixes) {
@@ -42,13 +51,12 @@ export function wrapCompilerHost<T extends HostType>(
             RESET
           );
           */
-          const result = typescript.resolveModuleName(
+          const result = resolveModuleName(
+            typescript,
             moduleName + suffix,
             containingFile,
             compilerOptions,
-            wrappedCompilerHost,
-            undefined,
-            redirectedReference
+            wrappedCompilerHost
           );
           if (result.resolvedModule) {
             /*
@@ -68,6 +76,20 @@ export function wrapCompilerHost<T extends HostType>(
         return undefined;
       });
     },
+    resolveTypeReferenceDirectives(
+      typeDirectiveNames: string[],
+      containingFile: string
+    ) {
+      return typeDirectiveNames.map(typeDirectiveName => {
+        return resolveTypeReferenceDirective(
+          typescript,
+          typeDirectiveName,
+          containingFile,
+          compilerOptions,
+          wrappedCompilerHost
+        ).resolvedTypeReferenceDirective;
+      });
+    },
     getSourceFile(...args) {
       let result = (origHost as ts.CompilerHost).getSourceFile(...args);
       if (result && result.text) {

src/wrapperUtils.ts

@@ -3,6 +3,7 @@
 import { extname } from 'path';
 import { handleMdxContents } from './handleMdxContents';
 import { handleVueContents } from './handleVueContents';
+import { ResolveModuleName, ResolveTypeReferenceDirective } from './resolution';
 
 export interface TypeScriptWrapperConfig {
   extensionHandlers: {
@@ -12,6 +13,8 @@ export interface TypeScriptWrapperConfig {
     ) => string;
   };
   wrapExtensions: string[];
+  resolveModuleName?: ResolveModuleName;
+  resolveTypeReferenceDirective?: ResolveTypeReferenceDirective;
 }
 
 export const wrapperConfigWithVue: TypeScriptWrapperConfig = {

test/integration/helpers.js

@@ -39,7 +39,8 @@ exports.createVueCompiler = async function(options) {
     resolve: {
       extensions: ['.ts', '.js', '.vue', '.json'],
       alias: {
-        '@': path.resolve(__dirname, './vue/src')
+        '@': path.resolve(__dirname, './vue/src'),
+        surprise: './src/index.ts'
       }
     },
     module: {

test/integration/index.spec.js

@@ -37,6 +37,8 @@ function makeCommonTests(useTypescriptIncrementalApi) {
       return compiler.webpack;
     }
 
+    const skipIfIncremental = useTypescriptIncrementalApi ? it.skip : it;
+
     /**
      * Implicitly check whether killService was called by checking that
      * the service property was set to undefined.
@@ -151,6 +153,34 @@ function makeCommonTests(useTypescriptIncrementalApi) {
       });
     });
 
+    it('should support custom resolution', function(callback) {
+      var compiler = createCompiler({
+        tsconfig: 'tsconfig-weird-resolutions.json',
+        resolveModuleNameModule: `${__dirname}/project/weirdResolver.js`,
+        resolveTypeReferenceDirectiveModule: `${__dirname}/project/weirdResolver.js`
+      });
+
+      compiler.run(function(err, stats) {
+        expect(stats.compilation.errors.length).to.be.eq(0);
+        callback();
+      });
+    });
+
+    skipIfIncremental('should support custom resolution w/ "paths"', function(
+      callback
+    ) {
+      var compiler = createCompiler({
+        tsconfig: 'tsconfig-weird-resolutions-with-paths.json',
+        resolveModuleNameModule: `${__dirname}/project/weirdResolver.js`,
+        resolveTypeReferenceDirectiveModule: `${__dirname}/project/weirdResolver.js`
+      });
+
+      compiler.run(function(err, stats) {
+        expect(stats.compilation.errors.length).to.be.eq(0);
+        callback();
+      });
+    });
+
     it('should fix linting errors with tslintAutofix flag set to true', function(callback) {
       const fileName = 'lintingError1';
       helpers.testLintAutoFixTest(

test/integration/project/src/defs.d.ts

@@ -0,0 +1 @@
+declare function helloWorld(): void;

test/integration/project/src/export.ts

@@ -0,0 +1 @@
+export const fortyTwo = 42;

test/integration/project/src/pathResolutions.ts

@@ -0,0 +1 @@
+import 'surprise';

test/integration/project/src/weirdResolutions.ts

@@ -0,0 +1,5 @@
+/// <reference types="where-am-i" />
+
+import { fortyTwo } from 'please-find-my-export';
+
+helloWorld();

test/integration/project/tsconfig-weird-resolutions-with-paths.json

@@ -0,0 +1,9 @@
+{
+  "compilerOptions": {
+    "lib": ["es2016"],
+    "paths": {
+      "surprise": "./index.ts"
+    }
+  },
+  "include": ["src/pathResolutions.ts", "src/weirdResolutions.ts"]
+}

test/integration/project/tsconfig-weird-resolutions.json

@@ -0,0 +1,6 @@
+{
+  "compilerOptions": {
+    "lib": ["es2016"]
+  },
+  "include": ["src/weirdResolutions.ts"]
+}

test/integration/project/weirdResolver.js

@@ -0,0 +1,11 @@
+exports.resolveModuleName = function() {
+  return { resolvedModule: { resolvedFileName: `${__dirname}/src/export.ts` } };
+};
+
+exports.resolveTypeReferenceDirective = function() {
+  return {
+    resolvedTypeReferenceDirective: {
+      resolvedFileName: `${__dirname}/src/defs.d.ts`
+    }
+  };
+};