Emitter SourceMaps

We said that the bulk of the emitter.ts is the local function emitJavaScript (we showed the initialization routine of this function before). It basically sets up a bunch of locals and hits off to emitSourceFile. The following is a revisiting of the function, this time focusing on SourceMap stuff:

  1. function emitJavaScript(jsFilePath: string, root?: SourceFile) {
  3.     // STUFF ........... removed
  5.     let writeComment = writeCommentRange;
  7.     /** Write emitted output to disk */
  8.     let writeEmittedFiles = writeJavaScriptFile;
  10.     /** Emit a node */
  11.     let emit = emitNodeWithoutSourceMap;
  13.     /** Called just before starting emit of a node */
  14.     let emitStart = function (node: Node) { };
  16.     /** Called once the emit of the node is done */
  17.     let emitEnd = function (node: Node) { };
  19.     /** Emit the text for the given token that comes after startPos
  20.       * This by default writes the text provided with the given tokenKind
  21.       * but if optional emitFn callback is provided the text is emitted using the callback instead of default text
  22.       * @param tokenKind the kind of the token to search and emit
  23.       * @param startPos the position in the source to start searching for the token
  24.       * @param emitFn if given will be invoked to emit the text instead of actual token emit */
  25.     let emitToken = emitTokenText;
  27.     /** Called to before starting the lexical scopes as in function/class in the emitted code because of node
  28.       * @param scopeDeclaration node that starts the lexical scope
  29.       * @param scopeName Optional name of this scope instead of deducing one from the declaration node */
  30.     let scopeEmitStart = function(scopeDeclaration: Node, scopeName?: string) { };
  32.     /** Called after coming out of the scope */
  33.     let scopeEmitEnd = function() { };
  35.     /** Sourcemap data that will get encoded */
  36.     let sourceMapData: SourceMapData;
  38.     if (compilerOptions.sourceMap || compilerOptions.inlineSourceMap) {
  39.         initializeEmitterWithSourceMaps();
  40.     }
  42.     if (root) {
  43.         // Do not call emit directly. It does not set the currentSourceFile.
  44.         emitSourceFile(root);
  45.     }
  46.     else {
  47.         forEach(host.getSourceFiles(), sourceFile => {
  48.             if (!isExternalModuleOrDeclarationFile(sourceFile)) {
  49.                 emitSourceFile(sourceFile);
  50.             }
  51.         });
  52.     }
  54.     writeLine();
  55.     writeEmittedFiles(writer.getText(), /*writeByteOrderMark*/ compilerOptions.emitBOM);
  56.     return;
  58.     /// BUNCH OF LOCAL FUNCTIONS

The important function call here : initializeEmitterWithSourceMaps which is a function local to emitJavaScript that overrides some locals that were already defined here. At the bottom of initializeEmitterWithSourceMaps you will notice the overriding:

  1.     // end of `initializeEmitterWithSourceMaps`
  3.     writeEmittedFiles = writeJavaScriptAndSourceMapFile;
  4.     emit = emitNodeWithSourceMap;
  5.     emitStart = recordEmitNodeStartSpan;
  6.     emitEnd = recordEmitNodeEndSpan;
  7.     emitToken = writeTextWithSpanRecord;
  8.     scopeEmitStart = recordScopeNameOfNode;
  9.     scopeEmitEnd = recordScopeNameEnd;
  10.     writeComment = writeCommentRangeWithMap;

This means that the bulk of emitter code can not care about SourceMap and just use these local functions the same way with or without SourceMaps.