Support project references

src/after-compile.ts

@@ -1,5 +1,10 @@
 import * as path from 'path';
-import { collectAllDependants, formatErrors } from './utils';
+
+import {
+  collectAllDependants,
+  formatErrors,
+  isUsingProjectReferences
+} from './utils';
 import * as constants from './constants';
 import {
   TSFiles,
@@ -60,6 +65,7 @@ export function makeAfterCompile(
 
     instance.filesWithErrors = filesWithErrors;
     instance.modifiedFiles = null;
+    instance.projectsMissingSourceMaps = new Set();
 
     callback();
   };
@@ -181,6 +187,15 @@ function provideErrorsToWebpack(
     }
 
     const sourceFile = program && program.getSourceFile(filePath);
+
+    // If the source file is undefined, that probably means it’s actually part of an unbuilt project reference,
+    // which will have already produced a more useful error than the one we would get by proceeding here.
+    // If it’s undefined and we’re not using project references at all, I guess carry on so the user will
+    // get a useful error about which file was unexpectedly missing.
+    if (isUsingProjectReferences(instance) && !sourceFile) {
+      continue;
+    }
+
     const errors = program
       ? [
           ...program.getSyntacticDiagnostics(sourceFile),

src/index.ts

@@ -3,7 +3,13 @@ import * as loaderUtils from 'loader-utils';
 import * as typescript from 'typescript';
 
 import { getTypeScriptInstance, getEmitOutput } from './instances';
-import { appendSuffixesIfMatch, arrify, formatErrors } from './utils';
+import {
+  appendSuffixesIfMatch,
+  arrify,
+  formatErrors,
+  getProjectReferenceForFile,
+  validateSourceMapOncePerProject
+} from './utils';
 import * as constants from './constants';
 import {
   AsyncCallback,
@@ -63,11 +69,80 @@ function successLoader(
       : rawFilePath;
 
   const fileVersion = updateFileInCache(filePath, contents, instance);
+  const referencedProject = getProjectReferenceForFile(filePath, instance);
+  if (referencedProject) {
+    if (referencedProject.commandLine.options.outFile) {
+      throw new Error(
+        `The referenced project at ${
+          referencedProject.sourceFile.fileName
+        } is using the ` +
+          `outFile' option, which is not supported with ts-loader.`
+      );
+    }
 
-  const { outputText, sourceMapText } = options.transpileOnly
-    ? getTranspilationEmit(filePath, contents, instance, loader)
-    : getEmit(rawFilePath, filePath, instance, loader);
+    const jsFileName = instance.compiler.getOutputJavaScriptFileName(
+      filePath,
+      referencedProject.commandLine
+    );
+
+    if (!instance.compiler.sys.fileExists(jsFileName)) {
+      throw new Error(
+        `Could not find output JavaScript file for input ${filePath} ` +
+          `(looked at ${jsFileName}).\nThe input file is part of a project ` +
+          `reference located at ${referencedProject.sourceFile.fileName}, ` +
+          'so ts-loader is looking for the project’s pre-built output on ' +
+          'disk. Try running `tsc --build` to build project references.'
+      );
+    }
+
+    validateSourceMapOncePerProject(
+      instance,
+      loader,
+      jsFileName,
+      referencedProject
+    );
+
+    const mapFileName = jsFileName + '.map';
+    const outputText = instance.compiler.sys.readFile(jsFileName);
+    const sourceMapText = instance.compiler.sys.readFile(mapFileName);
+    makeSourceMapAndFinish(
+      sourceMapText,
+      outputText,
+      filePath,
+      contents,
+      loader,
+      options,
+      fileVersion,
+      callback
+    );
+  } else {
+    const { outputText, sourceMapText } = options.transpileOnly
+      ? getTranspilationEmit(filePath, contents, instance, loader)
+      : getEmit(rawFilePath, filePath, instance, loader);
+
+    makeSourceMapAndFinish(
+      sourceMapText,
+      outputText,
+      filePath,
+      contents,
+      loader,
+      options,
+      fileVersion,
+      callback
+    );
+  }
+}
 
+function makeSourceMapAndFinish(
+  sourceMapText: string | undefined,
+  outputText: string | undefined,
+  filePath: string,
+  contents: string,
+  loader: Webpack,
+  options: LoaderOptions,
+  fileVersion: number,
+  callback: AsyncCallback
+) {
   if (outputText === null || outputText === undefined) {
     const additionalGuidance =
       !options.allowTsInNodeModules && filePath.indexOf('node_modules') !== -1
@@ -77,7 +152,7 @@ function successLoader(
         : '';
 
     throw new Error(
-      `Typescript emitted no output for ${filePath}.${additionalGuidance}`
+      `TypeScript emitted no output for ${filePath}.${additionalGuidance}`
     );
   }
 

src/instances.ts

@@ -7,7 +7,12 @@ import { makeAfterCompile } from './after-compile';
 import { getConfigFile, getConfigParseResult } from './config';
 import { EOL, dtsDtsxOrDtsDtsxMapRegex } from './constants';
 import { getCompilerOptions, getCompiler } from './compilerSetup';
-import { makeError, formatErrors } from './utils';
+import {
+  makeError,
+  formatErrors,
+  ensureProgram,
+  isUsingProjectReferences
+} from './utils';
 import * as logger from './logger';
 import { makeServicesHost, makeWatchHost } from './servicesHost';
 import { makeWatchRun } from './watch-run';
@@ -23,23 +28,6 @@ import {
 
 const instances = <TSInstances>{};
 
-function ensureProgram(instance: TSInstance) {
-  if (instance && instance.watchHost) {
-    if (instance.hasUnaccountedModifiedFiles) {
-      if (instance.changedFilesList) {
-        instance.watchHost.updateRootFileNames();
-      }
-      if (instance.watchOfFilesAndCompilerOptions) {
-        instance.program = instance.watchOfFilesAndCompilerOptions
-          .getProgram()
-          .getProgram();
-      }
-      instance.hasUnaccountedModifiedFiles = false;
-    }
-    return instance.program;
-  }
-  return undefined;
-}
 /**
  * The loader is executed once for each file seen by webpack. However, we need to keep
  * a persistent instance of TypeScript that contains all of the files in the program
@@ -167,7 +155,13 @@ function successfulTypeScriptInstance(
   if (loaderOptions.transpileOnly) {
     // quick return for transpiling
     // we do need to check for any issues with TS options though
-    const program = compiler!.createProgram([], compilerOptions);
+    const program = configParseResult.projectReferences
+      ? compiler!.createProgram({
+          rootNames: configParseResult.fileNames,
+          options: configParseResult.options,
+          projectReferences: configParseResult.projectReferences
+        })
+      : compiler!.createProgram([], compilerOptions);
 
     // happypack does not have _module.errors - see https://github.com/TypeStrong/ts-loader/issues/336
     if (!loaderOptions.happyPackMode) {
@@ -190,6 +184,7 @@ function successfulTypeScriptInstance(
       loaderOptions,
       files,
       otherFiles,
+      program,
       dependencyGraph: {},
       reverseDependencyGraph: {},
       transformers: getCustomTransformers(),
@@ -257,7 +252,8 @@ function successfulTypeScriptInstance(
       loader,
       instance,
       loaderOptions.appendTsSuffixTo,
-      loaderOptions.appendTsxSuffixTo
+      loaderOptions.appendTsxSuffixTo,
+      configParseResult.projectReferences
     );
     instance.watchOfFilesAndCompilerOptions = compiler.createWatchProgram(
       instance.watchHost
@@ -266,7 +262,13 @@ function successfulTypeScriptInstance(
       .getProgram()
       .getProgram();
   } else {
-    const servicesHost = makeServicesHost(scriptRegex, log, loader, instance);
+    const servicesHost = makeServicesHost(
+      scriptRegex,
+      log,
+      loader,
+      instance,
+      configParseResult.projectReferences
+    );
     instance.languageService = compiler.createLanguageService(
       servicesHost,
       compiler.createDocumentRegistry()
@@ -298,16 +300,21 @@ export function getEmitOutput(instance: TSInstance, filePath: string) {
       writeByteOrderMark: boolean
     ) => outputFiles.push({ name: fileName, writeByteOrderMark, text });
     const sourceFile = program.getSourceFile(filePath);
-    program.emit(
-      sourceFile,
-      writeFile,
-      /*cancellationToken*/ undefined,
-      /*emitOnlyDtsFiles*/ false,
-      instance.transformers
-    );
+    // The source file will be undefined if it’s part of an unbuilt project reference
+    if (sourceFile || !isUsingProjectReferences(instance)) {
+      program.emit(
+        sourceFile,
+        writeFile,
+        /*cancellationToken*/ undefined,
+        /*emitOnlyDtsFiles*/ false,
+        instance.transformers
+      );
+    }
     return outputFiles;
   } else {
     // Emit Javascript
-    return instance.languageService!.getEmitOutput(filePath).outputFiles;
+    return instance.languageService!.getProgram()!.getSourceFile(filePath)
+      ? instance.languageService!.getEmitOutput(filePath).outputFiles
+      : [];
   }
 }

src/interfaces.ts

@@ -94,11 +94,11 @@ export interface Webpack {
   /**
    * Emit a warning.
    */
-  emitWarning: (message: string) => void;
+  emitWarning: (message: Error) => void;
   /**
    * Emit an error.
    */
-  emitError: (message: string) => void;
+  emitError: (message: Error) => void;
   /**
    * Emit a file. This is webpack-specific
    */
@@ -239,6 +239,12 @@ export interface TSInstance {
    * contains the modified files - cleared each time after-compile is called
    */
   modifiedFiles?: TSFiles | null;
+  /**
+   * Paths to project references that are missing source maps.
+   * Cleared each time after-compile is called. Used to dedupe
+   * warnings about source maps during a single compilation.
+   */
+  projectsMissingSourceMaps?: Set<string>;
   languageService?: typescript.LanguageService | null;
   version?: number;
   dependencyGraph: DependencyGraph;

src/servicesHost.ts

@@ -21,7 +21,8 @@ export function makeServicesHost(
   scriptRegex: RegExp,
   log: logger.Logger,
   loader: Webpack,
-  instance: TSInstance
+  instance: TSInstance,
+  projectReferences?: ReadonlyArray<typescript.ProjectReference>
 ) {
   const {
     compiler,
@@ -61,6 +62,8 @@ export function makeServicesHost(
   const servicesHost: typescript.LanguageServiceHost = {
     getProjectVersion: () => `${instance.version}`,
 
+    getProjectReferences: () => projectReferences,
+
     getScriptFileNames: () =>
       [...files.keys()].filter(filePath => filePath.match(scriptRegex)),
 
@@ -149,7 +152,8 @@ export function makeWatchHost(
   loader: Webpack,
   instance: TSInstance,
   appendTsSuffixTo: RegExp[],
-  appendTsxSuffixTo: RegExp[]
+  appendTsxSuffixTo: RegExp[],
+  projectReferences?: ReadonlyArray<typescript.ProjectReference>
 ) {
   const { compiler, compilerOptions, files, otherFiles } = instance;
 
@@ -239,7 +243,9 @@ export function makeWatchHost(
         );
       }
     },
-    createProgram: compiler.createAbstractBuilder
+    createProgram: projectReferences
+      ? createBuilderProgramWithReferences
+      : compiler.createAbstractBuilder
   };
   return watchHost;
 
@@ -366,6 +372,33 @@ export function makeWatchHost(
       callback
     );
   }
+
+  function createBuilderProgramWithReferences(
+    rootNames: ReadonlyArray<string> | undefined,
+    options: typescript.CompilerOptions | undefined,
+    host: typescript.CompilerHost | undefined,
+    oldProgram: typescript.BuilderProgram | undefined,
+    configFileParsingDiagnostics:
+      | ReadonlyArray<typescript.Diagnostic>
+      | undefined
+  ) {
+    const program = compiler.createProgram({
+      rootNames: rootNames!,
+      options: options!,
+      host,
+      oldProgram: oldProgram && oldProgram.getProgram(),
+      configFileParsingDiagnostics,
+      projectReferences
+    });
+
+    const builderProgramHost: typescript.BuilderProgramHost = host!;
+    return compiler.createAbstractBuilder(
+      program,
+      builderProgramHost,
+      oldProgram,
+      configFileParsingDiagnostics
+    );
+  }
 }
 
 function resolveModuleNames(