Emitter

Relevant source files

• src/compiler/binder.ts
• src/compiler/checker.ts
• src/compiler/commandLineParser.ts
• src/compiler/core.ts
• src/compiler/diagnosticMessages.json
• src/compiler/emitter.ts
• src/compiler/moduleNameResolver.ts
• src/compiler/moduleSpecifiers.ts
• src/compiler/parser.ts
• src/compiler/program.ts
• src/compiler/resolutionCache.ts
• src/compiler/scanner.ts
• src/compiler/sourcemap.ts
• src/compiler/sys.ts
• src/compiler/transformers/es2015.ts
• src/compiler/transformers/es2017.ts
• src/compiler/transformers/esnext.ts
• src/compiler/transformers/generators.ts
• src/compiler/transformers/module/module.ts
• src/compiler/transformers/module/system.ts
• src/compiler/transformers/ts.ts
• src/compiler/types.ts
• src/compiler/utilities.ts
• src/harness/client.ts
• src/harness/fourslashImpl.ts
• src/harness/fourslashInterfaceImpl.ts
• src/harness/harnessLanguageService.ts
• src/server/editorServices.ts
• src/server/project.ts
• src/server/protocol.ts
• src/server/scriptInfo.ts
• src/server/scriptVersionCache.ts
• src/server/session.ts
• src/server/utilities.ts
• src/services/codefixes/importFixes.ts
• src/services/completions.ts
• src/services/exportInfoMap.ts
• src/services/findAllReferences.ts
• src/services/goToDefinition.ts
• src/services/importTracker.ts
• src/services/services.ts
• src/services/types.ts
• src/services/utilities.ts
• src/testRunner/unittests/tsserver/exportMapCache.ts
• tests/baselines/reference/api/typescript.d.ts
• tests/baselines/reference/emitter.asyncGenerators.classMethods.es2015.js
• tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2015.js
• tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2015.js
• tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2015.js
• tests/baselines/reference/tsserver/exportMapCache/invalidates-the-cache-when-a-file-is-opened-with-different-contents.js
• tests/cases/fourslash/fourslash.ts
• tests/cases/fourslash/server/completionsOverridingMethodCrash2.ts

The emitter is the final stage of the TypeScript compilation pipeline. It takes a type-checked AST (or a set of them, in the case of --outFile mode), applies a transformer pipeline to convert TypeScript-specific syntax into target-compatible JavaScript, and then writes the output: JavaScript files, declaration files (.d.ts), and source maps.

This page covers src/compiler/emitter.ts and its interactions with the transformer infrastructure. For the transformer pipeline itself, see 3. Transformation Pipeline. For how the Program object initiates emission, see 2.6. Program and Compilation.

---

High-Level Architecture

The emit process has two distinct phases:

1. Transform – The AST is run through a chain of TransformerFactory functions. Each transformer rewrites TypeScript-specific or downlevel syntax into forms appropriate for the target JavaScript version and module system.
2. Print – The transformed AST is visited by the Printer, which serializes nodes into text, interleaving source positions for source map generation.

Emit Pipeline

Sources: src/compiler/emitter.ts446-479 src/compiler/program.ts66-68

---

Emit Entry Points

emitFiles

The primary internal entry point is emitFiles, defined in src/compiler/emitter.ts and called by Program.emit() in src/compiler/program.ts. It receives an EmitResolver, an EmitHost, and an EmitTransformers object bundling the configured transformer factories.

forEachEmittedFile

forEachEmittedFile src/compiler/emitter.ts446-479 iterates over every file that is expected to produce output. For single-file-out (--outFile) mode, it creates a Bundle node. Otherwise, it iterates each SourceFile individually. For each file, it computes the output paths via getOutputPathsFor and calls the provided action.

Output file type	Condition
.js / .mjs / .cjs	emitDeclarationOnly is false
.js.map	sourceMap or inlineSourceMap is set
.d.ts	declaration or emitDeclarationOnly is set
.d.ts.map	declarationMap is set
.tsbuildinfo	incremental compilation or tscBuild is set

Sources: src/compiler/emitter.ts446-504

---

The Printer

The Printer interface is defined in src/compiler/types.ts. An instance is created by calling createPrinter(options, handlers) in src/compiler/emitter.ts.

Printer and its collaborators

Sources: src/compiler/types.ts4446-4475 src/compiler/emitter.ts1-425

Internal Emit Pipeline

Inside createPrinter, the core recursive function is pipelineEmitWithHint(hint, node). Before calling the actual node emitter, it:

1. Calls onBeforeEmitNode from PrintHandlers (used by transformers for bookkeeping).
2. Calls substituteNode from PrintHandlers, which allows transformers to swap out a node at emit time.
3. Invokes onEmitNode from PrintHandlers (transformers use this to inject helper prologues, etc.).
4. Calls the appropriate per-kind emit function (e.g., emitFunctionDeclaration, emitClassDeclaration).
5. Calls onAfterEmitNode.

This hook architecture allows the transformer pipeline to intercept every node in a non-destructive way.

ListFormat

When emitting node arrays (parameters, arguments, type parameters, etc.), the printer uses the ListFormat bitfield enum from src/compiler/types.ts. Key flags include:

Flag group	Examples
Delimiter	CommaDelimited, BarDelimited, AmpersandDelimited, SemicolonDelimited
Whitespace	SpaceBetweenBraces, Indented, MultiLine, SingleLine
Brackets	Braces, Brackets, Parenthesis, AngleBrackets
Special	NoTrailingNewLine, OptionalIfEmpty, PreferNewLine, AllowTrailingComma

Sources: src/compiler/types.ts4482-4581

---

EmitFlags

EmitFlags is a bitfield enum on src/compiler/types.ts that is stored on the EmitNode sidecar attached to each AST node (rather than directly on the node). It controls per-node printer behavior without mutating the original parsed tree.

Selected EmitFlags

Flag	Effect
NoLeadingComments	Suppress leading comment emit for the node
NoTrailingComments	Suppress trailing comment emit
SingleLine	Force single-line output
MultiLine	Force multi-line output
NoIndentation	Suppress indentation increase for children
AsyncFunctionBody	Node is the body of an async function
ReuseTempVariableScope	Reuse outer temp scope instead of a new one
CustomPrologue	Statement is a custom prologue emitted before hoisted declarations
NoHoisting	Prevent the declaration from being hoisted
HasEndOfDeclarationMarker	End-of-declaration marker for multi-statement transforms
Iterator	Iterate in a for-of without Symbol.iterator lookup
NoAsciiEscaping	Emit unicode characters directly instead of as escape sequences

The helpers setEmitFlags, addEmitFlags, and getEmitFlags in src/compiler/utilities.ts manipulate these flags through the EmitNode sidecar.

Sources: src/compiler/types.ts4602-4660 src/compiler/utilities.ts5-6

---

EmitHint

EmitHint is passed as the first argument to pipelineEmitWithHint and to the substituteNode / onEmitNode hooks in PrintHandlers. It tells the printer what syntactic role the node occupies so the correct emit path is taken.

Value	Usage
Unspecified	Default; the printer determines the path from node.kind
Expression	Emit the node as an expression (may add parentheses)
SourceFile	Emit as a full source file
MappedTypeParameter	Emit as a mapped type's TypeParameter
EmbeddedStatement	Emit as a statement inside another statement
IdentifierName	Emit as a plain identifier without keyword checks
JsxAttributeValue	Emit in a JSX attribute value context

Sources: src/compiler/types.ts4584-4600

---

EmitHost and EmitResolver

These two interfaces decouple the emitter from the rest of the compiler.

EmitHost (src/compiler/types.ts) is typically implemented by Program. It provides:

• getSourceFiles() – the set of source files
• getCompilerOptions() – compiler options
• writeFile() – the actual file write callback
• getCommonSourceDirectory(), getCanonicalFileName(), path helpers
• isEmitBlocked(file) – whether a given file's emit has been suppressed

EmitResolver (src/compiler/types.ts) is created by the type checker and answers semantic questions needed during emit:

• isDeclarationVisible(node) – needed by the declaration transformer
• getReferencedExportContainer(node) – for export alias resolution
• isValueAliasDeclaration(node), isReferencedAliasDeclaration(node) – import elision
• getConstantValue(node) – for const enum inlining
• getTypeReferenceSerializationKind(node) – for decorator metadata
• collectLinkedAliases(node) – for type-only imports

Sources: src/compiler/types.ts4311-4416 src/compiler/checker.ts166

---

Transformer Pipeline Integration

Before printing, transformNodes (defined in src/compiler/transformer.ts, called from emitter.ts) applies the full sequence of built-in and user-provided transformers. The printer's PrintHandlers are wired up from the TransformationResult so that substituteNode and onEmitNode delegate to each transformer that registered hooks.

Relationship between transformers and the printer

The built-in transformers are applied in this order (for JS output):

1. TypeScript-specific transformer (src/compiler/transformers/ts.ts) – strips type annotations, handles decorators, emits const enum values.
2. ESNext, ES2022, ES2021, … down to the target – each transformer handles one ECMAScript version's syntax.
3. Module transformer (src/compiler/transformers/module/module.ts) – converts import/export to the target module format.

Sources: src/compiler/emitter.ts77 src/compiler/transformers/ts.ts src/compiler/transformers/module/module.ts

---

Declaration File Emission

Declaration file (.d.ts) generation runs as a separate transformer pass using the declarationTransformer. This transformer walks the type-checked AST and serializes inferred types through TypeChecker calls when explicit annotations are absent.

Sources: src/compiler/emitter.ts130 src/compiler/program.ts113

---

Source Map Generation

Source maps track the correspondence between positions in the emitted output and positions in the original TypeScript source. The emitter uses SourceMapGenerator (created by createSourceMapGenerator) to record these mappings.

Sources: src/compiler/emitter.ts55 src/compiler/sourcemap.ts

---

Output Path Computation

getOutputPathsFor and getOwnEmitOutputFilePath in emitter.ts compute where each output file goes based on outDir, rootDir, outFile, and the input file path. .tsbuildinfo path resolution is handled by getTsBuildInfoEmitOutputFilePath src/compiler/emitter.ts481-500

Sources: src/compiler/emitter.ts506-560

---

Summary of Key Symbols

Symbol	File	Role
emitFiles	src/compiler/emitter.ts	Orchestrates the full emit for a Program
createPrinter	src/compiler/emitter.ts	Factory for Printer instances
Printer	src/compiler/types.ts	Interface for AST-to-text serialization
EmitHost	src/compiler/types.ts	Abstracts file I/O and program data
EmitResolver	src/compiler/types.ts	Semantic answers from type checker
EmitFlags	src/compiler/types.ts	Per-node printer control flags
EmitTextWriter	src/compiler/types.ts	Text buffer with indent tracking
SourceMapGenerator	src/compiler/types.ts	Records position mappings

Sources: src/compiler/emitter.ts src/compiler/types.ts