Use Jest sourcemaps and remove languageserver (#554)

This PR uses the jest infrastructure for sourcemaps. It completely removes any dependance on source-map-support from our part.

Note that removing the languageServer is a breaking change - however it was never documented. A language-server branch has been created based off master.

This PR is based on #552 so merge that in first.

It closes #340. Surprisingly enough it also closes #240 - passing the sourcemaps explicitly to babel means that the line# are correct in the other end - you'll see that in one of the updated tests.

It fixes part of #529 

Note that no line# has changed, but some column names have in the tests. I'm not sure the original column names were ever accurate.

Author: GeeWee

index.js

@@ -12,5 +12,4 @@ function lazyRequire(fnName) {
 module.exports = {
   process: lazyRequire('process'),
   getCacheKey: lazyRequire('getCacheKey'),
-  install: require('./dist/install').install,
 };

package.json

@@ -71,7 +71,6 @@
     "jest-config": "^23.0.0",
     "lodash": "^4.17.10",
     "pkg-dir": "^2.0.0",
-    "source-map-support": "^0.5.6",
     "yargs": "^11.0.0"
   },
   "peerDependencies": {

src/install.ts

@@ -1,4 +1,7 @@
-import { TransformOptions as BabelTransformOpts } from 'babel-core';
+import {
+  BabelFileResult,
+  TransformOptions as BabelTransformOpts,
+} from 'babel-core';
 
 export interface TransformOptions {
   instrument: boolean;
@@ -24,11 +27,11 @@ export interface BabelTransformOptions extends BabelTransformOpts {
 }
 
 export type PostProcessHook = (
-  src: string,
+  codeSourcemapPair: CodeSourceMapPair,
   filePath: string,
   config: JestConfig,
   transformOptions: TransformOptions,
-) => string;
+) => CodeSourceMapPair;
 
 export type JestConfig = Partial<FullJestConfig>;
 
@@ -95,3 +98,8 @@ export interface JestConfigNormalize {
   hasDeprecationWarnings: boolean;
   options: FullJestConfig;
 }
+
+export interface CodeSourceMapPair {
+  code: string;
+  map: string;
+}

src/jest-types.ts

@@ -5,44 +5,47 @@
 import * as __types__babel from 'babel-core';
 import __types__istanbulPlugin from 'babel-plugin-istanbul';
 import * as __types__jestPreset from 'babel-preset-jest';
+import * as ts from 'typescript';
 let babel: typeof __types__babel;
 let istanbulPlugin: typeof __types__istanbulPlugin;
 let jestPreset: typeof __types__jestPreset;
 function importBabelDeps() {
-    if (babel) {
-      return;
-    }
-    babel = require('babel-core');
-    istanbulPlugin = require('babel-plugin-istanbul').default;
-    jestPreset = require('babel-preset-jest');
+  if (babel) {
+    return;
+  }
+  babel = require('babel-core');
+  istanbulPlugin = require('babel-plugin-istanbul').default;
+  jestPreset = require('babel-preset-jest');
 }
 import { CompilerOptions } from 'typescript/lib/typescript';
 import {
   BabelTransformOptions,
+  CodeSourceMapPair,
   FullJestConfig,
   JestConfig,
   PostProcessHook,
   TransformOptions,
   TsJestConfig,
 } from './jest-types';
 import { logOnce } from './logger';
+import { BabelFileResult } from 'babel-core';
 
 // Function that takes the transpiled typescript and runs it through babel/whatever.
 export function postProcessCode(
   compilerOptions: CompilerOptions,
   jestConfig: JestConfig,
   tsJestConfig: TsJestConfig,
   transformOptions: TransformOptions,
-  transpiledText: string,
+  transpileOutput: CodeSourceMapPair,
   filePath: string,
-): string {
+): CodeSourceMapPair {
   const postHook = getPostProcessHook(
     compilerOptions,
     jestConfig,
     tsJestConfig,
   );
 
-  return postHook(transpiledText, filePath, jestConfig, transformOptions);
+  return postHook(transpileOutput, filePath, jestConfig, transformOptions);
 }
 
 function createBabelTransformer(
@@ -53,23 +56,20 @@ function createBabelTransformer(
     ...options,
     plugins: options.plugins || [],
     presets: (options.presets || []).concat([jestPreset]),
-    // If retainLines isn't set to true, the line numbers
-    // are off by 1
-    retainLines: true,
-    // force the sourceMaps property to be 'inline' during testing
-    // to help generate accurate sourcemaps.
-    sourceMaps: 'inline',
   };
   delete options.cacheDirectory;
   delete options.filename;
 
   return (
-    src: string,
+    codeSourcemapPair: CodeSourceMapPair,
     filename: string,
     config: JestConfig,
     transformOptions: TransformOptions,
-  ): string => {
-    const theseOptions = Object.assign({ filename }, options);
+  ): CodeSourceMapPair => {
+    const theseOptions = Object.assign(
+      { filename, inputSourceMap: codeSourcemapPair.map },
+      options,
+    );
     if (transformOptions && transformOptions.instrument) {
       theseOptions.auxiliaryCommentBefore = ' istanbul ignore next ';
       // Copied from jest-runtime transform.js
@@ -84,8 +84,11 @@ function createBabelTransformer(
         ],
       ]);
     }
-
-    return babel.transform(src, theseOptions).code;
+    // Babel has incorrect typings, where the map is an object instead of a string. So we have to typecast it here
+    return (babel.transform(
+      codeSourcemapPair.code,
+      theseOptions,
+    ) as any) as CodeSourceMapPair;
   };
 }
 
@@ -96,7 +99,8 @@ export const getPostProcessHook = (
 ): PostProcessHook => {
   if (tsJestConfig.skipBabel) {
     logOnce('Not using any postprocess hook.');
-    return src => src; // Identity function
+    // Identity function
+    return input => input;
   }
 
   const plugins = Array.from(
@@ -107,11 +111,12 @@ export const getPostProcessHook = (
     plugins.push('transform-es2015-modules-commonjs');
   }
 
-  const babelOptions = {
+  const babelOptions: BabelTransformOptions = {
     ...tsJestConfig.babelConfig,
     babelrc: tsJestConfig.useBabelrc || false,
     plugins,
     presets: tsJestConfig.babelConfig ? tsJestConfig.babelConfig.presets : [],
+    sourceMaps: tsJestConfig.disableSourceMapSupport !== true,
   };
 
   logOnce('Using babel with options:', babelOptions);

src/postprocess.ts

@@ -1,21 +1,22 @@
 import * as crypto from 'crypto';
-import { JestConfig, Path, TransformOptions } from './jest-types';
+import {
+  BabelTransformOptions,
+  CodeSourceMapPair,
+  JestConfig,
+  Path,
+  TransformOptions,
+} from './jest-types';
 import { flushLogs, logOnce } from './logger';
 import { postProcessCode } from './postprocess';
-import {
-  getTSConfig,
-  getTSJestConfig,
-  runTsDiagnostics,
-  injectSourcemapHook,
-} from './utils';
+import { getTSConfig, getTSJestConfig, runTsDiagnostics } from './utils';
 import { transpileTypescript } from './transpiler';
 
 export function process(
   src: string,
   filePath: Path,
   jestConfig: JestConfig,
   transformOptions: TransformOptions = { instrument: false },
-): string {
+): CodeSourceMapPair | string {
   // transformOptions.instrument is a proxy for collectCoverage
   // https://github.com/kulshekhar/ts-jest/issues/201#issuecomment-300572902
   const compilerOptions = getTSConfig(jestConfig.globals, jestConfig.rootDir);
@@ -47,21 +48,16 @@ export function process(
     runTsDiagnostics(filePath, compilerOptions);
   }
 
-  let tsTranspiledText = transpileTypescript(
-    filePath,
-    src,
-    compilerOptions,
-    tsJestConfig,
-  );
+  const transpileOutput = transpileTypescript(filePath, src, compilerOptions);
 
   if (tsJestConfig.ignoreCoverageForAllDecorators === true) {
-    tsTranspiledText = tsTranspiledText.replace(
+    transpileOutput.code = transpileOutput.code.replace(
       /__decorate/g,
       '/* istanbul ignore next */__decorate',
     );
   }
   if (tsJestConfig.ignoreCoverageForDecorators === true) {
-    tsTranspiledText = tsTranspiledText.replace(
+    transpileOutput.code = transpileOutput.code.replace(
       /(__decorate\(\[\r?\n[^\n\r]*)\/\*\s*istanbul\s*ignore\s*decorator(.*)\*\//g,
       '/* istanbul ignore next$2*/$1',
     );
@@ -72,18 +68,18 @@ export function process(
     jestConfig,
     tsJestConfig,
     transformOptions,
-    tsTranspiledText,
+    transpileOutput,
     filePath,
   );
 
-  const modified =
+  /*const modified =
     tsJestConfig.disableSourceMapSupport === true
       ? outputText
-      : injectSourcemapHook(filePath, tsTranspiledText, outputText);
-
+      : injectSourcemapHook(filePath, transpileOutput, outputText);
+*/
   flushLogs();
 
-  return modified;
+  return { code: outputText.code, map: outputText.map };
 }
 
 /**

src/preprocessor.ts

@@ -2,96 +2,24 @@ import * as fs from 'fs';
 import { cwd } from 'process';
 import * as ts from 'typescript';
 import { logOnce } from './logger';
-import { TsJestConfig } from './jest-types';
+import { CodeSourceMapPair, TsJestConfig } from './jest-types';
 
 // Takes the typescript code and by whatever method configured, makes it into javascript code.
 export function transpileTypescript(
   filePath: string,
   fileSrc: string,
   compilerOptions: ts.CompilerOptions,
-  tsJestConfig: TsJestConfig,
-): string {
-  if (tsJestConfig.useExperimentalLanguageServer) {
-    logOnce('Using experimental language server.');
-    return transpileViaLanguageServer(filePath, fileSrc, compilerOptions);
-  }
+): CodeSourceMapPair {
   logOnce('Compiling via normal transpileModule call');
-  return transpileViaTranspileModile(filePath, fileSrc, compilerOptions);
-}
-
-/**
- * This is slower, but can properly parse enums and deal with reflect metadata.
- * This is an experimental approach from our side. Potentially we should cache
- * the languageServer between calls.
- */
-function transpileViaLanguageServer(
-  filePath: string,
-  fileSrc: string,
-  compilerOptions: ts.CompilerOptions,
-): string {
-  const serviceHost: ts.LanguageServiceHost = {
-    // Returns an array of the files we need to consider
-    getScriptFileNames: () => {
-      return [filePath];
-    },
-
-    getScriptVersion: fileName => {
-      // We're not doing any watching or changing files, so versioning is not relevant for us
-      return undefined;
-    },
-
-    getCurrentDirectory: () => {
-      return cwd();
-    },
-
-    getScriptSnapshot: fileName => {
-      if (fileName === filePath) {
-        // jest has already served this file for us, so no need to hit disk again.
-        return ts.ScriptSnapshot.fromString(fileSrc);
-      }
-      // Read file from disk. I think this could be problematic if the files are not saved as utf8.
-      const result = fs.readFileSync(fileName, 'utf8');
-      return ts.ScriptSnapshot.fromString(result);
-    },
-
-    getCompilationSettings: () => {
-      return compilerOptions;
-    },
-
-    getDefaultLibFileName: () => {
-      return ts.getDefaultLibFilePath(compilerOptions);
-    },
-    fileExists: ts.sys.fileExists,
-    readFile: ts.sys.readFile,
-    readDirectory: ts.sys.readDirectory,
-    realpath: ts.sys.realpath,
-    getDirectories: ts.sys.getDirectories,
-    directoryExists: ts.sys.directoryExists,
+  const transpileOutput = transpileViaTranspileModile(
+    filePath,
+    fileSrc,
+    compilerOptions,
+  );
+  return {
+    code: transpileOutput.outputText,
+    map: transpileOutput.sourceMapText,
   };
-  const service = ts.createLanguageService(serviceHost);
-  const serviceOutput = service.getEmitOutput(filePath);
-  const files = serviceOutput.outputFiles.filter(file => {
-    // Service outputs both d.ts and .js files - we're not interested in the declarations.
-    return file.name.endsWith('js');
-  });
-  logOnce('JS files parsed', files.map(f => f.name));
-
-  // Log some diagnostics here:
-  const diagnostics = service
-    .getCompilerOptionsDiagnostics()
-    .concat(service.getSyntacticDiagnostics(filePath))
-    .concat(service.getSemanticDiagnostics(filePath));
-
-  if (diagnostics.length > 0) {
-    const errors = `${diagnostics.map(d => d.messageText)}\n`;
-    logOnce(`Diagnostic errors from TSC: ${errors}`);
-    // Maybe we should keep compiling even though there are errors. This can possibly be configured.
-    throw Error(
-      `TSC language server encountered errors while transpiling. Errors: ${errors}`,
-    );
-  }
-
-  return files[0].text;
 }
 
 /**
@@ -101,9 +29,9 @@ function transpileViaTranspileModile(
   filePath: string,
   fileSource: string,
   compilerOptions: ts.CompilerOptions,
-): string {
+): ts.TranspileOutput {
   return ts.transpileModule(fileSource, {
     compilerOptions,
     fileName: filePath,
-  }).outputText;
+  });
 }