ttsc 0.11.0 → 0.12.1

package/driver/rewrite.go

@@ -14,32 +14,32 @@
 package driver
 
 import (
-  "context"
-  "errors"
-  "fmt"
-  "os"
-  "path/filepath"
-  "strings"
-  "unicode"
-
-  "github.com/microsoft/typescript-go/shim/ast"
-  shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"unicode"
+
+	"github.com/microsoft/typescript-go/shim/ast"
+	shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
 )
 
 // Rewrite describes one emit-time patch. Produced by CollectCallSites after
 // the engine has generated a replacement JS fragment for the call.
 type Rewrite struct {
-  File          *ast.SourceFile
-  RootName      string
-  Namespaces    []string
-  Method        string
-  Replacement   string
-  ConsumeParens bool
+	File          *ast.SourceFile
+	RootName      string
+	Namespaces    []string
+	Method        string
+	Replacement   string
+	ConsumeParens bool
 }
 
 // RewriteSet groups rewrites by file, preserving source order.
 type RewriteSet struct {
-  byPath map[string][]Rewrite
+	byPath map[string][]Rewrite
 }
 
 // NewRewriteSet returns an empty set.
@@ -47,20 +47,20 @@ func NewRewriteSet() *RewriteSet { return &RewriteSet{byPath: map[string][]Rewri
 
 // Add registers a rewrite under the absolute path of its source file.
 func (rs *RewriteSet) Add(r Rewrite) {
-  if r.File == nil {
-    return
-  }
-  path := filepath.ToSlash(r.File.FileName())
-  rs.byPath[path] = append(rs.byPath[path], r)
+	if r.File == nil {
+		return
+	}
+	path := filepath.ToSlash(r.File.FileName())
+	rs.byPath[path] = append(rs.byPath[path], r)
 }
 
 // Len returns the total number of rewrites across every file.
 func (rs *RewriteSet) Len() int {
-  n := 0
-  for _, rws := range rs.byPath {
-    n += len(rws)
-  }
-  return n
+	n := 0
+	for _, rws := range rs.byPath {
+		n += len(rws)
+	}
+	return n
 }
 
 // RewriteSentinel is the marker inserted at the top of a patched file so
@@ -72,387 +72,384 @@ const RewriteSentinel = "/* @ttsc-rewritten */"
 // `writeFile` is nil, the patched JS is written to disk via the standard
 // tsgo WriteFile.
 func (p *Program) EmitAll(rs *RewriteSet, writeFile shimcompiler.WriteFile) (*shimcompiler.EmitResult, []Diagnostic, error) {
-  return p.emit(rs, nil, writeFile)
+	return p.emit(rs, nil, writeFile)
 }
 
 // EmitAllRaw runs TypeScript-Go emit without ttsc output-text rewrites.
 func (p *Program) EmitAllRaw(writeFile shimcompiler.WriteFile) (*shimcompiler.EmitResult, []Diagnostic, error) {
-  if p == nil || p.TSProgram == nil {
-    return nil, nil, errors.New("driver: nil program")
-  }
-  wf := writeFile
-  if wf == nil {
-    wf = func(fileName, text string, data *shimcompiler.WriteFileData) error {
-      return DefaultWriteFile(fileName, text)
-    }
-  }
-  result := p.TSProgram.Emit(context.Background(), shimcompiler.EmitOptions{
-    WriteFile: wf,
-  })
-  if result == nil {
-    return nil, nil, errors.New("driver: Emit returned nil")
-  }
-  return result, convertDiagnostics(result.Diagnostics), nil
+	if p == nil || p.TSProgram == nil {
+		return nil, nil, errors.New("driver: nil program")
+	}
+	if err := p.ApplyLinkedPlugins(); err != nil {
+		return nil, nil, err
+	}
+	wf := writeFile
+	if wf == nil {
+		wf = func(fileName, text string, data *shimcompiler.WriteFileData) error {
+			return DefaultWriteFile(fileName, text)
+		}
+	}
+	result := p.TSProgram.Emit(context.Background(), shimcompiler.EmitOptions{
+		WriteFile: wf,
+	})
+	return result, convertDiagnostics(result.Diagnostics), nil
 }
 
 // EmitFile runs tsgo's emitter for one source file, applying the same rewrite
 // pipeline as EmitAll.
 func (p *Program) EmitFile(rs *RewriteSet, target *ast.SourceFile, writeFile shimcompiler.WriteFile) (*shimcompiler.EmitResult, []Diagnostic, error) {
-  return p.emit(rs, target, writeFile)
+	return p.emit(rs, target, writeFile)
 }
 
 func (p *Program) emit(rs *RewriteSet, target *ast.SourceFile, writeFile shimcompiler.WriteFile) (*shimcompiler.EmitResult, []Diagnostic, error) {
-  if p == nil || p.TSProgram == nil {
-    return nil, nil, errors.New("driver: nil program")
-  }
-  if rs == nil {
-    rs = NewRewriteSet()
-  }
-  cursors := map[string]int{}
-  wf := func(fileName, text string, data *shimcompiler.WriteFileData) error {
-    // A patched file is idempotent: once the sentinel exists, the emitted text
-    // is passed through unchanged. This matters for watch/rebuild loops and
-    // tests that re-run emit over the same output directory.
-    if strings.Contains(text, RewriteSentinel) {
-      if writeFile != nil {
-        return writeFile(fileName, text, data)
-      }
-      return DefaultWriteFile(fileName, text)
-    }
-    // Rewrites are matched after tsgo has printed JavaScript. The source-file
-    // association is recovered from the output path because WriteFile receives
-    // only the final file name and text.
-    patched, err := applyRewrites(fileName, text, rs, cursors)
-    if err != nil {
-      return err
-    }
-    if patched != text {
-      patched = insertSentinel(patched)
-    }
-    if writeFile != nil {
-      return writeFile(fileName, patched, data)
-    }
-    return DefaultWriteFile(fileName, patched)
-  }
-
-  result := p.TSProgram.Emit(context.Background(), shimcompiler.EmitOptions{
-    TargetSourceFile: target,
-    WriteFile:        wf,
-  })
-  if result == nil {
-    return nil, nil, errors.New("driver: Emit returned nil")
-  }
-  return result, convertDiagnostics(result.Diagnostics), nil
+	if p == nil || p.TSProgram == nil {
+		return nil, nil, errors.New("driver: nil program")
+	}
+	if err := p.ApplyLinkedPlugins(); err != nil {
+		return nil, nil, err
+	}
+	if rs == nil {
+		rs = NewRewriteSet()
+	}
+	cursors := map[string]int{}
+	wf := func(fileName, text string, data *shimcompiler.WriteFileData) error {
+		// A patched file is idempotent: once the sentinel exists, the emitted text
+		// is passed through unchanged. This matters for watch/rebuild loops and
+		// tests that re-run emit over the same output directory.
+		if strings.Contains(text, RewriteSentinel) {
+			if writeFile != nil {
+				return writeFile(fileName, text, data)
+			}
+			return DefaultWriteFile(fileName, text)
+		}
+		// Rewrites are matched after tsgo has printed JavaScript. The source-file
+		// association is recovered from the output path because WriteFile receives
+		// only the final file name and text.
+		patched, err := applyRewrites(fileName, text, rs, cursors)
+		if err != nil {
+			return err
+		}
+		if patched != text {
+			patched = insertSentinel(patched)
+		}
+		if writeFile != nil {
+			return writeFile(fileName, patched, data)
+		}
+		return DefaultWriteFile(fileName, patched)
+	}
+
+	result := p.TSProgram.Emit(context.Background(), shimcompiler.EmitOptions{
+		TargetSourceFile: target,
+		WriteFile:        wf,
+	})
+	return result, convertDiagnostics(result.Diagnostics), nil
 }
 
 // DefaultWriteFile is the default disk writer used when EmitAll's caller does not
 // supply a custom WriteFile callback.
 func DefaultWriteFile(fileName, text string) error {
-  if dir := filepath.Dir(fileName); dir != "" {
-    if err := os.MkdirAll(dir, 0o755); err != nil {
-      return err
-    }
-  }
-  return os.WriteFile(fileName, []byte(text), 0o644)
+	if dir := filepath.Dir(fileName); dir != "" {
+		if err := os.MkdirAll(dir, 0o755); err != nil {
+			return err
+		}
+	}
+	return os.WriteFile(fileName, []byte(text), 0o644)
 }
 
 func insertSentinel(text string) string {
-  for _, prefix := range []string{"\"use strict\";\n", "'use strict';\n"} {
-    if strings.HasPrefix(text, prefix) {
-      return prefix + RewriteSentinel + "\n" + text[len(prefix):]
-    }
-  }
-  return RewriteSentinel + "\n" + text
+	for _, prefix := range []string{"\"use strict\";\n", "'use strict';\n"} {
+		if strings.HasPrefix(text, prefix) {
+			return prefix + RewriteSentinel + "\n" + text[len(prefix):]
+		}
+	}
+	return RewriteSentinel + "\n" + text
 }
 
 func applyRewrites(outputName, text string, rs *RewriteSet, cursors map[string]int) (string, error) {
-  srcPath, ok := findSourceForOutput(outputName, rs)
-  if !ok || len(rs.byPath[srcPath]) == 0 {
-    return text, nil
-  }
-  rewrites := rs.byPath[srcPath]
-  pos := cursors[srcPath]
-  out := text
-  searchFrom := 0
-  for pos < len(rewrites) {
-    r := rewrites[pos]
-    replaced, nextSearchFrom, ok, err := spliceCall(out, r, searchFrom)
-    if err != nil {
-      return "", err
-    }
-    if !ok {
-      preview := out
-      if len(preview) > 400 {
-        preview = preview[:400] + "…"
-      }
-      return "", fmt.Errorf("driver: could not locate %s.%s(…) call in %s (tried roots %v; preview: %q)", joinRootAndNamespaces(r), r.Method, outputName, candidateRoots(r.RootName), preview)
-    }
-    out = replaced
-    searchFrom = nextSearchFrom
-    pos++
-  }
-  cursors[srcPath] = pos
-  return out, nil
+	srcPath, ok := findSourceForOutput(outputName, rs)
+	if !ok || len(rs.byPath[srcPath]) == 0 {
+		return text, nil
+	}
+	rewrites := rs.byPath[srcPath]
+	pos := cursors[srcPath]
+	out := text
+	searchFrom := 0
+	for pos < len(rewrites) {
+		r := rewrites[pos]
+		replaced, nextSearchFrom, ok, err := spliceCall(out, r, searchFrom)
+		if err != nil {
+			return "", err
+		}
+		if !ok {
+			preview := out
+			if len(preview) > 400 {
+				preview = preview[:400] + "…"
+			}
+			return "", fmt.Errorf("driver: could not locate %s.%s(…) call in %s (tried roots %v; preview: %q)", joinRootAndNamespaces(r), r.Method, outputName, candidateRoots(r.RootName), preview)
+		}
+		out = replaced
+		searchFrom = nextSearchFrom
+		pos++
+	}
+	cursors[srcPath] = pos
+	return out, nil
 }
 
 func findSourceForOutput(outputName string, rs *RewriteSet) (string, bool) {
-  outSlash := strings.TrimSuffix(filepath.ToSlash(outputName), filepath.Ext(outputName))
-  var best string
-  bestScore := 0
-  for path := range rs.byPath {
-    srcStem := strings.TrimSuffix(filepath.ToSlash(path), filepath.Ext(path))
-    score := commonSuffixSegments(srcStem, outSlash)
-    if score > bestScore {
-      best = path
-      bestScore = score
-    }
-  }
-  return best, bestScore > 0
+	outSlash := strings.TrimSuffix(filepath.ToSlash(outputName), filepath.Ext(outputName))
+	var best string
+	bestScore := 0
+	for path := range rs.byPath {
+		srcStem := strings.TrimSuffix(filepath.ToSlash(path), filepath.Ext(path))
+		score := commonSuffixSegments(srcStem, outSlash)
+		if score > bestScore {
+			best = path
+			bestScore = score
+		}
+	}
+	return best, bestScore > 0
 }
 
 func commonSuffixSegments(a, b string) int {
-  as := strings.Split(a, "/")
-  bs := strings.Split(b, "/")
-  n := len(as)
-  if len(bs) < n {
-    n = len(bs)
-  }
-  shared := 0
-  for i := 1; i <= n; i++ {
-    if as[len(as)-i] != bs[len(bs)-i] {
-      break
-    }
-    shared++
-  }
-  return shared
+	as := strings.Split(a, "/")
+	bs := strings.Split(b, "/")
+	n := len(as)
+	if len(bs) < n {
+		n = len(bs)
+	}
+	shared := 0
+	for i := 1; i <= n; i++ {
+		if as[len(as)-i] != bs[len(bs)-i] {
+			break
+		}
+		shared++
+	}
+	return shared
 }
 
 func spliceCall(text string, r Rewrite, searchFrom int) (string, int, bool, error) {
-  aliases := candidateRoots(r.RootName)
-  tail := needleTail(r)
-  idx := -1
-  needleLen := 0
-  for _, cand := range aliases {
-    candNeedle := cand + tail
-    if i := indexAtCallStart(text, candNeedle, searchFrom); i >= 0 {
-      idx = i
-      needleLen = len(candNeedle) - 1
-      break
-    }
-  }
-  if idx < 0 {
-    return text, searchFrom, false, nil
-  }
-  parenPos := idx + needleLen
-  if parenPos >= len(text) || text[parenPos] != '(' {
-    return text, searchFrom, false, errors.New("driver: expected '(' after method name")
-  }
-  closePos, ok := matchParen(text, parenPos)
-  if !ok {
-    return text, searchFrom, false, errors.New("driver: unbalanced parens while locating plugin call")
-  }
-  if r.ConsumeParens {
-    replaced := text[:idx] + r.Replacement + text[closePos+1:]
-    return replaced, idx + len(r.Replacement), true, nil
-  }
-  replaced := text[:idx] + r.Replacement + text[idx+needleLen:]
-  return replaced, idx + len(r.Replacement), true, nil
+	aliases := candidateRoots(r.RootName)
+	tail := needleTail(r)
+	idx := -1
+	needleLen := 0
+	for _, cand := range aliases {
+		candNeedle := cand + tail
+		if i := indexAtCallStart(text, candNeedle, searchFrom); i >= 0 {
+			idx = i
+			needleLen = len(candNeedle) - 1
+			break
+		}
+	}
+	if idx < 0 {
+		return text, searchFrom, false, nil
+	}
+	parenPos := idx + needleLen
+	closePos, ok := matchParen(text, parenPos)
+	if !ok {
+		return text, searchFrom, false, errors.New("driver: unbalanced parens while locating plugin call")
+	}
+	if r.ConsumeParens {
+		replaced := text[:idx] + r.Replacement + text[closePos+1:]
+		return replaced, idx + len(r.Replacement), true, nil
+	}
+	replaced := text[:idx] + r.Replacement + text[idx+needleLen:]
+	return replaced, idx + len(r.Replacement), true, nil
 }
 
 func candidateRoots(root string) []string {
-  return []string{
-    root,
-    root + "_1.default",
-    root + "_2.default",
-    root + ".default",
-    root + "_1",
-    root + "_2",
-  }
+	return []string{
+		root,
+		root + "_1.default",
+		root + "_2.default",
+		root + ".default",
+		root + "_1",
+		root + "_2",
+	}
 }
 
 func joinRootAndNamespaces(r Rewrite) string {
-  if len(r.Namespaces) == 0 {
-    return r.RootName
-  }
-  return r.RootName + "." + strings.Join(r.Namespaces, ".")
+	if len(r.Namespaces) == 0 {
+		return r.RootName
+	}
+	return r.RootName + "." + strings.Join(r.Namespaces, ".")
 }
 
 func needleTail(r Rewrite) string {
-  if len(r.Namespaces) == 0 {
-    return "." + r.Method + "("
-  }
-  return "." + strings.Join(r.Namespaces, ".") + "." + r.Method + "("
+	if len(r.Namespaces) == 0 {
+		return "." + r.Method + "("
+	}
+	return "." + strings.Join(r.Namespaces, ".") + "." + r.Method + "("
 }
 
 func indexAtCallStart(text, needle string, searchFrom int) int {
-  start := searchFrom
-  if start < 0 {
-    start = 0
-  }
-  for {
-    hit := strings.Index(text[start:], needle)
-    if hit < 0 {
-      return -1
-    }
-    pos := start + hit
-    if pos == 0 {
-      return pos
-    }
-    prev := rune(text[pos-1])
-    if isIdentifierPart(prev) {
-      start = pos + 1
-      continue
-    }
-    return pos
-  }
+	start := searchFrom
+	if start < 0 {
+		start = 0
+	}
+	for {
+		hit := strings.Index(text[start:], needle)
+		if hit < 0 {
+			return -1
+		}
+		pos := start + hit
+		if pos == 0 {
+			return pos
+		}
+		prev := rune(text[pos-1])
+		if isIdentifierPart(prev) {
+			start = pos + 1
+			continue
+		}
+		return pos
+	}
 }
 
 func isIdentifierPart(r rune) bool {
-  return r == '_' || r == '$' || unicode.IsLetter(r) || unicode.IsDigit(r)
+	return r == '_' || r == '$' || unicode.IsLetter(r) || unicode.IsDigit(r)
 }
 
 func matchParen(text string, pos int) (int, bool) {
-  if pos >= len(text) || text[pos] != '(' {
-    return 0, false
-  }
-  depth := 1
-  lastSignificant := byte('(')
-  for i := pos + 1; i < len(text); i++ {
-    ch := text[i]
-    switch ch {
-    case ' ', '\t', '\n', '\r', '\f':
-      continue
-    case '(':
-      depth++
-      lastSignificant = ch
-    case ')':
-      depth--
-      if depth == 0 {
-        return i, true
-      }
-      lastSignificant = ch
-    case '"', '\'':
-      end, ok := skipQuoted(text, i, ch)
-      if !ok {
-        return 0, false
-      }
-      i = end
-      lastSignificant = 'x'
-    case '`':
-      end, ok := skipTemplate(text, i)
-      if !ok {
-        return 0, false
-      }
-      i = end
-      lastSignificant = 'x'
-    case '/':
-      if i+1 < len(text) {
-        switch text[i+1] {
-        case '/':
-          i = skipLineComment(text, i+2)
-          continue
-        case '*':
-          end, ok := skipBlockComment(text, i+2)
-          if !ok {
-            return 0, false
-          }
-          i = end
-          continue
-        }
-      }
-      if canStartRegexLiteral(lastSignificant) {
-        end, ok := skipRegexLiteral(text, i)
-        if !ok {
-          return 0, false
-        }
-        i = end
-        lastSignificant = 'x'
-        continue
-      }
-      lastSignificant = ch
-    default:
-      lastSignificant = ch
-    }
-  }
-  return 0, false
+	if pos >= len(text) || text[pos] != '(' {
+		return 0, false
+	}
+	depth := 1
+	lastSignificant := byte('(')
+	for i := pos + 1; i < len(text); i++ {
+		ch := text[i]
+		switch ch {
+		case ' ', '\t', '\n', '\r', '\f':
+			continue
+		case '(':
+			depth++
+			lastSignificant = ch
+		case ')':
+			depth--
+			if depth == 0 {
+				return i, true
+			}
+			lastSignificant = ch
+		case '"', '\'':
+			end, ok := skipQuoted(text, i, ch)
+			if !ok {
+				return 0, false
+			}
+			i = end
+			lastSignificant = 'x'
+		case '`':
+			end, ok := skipTemplate(text, i)
+			if !ok {
+				return 0, false
+			}
+			i = end
+			lastSignificant = 'x'
+		case '/':
+			if i+1 < len(text) {
+				switch text[i+1] {
+				case '/':
+					i = skipLineComment(text, i+2)
+					continue
+				case '*':
+					end, ok := skipBlockComment(text, i+2)
+					if !ok {
+						return 0, false
+					}
+					i = end
+					continue
+				}
+			}
+			if canStartRegexLiteral(lastSignificant) {
+				end, ok := skipRegexLiteral(text, i)
+				if !ok {
+					return 0, false
+				}
+				i = end
+				lastSignificant = 'x'
+				continue
+			}
+			lastSignificant = ch
+		default:
+			lastSignificant = ch
+		}
+	}
+	return 0, false
 }
 
 func skipQuoted(text string, pos int, quote byte) (int, bool) {
-  for i := pos + 1; i < len(text); i++ {
-    switch text[i] {
-    case '\\':
-      i++
-    case quote:
-      return i, true
-    case '\n', '\r':
-      return 0, false
-    }
-  }
-  return 0, false
+	for i := pos + 1; i < len(text); i++ {
+		switch text[i] {
+		case '\\':
+			i++
+		case quote:
+			return i, true
+		case '\n', '\r':
+			return 0, false
+		}
+	}
+	return 0, false
 }
 
 func skipTemplate(text string, pos int) (int, bool) {
-  for i := pos + 1; i < len(text); i++ {
-    switch text[i] {
-    case '\\':
-      i++
-    case '`':
-      return i, true
-    }
-  }
-  return 0, false
+	for i := pos + 1; i < len(text); i++ {
+		switch text[i] {
+		case '\\':
+			i++
+		case '`':
+			return i, true
+		}
+	}
+	return 0, false
 }
 
 func skipLineComment(text string, pos int) int {
-  for i := pos; i < len(text); i++ {
-    if text[i] == '\n' || text[i] == '\r' {
-      return i
-    }
-  }
-  return len(text) - 1
+	for i := pos; i < len(text); i++ {
+		if text[i] == '\n' || text[i] == '\r' {
+			return i
+		}
+	}
+	return len(text) - 1
 }
 
 func skipBlockComment(text string, pos int) (int, bool) {
-  for i := pos; i+1 < len(text); i++ {
-    if text[i] == '*' && text[i+1] == '/' {
-      return i + 1, true
-    }
-  }
-  return 0, false
+	for i := pos; i+1 < len(text); i++ {
+		if text[i] == '*' && text[i+1] == '/' {
+			return i + 1, true
+		}
+	}
+	return 0, false
 }
 
 func canStartRegexLiteral(previous byte) bool {
-  return strings.ContainsRune("([{=,:;!&|?+-*~^<>%", rune(previous))
+	return strings.ContainsRune("([{=,:;!&|?+-*~^<>%", rune(previous))
 }
 
 func skipRegexLiteral(text string, pos int) (int, bool) {
-  inClass := false
-  for i := pos + 1; i < len(text); i++ {
-    switch text[i] {
-    case '\\':
-      i++
-    case '[':
-      inClass = true
-    case ']':
-      inClass = false
-    case '/':
-      if inClass {
-        continue
-      }
-      for i+1 < len(text) && isRegexFlag(text[i+1]) {
-        i++
-      }
-      return i, true
-    case '\n', '\r':
-      return 0, false
-    }
-  }
-  return 0, false
+	inClass := false
+	for i := pos + 1; i < len(text); i++ {
+		switch text[i] {
+		case '\\':
+			i++
+		case '[':
+			inClass = true
+		case ']':
+			inClass = false
+		case '/':
+			if inClass {
+				continue
+			}
+			for i+1 < len(text) && isRegexFlag(text[i+1]) {
+				i++
+			}
+			return i, true
+		case '\n', '\r':
+			return 0, false
+		}
+	}
+	return 0, false
 }
 
 func isRegexFlag(ch byte) bool {
-  return ch == '_' ||
-    ch == '$' ||
-    unicode.IsLetter(rune(ch)) ||
-    unicode.IsDigit(rune(ch))
+	return ch == '_' ||
+		ch == '$' ||
+		unicode.IsLetter(rune(ch)) ||
+		unicode.IsDigit(rune(ch))
 }