ttsc 0.33.1 → 0.34.0

package/utility/host.go

@@ -11,6 +11,7 @@ import (
 
   shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
   shimprinter "github.com/microsoft/typescript-go/shim/printer"
+  shimtspath "github.com/microsoft/typescript-go/shim/tspath"
   "github.com/microsoft/typescript-go/shim/vfs"
 
   "github.com/samchon/ttsc/packages/ttsc/driver"
@@ -247,15 +248,15 @@ func RunBuildWithIO(args []string, stdout, stderr io.Writer) int {
   }
   emittedFiles := map[string]struct{}{}
   finalWriteFile := writeFile
-  eDiags, err := prog.EmitWithPluginTransformers(nil, func(fileName, text string, data *shimcompiler.WriteFileData) error {
+  eDiags, err := prog.EmitWithPluginTransformers(nil, func(fileName shimtspath.RootedFilePath, text string, data *shimcompiler.WriteFileData) error {
     var err error
     if finalWriteFile != nil {
       err = finalWriteFile(fileName, text, data)
     } else {
-      err = driver.DefaultWriteFile(fileName, text)
+      err = driver.DefaultWriteFile(string(fileName), text)
     }
     if err == nil && (data == nil || !data.SkippedDtsWrite) {
-      emittedFiles[fileName] = struct{}{}
+      emittedFiles[string(fileName)] = struct{}{}
     }
     return err
   })
@@ -353,7 +354,7 @@ func RunTransformWithIO(args []string, stdout, stderr io.Writer) int {
           nil,
           file,
         )
-        key := apiOutputKey(opts.cwd, file.FileName())
+        key := apiOutputKey(opts.cwd, string(file.FileName()))
         out.TypeScript[key] = text
         // A source preamble sits in the parsed text, not in the author's
         // file, so both the comparison and the map use the authored text.

package/utility/preamble_output.go

@@ -32,17 +32,17 @@ type preambleInsertion struct {
 // can leave partial disk output, as with the underlying compiler writer.
 func newPreambleOutputWriter(prog *driver.Program) (shimcompiler.WriteFile, func() error) {
   if shouldRemoveComments(prog) {
-    return func(name, text string, _ *shimcompiler.WriteFileData) error {
-      return driver.DefaultWriteFile(name, text)
+    return func(name shimtspath.RootedFilePath, text string, _ *shimcompiler.WriteFileData) error {
+      return driver.DefaultWriteFile(string(name), text)
     }, func() error { return nil }
   }
   program := prog.TSProgram
-  key := func(name string) shimtspath.Path {
-    return shimtspath.ToPath(name, program.GetCurrentDirectory(), program.UseCaseSensitiveFileNames())
+  key := func(name shimtspath.RootedFilePath) shimtspath.PathKey {
+    return shimcompiler.ProgramPathKey(program, name)
   }
-  pairs := map[shimtspath.Path]shimtspath.Path{}
-  for _, source := range shimcompiler.GetSourceFilesToEmit(program, nil, false) {
-    paths := shimcompiler.GetOutputPathsFor(source, program.Options(), program, false)
+  pairs := map[shimtspath.PathKey]shimtspath.PathKey{}
+  for _, source := range shimcompiler.SourceFilesToEmit(program) {
+    paths := shimcompiler.OutputPathsFor(source, program.Options(), program)
     if paths.SourceMapFilePath() != "" && paths.JsFilePath() != "" {
       pairs[key(paths.SourceMapFilePath())] = key(paths.JsFilePath())
     }
@@ -51,20 +51,20 @@ func newPreambleOutputWriter(prog *driver.Program) (shimcompiler.WriteFile, func
     }
   }
   type pendingMap struct {
-    name string
+    name shimtspath.RootedFilePath
     text string
   }
-  pending := map[shimtspath.Path]pendingMap{}
-  decisions := map[shimtspath.Path]preambleInsertion{}
+  pending := map[shimtspath.PathKey]pendingMap{}
+  decisions := map[shimtspath.PathKey]preambleInsertion{}
   var mutex sync.Mutex
-  writeMap := func(name, text string, insertion preambleInsertion) error {
+  writeMap := func(name shimtspath.RootedFilePath, text string, insertion preambleInsertion) error {
     shifted, err := shiftPreambleMap(text, insertion)
     if err != nil {
       return fmt.Errorf("ttsc utility: generated source map %s: %w", name, err)
     }
-    return driver.DefaultWriteFile(name, shifted)
+    return driver.DefaultWriteFile(string(name), shifted)
   }
-  writer := func(name, text string, _ *shimcompiler.WriteFileData) error {
+  writer := func(name shimtspath.RootedFilePath, text string, _ *shimcompiler.WriteFileData) error {
     mutex.Lock()
     defer mutex.Unlock()
     output := key(name)
@@ -76,7 +76,7 @@ func newPreambleOutputWriter(prog *driver.Program) (shimcompiler.WriteFile, func
       return nil
     }
     insertion := preambleInsertion{}
-    if shouldEnsureSourcePreamble(name, text, prog.SourcePreamble) {
+    if shouldEnsureSourcePreamble(string(name), text, prog.SourcePreamble) {
       insertion = preambleInsertionFor(text, prog.SourcePreamble)
       var err error
       text, err = shiftPreambleInlineMap(text, insertion)
@@ -94,7 +94,7 @@ func newPreambleOutputWriter(prog *driver.Program) (shimcompiler.WriteFile, func
         }
       }
     }
-    return driver.DefaultWriteFile(name, text)
+    return driver.DefaultWriteFile(string(name), text)
   }
   finish := func() error {
     mutex.Lock()

package/utility/serve.go

@@ -183,7 +183,7 @@ func buildServeCache(opts hostOptions) (map[string]string, bool) {
   printer := shimprinter.NewPrinter(shimprinter.PrinterOptions{}, shimprinter.PrintHandlers{}, nil)
   cache := map[string]string{}
   for _, file := range prog.SourceFiles() {
-    cache[apiOutputKey(opts.cwd, file.FileName())] = shimprinter.EmitSourceFile(printer, file)
+    cache[apiOutputKey(opts.cwd, string(file.FileName()))] = shimprinter.EmitSourceFile(printer, file)
   }
   if opts.observationsIncomplete != nil {
     *opts.observationsIncomplete = prog.PluginObservationsIncomplete()