ttsc 0.7.2 → 0.8.0-dev.20260505

package/shim/compiler/emit_hooks.go

@@ -0,0 +1,494 @@
+package compiler
+
+import (
+  "context"
+
+  "github.com/microsoft/typescript-go/internal/ast"
+  "github.com/microsoft/typescript-go/internal/binder"
+  innercompiler "github.com/microsoft/typescript-go/internal/compiler"
+  "github.com/microsoft/typescript-go/internal/core"
+  "github.com/microsoft/typescript-go/internal/diagnostics"
+  "github.com/microsoft/typescript-go/internal/module"
+  "github.com/microsoft/typescript-go/internal/outputpaths"
+  "github.com/microsoft/typescript-go/internal/packagejson"
+  "github.com/microsoft/typescript-go/internal/printer"
+  "github.com/microsoft/typescript-go/internal/sourcemap"
+  "github.com/microsoft/typescript-go/internal/stringutil"
+  "github.com/microsoft/typescript-go/internal/symlinks"
+  "github.com/microsoft/typescript-go/internal/transformers"
+  "github.com/microsoft/typescript-go/internal/transformers/declarations"
+  "github.com/microsoft/typescript-go/internal/transformers/estransforms"
+  "github.com/microsoft/typescript-go/internal/transformers/inliners"
+  "github.com/microsoft/typescript-go/internal/transformers/jsxtransforms"
+  "github.com/microsoft/typescript-go/internal/transformers/moduletransforms"
+  "github.com/microsoft/typescript-go/internal/transformers/tstransforms"
+  "github.com/microsoft/typescript-go/internal/tsoptions"
+  "github.com/microsoft/typescript-go/internal/tspath"
+)
+
+type EmitContext = printer.EmitContext
+
+type EmitSourceFileHook func(context *EmitContext, file *ast.SourceFile) *ast.SourceFile
+
+type EmitHooks struct {
+  BeforePrintDeclaration EmitSourceFileHook
+  BeforePrintJS          EmitSourceFileHook
+}
+
+type hookEmitHost struct {
+  program      *innercompiler.Program
+  emitResolver printer.EmitResolver
+}
+
+type hookEmitter struct {
+  host       *hookEmitHost
+  emitOnly   innercompiler.EmitOnly
+  emitResult innercompiler.EmitResult
+  hooks      EmitHooks
+  paths      *outputpaths.OutputPaths
+  sourceFile *ast.SourceFile
+  writeFile  innercompiler.WriteFile
+  writer     printer.EmitTextWriter
+}
+
+func EmitWithHooks(ctx context.Context, program *innercompiler.Program, options innercompiler.EmitOptions, hooks EmitHooks) *innercompiler.EmitResult {
+  if program == nil {
+    return nil
+  }
+  if options.EmitOnly != innercompiler.EmitOnlyForcedDts {
+    result := HandleNoEmitOnError(ctx, program, options.TargetSourceFile)
+    if result != nil || ctx.Err() != nil {
+      return result
+    }
+  }
+  var results []*innercompiler.EmitResult
+  newLine := program.Options().NewLine.GetNewLineCharacter()
+  for _, sourceFile := range hookSourceFilesToEmit(program, options.TargetSourceFile, options.EmitOnly == innercompiler.EmitOnlyForcedDts) {
+    host, done := newHookEmitHost(ctx, program, sourceFile)
+    emitter := &hookEmitter{
+      host:       host,
+      emitOnly:   options.EmitOnly,
+      hooks:      hooks,
+      paths:      outputpaths.GetOutputPathsFor(sourceFile, host.Options(), host, options.EmitOnly == innercompiler.EmitOnlyForcedDts),
+      sourceFile: sourceFile,
+      writeFile:  options.WriteFile,
+      writer:     printer.NewTextWriter(newLine, 0),
+    }
+    emitter.emit()
+    done()
+    results = append(results, &emitter.emitResult)
+  }
+  return CombineEmitResults(results)
+}
+
+func hookSourceFilesToEmit(program *innercompiler.Program, target *ast.SourceFile, forceDtsEmit bool) []*ast.SourceFile {
+  if target != nil {
+    if program.SourceFileMayBeEmitted(target, forceDtsEmit) {
+      return []*ast.SourceFile{target}
+    }
+    return nil
+  }
+  var out []*ast.SourceFile
+  for _, sourceFile := range program.SourceFiles() {
+    if program.SourceFileMayBeEmitted(sourceFile, forceDtsEmit) {
+      out = append(out, sourceFile)
+    }
+  }
+  return out
+}
+
+func newHookEmitHost(ctx context.Context, program *innercompiler.Program, file *ast.SourceFile) (*hookEmitHost, func()) {
+  checker, done := program.GetTypeCheckerForFile(ctx, file)
+  return &hookEmitHost{
+    program:      program,
+    emitResolver: checker.GetEmitResolver(),
+  }, done
+}
+
+func (e *hookEmitter) emit() {
+  e.emitJSFile(e.sourceFile, e.paths.JsFilePath(), e.paths.SourceMapFilePath())
+  e.emitDeclarationFile(e.sourceFile, e.paths.DeclarationFilePath(), e.paths.DeclarationMapPath())
+  e.emitResult.Diagnostics = e.emitterDiagnostics()
+}
+
+func (e *hookEmitter) emitterDiagnostics() []*ast.Diagnostic {
+  return e.emitResult.Diagnostics
+}
+
+func (e *hookEmitter) addDiagnostic(diag *ast.Diagnostic) {
+  e.emitResult.Diagnostics = append(e.emitResult.Diagnostics, diag)
+}
+
+func (e *hookEmitter) runScriptTransformers(emitContext *printer.EmitContext, sourceFile *ast.SourceFile) *ast.SourceFile {
+  for _, transformer := range hookScriptTransformers(emitContext, e.host, sourceFile) {
+    sourceFile = transformer.TransformSourceFile(sourceFile)
+  }
+  return sourceFile
+}
+
+func (e *hookEmitter) runDeclarationTransformers(emitContext *printer.EmitContext, sourceFile *ast.SourceFile, declarationFilePath, declarationMapPath string) (*ast.SourceFile, []*ast.Diagnostic) {
+  transform := declarations.NewDeclarationTransformer(e.host, emitContext, e.host.Options(), declarationFilePath, declarationMapPath)
+  sourceFile = transform.TransformSourceFile(sourceFile)
+  return sourceFile, transform.GetDiagnostics()
+}
+
+func (e *hookEmitter) emitJSFile(sourceFile *ast.SourceFile, jsFilePath string, sourceMapFilePath string) {
+  options := e.host.Options()
+  if sourceFile == nil || e.emitOnly != innercompiler.EmitAll && e.emitOnly != innercompiler.EmitOnlyJs || len(jsFilePath) == 0 {
+    return
+  }
+  if options.NoEmit == core.TSTrue || e.host.IsEmitBlocked(jsFilePath) {
+    e.emitResult.EmitSkipped = true
+    return
+  }
+  emitContext, putEmitContext := printer.GetEmitContext()
+  defer putEmitContext()
+  sourceFile = e.runScriptTransformers(emitContext, sourceFile)
+  if e.hooks.BeforePrintJS != nil {
+    sourceFile = e.hooks.BeforePrintJS(emitContext, sourceFile)
+  }
+  printerOptions := printer.PrinterOptions{
+    RemoveComments:  options.RemoveComments.IsTrue(),
+    NewLine:         options.NewLine,
+    NoEmitHelpers:   options.NoEmitHelpers.IsTrue(),
+    SourceMap:       options.SourceMap.IsTrue(),
+    InlineSourceMap: options.InlineSourceMap.IsTrue(),
+    InlineSources:   options.InlineSources.IsTrue(),
+    Target:          options.Target,
+  }
+  p := printer.NewPrinter(printerOptions, printer.PrintHandlers{}, emitContext)
+  e.printSourceFile(jsFilePath, sourceMapFilePath, sourceFile, p, hookShouldEmitSourceMaps(options, sourceFile))
+}
+
+func (e *hookEmitter) emitDeclarationFile(sourceFile *ast.SourceFile, declarationFilePath string, declarationMapPath string) {
+  options := e.host.Options()
+  if sourceFile == nil || e.emitOnly == innercompiler.EmitOnlyJs || len(declarationFilePath) == 0 {
+    return
+  }
+  if e.emitOnly != innercompiler.EmitOnlyForcedDts && (options.NoEmit == core.TSTrue || e.host.IsEmitBlocked(declarationFilePath)) {
+    e.emitResult.EmitSkipped = true
+    return
+  }
+  emitContext, putEmitContext := printer.GetEmitContext()
+  defer putEmitContext()
+  sourceFile, diags := e.runDeclarationTransformers(emitContext, sourceFile, declarationFilePath, declarationMapPath)
+  if e.hooks.BeforePrintDeclaration != nil {
+    sourceFile = e.hooks.BeforePrintDeclaration(emitContext, sourceFile)
+  }
+  printerOptions := printer.PrinterOptions{
+    RemoveComments:      options.RemoveComments.IsTrue(),
+    OnlyPrintJSDocStyle: true,
+    NewLine:             options.NewLine,
+    NoEmitHelpers:       options.NoEmitHelpers.IsTrue(),
+    SourceMap:           options.DeclarationMap.IsTrue(),
+    InlineSourceMap:     options.InlineSourceMap.IsTrue(),
+    InlineSources:       options.InlineSources.IsTrue(),
+  }
+  p := printer.NewPrinter(printerOptions, printer.PrintHandlers{}, emitContext)
+  for _, diag := range diags {
+    e.addDiagnostic(diag)
+  }
+  e.printSourceFile(declarationFilePath, declarationMapPath, sourceFile, p, e.emitOnly != innercompiler.EmitOnlyForcedDts && hookShouldEmitDeclarationSourceMaps(options, sourceFile))
+}
+
+func (e *hookEmitter) printSourceFile(filePath string, sourceMapFilePath string, sourceFile *ast.SourceFile, printer_ *printer.Printer, shouldEmitSourceMaps bool) {
+  options := e.host.Options()
+  var sourceMapGenerator *sourcemap.Generator
+  if shouldEmitSourceMaps {
+    sourceMapGenerator = sourcemap.NewGenerator(
+      tspath.GetBaseFileName(tspath.NormalizeSlashes(filePath)),
+      hookSourceRoot(options),
+      e.sourceMapDirectory(options, filePath, sourceFile),
+      tspath.ComparePathsOptions{
+        UseCaseSensitiveFileNames: e.host.UseCaseSensitiveFileNames(),
+        CurrentDirectory:          e.host.GetCurrentDirectory(),
+      },
+    )
+  }
+  printer_.Write(sourceFile.AsNode(), sourceFile, e.writer, sourceMapGenerator)
+  sourceMapURLPos := -1
+  if sourceMapGenerator != nil {
+    if options.SourceMap.IsTrue() || options.InlineSourceMap.IsTrue() || options.GetAreDeclarationMapsEnabled() {
+      e.emitResult.SourceMaps = append(e.emitResult.SourceMaps, &innercompiler.SourceMapEmitResult{
+        InputSourceFileNames: sourceMapGenerator.Sources(),
+        SourceMap:            sourceMapGenerator.RawSourceMap(),
+        GeneratedFile:        filePath,
+      })
+    }
+    sourceMappingURL := e.sourceMappingURL(options, sourceMapGenerator, filePath, sourceMapFilePath, sourceFile)
+    if len(sourceMappingURL) > 0 {
+      if !e.writer.IsAtStartOfLine() {
+        e.writer.RawWrite(core.IfElse(options.NewLine == core.NewLineKindCRLF, "\r\n", "\n"))
+      }
+      sourceMapURLPos = e.writer.GetTextPos()
+      e.writer.WriteComment("//# sourceMappingURL=")
+      e.writer.WriteComment(sourceMappingURL)
+    }
+    if len(sourceMapFilePath) > 0 {
+      sourceMap := sourceMapGenerator.String()
+      if err := e.writeText(sourceMapFilePath, sourceMap, nil); err != nil {
+        e.addDiagnostic(ast.NewCompilerDiagnostic(diagnostics.Could_not_write_file_0_Colon_1, filePath, err.Error()))
+      } else {
+        e.emitResult.EmittedFiles = append(e.emitResult.EmittedFiles, sourceMapFilePath)
+      }
+    }
+  } else {
+    e.writer.WriteLine()
+  }
+  text := e.writer.String()
+  if options.EmitBOM.IsTrue() {
+    text = stringutil.AddUTF8ByteOrderMark(text)
+  }
+  data := &innercompiler.WriteFileData{
+    SourceMapUrlPos: sourceMapURLPos,
+    Diagnostics:     e.emitterDiagnostics(),
+  }
+  err := e.writeText(filePath, text, data)
+  skippedDtsWrite := data.SkippedDtsWrite
+  if err != nil {
+    e.addDiagnostic(ast.NewCompilerDiagnostic(diagnostics.Could_not_write_file_0_Colon_1, filePath, err.Error()))
+  } else if !skippedDtsWrite {
+    e.emitResult.EmittedFiles = append(e.emitResult.EmittedFiles, filePath)
+  }
+  e.writer.Clear()
+}
+
+func (e *hookEmitter) writeText(fileName string, text string, data *innercompiler.WriteFileData) error {
+  if e.writeFile != nil {
+    return e.writeFile(fileName, text, data)
+  }
+  return e.host.WriteFile(fileName, text)
+}
+
+func (e *hookEmitter) sourceMapDirectory(options *core.CompilerOptions, filePath string, sourceFile *ast.SourceFile) string {
+  if len(options.SourceRoot) > 0 {
+    return e.host.CommonSourceDirectory()
+  }
+  if len(options.MapRoot) > 0 {
+    sourceMapDir := tspath.NormalizeSlashes(options.MapRoot)
+    if sourceFile != nil {
+      sourceMapDir = tspath.GetDirectoryPath(outputpaths.GetSourceFilePathInNewDir(
+        sourceFile.FileName(),
+        sourceMapDir,
+        e.host.GetCurrentDirectory(),
+        e.host.CommonSourceDirectory(),
+        e.host.UseCaseSensitiveFileNames(),
+      ))
+    }
+    if tspath.GetRootLength(sourceMapDir) == 0 {
+      sourceMapDir = tspath.CombinePaths(e.host.CommonSourceDirectory(), sourceMapDir)
+    }
+    return sourceMapDir
+  }
+  return tspath.GetDirectoryPath(tspath.NormalizePath(filePath))
+}
+
+func (e *hookEmitter) sourceMappingURL(options *core.CompilerOptions, sourceMapGenerator *sourcemap.Generator, filePath string, sourceMapFilePath string, sourceFile *ast.SourceFile) string {
+  if options.InlineSourceMap.IsTrue() {
+    return sourceMapGenerator.Base64DataURL()
+  }
+  sourceMapFile := tspath.GetBaseFileName(tspath.NormalizeSlashes(sourceMapFilePath))
+  if len(options.MapRoot) > 0 {
+    sourceMapDir := tspath.NormalizeSlashes(options.MapRoot)
+    if sourceFile != nil {
+      sourceMapDir = tspath.GetDirectoryPath(outputpaths.GetSourceFilePathInNewDir(
+        sourceFile.FileName(),
+        sourceMapDir,
+        e.host.GetCurrentDirectory(),
+        e.host.CommonSourceDirectory(),
+        e.host.UseCaseSensitiveFileNames(),
+      ))
+    }
+    if tspath.GetRootLength(sourceMapDir) == 0 {
+      sourceMapDir = tspath.CombinePaths(e.host.CommonSourceDirectory(), sourceMapDir)
+      return stringutil.EncodeURI(
+        tspath.GetRelativePathToDirectoryOrUrl(
+          tspath.GetDirectoryPath(tspath.NormalizePath(filePath)),
+          tspath.CombinePaths(sourceMapDir, sourceMapFile),
+          true,
+          tspath.ComparePathsOptions{
+            UseCaseSensitiveFileNames: e.host.UseCaseSensitiveFileNames(),
+            CurrentDirectory:          e.host.GetCurrentDirectory(),
+          },
+        ),
+      )
+    }
+    return stringutil.EncodeURI(tspath.CombinePaths(sourceMapDir, sourceMapFile))
+  }
+  return stringutil.EncodeURI(sourceMapFile)
+}
+
+func hookShouldEmitSourceMaps(options *core.CompilerOptions, sourceFile *ast.SourceFile) bool {
+  return (options.SourceMap.IsTrue() || options.InlineSourceMap.IsTrue()) &&
+    !tspath.FileExtensionIs(sourceFile.FileName(), tspath.ExtensionJson)
+}
+
+func hookShouldEmitDeclarationSourceMaps(options *core.CompilerOptions, sourceFile *ast.SourceFile) bool {
+  return options.DeclarationMap.IsTrue() &&
+    !tspath.FileExtensionIs(sourceFile.FileName(), tspath.ExtensionJson)
+}
+
+func hookSourceRoot(options *core.CompilerOptions) string {
+  sourceRoot := tspath.NormalizeSlashes(options.SourceRoot)
+  if len(sourceRoot) > 0 {
+    sourceRoot = tspath.EnsureTrailingDirectorySeparator(sourceRoot)
+  }
+  return sourceRoot
+}
+
+func hookScriptTransformers(emitContext *printer.EmitContext, host printer.EmitHost, sourceFile *ast.SourceFile) []*transformers.Transformer {
+  var tx []*transformers.Transformer
+  options := host.Options()
+  importElisionEnabled := !options.VerbatimModuleSyntax.IsTrue() && !ast.IsInJSFile(sourceFile.AsNode())
+  jsxTransformEnabled := options.GetJSXTransformEnabled() && sourceFile.LanguageVariant == core.LanguageVariantJSX
+  emitResolver := host.GetEmitResolver()
+  var referenceResolver binder.ReferenceResolver
+  if importElisionEnabled || jsxTransformEnabled || !options.GetIsolatedModules() || options.EmitDecoratorMetadata.IsTrue() {
+    emitResolver.MarkLinkedReferencesRecursively(sourceFile)
+    referenceResolver = emitResolver
+  } else {
+    referenceResolver = binder.NewReferenceResolver(options, binder.ReferenceResolverHooks{})
+  }
+  opts := transformers.TransformOptions{
+    Context:                   emitContext,
+    CompilerOptions:           options,
+    Resolver:                  referenceResolver,
+    EmitResolver:              emitResolver,
+    GetEmitModuleFormatOfFile: host.GetEmitModuleFormatOfFile,
+  }
+  if options.EmitDecoratorMetadata.IsTrue() {
+    tx = append(tx, tstransforms.NewMetadataTransformer(&opts))
+  }
+  tx = append(tx, tstransforms.NewTypeEraserTransformer(&opts))
+  if importElisionEnabled {
+    tx = append(tx, tstransforms.NewImportElisionTransformer(&opts))
+  }
+  tx = append(tx, tstransforms.NewRuntimeSyntaxTransformer(&opts))
+  if options.ExperimentalDecorators.IsTrue() {
+    tx = append(tx, tstransforms.NewLegacyDecoratorsTransformer(&opts))
+  }
+  if jsxTransformEnabled {
+    tx = append(tx, jsxtransforms.NewJSXTransformer(&opts))
+  }
+  downleveler := estransforms.GetESTransformer(&opts)
+  if downleveler != nil {
+    tx = append(tx, downleveler)
+  }
+  tx = append(tx, estransforms.NewUseStrictTransformer(&opts))
+  tx = append(tx, hookModuleTransformer(&opts))
+  if !options.GetIsolatedModules() {
+    tx = append(tx, inliners.NewConstEnumInliningTransformer(&opts))
+  }
+  return tx
+}
+
+func hookModuleTransformer(opts *transformers.TransformOptions) *transformers.Transformer {
+  switch opts.CompilerOptions.GetEmitModuleKind() {
+  case core.ModuleKindPreserve:
+    return moduletransforms.NewESModuleTransformer(opts)
+  case core.ModuleKindESNext,
+    core.ModuleKindES2022,
+    core.ModuleKindES2020,
+    core.ModuleKindES2015,
+    core.ModuleKindNode20,
+    core.ModuleKindNode18,
+    core.ModuleKindNode16,
+    core.ModuleKindNodeNext,
+    core.ModuleKindCommonJS:
+    return moduletransforms.NewImpliedModuleTransformer(opts)
+  default:
+    return moduletransforms.NewCommonJSModuleTransformer(opts)
+  }
+}
+
+func (host *hookEmitHost) GetModeForUsageLocation(file ast.HasFileName, moduleSpecifier *ast.StringLiteralLike) core.ResolutionMode {
+  return host.program.GetModeForUsageLocation(file, moduleSpecifier)
+}
+
+func (host *hookEmitHost) GetResolvedModuleFromModuleSpecifier(file ast.HasFileName, moduleSpecifier *ast.StringLiteralLike) *module.ResolvedModule {
+  return host.program.GetResolvedModuleFromModuleSpecifier(file, moduleSpecifier)
+}
+
+func (host *hookEmitHost) GetDefaultResolutionModeForFile(file ast.HasFileName) core.ResolutionMode {
+  return host.program.GetDefaultResolutionModeForFile(file)
+}
+
+func (host *hookEmitHost) GetEmitModuleFormatOfFile(file ast.HasFileName) core.ModuleKind {
+  return host.program.GetEmitModuleFormatOfFile(file)
+}
+
+func (host *hookEmitHost) FileExists(path string) bool {
+  return host.program.FileExists(path)
+}
+
+func (host *hookEmitHost) GetGlobalTypingsCacheLocation() string {
+  return host.program.GetGlobalTypingsCacheLocation()
+}
+
+func (host *hookEmitHost) GetNearestAncestorDirectoryWithPackageJson(dirname string) string {
+  return host.program.GetNearestAncestorDirectoryWithPackageJson(dirname)
+}
+
+func (host *hookEmitHost) GetPackageJsonInfo(pkgJSONPath string) *packagejson.InfoCacheEntry {
+  return host.program.GetPackageJsonInfo(pkgJSONPath)
+}
+
+func (host *hookEmitHost) GetSourceOfProjectReferenceIfOutputIncluded(file ast.HasFileName) string {
+  return host.program.GetSourceOfProjectReferenceIfOutputIncluded(file)
+}
+
+func (host *hookEmitHost) GetProjectReferenceFromSource(path tspath.Path) *tsoptions.SourceOutputAndProjectReference {
+  return host.program.GetProjectReferenceFromSource(path)
+}
+
+func (host *hookEmitHost) GetRedirectTargets(path tspath.Path) []string {
+  return host.program.GetRedirectTargets(path)
+}
+
+func (host *hookEmitHost) GetEffectiveDeclarationFlags(node *ast.Node, flags ast.ModifierFlags) ast.ModifierFlags {
+  return host.GetEmitResolver().GetEffectiveDeclarationFlags(node, flags)
+}
+
+func (host *hookEmitHost) GetOutputPathsFor(file *ast.SourceFile, forceDtsPaths bool) declarations.OutputPaths {
+  return outputpaths.GetOutputPathsFor(file, host.Options(), host, forceDtsPaths)
+}
+
+func (host *hookEmitHost) GetResolutionModeOverride(node *ast.Node) core.ResolutionMode {
+  return host.GetEmitResolver().GetResolutionModeOverride(node)
+}
+
+func (host *hookEmitHost) GetSourceFileFromReference(origin *ast.SourceFile, ref *ast.FileReference) *ast.SourceFile {
+  return host.program.GetSourceFileFromReference(origin, ref)
+}
+
+func (host *hookEmitHost) Options() *core.CompilerOptions { return host.program.Options() }
+func (host *hookEmitHost) SourceFiles() []*ast.SourceFile { return host.program.SourceFiles() }
+func (host *hookEmitHost) GetCurrentDirectory() string    { return host.program.GetCurrentDirectory() }
+func (host *hookEmitHost) CommonSourceDirectory() string  { return host.program.CommonSourceDirectory() }
+func (host *hookEmitHost) UseCaseSensitiveFileNames() bool {
+  return host.program.UseCaseSensitiveFileNames()
+}
+
+func (host *hookEmitHost) IsEmitBlocked(file string) bool {
+  return host.program.IsEmitBlocked(file)
+}
+
+func (host *hookEmitHost) WriteFile(fileName string, text string) error {
+  return host.program.Host().FS().WriteFile(fileName, text)
+}
+
+func (host *hookEmitHost) GetEmitResolver() printer.EmitResolver {
+  return host.emitResolver
+}
+
+func (host *hookEmitHost) IsSourceFileFromExternalLibrary(file *ast.SourceFile) bool {
+  return host.program.IsSourceFileFromExternalLibrary(file)
+}
+
+func (host *hookEmitHost) GetSymlinkCache() *symlinks.KnownSymlinks {
+  return host.program.GetSymlinkCache()
+}
+
+func (host *hookEmitHost) ResolveModuleName(moduleName string, containingFile string, resolutionMode core.ResolutionMode) *module.ResolvedModule {
+  return host.program.ResolveModuleName(moduleName, containingFile, resolutionMode)
+}

package/shim/compiler/shim.go

@@ -1,4 +1,3 @@
-
 // Code generated by packages/ttsc/tools/gen_shims. DO NOT EDIT.
 
 package compiler
@@ -13,37 +12,53 @@ import "github.com/microsoft/typescript-go/internal/vfs"
 import _ "unsafe"
 
 type CheckerPool = compiler.CheckerPool
+
 //go:linkname CombineEmitResults github.com/microsoft/typescript-go/internal/compiler.CombineEmitResults
 func CombineEmitResults(results []*compiler.EmitResult) *compiler.EmitResult
+
 type CompilerHost = compiler.CompilerHost
 type DuplicateSourceFile = compiler.DuplicateSourceFile
+
 const EmitAll = compiler.EmitAll
+
 type EmitHost = compiler.EmitHost
 type EmitOnly = compiler.EmitOnly
+
 const EmitOnlyDts = compiler.EmitOnlyDts
 const EmitOnlyForcedDts = compiler.EmitOnlyForcedDts
 const EmitOnlyJs = compiler.EmitOnlyJs
+
 type EmitOptions = compiler.EmitOptions
 type EmitResult = compiler.EmitResult
 type FileIncludeReason = compiler.FileIncludeReason
+
 //go:linkname FilterNoEmitSemanticDiagnostics github.com/microsoft/typescript-go/internal/compiler.FilterNoEmitSemanticDiagnostics
 func FilterNoEmitSemanticDiagnostics(diagnostics []*ast.Diagnostic, options *core.CompilerOptions) []*ast.Diagnostic
+
 //go:linkname GetDiagnosticsOfAnyProgram github.com/microsoft/typescript-go/internal/compiler.GetDiagnosticsOfAnyProgram
 func GetDiagnosticsOfAnyProgram(ctx context.Context, program compiler.ProgramLike, file *ast.SourceFile, skipNoEmitCheckForDtsDiagnostics bool, getBindDiagnostics func(context.Context, *ast.SourceFile) []*ast.Diagnostic, getSemanticDiagnostics func(context.Context, *ast.SourceFile) []*ast.Diagnostic) []*ast.Diagnostic
+
 //go:linkname HandleNoEmitOnError github.com/microsoft/typescript-go/internal/compiler.HandleNoEmitOnError
 func HandleNoEmitOnError(ctx context.Context, program compiler.ProgramLike, file *ast.SourceFile) *compiler.EmitResult
+
 type LibFile = compiler.LibFile
+
 //go:linkname NewCachedFSCompilerHost github.com/microsoft/typescript-go/internal/compiler.NewCachedFSCompilerHost
 func NewCachedFSCompilerHost(currentDirectory string, fs vfs.FS, defaultLibraryPath string, extendedConfigCache tsoptions.ExtendedConfigCache, trace func(msg *diagnostics.Message, args ...any)) compiler.CompilerHost
+
 //go:linkname NewCompilerHost github.com/microsoft/typescript-go/internal/compiler.NewCompilerHost
 func NewCompilerHost(currentDirectory string, fs vfs.FS, defaultLibraryPath string, extendedConfigCache tsoptions.ExtendedConfigCache, trace func(msg *diagnostics.Message, args ...any)) compiler.CompilerHost
+
 //go:linkname NewProgram github.com/microsoft/typescript-go/internal/compiler.NewProgram
 func NewProgram(opts compiler.ProgramOptions) *compiler.Program
+
 type Program = compiler.Program
 type ProgramLike = compiler.ProgramLike
 type ProgramOptions = compiler.ProgramOptions
+
 //go:linkname SortAndDeduplicateDiagnostics github.com/microsoft/typescript-go/internal/compiler.SortAndDeduplicateDiagnostics
 func SortAndDeduplicateDiagnostics(diagnostics []*ast.Diagnostic) []*ast.Diagnostic
+
 type SourceFileMayBeEmittedHost = compiler.SourceFileMayBeEmittedHost
 type SourceMapEmitResult = compiler.SourceMapEmitResult
 type WriteFile = compiler.WriteFile

package/shim/core/shim.go

@@ -9,18 +9,21 @@ type TextRange = innercore.TextRange
 type ScriptKind = innercore.ScriptKind
 
 const (
-	TSFalse = innercore.TSFalse
-	TSTrue  = innercore.TSTrue
+  TSFalse = innercore.TSFalse
+  TSTrue  = innercore.TSTrue
 
-	ScriptKindUnknown  = innercore.ScriptKindUnknown
-	ScriptKindJS       = innercore.ScriptKindJS
-	ScriptKindJSX      = innercore.ScriptKindJSX
-	ScriptKindTS       = innercore.ScriptKindTS
-	ScriptKindTSX      = innercore.ScriptKindTSX
-	ScriptKindExternal = innercore.ScriptKindExternal
-	ScriptKindJSON     = innercore.ScriptKindJSON
-	ScriptKindDeferred = innercore.ScriptKindDeferred
+  ScriptKindUnknown  = innercore.ScriptKindUnknown
+  ScriptKindJS       = innercore.ScriptKindJS
+  ScriptKindJSX      = innercore.ScriptKindJSX
+  ScriptKindTS       = innercore.ScriptKindTS
+  ScriptKindTSX      = innercore.ScriptKindTSX
+  ScriptKindExternal = innercore.ScriptKindExternal
+  ScriptKindJSON     = innercore.ScriptKindJSON
+  ScriptKindDeferred = innercore.ScriptKindDeferred
 )
 
 // NewTextRange constructs a closed/open [pos, end) text range.
 func NewTextRange(pos, end int) TextRange { return innercore.NewTextRange(pos, end) }
+
+// UndefinedTextRange marks synthesized AST nodes that do not map to source.
+func UndefinedTextRange() TextRange { return innercore.UndefinedTextRange() }