remove unused packages
This commit is contained in:
parent
b1f5661baf
commit
2ba4cf4f1e
GPG Key ID:
40482A264AAEC85F
@ -1,90 +0,0 @@
|
|||||||
package compiler
|
|
||||||
|
|
||||||
import (
|
|
||||||
"context"
|
|
||||||
"iter"
|
|
||||||
"slices"
|
|
||||||
"sync"
|
|
||||||
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/ast"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/checker"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/core"
|
|
||||||
)
|
|
||||||
|
|
||||||
type CheckerPool interface {
|
|
||||||
GetChecker(ctx context.Context) (*checker.Checker, func())
|
|
||||||
GetCheckerForFile(ctx context.Context, file *ast.SourceFile) (*checker.Checker, func())
|
|
||||||
GetAllCheckers(ctx context.Context) ([]*checker.Checker, func())
|
|
||||||
Files(checker *checker.Checker) iter.Seq[*ast.SourceFile]
|
|
||||||
}
|
|
||||||
|
|
||||||
type checkerPool struct {
|
|
||||||
checkerCount int
|
|
||||||
program *Program
|
|
||||||
|
|
||||||
createCheckersOnce sync.Once
|
|
||||||
checkers []*checker.Checker
|
|
||||||
fileAssociations map[*ast.SourceFile]*checker.Checker
|
|
||||||
}
|
|
||||||
|
|
||||||
var _ CheckerPool = (*checkerPool)(nil)
|
|
||||||
|
|
||||||
func newCheckerPool(checkerCount int, program *Program) *checkerPool {
|
|
||||||
pool := &checkerPool{
|
|
||||||
program: program,
|
|
||||||
checkerCount: checkerCount,
|
|
||||||
checkers: make([]*checker.Checker, checkerCount),
|
|
||||||
}
|
|
||||||
|
|
||||||
return pool
|
|
||||||
}
|
|
||||||
|
|
||||||
func (p *checkerPool) GetCheckerForFile(ctx context.Context, file *ast.SourceFile) (*checker.Checker, func()) {
|
|
||||||
p.createCheckers()
|
|
||||||
checker := p.fileAssociations[file]
|
|
||||||
return checker, noop
|
|
||||||
}
|
|
||||||
|
|
||||||
func (p *checkerPool) GetChecker(ctx context.Context) (*checker.Checker, func()) {
|
|
||||||
p.createCheckers()
|
|
||||||
checker := p.checkers[0]
|
|
||||||
return checker, noop
|
|
||||||
}
|
|
||||||
|
|
||||||
func (p *checkerPool) createCheckers() {
|
|
||||||
p.createCheckersOnce.Do(func() {
|
|
||||||
wg := core.NewWorkGroup(p.program.SingleThreaded())
|
|
||||||
for i := range p.checkerCount {
|
|
||||||
wg.Queue(func() {
|
|
||||||
p.checkers[i] = checker.NewChecker(p.program)
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
wg.RunAndWait()
|
|
||||||
|
|
||||||
p.fileAssociations = make(map[*ast.SourceFile]*checker.Checker, len(p.program.files))
|
|
||||||
for i, file := range p.program.files {
|
|
||||||
p.fileAssociations[file] = p.checkers[i%p.checkerCount]
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (p *checkerPool) GetAllCheckers(ctx context.Context) ([]*checker.Checker, func()) {
|
|
||||||
p.createCheckers()
|
|
||||||
return p.checkers, noop
|
|
||||||
}
|
|
||||||
|
|
||||||
func (p *checkerPool) Files(checker *checker.Checker) iter.Seq[*ast.SourceFile] {
|
|
||||||
checkerIndex := slices.Index(p.checkers, checker)
|
|
||||||
return func(yield func(*ast.SourceFile) bool) {
|
|
||||||
for i, file := range p.program.files {
|
|
||||||
if i%p.checkerCount == checkerIndex {
|
|
||||||
if !yield(file) {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func noop() {}
|
|
||||||
@ -1,128 +0,0 @@
|
|||||||
package compiler
|
|
||||||
|
|
||||||
import (
|
|
||||||
"context"
|
|
||||||
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/ast"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/core"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/module"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/modulespecifiers"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/outputpaths"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/printer"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/transformers/declarations"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/tsoptions"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/tspath"
|
|
||||||
)
|
|
||||||
|
|
||||||
// NOTE: EmitHost operations must be thread-safe
|
|
||||||
type EmitHost interface {
|
|
||||||
printer.EmitHost
|
|
||||||
declarations.DeclarationEmitHost
|
|
||||||
Options() *core.CompilerOptions
|
|
||||||
SourceFiles() []*ast.SourceFile
|
|
||||||
UseCaseSensitiveFileNames() bool
|
|
||||||
GetCurrentDirectory() string
|
|
||||||
CommonSourceDirectory() string
|
|
||||||
IsEmitBlocked(file string) bool
|
|
||||||
}
|
|
||||||
|
|
||||||
var _ EmitHost = (*emitHost)(nil)
|
|
||||||
|
|
||||||
// NOTE: emitHost operations must be thread-safe
|
|
||||||
type emitHost struct {
|
|
||||||
program *Program
|
|
||||||
emitResolver printer.EmitResolver
|
|
||||||
}
|
|
||||||
|
|
||||||
func newEmitHost(ctx context.Context, program *Program, file *ast.SourceFile) (*emitHost, func()) {
|
|
||||||
checker, done := program.GetTypeCheckerForFile(ctx, file)
|
|
||||||
return &emitHost{
|
|
||||||
program: program,
|
|
||||||
emitResolver: checker.GetEmitResolver(),
|
|
||||||
}, done
|
|
||||||
}
|
|
||||||
|
|
||||||
func (host *emitHost) GetModeForUsageLocation(file ast.HasFileName, moduleSpecifier *ast.StringLiteralLike) core.ResolutionMode {
|
|
||||||
return host.program.GetModeForUsageLocation(file, moduleSpecifier)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (host *emitHost) GetResolvedModuleFromModuleSpecifier(file ast.HasFileName, moduleSpecifier *ast.StringLiteralLike) *module.ResolvedModule {
|
|
||||||
return host.program.GetResolvedModuleFromModuleSpecifier(file, moduleSpecifier)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (host *emitHost) GetDefaultResolutionModeForFile(file ast.HasFileName) core.ResolutionMode {
|
|
||||||
return host.program.GetDefaultResolutionModeForFile(file)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (host *emitHost) GetEmitModuleFormatOfFile(file ast.HasFileName) core.ModuleKind {
|
|
||||||
return host.program.GetEmitModuleFormatOfFile(file)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (host *emitHost) FileExists(path string) bool {
|
|
||||||
return host.program.FileExists(path)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (host *emitHost) GetGlobalTypingsCacheLocation() string {
|
|
||||||
return host.program.GetGlobalTypingsCacheLocation()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (host *emitHost) GetNearestAncestorDirectoryWithPackageJson(dirname string) string {
|
|
||||||
return host.program.GetNearestAncestorDirectoryWithPackageJson(dirname)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (host *emitHost) GetPackageJsonInfo(pkgJsonPath string) modulespecifiers.PackageJsonInfo {
|
|
||||||
return host.program.GetPackageJsonInfo(pkgJsonPath)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (host *emitHost) GetSourceOfProjectReferenceIfOutputIncluded(file ast.HasFileName) string {
|
|
||||||
return host.program.GetSourceOfProjectReferenceIfOutputIncluded(file)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (host *emitHost) GetProjectReferenceFromSource(path tspath.Path) *tsoptions.SourceOutputAndProjectReference {
|
|
||||||
return host.program.GetProjectReferenceFromSource(path)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (host *emitHost) GetRedirectTargets(path tspath.Path) []string {
|
|
||||||
return host.program.GetRedirectTargets(path)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (host *emitHost) GetEffectiveDeclarationFlags(node *ast.Node, flags ast.ModifierFlags) ast.ModifierFlags {
|
|
||||||
return host.GetEmitResolver().GetEffectiveDeclarationFlags(node, flags)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (host *emitHost) GetOutputPathsFor(file *ast.SourceFile, forceDtsPaths bool) declarations.OutputPaths {
|
|
||||||
// TODO: cache
|
|
||||||
return outputpaths.GetOutputPathsFor(file, host.Options(), host, forceDtsPaths)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (host *emitHost) GetResolutionModeOverride(node *ast.Node) core.ResolutionMode {
|
|
||||||
return host.GetEmitResolver().GetResolutionModeOverride(node)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (host *emitHost) GetSourceFileFromReference(origin *ast.SourceFile, ref *ast.FileReference) *ast.SourceFile {
|
|
||||||
return host.program.GetSourceFileFromReference(origin, ref)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (host *emitHost) Options() *core.CompilerOptions { return host.program.Options() }
|
|
||||||
func (host *emitHost) SourceFiles() []*ast.SourceFile { return host.program.SourceFiles() }
|
|
||||||
func (host *emitHost) GetCurrentDirectory() string { return host.program.GetCurrentDirectory() }
|
|
||||||
func (host *emitHost) CommonSourceDirectory() string { return host.program.CommonSourceDirectory() }
|
|
||||||
func (host *emitHost) UseCaseSensitiveFileNames() bool {
|
|
||||||
return host.program.UseCaseSensitiveFileNames()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (host *emitHost) IsEmitBlocked(file string) bool {
|
|
||||||
return host.program.IsEmitBlocked(file)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (host *emitHost) WriteFile(fileName string, text string, writeByteOrderMark bool) error {
|
|
||||||
return host.program.Host().FS().WriteFile(fileName, text, writeByteOrderMark)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (host *emitHost) GetEmitResolver() printer.EmitResolver {
|
|
||||||
return host.emitResolver
|
|
||||||
}
|
|
||||||
|
|
||||||
func (host *emitHost) IsSourceFileFromExternalLibrary(file *ast.SourceFile) bool {
|
|
||||||
return host.program.IsSourceFileFromExternalLibrary(file)
|
|
||||||
}
|
|
||||||
@ -1,482 +0,0 @@
|
|||||||
package compiler
|
|
||||||
|
|
||||||
import (
|
|
||||||
"encoding/base64"
|
|
||||||
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/ast"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/binder"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/core"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/diagnostics"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/outputpaths"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/printer"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/sourcemap"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/stringutil"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/transformers"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/transformers/declarations"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/transformers/estransforms"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/transformers/inliners"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/transformers/jsxtransforms"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/transformers/moduletransforms"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/transformers/tstransforms"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/tsoptions"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/tspath"
|
|
||||||
)
|
|
||||||
|
|
||||||
type EmitOnly byte
|
|
||||||
|
|
||||||
const (
|
|
||||||
EmitAll EmitOnly = iota
|
|
||||||
EmitOnlyJs
|
|
||||||
EmitOnlyDts
|
|
||||||
EmitOnlyForcedDts
|
|
||||||
)
|
|
||||||
|
|
||||||
type emitter struct {
|
|
||||||
host EmitHost
|
|
||||||
emitOnly EmitOnly
|
|
||||||
emitterDiagnostics ast.DiagnosticsCollection
|
|
||||||
writer printer.EmitTextWriter
|
|
||||||
paths *outputpaths.OutputPaths
|
|
||||||
sourceFile *ast.SourceFile
|
|
||||||
emitResult EmitResult
|
|
||||||
writeFile func(fileName string, text string, writeByteOrderMark bool, data *WriteFileData) error
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *emitter) emit() {
|
|
||||||
// !!! tracing
|
|
||||||
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.GetDiagnostics()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *emitter) getDeclarationTransformers(emitContext *printer.EmitContext, declarationFilePath string, declarationMapPath string) []*declarations.DeclarationTransformer {
|
|
||||||
transform := declarations.NewDeclarationTransformer(e.host, emitContext, e.host.Options(), declarationFilePath, declarationMapPath)
|
|
||||||
return []*declarations.DeclarationTransformer{transform}
|
|
||||||
}
|
|
||||||
|
|
||||||
func getModuleTransformer(opts *transformers.TransformOptions) *transformers.Transformer {
|
|
||||||
switch opts.CompilerOptions.GetEmitModuleKind() {
|
|
||||||
case core.ModuleKindPreserve:
|
|
||||||
// `ESModuleTransformer` contains logic for preserving CJS input syntax in `--module preserve`
|
|
||||||
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 getScriptTransformers(emitContext *printer.EmitContext, host printer.EmitHost, sourceFile *ast.SourceFile) []*transformers.Transformer {
|
|
||||||
var tx []*transformers.Transformer
|
|
||||||
options := host.Options()
|
|
||||||
|
|
||||||
// JS files don't use reference calculations as they don't do import elision, no need to calculate it
|
|
||||||
importElisionEnabled := !options.VerbatimModuleSyntax.IsTrue() && !ast.IsInJSFile(sourceFile.AsNode())
|
|
||||||
|
|
||||||
var emitResolver printer.EmitResolver
|
|
||||||
var referenceResolver binder.ReferenceResolver
|
|
||||||
if importElisionEnabled || options.GetJSXTransformEnabled() || !options.GetIsolatedModules() { // full emit resolver is needed for import ellision and const enum inlining
|
|
||||||
emitResolver = host.GetEmitResolver()
|
|
||||||
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,
|
|
||||||
}
|
|
||||||
|
|
||||||
// transform TypeScript syntax
|
|
||||||
{
|
|
||||||
// erase types
|
|
||||||
tx = append(tx, tstransforms.NewTypeEraserTransformer(&opts))
|
|
||||||
|
|
||||||
// elide imports
|
|
||||||
if importElisionEnabled {
|
|
||||||
tx = append(tx, tstransforms.NewImportElisionTransformer(&opts))
|
|
||||||
}
|
|
||||||
|
|
||||||
// transform `enum`, `namespace`, and parameter properties
|
|
||||||
tx = append(tx, tstransforms.NewRuntimeSyntaxTransformer(&opts))
|
|
||||||
}
|
|
||||||
|
|
||||||
// !!! transform legacy decorator syntax
|
|
||||||
if options.GetJSXTransformEnabled() {
|
|
||||||
tx = append(tx, jsxtransforms.NewJSXTransformer(&opts))
|
|
||||||
}
|
|
||||||
|
|
||||||
downleveler := estransforms.GetESTransformer(&opts)
|
|
||||||
if downleveler != nil {
|
|
||||||
tx = append(tx, downleveler)
|
|
||||||
}
|
|
||||||
|
|
||||||
// transform module syntax
|
|
||||||
tx = append(tx, getModuleTransformer(&opts))
|
|
||||||
|
|
||||||
// inlining (formerly done via substitutions)
|
|
||||||
if !options.GetIsolatedModules() {
|
|
||||||
tx = append(tx, inliners.NewConstEnumInliningTransformer(&opts))
|
|
||||||
}
|
|
||||||
return tx
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *emitter) emitJSFile(sourceFile *ast.SourceFile, jsFilePath string, sourceMapFilePath string) {
|
|
||||||
options := e.host.Options()
|
|
||||||
|
|
||||||
if sourceFile == nil || e.emitOnly != EmitAll && e.emitOnly != 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()
|
|
||||||
|
|
||||||
for _, transformer := range getScriptTransformers(emitContext, e.host, sourceFile) {
|
|
||||||
sourceFile = transformer.TransformSourceFile(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(),
|
|
||||||
// !!!
|
|
||||||
}
|
|
||||||
|
|
||||||
// create a printer to print the nodes
|
|
||||||
printer := printer.NewPrinter(printerOptions, printer.PrintHandlers{
|
|
||||||
// !!!
|
|
||||||
}, emitContext)
|
|
||||||
|
|
||||||
e.printSourceFile(jsFilePath, sourceMapFilePath, sourceFile, printer, shouldEmitSourceMaps(options, sourceFile))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *emitter) emitDeclarationFile(sourceFile *ast.SourceFile, declarationFilePath string, declarationMapPath string) {
|
|
||||||
options := e.host.Options()
|
|
||||||
|
|
||||||
if sourceFile == nil || e.emitOnly == EmitOnlyJs || len(declarationFilePath) == 0 {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
if e.emitOnly != EmitOnlyForcedDts && (options.NoEmit == core.TSTrue || e.host.IsEmitBlocked(declarationFilePath)) {
|
|
||||||
e.emitResult.EmitSkipped = true
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
var diags []*ast.Diagnostic
|
|
||||||
emitContext, putEmitContext := printer.GetEmitContext()
|
|
||||||
defer putEmitContext()
|
|
||||||
for _, transformer := range e.getDeclarationTransformers(emitContext, declarationFilePath, declarationMapPath) {
|
|
||||||
sourceFile = transformer.TransformSourceFile(sourceFile)
|
|
||||||
diags = append(diags, transformer.GetDiagnostics()...)
|
|
||||||
}
|
|
||||||
|
|
||||||
// !!! strada skipped emit if there were diagnostics
|
|
||||||
|
|
||||||
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(),
|
|
||||||
// !!!
|
|
||||||
}
|
|
||||||
|
|
||||||
// create a printer to print the nodes
|
|
||||||
printer := printer.NewPrinter(printerOptions, printer.PrintHandlers{
|
|
||||||
// !!!
|
|
||||||
}, emitContext)
|
|
||||||
|
|
||||||
for _, elem := range diags {
|
|
||||||
// Add declaration transform diagnostics to emit diagnostics
|
|
||||||
e.emitterDiagnostics.Add(elem)
|
|
||||||
}
|
|
||||||
e.printSourceFile(declarationFilePath, declarationMapPath, sourceFile, printer, e.emitOnly != EmitOnlyForcedDts && shouldEmitDeclarationSourceMaps(options, sourceFile))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *emitter) printSourceFile(jsFilePath string, sourceMapFilePath string, sourceFile *ast.SourceFile, printer_ *printer.Printer, shouldEmitSourceMaps bool) {
|
|
||||||
// !!! sourceMapGenerator
|
|
||||||
options := e.host.Options()
|
|
||||||
var sourceMapGenerator *sourcemap.Generator
|
|
||||||
if shouldEmitSourceMaps {
|
|
||||||
sourceMapGenerator = sourcemap.NewGenerator(
|
|
||||||
tspath.GetBaseFileName(tspath.NormalizeSlashes(jsFilePath)),
|
|
||||||
getSourceRoot(options),
|
|
||||||
e.getSourceMapDirectory(options, jsFilePath, 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, &SourceMapEmitResult{
|
|
||||||
InputSourceFileNames: sourceMapGenerator.Sources(),
|
|
||||||
SourceMap: sourceMapGenerator.RawSourceMap(),
|
|
||||||
GeneratedFile: jsFilePath,
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
sourceMappingURL := e.getSourceMappingURL(
|
|
||||||
options,
|
|
||||||
sourceMapGenerator,
|
|
||||||
jsFilePath,
|
|
||||||
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=" + sourceMappingURL)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Write the source map
|
|
||||||
if len(sourceMapFilePath) > 0 {
|
|
||||||
sourceMap := sourceMapGenerator.String()
|
|
||||||
err := e.writeText(sourceMapFilePath, sourceMap, false /*writeByteOrderMark*/, nil)
|
|
||||||
if err != nil {
|
|
||||||
e.emitterDiagnostics.Add(ast.NewCompilerDiagnostic(diagnostics.Could_not_write_file_0_Colon_1, jsFilePath, err.Error()))
|
|
||||||
} else {
|
|
||||||
e.emitResult.EmittedFiles = append(e.emitResult.EmittedFiles, sourceMapFilePath)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
e.writer.WriteLine()
|
|
||||||
}
|
|
||||||
|
|
||||||
// Write the output file
|
|
||||||
text := e.writer.String()
|
|
||||||
data := &WriteFileData{
|
|
||||||
SourceMapUrlPos: sourceMapUrlPos,
|
|
||||||
Diagnostics: e.emitterDiagnostics.GetDiagnostics(),
|
|
||||||
}
|
|
||||||
err := e.writeText(jsFilePath, text, options.EmitBOM.IsTrue(), data)
|
|
||||||
skippedDtsWrite := data.SkippedDtsWrite
|
|
||||||
if err != nil {
|
|
||||||
e.emitterDiagnostics.Add(ast.NewCompilerDiagnostic(diagnostics.Could_not_write_file_0_Colon_1, jsFilePath, err.Error()))
|
|
||||||
} else if !skippedDtsWrite {
|
|
||||||
e.emitResult.EmittedFiles = append(e.emitResult.EmittedFiles, jsFilePath)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Reset state
|
|
||||||
e.writer.Clear()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *emitter) writeText(fileName string, text string, writeByteOrderMark bool, data *WriteFileData) error {
|
|
||||||
if e.writeFile != nil {
|
|
||||||
return e.writeFile(fileName, text, writeByteOrderMark, data)
|
|
||||||
}
|
|
||||||
return e.host.WriteFile(fileName, text, writeByteOrderMark)
|
|
||||||
}
|
|
||||||
|
|
||||||
func shouldEmitSourceMaps(mapOptions *core.CompilerOptions, sourceFile *ast.SourceFile) bool {
|
|
||||||
return (mapOptions.SourceMap.IsTrue() || mapOptions.InlineSourceMap.IsTrue()) &&
|
|
||||||
!tspath.FileExtensionIs(sourceFile.FileName(), tspath.ExtensionJson)
|
|
||||||
}
|
|
||||||
|
|
||||||
func shouldEmitDeclarationSourceMaps(mapOptions *core.CompilerOptions, sourceFile *ast.SourceFile) bool {
|
|
||||||
return mapOptions.DeclarationMap.IsTrue() &&
|
|
||||||
!tspath.FileExtensionIs(sourceFile.FileName(), tspath.ExtensionJson)
|
|
||||||
}
|
|
||||||
|
|
||||||
func getSourceRoot(mapOptions *core.CompilerOptions) string {
|
|
||||||
// Normalize source root and make sure it has trailing "/" so that it can be used to combine paths with the
|
|
||||||
// relative paths of the sources list in the sourcemap
|
|
||||||
sourceRoot := tspath.NormalizeSlashes(mapOptions.SourceRoot)
|
|
||||||
if len(sourceRoot) > 0 {
|
|
||||||
sourceRoot = tspath.EnsureTrailingDirectorySeparator(sourceRoot)
|
|
||||||
}
|
|
||||||
return sourceRoot
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *emitter) getSourceMapDirectory(mapOptions *core.CompilerOptions, filePath string, sourceFile *ast.SourceFile) string {
|
|
||||||
if len(mapOptions.SourceRoot) > 0 {
|
|
||||||
return e.host.CommonSourceDirectory()
|
|
||||||
}
|
|
||||||
if len(mapOptions.MapRoot) > 0 {
|
|
||||||
sourceMapDir := tspath.NormalizeSlashes(mapOptions.MapRoot)
|
|
||||||
if sourceFile != nil {
|
|
||||||
// For modules or multiple emit files the mapRoot will have directory structure like the sources
|
|
||||||
// So if src\a.ts and src\lib\b.ts are compiled together user would be moving the maps into mapRoot\a.js.map and mapRoot\lib\b.js.map
|
|
||||||
sourceMapDir = tspath.GetDirectoryPath(outputpaths.GetSourceFilePathInNewDir(
|
|
||||||
sourceFile.FileName(),
|
|
||||||
sourceMapDir,
|
|
||||||
e.host.GetCurrentDirectory(),
|
|
||||||
e.host.CommonSourceDirectory(),
|
|
||||||
e.host.UseCaseSensitiveFileNames(),
|
|
||||||
))
|
|
||||||
}
|
|
||||||
if tspath.GetRootLength(sourceMapDir) == 0 {
|
|
||||||
// The relative paths are relative to the common directory
|
|
||||||
sourceMapDir = tspath.CombinePaths(e.host.CommonSourceDirectory(), sourceMapDir)
|
|
||||||
}
|
|
||||||
return sourceMapDir
|
|
||||||
}
|
|
||||||
return tspath.GetDirectoryPath(tspath.NormalizePath(filePath))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *emitter) getSourceMappingURL(mapOptions *core.CompilerOptions, sourceMapGenerator *sourcemap.Generator, filePath string, sourceMapFilePath string, sourceFile *ast.SourceFile) string {
|
|
||||||
if mapOptions.InlineSourceMap.IsTrue() {
|
|
||||||
// Encode the sourceMap into the sourceMap url
|
|
||||||
sourceMapText := sourceMapGenerator.String()
|
|
||||||
base64SourceMapText := base64.StdEncoding.EncodeToString([]byte(sourceMapText))
|
|
||||||
return "data:application/json;base64," + base64SourceMapText
|
|
||||||
}
|
|
||||||
|
|
||||||
sourceMapFile := tspath.GetBaseFileName(tspath.NormalizeSlashes(sourceMapFilePath))
|
|
||||||
if len(mapOptions.MapRoot) > 0 {
|
|
||||||
sourceMapDir := tspath.NormalizeSlashes(mapOptions.MapRoot)
|
|
||||||
if sourceFile != nil {
|
|
||||||
// For modules or multiple emit files the mapRoot will have directory structure like the sources
|
|
||||||
// So if src\a.ts and src\lib\b.ts are compiled together user would be moving the maps into mapRoot\a.js.map and mapRoot\lib\b.js.map
|
|
||||||
sourceMapDir = tspath.GetDirectoryPath(outputpaths.GetSourceFilePathInNewDir(
|
|
||||||
sourceFile.FileName(),
|
|
||||||
sourceMapDir,
|
|
||||||
e.host.GetCurrentDirectory(),
|
|
||||||
e.host.CommonSourceDirectory(),
|
|
||||||
e.host.UseCaseSensitiveFileNames(),
|
|
||||||
))
|
|
||||||
}
|
|
||||||
if tspath.GetRootLength(sourceMapDir) == 0 {
|
|
||||||
// The relative paths are relative to the common directory
|
|
||||||
sourceMapDir = tspath.CombinePaths(e.host.CommonSourceDirectory(), sourceMapDir)
|
|
||||||
return stringutil.EncodeURI(
|
|
||||||
tspath.GetRelativePathToDirectoryOrUrl(
|
|
||||||
tspath.GetDirectoryPath(tspath.NormalizePath(filePath)), // get the relative sourceMapDir path based on jsFilePath
|
|
||||||
tspath.CombinePaths(sourceMapDir, sourceMapFile), // this is where user expects to see sourceMap
|
|
||||||
/*isAbsolutePathAnUrl*/ true,
|
|
||||||
tspath.ComparePathsOptions{
|
|
||||||
UseCaseSensitiveFileNames: e.host.UseCaseSensitiveFileNames(),
|
|
||||||
CurrentDirectory: e.host.GetCurrentDirectory(),
|
|
||||||
},
|
|
||||||
),
|
|
||||||
)
|
|
||||||
} else {
|
|
||||||
return stringutil.EncodeURI(tspath.CombinePaths(sourceMapDir, sourceMapFile))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return stringutil.EncodeURI(sourceMapFile)
|
|
||||||
}
|
|
||||||
|
|
||||||
type SourceFileMayBeEmittedHost interface {
|
|
||||||
Options() *core.CompilerOptions
|
|
||||||
GetProjectReferenceFromSource(path tspath.Path) *tsoptions.SourceOutputAndProjectReference
|
|
||||||
IsSourceFileFromExternalLibrary(file *ast.SourceFile) bool
|
|
||||||
GetCurrentDirectory() string
|
|
||||||
UseCaseSensitiveFileNames() bool
|
|
||||||
SourceFiles() []*ast.SourceFile
|
|
||||||
}
|
|
||||||
|
|
||||||
func sourceFileMayBeEmitted(sourceFile *ast.SourceFile, host SourceFileMayBeEmittedHost, forceDtsEmit bool) bool {
|
|
||||||
// TODO: move this to outputpaths?
|
|
||||||
|
|
||||||
options := host.Options()
|
|
||||||
// Js files are emitted only if option is enabled
|
|
||||||
if options.NoEmitForJsFiles.IsTrue() && ast.IsSourceFileJS(sourceFile) {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
// Declaration files are not emitted
|
|
||||||
if sourceFile.IsDeclarationFile {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
// Source file from node_modules are not emitted
|
|
||||||
if host.IsSourceFileFromExternalLibrary(sourceFile) {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
// forcing dts emit => file needs to be emitted
|
|
||||||
if forceDtsEmit {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check other conditions for file emit
|
|
||||||
// Source files from referenced projects are not emitted
|
|
||||||
if host.GetProjectReferenceFromSource(sourceFile.Path()) != nil {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
// Any non json file should be emitted
|
|
||||||
if !ast.IsJsonSourceFile(sourceFile) {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
// Json file is not emitted if outDir is not specified
|
|
||||||
if options.OutDir == "" {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
// Otherwise if rootDir or composite config file, we know common sourceDir and can check if file would be emitted in same location
|
|
||||||
if options.RootDir != "" || (options.Composite.IsTrue() && options.ConfigFilePath != "") {
|
|
||||||
commonDir := tspath.GetNormalizedAbsolutePath(outputpaths.GetCommonSourceDirectory(options, func() []string { return nil }, host.GetCurrentDirectory(), host.UseCaseSensitiveFileNames()), host.GetCurrentDirectory())
|
|
||||||
outputPath := outputpaths.GetSourceFilePathInNewDirWorker(sourceFile.FileName(), options.OutDir, host.GetCurrentDirectory(), commonDir, host.UseCaseSensitiveFileNames())
|
|
||||||
if tspath.ComparePaths(sourceFile.FileName(), outputPath, tspath.ComparePathsOptions{
|
|
||||||
UseCaseSensitiveFileNames: host.UseCaseSensitiveFileNames(),
|
|
||||||
CurrentDirectory: host.GetCurrentDirectory(),
|
|
||||||
}) == 0 {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
func getSourceFilesToEmit(host SourceFileMayBeEmittedHost, targetSourceFile *ast.SourceFile, forceDtsEmit bool) []*ast.SourceFile {
|
|
||||||
var sourceFiles []*ast.SourceFile
|
|
||||||
if targetSourceFile != nil {
|
|
||||||
sourceFiles = []*ast.SourceFile{targetSourceFile}
|
|
||||||
} else {
|
|
||||||
sourceFiles = host.SourceFiles()
|
|
||||||
}
|
|
||||||
return core.Filter(sourceFiles, func(sourceFile *ast.SourceFile) bool {
|
|
||||||
return sourceFileMayBeEmitted(sourceFile, host, forceDtsEmit)
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func isSourceFileNotJson(file *ast.SourceFile) bool {
|
|
||||||
return !ast.IsJsonSourceFile(file)
|
|
||||||
}
|
|
||||||
|
|
||||||
func getDeclarationDiagnostics(host EmitHost, file *ast.SourceFile) []*ast.Diagnostic {
|
|
||||||
// TODO: use p.getSourceFilesToEmit cache
|
|
||||||
fullFiles := core.Filter(getSourceFilesToEmit(host, file, false), isSourceFileNotJson)
|
|
||||||
if !core.Some(fullFiles, func(f *ast.SourceFile) bool { return f == file }) {
|
|
||||||
return []*ast.Diagnostic{}
|
|
||||||
}
|
|
||||||
options := host.Options()
|
|
||||||
transform := declarations.NewDeclarationTransformer(host, nil, options, "", "")
|
|
||||||
transform.TransformSourceFile(file)
|
|
||||||
return transform.GetDiagnostics()
|
|
||||||
}
|
|
||||||
@ -1,341 +0,0 @@
|
|||||||
package compiler
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"sync"
|
|
||||||
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/ast"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/core"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/diagnostics"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/module"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/scanner"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/tsoptions"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/tspath"
|
|
||||||
)
|
|
||||||
|
|
||||||
type fileIncludeKind int
|
|
||||||
|
|
||||||
const (
|
|
||||||
// References from file
|
|
||||||
fileIncludeKindImport = iota
|
|
||||||
fileIncludeKindReferenceFile
|
|
||||||
fileIncludeKindTypeReferenceDirective
|
|
||||||
fileIncludeKindLibReferenceDirective
|
|
||||||
|
|
||||||
fileIncludeKindRootFile
|
|
||||||
fileIncludeKindSourceFromProjectReference
|
|
||||||
fileIncludeKindOutputFromProjectReference
|
|
||||||
fileIncludeKindLibFile
|
|
||||||
fileIncludeKindAutomaticTypeDirectiveFile
|
|
||||||
)
|
|
||||||
|
|
||||||
type fileIncludeReason struct {
|
|
||||||
kind fileIncludeKind
|
|
||||||
data any
|
|
||||||
|
|
||||||
// Uses relative file name
|
|
||||||
relativeFileNameDiag *ast.Diagnostic
|
|
||||||
relativeFileNameDiagOnce sync.Once
|
|
||||||
|
|
||||||
// Uses file name as is
|
|
||||||
diag *ast.Diagnostic
|
|
||||||
diagOnce sync.Once
|
|
||||||
}
|
|
||||||
|
|
||||||
type referencedFileData struct {
|
|
||||||
file tspath.Path
|
|
||||||
index int
|
|
||||||
synthetic *ast.Node
|
|
||||||
}
|
|
||||||
|
|
||||||
type referenceFileLocation struct {
|
|
||||||
file *ast.SourceFile
|
|
||||||
node *ast.Node
|
|
||||||
ref *ast.FileReference
|
|
||||||
packageId module.PackageId
|
|
||||||
isSynthetic bool
|
|
||||||
}
|
|
||||||
|
|
||||||
func (r *referenceFileLocation) text() string {
|
|
||||||
if r.node != nil {
|
|
||||||
if !ast.NodeIsSynthesized(r.node) {
|
|
||||||
return r.file.Text()[scanner.SkipTrivia(r.file.Text(), r.node.Loc.Pos()):r.node.End()]
|
|
||||||
} else {
|
|
||||||
return fmt.Sprintf(`"%s"`, r.node.Text())
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
return r.file.Text()[r.ref.Pos():r.ref.End()]
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (r *referenceFileLocation) diagnosticAt(message *diagnostics.Message, args ...any) *ast.Diagnostic {
|
|
||||||
if r.node != nil {
|
|
||||||
return tsoptions.CreateDiagnosticForNodeInSourceFile(r.file, r.node, message, args...)
|
|
||||||
} else {
|
|
||||||
return ast.NewDiagnostic(r.file, r.ref.TextRange, message, args...)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
type automaticTypeDirectiveFileData struct {
|
|
||||||
typeReference string
|
|
||||||
packageId module.PackageId
|
|
||||||
}
|
|
||||||
|
|
||||||
func (r *fileIncludeReason) asIndex() int {
|
|
||||||
return r.data.(int)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (r *fileIncludeReason) asLibFileIndex() (int, bool) {
|
|
||||||
index, ok := r.data.(int)
|
|
||||||
return index, ok
|
|
||||||
}
|
|
||||||
|
|
||||||
func (r *fileIncludeReason) isReferencedFile() bool {
|
|
||||||
return r != nil && r.kind <= fileIncludeKindLibReferenceDirective
|
|
||||||
}
|
|
||||||
|
|
||||||
func (r *fileIncludeReason) asReferencedFileData() *referencedFileData {
|
|
||||||
return r.data.(*referencedFileData)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (r *fileIncludeReason) asAutomaticTypeDirectiveFileData() *automaticTypeDirectiveFileData {
|
|
||||||
return r.data.(*automaticTypeDirectiveFileData)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (r *fileIncludeReason) getReferencedLocation(program *Program) *referenceFileLocation {
|
|
||||||
ref := r.asReferencedFileData()
|
|
||||||
file := program.GetSourceFileByPath(ref.file)
|
|
||||||
switch r.kind {
|
|
||||||
case fileIncludeKindImport:
|
|
||||||
var specifier *ast.Node
|
|
||||||
var isSynthetic bool
|
|
||||||
if ref.synthetic != nil {
|
|
||||||
specifier = ref.synthetic
|
|
||||||
isSynthetic = true
|
|
||||||
} else if ref.index < len(file.Imports()) {
|
|
||||||
specifier = file.Imports()[ref.index]
|
|
||||||
} else {
|
|
||||||
augIndex := len(file.Imports())
|
|
||||||
for _, imp := range file.ModuleAugmentations {
|
|
||||||
if imp.Kind == ast.KindStringLiteral {
|
|
||||||
if augIndex == ref.index {
|
|
||||||
specifier = imp
|
|
||||||
break
|
|
||||||
}
|
|
||||||
augIndex++
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
resolution := program.GetResolvedModuleFromModuleSpecifier(file, specifier)
|
|
||||||
return &referenceFileLocation{
|
|
||||||
file: file,
|
|
||||||
node: specifier,
|
|
||||||
packageId: resolution.PackageId,
|
|
||||||
isSynthetic: isSynthetic,
|
|
||||||
}
|
|
||||||
case fileIncludeKindReferenceFile:
|
|
||||||
return &referenceFileLocation{
|
|
||||||
file: file,
|
|
||||||
ref: file.ReferencedFiles[ref.index],
|
|
||||||
}
|
|
||||||
case fileIncludeKindTypeReferenceDirective:
|
|
||||||
return &referenceFileLocation{
|
|
||||||
file: file,
|
|
||||||
ref: file.TypeReferenceDirectives[ref.index],
|
|
||||||
}
|
|
||||||
case fileIncludeKindLibReferenceDirective:
|
|
||||||
return &referenceFileLocation{
|
|
||||||
file: file,
|
|
||||||
ref: file.LibReferenceDirectives[ref.index],
|
|
||||||
}
|
|
||||||
default:
|
|
||||||
panic(fmt.Sprintf("unknown reason: %v", r.kind))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (r *fileIncludeReason) toDiagnostic(program *Program, relativeFileName bool) *ast.Diagnostic {
|
|
||||||
if relativeFileName {
|
|
||||||
r.relativeFileNameDiagOnce.Do(func() {
|
|
||||||
r.relativeFileNameDiag = r.computeDiagnostic(program, func(fileName string) string {
|
|
||||||
return tspath.GetRelativePathFromDirectory(program.GetCurrentDirectory(), fileName, program.comparePathsOptions)
|
|
||||||
})
|
|
||||||
})
|
|
||||||
return r.relativeFileNameDiag
|
|
||||||
} else {
|
|
||||||
r.diagOnce.Do(func() {
|
|
||||||
r.diag = r.computeDiagnostic(program, func(fileName string) string { return fileName })
|
|
||||||
})
|
|
||||||
return r.diag
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (r *fileIncludeReason) computeDiagnostic(program *Program, toFileName func(string) string) *ast.Diagnostic {
|
|
||||||
if r.isReferencedFile() {
|
|
||||||
return r.computeReferenceFileDiagnostic(program, toFileName)
|
|
||||||
}
|
|
||||||
switch r.kind {
|
|
||||||
case fileIncludeKindRootFile:
|
|
||||||
if program.opts.Config.ConfigFile != nil {
|
|
||||||
config := program.opts.Config
|
|
||||||
fileName := tspath.GetNormalizedAbsolutePath(config.FileNames()[r.asIndex()], program.GetCurrentDirectory())
|
|
||||||
if matchedFileSpec := config.GetMatchedFileSpec(fileName); matchedFileSpec != "" {
|
|
||||||
return ast.NewCompilerDiagnostic(diagnostics.Part_of_files_list_in_tsconfig_json, matchedFileSpec, toFileName(fileName))
|
|
||||||
} else if matchedIncludeSpec, isDefaultIncludeSpec := config.GetMatchedIncludeSpec(fileName); matchedIncludeSpec != "" {
|
|
||||||
if isDefaultIncludeSpec {
|
|
||||||
return ast.NewCompilerDiagnostic(diagnostics.Matched_by_default_include_pattern_Asterisk_Asterisk_Slash_Asterisk)
|
|
||||||
} else {
|
|
||||||
return ast.NewCompilerDiagnostic(diagnostics.Matched_by_include_pattern_0_in_1, matchedIncludeSpec, toFileName(config.ConfigName()))
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
return ast.NewCompilerDiagnostic(diagnostics.Root_file_specified_for_compilation)
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
return ast.NewCompilerDiagnostic(diagnostics.Root_file_specified_for_compilation)
|
|
||||||
}
|
|
||||||
case fileIncludeKindSourceFromProjectReference,
|
|
||||||
fileIncludeKindOutputFromProjectReference:
|
|
||||||
diag := core.IfElse(
|
|
||||||
r.kind == fileIncludeKindOutputFromProjectReference,
|
|
||||||
diagnostics.Output_from_referenced_project_0_included_because_module_is_specified_as_none,
|
|
||||||
diagnostics.Source_from_referenced_project_0_included_because_module_is_specified_as_none,
|
|
||||||
)
|
|
||||||
referencedResolvedRef := program.projectReferenceFileMapper.getResolvedProjectReferences()[r.asIndex()]
|
|
||||||
return ast.NewCompilerDiagnostic(diag, toFileName(referencedResolvedRef.ConfigName()))
|
|
||||||
case fileIncludeKindAutomaticTypeDirectiveFile:
|
|
||||||
data := r.asAutomaticTypeDirectiveFileData()
|
|
||||||
if program.Options().Types != nil {
|
|
||||||
if data.packageId.Name != "" {
|
|
||||||
return ast.NewCompilerDiagnostic(diagnostics.Entry_point_of_type_library_0_specified_in_compilerOptions_with_packageId_1, data.typeReference, data.packageId.String())
|
|
||||||
} else {
|
|
||||||
return ast.NewCompilerDiagnostic(diagnostics.Entry_point_of_type_library_0_specified_in_compilerOptions, data.typeReference)
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
if data.packageId.Name != "" {
|
|
||||||
return ast.NewCompilerDiagnostic(diagnostics.Entry_point_for_implicit_type_library_0_with_packageId_1, data.typeReference, data.packageId.String())
|
|
||||||
} else {
|
|
||||||
return ast.NewCompilerDiagnostic(diagnostics.Entry_point_for_implicit_type_library_0, data.typeReference)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
case fileIncludeKindLibFile:
|
|
||||||
if index, ok := r.asLibFileIndex(); ok {
|
|
||||||
return ast.NewCompilerDiagnostic(diagnostics.Library_0_specified_in_compilerOptions, program.Options().Lib[index])
|
|
||||||
} else if target := program.Options().GetEmitScriptTarget().String(); target != "" {
|
|
||||||
return ast.NewCompilerDiagnostic(diagnostics.Default_library_for_target_0, target)
|
|
||||||
} else {
|
|
||||||
return ast.NewCompilerDiagnostic(diagnostics.Default_library)
|
|
||||||
}
|
|
||||||
default:
|
|
||||||
panic(fmt.Sprintf("unknown reason: %v", r.kind))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (r *fileIncludeReason) computeReferenceFileDiagnostic(program *Program, toFileName func(string) string) *ast.Diagnostic {
|
|
||||||
referenceLocation := program.includeProcessor.getReferenceLocation(r, program)
|
|
||||||
referenceText := referenceLocation.text()
|
|
||||||
switch r.kind {
|
|
||||||
case fileIncludeKindImport:
|
|
||||||
if !referenceLocation.isSynthetic {
|
|
||||||
if referenceLocation.packageId.Name != "" {
|
|
||||||
return ast.NewCompilerDiagnostic(diagnostics.Imported_via_0_from_file_1_with_packageId_2, referenceText, toFileName(referenceLocation.file.FileName()), referenceLocation.packageId.String())
|
|
||||||
} else {
|
|
||||||
return ast.NewCompilerDiagnostic(diagnostics.Imported_via_0_from_file_1, referenceText, toFileName(referenceLocation.file.FileName()))
|
|
||||||
}
|
|
||||||
} else if specifier, ok := program.importHelpersImportSpecifiers[referenceLocation.file.Path()]; ok && specifier == referenceLocation.node {
|
|
||||||
if referenceLocation.packageId.Name != "" {
|
|
||||||
return ast.NewCompilerDiagnostic(diagnostics.Imported_via_0_from_file_1_with_packageId_2_to_import_importHelpers_as_specified_in_compilerOptions, referenceText, toFileName(referenceLocation.file.FileName()), referenceLocation.packageId.String())
|
|
||||||
} else {
|
|
||||||
return ast.NewCompilerDiagnostic(diagnostics.Imported_via_0_from_file_1_to_import_importHelpers_as_specified_in_compilerOptions, referenceText, toFileName(referenceLocation.file.FileName()))
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
if referenceLocation.packageId.Name != "" {
|
|
||||||
return ast.NewCompilerDiagnostic(diagnostics.Imported_via_0_from_file_1_with_packageId_2_to_import_jsx_and_jsxs_factory_functions, referenceText, toFileName(referenceLocation.file.FileName()), referenceLocation.packageId.String())
|
|
||||||
} else {
|
|
||||||
return ast.NewCompilerDiagnostic(diagnostics.Imported_via_0_from_file_1_to_import_jsx_and_jsxs_factory_functions, referenceText, toFileName(referenceLocation.file.FileName()))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
case fileIncludeKindReferenceFile:
|
|
||||||
return ast.NewCompilerDiagnostic(diagnostics.Referenced_via_0_from_file_1, referenceText, toFileName(referenceLocation.file.FileName()))
|
|
||||||
case fileIncludeKindTypeReferenceDirective:
|
|
||||||
if referenceLocation.packageId.Name != "" {
|
|
||||||
return ast.NewCompilerDiagnostic(diagnostics.Type_library_referenced_via_0_from_file_1_with_packageId_2, referenceText, toFileName(referenceLocation.file.FileName()), referenceLocation.packageId.String())
|
|
||||||
} else {
|
|
||||||
return ast.NewCompilerDiagnostic(diagnostics.Type_library_referenced_via_0_from_file_1, referenceText, toFileName(referenceLocation.file.FileName()))
|
|
||||||
}
|
|
||||||
case fileIncludeKindLibReferenceDirective:
|
|
||||||
return ast.NewCompilerDiagnostic(diagnostics.Library_referenced_via_0_from_file_1, referenceText, toFileName(referenceLocation.file.FileName()))
|
|
||||||
default:
|
|
||||||
panic(fmt.Sprintf("unknown reason: %v", r.kind))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (r *fileIncludeReason) toRelatedInfo(program *Program) *ast.Diagnostic {
|
|
||||||
if r.isReferencedFile() {
|
|
||||||
return r.computeReferenceFileRelatedInfo(program)
|
|
||||||
}
|
|
||||||
if program.opts.Config.ConfigFile == nil {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
config := program.opts.Config
|
|
||||||
switch r.kind {
|
|
||||||
case fileIncludeKindRootFile:
|
|
||||||
fileName := tspath.GetNormalizedAbsolutePath(config.FileNames()[r.asIndex()], program.GetCurrentDirectory())
|
|
||||||
if matchedFileSpec := config.GetMatchedFileSpec(fileName); matchedFileSpec != "" {
|
|
||||||
if filesNode := tsoptions.GetTsConfigPropArrayElementValue(config.ConfigFile.SourceFile, "files", matchedFileSpec); filesNode != nil {
|
|
||||||
return tsoptions.CreateDiagnosticForNodeInSourceFile(config.ConfigFile.SourceFile, filesNode.AsNode(), diagnostics.File_is_matched_by_files_list_specified_here)
|
|
||||||
}
|
|
||||||
} else if matchedIncludeSpec, isDefaultIncludeSpec := config.GetMatchedIncludeSpec(fileName); matchedIncludeSpec != "" && !isDefaultIncludeSpec {
|
|
||||||
if includeNode := tsoptions.GetTsConfigPropArrayElementValue(config.ConfigFile.SourceFile, "include", matchedIncludeSpec); includeNode != nil {
|
|
||||||
return tsoptions.CreateDiagnosticForNodeInSourceFile(config.ConfigFile.SourceFile, includeNode.AsNode(), diagnostics.File_is_matched_by_include_pattern_specified_here)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
case fileIncludeKindSourceFromProjectReference,
|
|
||||||
fileIncludeKindOutputFromProjectReference:
|
|
||||||
return tsoptions.CreateDiagnosticAtReferenceSyntax(
|
|
||||||
config,
|
|
||||||
r.asIndex(),
|
|
||||||
core.IfElse(
|
|
||||||
r.kind == fileIncludeKindOutputFromProjectReference,
|
|
||||||
diagnostics.File_is_output_from_referenced_project_specified_here,
|
|
||||||
diagnostics.File_is_source_from_referenced_project_specified_here,
|
|
||||||
))
|
|
||||||
case fileIncludeKindAutomaticTypeDirectiveFile:
|
|
||||||
if program.Options().Types != nil {
|
|
||||||
data := r.asAutomaticTypeDirectiveFileData()
|
|
||||||
if typesSyntax := tsoptions.GetOptionsSyntaxByArrayElementValue(program.includeProcessor.getCompilerOptionsObjectLiteralSyntax(program), "types", data.typeReference); typesSyntax != nil {
|
|
||||||
return tsoptions.CreateDiagnosticForNodeInSourceFile(config.ConfigFile.SourceFile, typesSyntax.AsNode(), diagnostics.File_is_entry_point_of_type_library_specified_here)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
case fileIncludeKindLibFile:
|
|
||||||
if index, ok := r.asLibFileIndex(); ok {
|
|
||||||
if libSyntax := tsoptions.GetOptionsSyntaxByArrayElementValue(program.includeProcessor.getCompilerOptionsObjectLiteralSyntax(program), "lib", program.Options().Lib[index]); libSyntax != nil {
|
|
||||||
return tsoptions.CreateDiagnosticForNodeInSourceFile(config.ConfigFile.SourceFile, libSyntax.AsNode(), diagnostics.File_is_library_specified_here)
|
|
||||||
}
|
|
||||||
} else if target := program.Options().GetEmitScriptTarget().String(); target != "" {
|
|
||||||
if targetValueSyntax := tsoptions.ForEachPropertyAssignment(program.includeProcessor.getCompilerOptionsObjectLiteralSyntax(program), "target", tsoptions.GetCallbackForFindingPropertyAssignmentByValue(target)); targetValueSyntax != nil {
|
|
||||||
return tsoptions.CreateDiagnosticForNodeInSourceFile(config.ConfigFile.SourceFile, targetValueSyntax.AsNode(), diagnostics.File_is_default_library_for_target_specified_here)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
default:
|
|
||||||
panic(fmt.Sprintf("unknown reason: %v", r.kind))
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (r *fileIncludeReason) computeReferenceFileRelatedInfo(program *Program) *ast.Diagnostic {
|
|
||||||
referenceLocation := program.includeProcessor.getReferenceLocation(r, program)
|
|
||||||
if referenceLocation.isSynthetic {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
switch r.kind {
|
|
||||||
case fileIncludeKindImport:
|
|
||||||
return referenceLocation.diagnosticAt(diagnostics.File_is_included_via_import_here)
|
|
||||||
case fileIncludeKindReferenceFile:
|
|
||||||
return referenceLocation.diagnosticAt(diagnostics.File_is_included_via_reference_here)
|
|
||||||
case fileIncludeKindTypeReferenceDirective:
|
|
||||||
return referenceLocation.diagnosticAt(diagnostics.File_is_included_via_type_library_reference_here)
|
|
||||||
case fileIncludeKindLibReferenceDirective:
|
|
||||||
return referenceLocation.diagnosticAt(diagnostics.File_is_included_via_library_reference_here)
|
|
||||||
default:
|
|
||||||
panic(fmt.Sprintf("unknown reason: %v", r.kind))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,744 +0,0 @@
|
|||||||
package compiler
|
|
||||||
|
|
||||||
import (
|
|
||||||
"cmp"
|
|
||||||
"slices"
|
|
||||||
"strings"
|
|
||||||
"sync"
|
|
||||||
"sync/atomic"
|
|
||||||
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/ast"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/collections"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/core"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/module"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/tsoptions"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/tspath"
|
|
||||||
)
|
|
||||||
|
|
||||||
type libResolution struct {
|
|
||||||
libraryName string
|
|
||||||
resolution *module.ResolvedModule
|
|
||||||
trace []string
|
|
||||||
}
|
|
||||||
|
|
||||||
type LibFile struct {
|
|
||||||
Name string
|
|
||||||
path string
|
|
||||||
Replaced bool
|
|
||||||
}
|
|
||||||
|
|
||||||
type fileLoader struct {
|
|
||||||
opts ProgramOptions
|
|
||||||
resolver *module.Resolver
|
|
||||||
defaultLibraryPath string
|
|
||||||
comparePathsOptions tspath.ComparePathsOptions
|
|
||||||
supportedExtensions []string
|
|
||||||
|
|
||||||
filesParser *filesParser
|
|
||||||
rootTasks []*parseTask
|
|
||||||
includeProcessor *includeProcessor
|
|
||||||
|
|
||||||
totalFileCount atomic.Int32
|
|
||||||
libFileCount atomic.Int32
|
|
||||||
|
|
||||||
factoryMu sync.Mutex
|
|
||||||
factory ast.NodeFactory
|
|
||||||
|
|
||||||
projectReferenceFileMapper *projectReferenceFileMapper
|
|
||||||
dtsDirectories collections.Set[tspath.Path]
|
|
||||||
|
|
||||||
pathForLibFileCache collections.SyncMap[string, *LibFile]
|
|
||||||
pathForLibFileResolutions collections.SyncMap[tspath.Path, *libResolution]
|
|
||||||
}
|
|
||||||
|
|
||||||
type processedFiles struct {
|
|
||||||
resolver *module.Resolver
|
|
||||||
files []*ast.SourceFile
|
|
||||||
filesByPath map[tspath.Path]*ast.SourceFile
|
|
||||||
projectReferenceFileMapper *projectReferenceFileMapper
|
|
||||||
missingFiles []string
|
|
||||||
resolvedModules map[tspath.Path]module.ModeAwareCache[*module.ResolvedModule]
|
|
||||||
typeResolutionsInFile map[tspath.Path]module.ModeAwareCache[*module.ResolvedTypeReferenceDirective]
|
|
||||||
sourceFileMetaDatas map[tspath.Path]ast.SourceFileMetaData
|
|
||||||
jsxRuntimeImportSpecifiers map[tspath.Path]*jsxRuntimeImportSpecifier
|
|
||||||
importHelpersImportSpecifiers map[tspath.Path]*ast.Node
|
|
||||||
libFiles map[tspath.Path]*LibFile
|
|
||||||
// List of present unsupported extensions
|
|
||||||
unsupportedExtensions []string
|
|
||||||
sourceFilesFoundSearchingNodeModules collections.Set[tspath.Path]
|
|
||||||
includeProcessor *includeProcessor
|
|
||||||
// if file was included using source file and its output is actually part of program
|
|
||||||
// this contains mapping from output to source file
|
|
||||||
outputFileToProjectReferenceSource map[tspath.Path]string
|
|
||||||
}
|
|
||||||
|
|
||||||
type jsxRuntimeImportSpecifier struct {
|
|
||||||
moduleReference string
|
|
||||||
specifier *ast.Node
|
|
||||||
}
|
|
||||||
|
|
||||||
func processAllProgramFiles(
|
|
||||||
opts ProgramOptions,
|
|
||||||
singleThreaded bool,
|
|
||||||
) processedFiles {
|
|
||||||
compilerOptions := opts.Config.CompilerOptions()
|
|
||||||
rootFiles := opts.Config.FileNames()
|
|
||||||
supportedExtensions := tsoptions.GetSupportedExtensions(compilerOptions, nil /*extraFileExtensions*/)
|
|
||||||
var maxNodeModuleJsDepth int
|
|
||||||
if p := opts.Config.CompilerOptions().MaxNodeModuleJsDepth; p != nil {
|
|
||||||
maxNodeModuleJsDepth = *p
|
|
||||||
}
|
|
||||||
loader := fileLoader{
|
|
||||||
opts: opts,
|
|
||||||
defaultLibraryPath: tspath.GetNormalizedAbsolutePath(opts.Host.DefaultLibraryPath(), opts.Host.GetCurrentDirectory()),
|
|
||||||
comparePathsOptions: tspath.ComparePathsOptions{
|
|
||||||
UseCaseSensitiveFileNames: opts.Host.FS().UseCaseSensitiveFileNames(),
|
|
||||||
CurrentDirectory: opts.Host.GetCurrentDirectory(),
|
|
||||||
},
|
|
||||||
filesParser: &filesParser{
|
|
||||||
wg: core.NewWorkGroup(singleThreaded),
|
|
||||||
maxDepth: maxNodeModuleJsDepth,
|
|
||||||
},
|
|
||||||
rootTasks: make([]*parseTask, 0, len(rootFiles)+len(compilerOptions.Lib)),
|
|
||||||
supportedExtensions: core.Flatten(tsoptions.GetSupportedExtensionsWithJsonIfResolveJsonModule(compilerOptions, supportedExtensions)),
|
|
||||||
includeProcessor: &includeProcessor{},
|
|
||||||
}
|
|
||||||
loader.addProjectReferenceTasks(singleThreaded)
|
|
||||||
loader.resolver = module.NewResolver(loader.projectReferenceFileMapper.host, compilerOptions, opts.TypingsLocation, opts.ProjectName)
|
|
||||||
for index, rootFile := range rootFiles {
|
|
||||||
loader.addRootTask(rootFile, nil, &fileIncludeReason{kind: fileIncludeKindRootFile, data: index})
|
|
||||||
}
|
|
||||||
if len(rootFiles) > 0 && compilerOptions.NoLib.IsFalseOrUnknown() {
|
|
||||||
if compilerOptions.Lib == nil {
|
|
||||||
name := tsoptions.GetDefaultLibFileName(compilerOptions)
|
|
||||||
libFile := loader.pathForLibFile(name)
|
|
||||||
loader.addRootTask(libFile.path, libFile, &fileIncludeReason{kind: fileIncludeKindLibFile})
|
|
||||||
|
|
||||||
} else {
|
|
||||||
for index, lib := range compilerOptions.Lib {
|
|
||||||
if name, ok := tsoptions.GetLibFileName(lib); ok {
|
|
||||||
libFile := loader.pathForLibFile(name)
|
|
||||||
loader.addRootTask(libFile.path, libFile, &fileIncludeReason{kind: fileIncludeKindLibFile, data: index})
|
|
||||||
}
|
|
||||||
// !!! error on unknown name
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if len(rootFiles) > 0 {
|
|
||||||
loader.addAutomaticTypeDirectiveTasks()
|
|
||||||
}
|
|
||||||
|
|
||||||
loader.filesParser.parse(&loader, loader.rootTasks)
|
|
||||||
// Clear out loader and host to ensure its not used post program creation
|
|
||||||
loader.projectReferenceFileMapper.loader = nil
|
|
||||||
loader.projectReferenceFileMapper.host = nil
|
|
||||||
|
|
||||||
totalFileCount := int(loader.totalFileCount.Load())
|
|
||||||
libFileCount := int(loader.libFileCount.Load())
|
|
||||||
|
|
||||||
var missingFiles []string
|
|
||||||
files := make([]*ast.SourceFile, 0, totalFileCount-libFileCount)
|
|
||||||
libFiles := make([]*ast.SourceFile, 0, totalFileCount) // totalFileCount here since we append files to it later to construct the final list
|
|
||||||
|
|
||||||
filesByPath := make(map[tspath.Path]*ast.SourceFile, totalFileCount)
|
|
||||||
loader.includeProcessor.fileIncludeReasons = make(map[tspath.Path][]*fileIncludeReason, totalFileCount)
|
|
||||||
var outputFileToProjectReferenceSource map[tspath.Path]string
|
|
||||||
if !opts.canUseProjectReferenceSource() {
|
|
||||||
outputFileToProjectReferenceSource = make(map[tspath.Path]string, totalFileCount)
|
|
||||||
}
|
|
||||||
resolvedModules := make(map[tspath.Path]module.ModeAwareCache[*module.ResolvedModule], totalFileCount+1)
|
|
||||||
typeResolutionsInFile := make(map[tspath.Path]module.ModeAwareCache[*module.ResolvedTypeReferenceDirective], totalFileCount)
|
|
||||||
sourceFileMetaDatas := make(map[tspath.Path]ast.SourceFileMetaData, totalFileCount)
|
|
||||||
var jsxRuntimeImportSpecifiers map[tspath.Path]*jsxRuntimeImportSpecifier
|
|
||||||
var importHelpersImportSpecifiers map[tspath.Path]*ast.Node
|
|
||||||
var unsupportedExtensions []string
|
|
||||||
var sourceFilesFoundSearchingNodeModules collections.Set[tspath.Path]
|
|
||||||
libFilesMap := make(map[tspath.Path]*LibFile, libFileCount)
|
|
||||||
|
|
||||||
loader.filesParser.collect(&loader, loader.rootTasks, func(task *parseTask) {
|
|
||||||
if task.redirectedParseTask != nil {
|
|
||||||
if !opts.canUseProjectReferenceSource() {
|
|
||||||
outputFileToProjectReferenceSource[task.redirectedParseTask.path] = task.FileName()
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
if task.isForAutomaticTypeDirective {
|
|
||||||
typeResolutionsInFile[task.path] = task.typeResolutionsInFile
|
|
||||||
return
|
|
||||||
}
|
|
||||||
file := task.file
|
|
||||||
path := task.path
|
|
||||||
if file == nil {
|
|
||||||
// !!! sheetal file preprocessing diagnostic explaining getSourceFileFromReferenceWorker
|
|
||||||
missingFiles = append(missingFiles, task.normalizedFilePath)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// !!! sheetal todo porting file case errors
|
|
||||||
// if _, ok := filesByPath[path]; ok {
|
|
||||||
// Check if it differs only in drive letters its ok to ignore that error:
|
|
||||||
// const checkedAbsolutePath = getNormalizedAbsolutePathWithoutRoot(checkedName, currentDirectory);
|
|
||||||
// const inputAbsolutePath = getNormalizedAbsolutePathWithoutRoot(fileName, currentDirectory);
|
|
||||||
// if (checkedAbsolutePath !== inputAbsolutePath) {
|
|
||||||
// reportFileNamesDifferOnlyInCasingError(fileName, file, reason);
|
|
||||||
// }
|
|
||||||
// } else if loader.comparePathsOptions.UseCaseSensitiveFileNames {
|
|
||||||
// pathIgnoreCase := tspath.ToPath(file.FileName(), loader.comparePathsOptions.CurrentDirectory, false)
|
|
||||||
// // for case-sensitsive file systems check if we've already seen some file with similar filename ignoring case
|
|
||||||
// if _, ok := filesByNameIgnoreCase[pathIgnoreCase]; ok {
|
|
||||||
// reportFileNamesDifferOnlyInCasingError(fileName, existingFile, reason);
|
|
||||||
// } else {
|
|
||||||
// filesByNameIgnoreCase[pathIgnoreCase] = file
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
|
|
||||||
if task.libFile != nil {
|
|
||||||
libFiles = append(libFiles, file)
|
|
||||||
libFilesMap[path] = task.libFile
|
|
||||||
} else {
|
|
||||||
files = append(files, file)
|
|
||||||
}
|
|
||||||
filesByPath[path] = file
|
|
||||||
resolvedModules[path] = task.resolutionsInFile
|
|
||||||
typeResolutionsInFile[path] = task.typeResolutionsInFile
|
|
||||||
sourceFileMetaDatas[path] = task.metadata
|
|
||||||
|
|
||||||
if task.jsxRuntimeImportSpecifier != nil {
|
|
||||||
if jsxRuntimeImportSpecifiers == nil {
|
|
||||||
jsxRuntimeImportSpecifiers = make(map[tspath.Path]*jsxRuntimeImportSpecifier, totalFileCount)
|
|
||||||
}
|
|
||||||
jsxRuntimeImportSpecifiers[path] = task.jsxRuntimeImportSpecifier
|
|
||||||
}
|
|
||||||
if task.importHelpersImportSpecifier != nil {
|
|
||||||
if importHelpersImportSpecifiers == nil {
|
|
||||||
importHelpersImportSpecifiers = make(map[tspath.Path]*ast.Node, totalFileCount)
|
|
||||||
}
|
|
||||||
importHelpersImportSpecifiers[path] = task.importHelpersImportSpecifier
|
|
||||||
}
|
|
||||||
extension := tspath.TryGetExtensionFromPath(file.FileName())
|
|
||||||
if slices.Contains(tspath.SupportedJSExtensionsFlat, extension) {
|
|
||||||
unsupportedExtensions = core.AppendIfUnique(unsupportedExtensions, extension)
|
|
||||||
}
|
|
||||||
if task.fromExternalLibrary {
|
|
||||||
sourceFilesFoundSearchingNodeModules.Add(path)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
loader.sortLibs(libFiles)
|
|
||||||
|
|
||||||
allFiles := append(libFiles, files...)
|
|
||||||
|
|
||||||
keys := slices.Collect(loader.pathForLibFileResolutions.Keys())
|
|
||||||
slices.Sort(keys)
|
|
||||||
for _, key := range keys {
|
|
||||||
value, _ := loader.pathForLibFileResolutions.Load(key)
|
|
||||||
resolvedModules[key] = module.ModeAwareCache[*module.ResolvedModule]{
|
|
||||||
module.ModeAwareCacheKey{Name: value.libraryName, Mode: core.ModuleKindCommonJS}: value.resolution,
|
|
||||||
}
|
|
||||||
for _, trace := range value.trace {
|
|
||||||
opts.Host.Trace(trace)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return processedFiles{
|
|
||||||
resolver: loader.resolver,
|
|
||||||
files: allFiles,
|
|
||||||
filesByPath: filesByPath,
|
|
||||||
projectReferenceFileMapper: loader.projectReferenceFileMapper,
|
|
||||||
resolvedModules: resolvedModules,
|
|
||||||
typeResolutionsInFile: typeResolutionsInFile,
|
|
||||||
sourceFileMetaDatas: sourceFileMetaDatas,
|
|
||||||
jsxRuntimeImportSpecifiers: jsxRuntimeImportSpecifiers,
|
|
||||||
importHelpersImportSpecifiers: importHelpersImportSpecifiers,
|
|
||||||
unsupportedExtensions: unsupportedExtensions,
|
|
||||||
sourceFilesFoundSearchingNodeModules: sourceFilesFoundSearchingNodeModules,
|
|
||||||
libFiles: libFilesMap,
|
|
||||||
missingFiles: missingFiles,
|
|
||||||
includeProcessor: loader.includeProcessor,
|
|
||||||
outputFileToProjectReferenceSource: outputFileToProjectReferenceSource,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (p *fileLoader) toPath(file string) tspath.Path {
|
|
||||||
return tspath.ToPath(file, p.opts.Host.GetCurrentDirectory(), p.opts.Host.FS().UseCaseSensitiveFileNames())
|
|
||||||
}
|
|
||||||
|
|
||||||
func (p *fileLoader) addRootTask(fileName string, libFile *LibFile, includeReason *fileIncludeReason) {
|
|
||||||
absPath := tspath.GetNormalizedAbsolutePath(fileName, p.opts.Host.GetCurrentDirectory())
|
|
||||||
if core.Tristate.IsTrue(p.opts.Config.CompilerOptions().AllowNonTsExtensions) || slices.Contains(p.supportedExtensions, tspath.TryGetExtensionFromPath(absPath)) {
|
|
||||||
p.rootTasks = append(p.rootTasks, &parseTask{
|
|
||||||
normalizedFilePath: absPath,
|
|
||||||
libFile: libFile,
|
|
||||||
includeReason: includeReason,
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (p *fileLoader) addAutomaticTypeDirectiveTasks() {
|
|
||||||
var containingDirectory string
|
|
||||||
compilerOptions := p.opts.Config.CompilerOptions()
|
|
||||||
if compilerOptions.ConfigFilePath != "" {
|
|
||||||
containingDirectory = tspath.GetDirectoryPath(compilerOptions.ConfigFilePath)
|
|
||||||
} else {
|
|
||||||
containingDirectory = p.opts.Host.GetCurrentDirectory()
|
|
||||||
}
|
|
||||||
containingFileName := tspath.CombinePaths(containingDirectory, module.InferredTypesContainingFile)
|
|
||||||
p.rootTasks = append(p.rootTasks, &parseTask{
|
|
||||||
normalizedFilePath: containingFileName,
|
|
||||||
isForAutomaticTypeDirective: true,
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (p *fileLoader) resolveAutomaticTypeDirectives(containingFileName string) (
|
|
||||||
toParse []resolvedRef,
|
|
||||||
typeResolutionsInFile module.ModeAwareCache[*module.ResolvedTypeReferenceDirective],
|
|
||||||
typeResolutionsTrace []string,
|
|
||||||
) {
|
|
||||||
automaticTypeDirectiveNames := module.GetAutomaticTypeDirectiveNames(p.opts.Config.CompilerOptions(), p.opts.Host)
|
|
||||||
if len(automaticTypeDirectiveNames) != 0 {
|
|
||||||
toParse = make([]resolvedRef, 0, len(automaticTypeDirectiveNames))
|
|
||||||
typeResolutionsInFile = make(module.ModeAwareCache[*module.ResolvedTypeReferenceDirective], len(automaticTypeDirectiveNames))
|
|
||||||
for _, name := range automaticTypeDirectiveNames {
|
|
||||||
resolutionMode := core.ModuleKindNodeNext
|
|
||||||
resolved, trace := p.resolver.ResolveTypeReferenceDirective(name, containingFileName, resolutionMode, nil)
|
|
||||||
typeResolutionsInFile[module.ModeAwareCacheKey{Name: name, Mode: resolutionMode}] = resolved
|
|
||||||
typeResolutionsTrace = append(typeResolutionsTrace, trace...)
|
|
||||||
if resolved.IsResolved() {
|
|
||||||
toParse = append(toParse, resolvedRef{
|
|
||||||
fileName: resolved.ResolvedFileName,
|
|
||||||
increaseDepth: resolved.IsExternalLibraryImport,
|
|
||||||
elideOnDepth: false,
|
|
||||||
includeReason: &fileIncludeReason{
|
|
||||||
kind: fileIncludeKindAutomaticTypeDirectiveFile,
|
|
||||||
data: &automaticTypeDirectiveFileData{name, resolved.PackageId},
|
|
||||||
},
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return toParse, typeResolutionsInFile, typeResolutionsTrace
|
|
||||||
}
|
|
||||||
|
|
||||||
func (p *fileLoader) addProjectReferenceTasks(singleThreaded bool) {
|
|
||||||
p.projectReferenceFileMapper = &projectReferenceFileMapper{
|
|
||||||
opts: p.opts,
|
|
||||||
host: p.opts.Host,
|
|
||||||
}
|
|
||||||
projectReferences := p.opts.Config.ResolvedProjectReferencePaths()
|
|
||||||
if len(projectReferences) == 0 {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
parser := &projectReferenceParser{
|
|
||||||
loader: p,
|
|
||||||
wg: core.NewWorkGroup(singleThreaded),
|
|
||||||
}
|
|
||||||
rootTasks := createProjectReferenceParseTasks(projectReferences)
|
|
||||||
parser.parse(rootTasks)
|
|
||||||
|
|
||||||
// Add files from project references as root if the module kind is 'none'.
|
|
||||||
// This ensures that files from project references are included in the root tasks
|
|
||||||
// when no module system is specified, allowing including all files for global symbol merging
|
|
||||||
// !!! sheetal Do we really need it?
|
|
||||||
if len(p.opts.Config.FileNames()) != 0 {
|
|
||||||
for index, resolved := range p.projectReferenceFileMapper.getResolvedProjectReferences() {
|
|
||||||
if resolved == nil || resolved.CompilerOptions().GetEmitModuleKind() != core.ModuleKindNone {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
if p.opts.canUseProjectReferenceSource() {
|
|
||||||
for _, fileName := range resolved.FileNames() {
|
|
||||||
p.rootTasks = append(p.rootTasks, &parseTask{
|
|
||||||
normalizedFilePath: fileName,
|
|
||||||
includeReason: &fileIncludeReason{
|
|
||||||
kind: fileIncludeKindSourceFromProjectReference,
|
|
||||||
data: index,
|
|
||||||
},
|
|
||||||
})
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
for outputDts := range resolved.GetOutputDeclarationAndSourceFileNames() {
|
|
||||||
if outputDts != "" {
|
|
||||||
p.rootTasks = append(p.rootTasks, &parseTask{
|
|
||||||
normalizedFilePath: outputDts,
|
|
||||||
includeReason: &fileIncludeReason{
|
|
||||||
kind: fileIncludeKindOutputFromProjectReference,
|
|
||||||
data: index,
|
|
||||||
},
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (p *fileLoader) sortLibs(libFiles []*ast.SourceFile) {
|
|
||||||
slices.SortFunc(libFiles, func(f1 *ast.SourceFile, f2 *ast.SourceFile) int {
|
|
||||||
return cmp.Compare(p.getDefaultLibFilePriority(f1), p.getDefaultLibFilePriority(f2))
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (p *fileLoader) getDefaultLibFilePriority(a *ast.SourceFile) int {
|
|
||||||
// defaultLibraryPath and a.FileName() are absolute and normalized; a prefix check should suffice.
|
|
||||||
defaultLibraryPath := tspath.RemoveTrailingDirectorySeparator(p.defaultLibraryPath)
|
|
||||||
aFileName := a.FileName()
|
|
||||||
|
|
||||||
if strings.HasPrefix(aFileName, defaultLibraryPath) && len(aFileName) > len(defaultLibraryPath) && aFileName[len(defaultLibraryPath)] == tspath.DirectorySeparator {
|
|
||||||
// avoid tspath.GetBaseFileName; we know these paths are already absolute and normalized.
|
|
||||||
basename := aFileName[strings.LastIndexByte(aFileName, tspath.DirectorySeparator)+1:]
|
|
||||||
if basename == "lib.d.ts" || basename == "lib.es6.d.ts" {
|
|
||||||
return 0
|
|
||||||
}
|
|
||||||
name := strings.TrimSuffix(strings.TrimPrefix(basename, "lib."), ".d.ts")
|
|
||||||
index := slices.Index(tsoptions.Libs, name)
|
|
||||||
if index != -1 {
|
|
||||||
return index + 1
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return len(tsoptions.Libs) + 2
|
|
||||||
}
|
|
||||||
|
|
||||||
func (p *fileLoader) loadSourceFileMetaData(fileName string) ast.SourceFileMetaData {
|
|
||||||
packageJsonScope := p.resolver.GetPackageJsonScopeIfApplicable(fileName)
|
|
||||||
var packageJsonType, packageJsonDirectory string
|
|
||||||
if packageJsonScope.Exists() {
|
|
||||||
packageJsonDirectory = packageJsonScope.PackageDirectory
|
|
||||||
if value, ok := packageJsonScope.Contents.Type.GetValue(); ok {
|
|
||||||
packageJsonType = value
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impliedNodeFormat := ast.GetImpliedNodeFormatForFile(fileName, packageJsonType)
|
|
||||||
return ast.SourceFileMetaData{
|
|
||||||
PackageJsonType: packageJsonType,
|
|
||||||
PackageJsonDirectory: packageJsonDirectory,
|
|
||||||
ImpliedNodeFormat: impliedNodeFormat,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (p *fileLoader) parseSourceFile(t *parseTask) *ast.SourceFile {
|
|
||||||
path := p.toPath(t.normalizedFilePath)
|
|
||||||
options := p.projectReferenceFileMapper.getCompilerOptionsForFile(t)
|
|
||||||
sourceFile := p.opts.Host.GetSourceFile(ast.SourceFileParseOptions{
|
|
||||||
FileName: t.normalizedFilePath,
|
|
||||||
Path: path,
|
|
||||||
CompilerOptions: ast.GetSourceFileAffectingCompilerOptions(t.normalizedFilePath, options),
|
|
||||||
ExternalModuleIndicatorOptions: ast.GetExternalModuleIndicatorOptions(t.normalizedFilePath, options, t.metadata),
|
|
||||||
JSDocParsingMode: p.opts.JSDocParsingMode,
|
|
||||||
})
|
|
||||||
return sourceFile
|
|
||||||
}
|
|
||||||
|
|
||||||
func (p *fileLoader) resolveTripleslashPathReference(moduleName string, containingFile string, index int) resolvedRef {
|
|
||||||
basePath := tspath.GetDirectoryPath(containingFile)
|
|
||||||
referencedFileName := moduleName
|
|
||||||
|
|
||||||
if !tspath.IsRootedDiskPath(moduleName) {
|
|
||||||
referencedFileName = tspath.CombinePaths(basePath, moduleName)
|
|
||||||
}
|
|
||||||
return resolvedRef{
|
|
||||||
fileName: tspath.NormalizePath(referencedFileName),
|
|
||||||
includeReason: &fileIncludeReason{
|
|
||||||
kind: fileIncludeKindReferenceFile,
|
|
||||||
data: &referencedFileData{
|
|
||||||
file: p.toPath(containingFile),
|
|
||||||
index: index,
|
|
||||||
},
|
|
||||||
},
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (p *fileLoader) resolveTypeReferenceDirectives(t *parseTask) {
|
|
||||||
file := t.file
|
|
||||||
if len(file.TypeReferenceDirectives) == 0 {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
meta := t.metadata
|
|
||||||
|
|
||||||
typeResolutionsInFile := make(module.ModeAwareCache[*module.ResolvedTypeReferenceDirective], len(file.TypeReferenceDirectives))
|
|
||||||
var typeResolutionsTrace []string
|
|
||||||
for index, ref := range file.TypeReferenceDirectives {
|
|
||||||
redirect, fileName := p.projectReferenceFileMapper.getRedirectForResolution(file)
|
|
||||||
resolutionMode := getModeForTypeReferenceDirectiveInFile(ref, file, meta, module.GetCompilerOptionsWithRedirect(p.opts.Config.CompilerOptions(), redirect))
|
|
||||||
resolved, trace := p.resolver.ResolveTypeReferenceDirective(ref.FileName, fileName, resolutionMode, redirect)
|
|
||||||
typeResolutionsInFile[module.ModeAwareCacheKey{Name: ref.FileName, Mode: resolutionMode}] = resolved
|
|
||||||
includeReason := &fileIncludeReason{
|
|
||||||
kind: fileIncludeKindTypeReferenceDirective,
|
|
||||||
data: &referencedFileData{
|
|
||||||
file: t.path,
|
|
||||||
index: index,
|
|
||||||
},
|
|
||||||
}
|
|
||||||
typeResolutionsTrace = append(typeResolutionsTrace, trace...)
|
|
||||||
|
|
||||||
if resolved.IsResolved() {
|
|
||||||
t.addSubTask(resolvedRef{
|
|
||||||
fileName: resolved.ResolvedFileName,
|
|
||||||
increaseDepth: resolved.IsExternalLibraryImport,
|
|
||||||
elideOnDepth: false,
|
|
||||||
isFromExternalLibrary: resolved.IsExternalLibraryImport,
|
|
||||||
includeReason: includeReason,
|
|
||||||
}, nil)
|
|
||||||
} else {
|
|
||||||
p.includeProcessor.addProcessingDiagnostic(&processingDiagnostic{
|
|
||||||
kind: processingDiagnosticKindUnknownReference,
|
|
||||||
data: includeReason,
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
t.typeResolutionsInFile = typeResolutionsInFile
|
|
||||||
t.typeResolutionsTrace = typeResolutionsTrace
|
|
||||||
}
|
|
||||||
|
|
||||||
const externalHelpersModuleNameText = "tslib" // TODO(jakebailey): dedupe
|
|
||||||
|
|
||||||
func (p *fileLoader) resolveImportsAndModuleAugmentations(t *parseTask) {
|
|
||||||
file := t.file
|
|
||||||
meta := t.metadata
|
|
||||||
|
|
||||||
moduleNames := make([]*ast.Node, 0, len(file.Imports())+len(file.ModuleAugmentations)+2)
|
|
||||||
|
|
||||||
isJavaScriptFile := ast.IsSourceFileJS(file)
|
|
||||||
isExternalModuleFile := ast.IsExternalModule(file)
|
|
||||||
|
|
||||||
redirect, fileName := p.projectReferenceFileMapper.getRedirectForResolution(file)
|
|
||||||
optionsForFile := module.GetCompilerOptionsWithRedirect(p.opts.Config.CompilerOptions(), redirect)
|
|
||||||
if isJavaScriptFile || (!file.IsDeclarationFile && (optionsForFile.GetIsolatedModules() || isExternalModuleFile)) {
|
|
||||||
if optionsForFile.ImportHelpers.IsTrue() {
|
|
||||||
specifier := p.createSyntheticImport(externalHelpersModuleNameText, file)
|
|
||||||
moduleNames = append(moduleNames, specifier)
|
|
||||||
t.importHelpersImportSpecifier = specifier
|
|
||||||
}
|
|
||||||
|
|
||||||
jsxImport := ast.GetJSXRuntimeImport(ast.GetJSXImplicitImportBase(optionsForFile, file), optionsForFile)
|
|
||||||
if jsxImport != "" {
|
|
||||||
specifier := p.createSyntheticImport(jsxImport, file)
|
|
||||||
moduleNames = append(moduleNames, specifier)
|
|
||||||
t.jsxRuntimeImportSpecifier = &jsxRuntimeImportSpecifier{
|
|
||||||
moduleReference: jsxImport,
|
|
||||||
specifier: specifier,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
importsStart := len(moduleNames)
|
|
||||||
|
|
||||||
moduleNames = append(moduleNames, file.Imports()...)
|
|
||||||
for _, imp := range file.ModuleAugmentations {
|
|
||||||
if imp.Kind == ast.KindStringLiteral {
|
|
||||||
moduleNames = append(moduleNames, imp)
|
|
||||||
}
|
|
||||||
// Do nothing if it's an Identifier; we don't need to do module resolution for `declare global`.
|
|
||||||
}
|
|
||||||
|
|
||||||
if len(moduleNames) != 0 {
|
|
||||||
resolutionsInFile := make(module.ModeAwareCache[*module.ResolvedModule], len(moduleNames))
|
|
||||||
var resolutionsTrace []string
|
|
||||||
|
|
||||||
for index, entry := range moduleNames {
|
|
||||||
moduleName := entry.Text()
|
|
||||||
if moduleName == "" {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
|
|
||||||
mode := getModeForUsageLocation(file.FileName(), meta, entry, optionsForFile)
|
|
||||||
resolvedModule, trace := p.resolver.ResolveModuleName(moduleName, fileName, mode, redirect)
|
|
||||||
resolutionsInFile[module.ModeAwareCacheKey{Name: moduleName, Mode: mode}] = resolvedModule
|
|
||||||
resolutionsTrace = append(resolutionsTrace, trace...)
|
|
||||||
|
|
||||||
if !resolvedModule.IsResolved() {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
|
|
||||||
resolvedFileName := resolvedModule.ResolvedFileName
|
|
||||||
isFromNodeModulesSearch := resolvedModule.IsExternalLibraryImport
|
|
||||||
// Don't treat redirected files as JS files.
|
|
||||||
isJsFile := !tspath.FileExtensionIsOneOf(resolvedFileName, tspath.SupportedTSExtensionsWithJsonFlat) && p.projectReferenceFileMapper.getRedirectParsedCommandLineForResolution(ast.NewHasFileName(resolvedFileName, p.toPath(resolvedFileName))) == nil
|
|
||||||
isJsFileFromNodeModules := isFromNodeModulesSearch && isJsFile && strings.Contains(resolvedFileName, "/node_modules/")
|
|
||||||
|
|
||||||
// add file to program only if:
|
|
||||||
// - resolution was successful
|
|
||||||
// - noResolve is falsy
|
|
||||||
// - module name comes from the list of imports
|
|
||||||
// - it's not a top level JavaScript module that exceeded the search max
|
|
||||||
|
|
||||||
importIndex := index - importsStart
|
|
||||||
|
|
||||||
shouldAddFile := moduleName != "" &&
|
|
||||||
module.GetResolutionDiagnostic(optionsForFile, resolvedModule, file) == nil &&
|
|
||||||
!optionsForFile.NoResolve.IsTrue() &&
|
|
||||||
!(isJsFile && !optionsForFile.GetAllowJS()) &&
|
|
||||||
(importIndex < 0 || (importIndex < len(file.Imports()) && (ast.IsInJSFile(file.Imports()[importIndex]) || file.Imports()[importIndex].Flags&ast.NodeFlagsJSDoc == 0)))
|
|
||||||
|
|
||||||
if shouldAddFile {
|
|
||||||
t.addSubTask(resolvedRef{
|
|
||||||
fileName: resolvedFileName,
|
|
||||||
increaseDepth: resolvedModule.IsExternalLibraryImport,
|
|
||||||
elideOnDepth: isJsFileFromNodeModules,
|
|
||||||
isFromExternalLibrary: resolvedModule.IsExternalLibraryImport,
|
|
||||||
includeReason: &fileIncludeReason{
|
|
||||||
kind: fileIncludeKindImport,
|
|
||||||
data: &referencedFileData{
|
|
||||||
file: t.path,
|
|
||||||
index: importIndex,
|
|
||||||
synthetic: core.IfElse(importIndex < 0, entry, nil),
|
|
||||||
},
|
|
||||||
},
|
|
||||||
}, nil)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
t.resolutionsInFile = resolutionsInFile
|
|
||||||
t.resolutionsTrace = resolutionsTrace
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (p *fileLoader) createSyntheticImport(text string, file *ast.SourceFile) *ast.Node {
|
|
||||||
p.factoryMu.Lock()
|
|
||||||
defer p.factoryMu.Unlock()
|
|
||||||
externalHelpersModuleReference := p.factory.NewStringLiteral(text)
|
|
||||||
importDecl := p.factory.NewImportDeclaration(nil, nil, externalHelpersModuleReference, nil)
|
|
||||||
// !!! addInternalEmitFlags(importDecl, InternalEmitFlags.NeverApplyImportHelper);
|
|
||||||
externalHelpersModuleReference.Parent = importDecl
|
|
||||||
importDecl.Parent = file.AsNode()
|
|
||||||
// !!! externalHelpersModuleReference.Flags &^= ast.NodeFlagsSynthesized
|
|
||||||
// !!! importDecl.Flags &^= ast.NodeFlagsSynthesized
|
|
||||||
return externalHelpersModuleReference
|
|
||||||
}
|
|
||||||
|
|
||||||
func (p *fileLoader) pathForLibFile(name string) *LibFile {
|
|
||||||
if cached, ok := p.pathForLibFileCache.Load(name); ok {
|
|
||||||
return cached
|
|
||||||
}
|
|
||||||
|
|
||||||
path := tspath.CombinePaths(p.defaultLibraryPath, name)
|
|
||||||
replaced := false
|
|
||||||
if p.opts.Config.CompilerOptions().LibReplacement.IsTrue() && name != "lib.d.ts" {
|
|
||||||
libraryName := getLibraryNameFromLibFileName(name)
|
|
||||||
resolveFrom := getInferredLibraryNameResolveFrom(p.opts.Config.CompilerOptions(), p.opts.Host.GetCurrentDirectory(), name)
|
|
||||||
resolution, trace := p.resolver.ResolveModuleName(libraryName, resolveFrom, core.ModuleKindCommonJS, nil)
|
|
||||||
if resolution.IsResolved() {
|
|
||||||
path = resolution.ResolvedFileName
|
|
||||||
replaced = true
|
|
||||||
}
|
|
||||||
p.pathForLibFileResolutions.LoadOrStore(p.toPath(resolveFrom), &libResolution{
|
|
||||||
libraryName: libraryName,
|
|
||||||
resolution: resolution,
|
|
||||||
trace: trace,
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
libPath, _ := p.pathForLibFileCache.LoadOrStore(name, &LibFile{name, path, replaced})
|
|
||||||
return libPath
|
|
||||||
}
|
|
||||||
|
|
||||||
func getLibraryNameFromLibFileName(libFileName string) string {
|
|
||||||
// Support resolving to lib.dom.d.ts -> @typescript/lib-dom, and
|
|
||||||
// lib.dom.iterable.d.ts -> @typescript/lib-dom/iterable
|
|
||||||
// lib.es2015.symbol.wellknown.d.ts -> @typescript/lib-es2015/symbol-wellknown
|
|
||||||
components := strings.Split(libFileName, ".")
|
|
||||||
var path string
|
|
||||||
if len(components) > 1 {
|
|
||||||
path = components[1]
|
|
||||||
}
|
|
||||||
i := 2
|
|
||||||
for i < len(components) && components[i] != "" && components[i] != "d" {
|
|
||||||
path += core.IfElse(i == 2, "/", "-") + components[i]
|
|
||||||
i++
|
|
||||||
}
|
|
||||||
return "@typescript/lib-" + path
|
|
||||||
}
|
|
||||||
|
|
||||||
func getInferredLibraryNameResolveFrom(options *core.CompilerOptions, currentDirectory string, libFileName string) string {
|
|
||||||
var containingDirectory string
|
|
||||||
if options.ConfigFilePath != "" {
|
|
||||||
containingDirectory = tspath.GetDirectoryPath(options.ConfigFilePath)
|
|
||||||
} else {
|
|
||||||
containingDirectory = currentDirectory
|
|
||||||
}
|
|
||||||
return tspath.CombinePaths(containingDirectory, "__lib_node_modules_lookup_"+libFileName+"__.ts")
|
|
||||||
}
|
|
||||||
|
|
||||||
func getModeForTypeReferenceDirectiveInFile(ref *ast.FileReference, file *ast.SourceFile, meta ast.SourceFileMetaData, options *core.CompilerOptions) core.ResolutionMode {
|
|
||||||
if ref.ResolutionMode != core.ResolutionModeNone {
|
|
||||||
return ref.ResolutionMode
|
|
||||||
} else {
|
|
||||||
return getDefaultResolutionModeForFile(file.FileName(), meta, options)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func getDefaultResolutionModeForFile(fileName string, meta ast.SourceFileMetaData, options *core.CompilerOptions) core.ResolutionMode {
|
|
||||||
if importSyntaxAffectsModuleResolution(options) {
|
|
||||||
return ast.GetImpliedNodeFormatForEmitWorker(fileName, options.GetEmitModuleKind(), meta)
|
|
||||||
} else {
|
|
||||||
return core.ResolutionModeNone
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func getModeForUsageLocation(fileName string, meta ast.SourceFileMetaData, usage *ast.StringLiteralLike, options *core.CompilerOptions) core.ResolutionMode {
|
|
||||||
if ast.IsImportDeclaration(usage.Parent) || usage.Parent.Kind == ast.KindJSImportDeclaration || ast.IsExportDeclaration(usage.Parent) || ast.IsJSDocImportTag(usage.Parent) {
|
|
||||||
isTypeOnly := ast.IsExclusivelyTypeOnlyImportOrExport(usage.Parent)
|
|
||||||
if isTypeOnly {
|
|
||||||
var override core.ResolutionMode
|
|
||||||
var ok bool
|
|
||||||
switch usage.Parent.Kind {
|
|
||||||
case ast.KindImportDeclaration, ast.KindJSImportDeclaration:
|
|
||||||
override, ok = usage.Parent.AsImportDeclaration().Attributes.GetResolutionModeOverride()
|
|
||||||
case ast.KindExportDeclaration:
|
|
||||||
override, ok = usage.Parent.AsExportDeclaration().Attributes.GetResolutionModeOverride()
|
|
||||||
case ast.KindJSDocImportTag:
|
|
||||||
override, ok = usage.Parent.AsJSDocImportTag().Attributes.GetResolutionModeOverride()
|
|
||||||
}
|
|
||||||
if ok {
|
|
||||||
return override
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if ast.IsLiteralTypeNode(usage.Parent) && ast.IsImportTypeNode(usage.Parent.Parent) {
|
|
||||||
if override, ok := usage.Parent.Parent.AsImportTypeNode().Attributes.GetResolutionModeOverride(); ok {
|
|
||||||
return override
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if options != nil && importSyntaxAffectsModuleResolution(options) {
|
|
||||||
return getEmitSyntaxForUsageLocationWorker(fileName, meta, usage, options)
|
|
||||||
}
|
|
||||||
|
|
||||||
return core.ResolutionModeNone
|
|
||||||
}
|
|
||||||
|
|
||||||
func importSyntaxAffectsModuleResolution(options *core.CompilerOptions) bool {
|
|
||||||
moduleResolution := options.GetModuleResolutionKind()
|
|
||||||
return core.ModuleResolutionKindNode16 <= moduleResolution && moduleResolution <= core.ModuleResolutionKindNodeNext ||
|
|
||||||
options.GetResolvePackageJsonExports() || options.GetResolvePackageJsonImports()
|
|
||||||
}
|
|
||||||
|
|
||||||
func getEmitSyntaxForUsageLocationWorker(fileName string, meta ast.SourceFileMetaData, usage *ast.Node, options *core.CompilerOptions) core.ResolutionMode {
|
|
||||||
if ast.IsRequireCall(usage.Parent, false /*requireStringLiteralLikeArgument*/) || ast.IsExternalModuleReference(usage.Parent) && ast.IsImportEqualsDeclaration(usage.Parent.Parent) {
|
|
||||||
return core.ModuleKindCommonJS
|
|
||||||
}
|
|
||||||
fileEmitMode := ast.GetEmitModuleFormatOfFileWorker(fileName, options, meta)
|
|
||||||
if ast.IsImportCall(ast.WalkUpParenthesizedExpressions(usage.Parent)) {
|
|
||||||
if ast.ShouldTransformImportCall(fileName, options, fileEmitMode) {
|
|
||||||
return core.ModuleKindCommonJS
|
|
||||||
} else {
|
|
||||||
return core.ModuleKindESNext
|
|
||||||
}
|
|
||||||
}
|
|
||||||
// If we're in --module preserve on an input file, we know that an import
|
|
||||||
// is an import. But if this is a declaration file, we'd prefer to use the
|
|
||||||
// impliedNodeFormat. Since we want things to be consistent between the two,
|
|
||||||
// we need to issue errors when the user writes ESM syntax in a definitely-CJS
|
|
||||||
// file, until/unless declaration emit can indicate a true ESM import. On the
|
|
||||||
// other hand, writing CJS syntax in a definitely-ESM file is fine, since declaration
|
|
||||||
// emit preserves the CJS syntax.
|
|
||||||
if fileEmitMode == core.ModuleKindCommonJS {
|
|
||||||
return core.ModuleKindCommonJS
|
|
||||||
} else {
|
|
||||||
if fileEmitMode.IsNonNodeESM() || fileEmitMode == core.ModuleKindPreserve {
|
|
||||||
return core.ModuleKindESNext
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return core.ModuleKindNone
|
|
||||||
}
|
|
||||||
@ -1,280 +0,0 @@
|
|||||||
package compiler
|
|
||||||
|
|
||||||
import (
|
|
||||||
"math"
|
|
||||||
"sync"
|
|
||||||
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/ast"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/collections"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/core"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/module"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/tsoptions"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/tspath"
|
|
||||||
)
|
|
||||||
|
|
||||||
type parseTask struct {
|
|
||||||
normalizedFilePath string
|
|
||||||
path tspath.Path
|
|
||||||
file *ast.SourceFile
|
|
||||||
libFile *LibFile
|
|
||||||
redirectedParseTask *parseTask
|
|
||||||
subTasks []*parseTask
|
|
||||||
loaded bool
|
|
||||||
isForAutomaticTypeDirective bool
|
|
||||||
includeReason *fileIncludeReason
|
|
||||||
|
|
||||||
metadata ast.SourceFileMetaData
|
|
||||||
resolutionsInFile module.ModeAwareCache[*module.ResolvedModule]
|
|
||||||
resolutionsTrace []string
|
|
||||||
typeResolutionsInFile module.ModeAwareCache[*module.ResolvedTypeReferenceDirective]
|
|
||||||
typeResolutionsTrace []string
|
|
||||||
resolutionDiagnostics []*ast.Diagnostic
|
|
||||||
importHelpersImportSpecifier *ast.Node
|
|
||||||
jsxRuntimeImportSpecifier *jsxRuntimeImportSpecifier
|
|
||||||
increaseDepth bool
|
|
||||||
elideOnDepth bool
|
|
||||||
|
|
||||||
// Track if this file is from an external library (node_modules)
|
|
||||||
// This mirrors the TypeScript currentNodeModulesDepth > 0 check
|
|
||||||
fromExternalLibrary bool
|
|
||||||
|
|
||||||
loadedTask *parseTask
|
|
||||||
allIncludeReasons []*fileIncludeReason
|
|
||||||
}
|
|
||||||
|
|
||||||
func (t *parseTask) FileName() string {
|
|
||||||
return t.normalizedFilePath
|
|
||||||
}
|
|
||||||
|
|
||||||
func (t *parseTask) Path() tspath.Path {
|
|
||||||
return t.path
|
|
||||||
}
|
|
||||||
|
|
||||||
func (t *parseTask) isRoot() bool {
|
|
||||||
// Intentionally not checking t.includeReason != nil to ensure we can catch cases for missing include reason
|
|
||||||
return !t.isForAutomaticTypeDirective && (t.includeReason.kind == fileIncludeKindRootFile || t.includeReason.kind == fileIncludeKindLibFile)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (t *parseTask) load(loader *fileLoader) {
|
|
||||||
t.loaded = true
|
|
||||||
t.path = loader.toPath(t.normalizedFilePath)
|
|
||||||
if t.isForAutomaticTypeDirective {
|
|
||||||
t.loadAutomaticTypeDirectives(loader)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
redirect := loader.projectReferenceFileMapper.getParseFileRedirect(t)
|
|
||||||
if redirect != "" {
|
|
||||||
t.redirect(loader, redirect)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
loader.totalFileCount.Add(1)
|
|
||||||
if t.libFile != nil {
|
|
||||||
loader.libFileCount.Add(1)
|
|
||||||
}
|
|
||||||
|
|
||||||
t.metadata = loader.loadSourceFileMetaData(t.normalizedFilePath)
|
|
||||||
file := loader.parseSourceFile(t)
|
|
||||||
if file == nil {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
t.file = file
|
|
||||||
t.subTasks = make([]*parseTask, 0, len(file.ReferencedFiles)+len(file.Imports())+len(file.ModuleAugmentations))
|
|
||||||
|
|
||||||
for index, ref := range file.ReferencedFiles {
|
|
||||||
resolvedPath := loader.resolveTripleslashPathReference(ref.FileName, file.FileName(), index)
|
|
||||||
t.addSubTask(resolvedPath, nil)
|
|
||||||
}
|
|
||||||
|
|
||||||
compilerOptions := loader.opts.Config.CompilerOptions()
|
|
||||||
loader.resolveTypeReferenceDirectives(t)
|
|
||||||
|
|
||||||
if compilerOptions.NoLib != core.TSTrue {
|
|
||||||
for index, lib := range file.LibReferenceDirectives {
|
|
||||||
includeReason := &fileIncludeReason{
|
|
||||||
kind: fileIncludeKindLibReferenceDirective,
|
|
||||||
data: &referencedFileData{
|
|
||||||
file: t.path,
|
|
||||||
index: index,
|
|
||||||
},
|
|
||||||
}
|
|
||||||
if name, ok := tsoptions.GetLibFileName(lib.FileName); ok {
|
|
||||||
libFile := loader.pathForLibFile(name)
|
|
||||||
t.addSubTask(resolvedRef{
|
|
||||||
fileName: libFile.path,
|
|
||||||
includeReason: includeReason,
|
|
||||||
}, libFile)
|
|
||||||
} else {
|
|
||||||
loader.includeProcessor.addProcessingDiagnostic(&processingDiagnostic{
|
|
||||||
kind: processingDiagnosticKindUnknownReference,
|
|
||||||
data: includeReason,
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
loader.resolveImportsAndModuleAugmentations(t)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (t *parseTask) redirect(loader *fileLoader, fileName string) {
|
|
||||||
t.redirectedParseTask = &parseTask{
|
|
||||||
normalizedFilePath: tspath.NormalizePath(fileName),
|
|
||||||
libFile: t.libFile,
|
|
||||||
fromExternalLibrary: t.fromExternalLibrary,
|
|
||||||
includeReason: t.includeReason,
|
|
||||||
}
|
|
||||||
// increaseDepth and elideOnDepth are not copied to redirects, otherwise their depth would be double counted.
|
|
||||||
t.subTasks = []*parseTask{t.redirectedParseTask}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (t *parseTask) loadAutomaticTypeDirectives(loader *fileLoader) {
|
|
||||||
toParseTypeRefs, typeResolutionsInFile, typeResolutionsTrace := loader.resolveAutomaticTypeDirectives(t.normalizedFilePath)
|
|
||||||
t.typeResolutionsInFile = typeResolutionsInFile
|
|
||||||
t.typeResolutionsTrace = typeResolutionsTrace
|
|
||||||
for _, typeResolution := range toParseTypeRefs {
|
|
||||||
t.addSubTask(typeResolution, nil)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
type resolvedRef struct {
|
|
||||||
fileName string
|
|
||||||
increaseDepth bool
|
|
||||||
elideOnDepth bool
|
|
||||||
isFromExternalLibrary bool
|
|
||||||
includeReason *fileIncludeReason
|
|
||||||
}
|
|
||||||
|
|
||||||
func (t *parseTask) addSubTask(ref resolvedRef, libFile *LibFile) {
|
|
||||||
normalizedFilePath := tspath.NormalizePath(ref.fileName)
|
|
||||||
subTask := &parseTask{
|
|
||||||
normalizedFilePath: normalizedFilePath,
|
|
||||||
libFile: libFile,
|
|
||||||
increaseDepth: ref.increaseDepth,
|
|
||||||
elideOnDepth: ref.elideOnDepth,
|
|
||||||
fromExternalLibrary: ref.isFromExternalLibrary,
|
|
||||||
includeReason: ref.includeReason,
|
|
||||||
}
|
|
||||||
t.subTasks = append(t.subTasks, subTask)
|
|
||||||
}
|
|
||||||
|
|
||||||
type filesParser struct {
|
|
||||||
wg core.WorkGroup
|
|
||||||
tasksByFileName collections.SyncMap[string, *queuedParseTask]
|
|
||||||
maxDepth int
|
|
||||||
}
|
|
||||||
|
|
||||||
type queuedParseTask struct {
|
|
||||||
task *parseTask
|
|
||||||
mu sync.Mutex
|
|
||||||
lowestDepth int
|
|
||||||
fromExternalLibrary bool
|
|
||||||
}
|
|
||||||
|
|
||||||
func (w *filesParser) parse(loader *fileLoader, tasks []*parseTask) {
|
|
||||||
w.start(loader, tasks, 0, false)
|
|
||||||
w.wg.RunAndWait()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (w *filesParser) start(loader *fileLoader, tasks []*parseTask, depth int, isFromExternalLibrary bool) {
|
|
||||||
for i, task := range tasks {
|
|
||||||
taskIsFromExternalLibrary := isFromExternalLibrary || task.fromExternalLibrary
|
|
||||||
newTask := &queuedParseTask{task: task, lowestDepth: math.MaxInt}
|
|
||||||
loadedTask, loaded := w.tasksByFileName.LoadOrStore(task.FileName(), newTask)
|
|
||||||
task = loadedTask.task
|
|
||||||
if loaded {
|
|
||||||
tasks[i].loadedTask = task
|
|
||||||
// Add in the loaded task's external-ness.
|
|
||||||
taskIsFromExternalLibrary = taskIsFromExternalLibrary || task.fromExternalLibrary
|
|
||||||
}
|
|
||||||
|
|
||||||
w.wg.Queue(func() {
|
|
||||||
loadedTask.mu.Lock()
|
|
||||||
defer loadedTask.mu.Unlock()
|
|
||||||
|
|
||||||
startSubtasks := false
|
|
||||||
|
|
||||||
currentDepth := depth
|
|
||||||
if task.increaseDepth {
|
|
||||||
currentDepth++
|
|
||||||
}
|
|
||||||
if currentDepth < loadedTask.lowestDepth {
|
|
||||||
// If we're seeing this task at a lower depth than before,
|
|
||||||
// reprocess its subtasks to ensure they are loaded.
|
|
||||||
loadedTask.lowestDepth = currentDepth
|
|
||||||
startSubtasks = true
|
|
||||||
}
|
|
||||||
|
|
||||||
if !task.isRoot() && taskIsFromExternalLibrary && !loadedTask.fromExternalLibrary {
|
|
||||||
// If we're seeing this task now as an external library,
|
|
||||||
// reprocess its subtasks to ensure they are also marked as external.
|
|
||||||
loadedTask.fromExternalLibrary = true
|
|
||||||
startSubtasks = true
|
|
||||||
}
|
|
||||||
|
|
||||||
if task.elideOnDepth && currentDepth > w.maxDepth {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
if !task.loaded {
|
|
||||||
task.load(loader)
|
|
||||||
}
|
|
||||||
|
|
||||||
if startSubtasks {
|
|
||||||
w.start(loader, task.subTasks, loadedTask.lowestDepth, loadedTask.fromExternalLibrary)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (w *filesParser) collect(loader *fileLoader, tasks []*parseTask, iterate func(*parseTask)) {
|
|
||||||
// Mark all tasks we saw as external after the fact.
|
|
||||||
w.tasksByFileName.Range(func(key string, value *queuedParseTask) bool {
|
|
||||||
if value.fromExternalLibrary {
|
|
||||||
value.task.fromExternalLibrary = true
|
|
||||||
}
|
|
||||||
return true
|
|
||||||
})
|
|
||||||
w.collectWorker(loader, tasks, iterate, collections.Set[*parseTask]{})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (w *filesParser) collectWorker(loader *fileLoader, tasks []*parseTask, iterate func(*parseTask), seen collections.Set[*parseTask]) {
|
|
||||||
for _, task := range tasks {
|
|
||||||
// Exclude automatic type directive tasks from include reason processing,
|
|
||||||
// as these are internal implementation details and should not contribute
|
|
||||||
// to the reasons for including files.
|
|
||||||
if task.redirectedParseTask == nil && !task.isForAutomaticTypeDirective {
|
|
||||||
includeReason := task.includeReason
|
|
||||||
if task.loadedTask != nil {
|
|
||||||
task = task.loadedTask
|
|
||||||
}
|
|
||||||
w.addIncludeReason(loader, task, includeReason)
|
|
||||||
}
|
|
||||||
// ensure we only walk each task once
|
|
||||||
if !task.loaded || !seen.AddIfAbsent(task) {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
for _, trace := range task.typeResolutionsTrace {
|
|
||||||
loader.opts.Host.Trace(trace)
|
|
||||||
}
|
|
||||||
for _, trace := range task.resolutionsTrace {
|
|
||||||
loader.opts.Host.Trace(trace)
|
|
||||||
}
|
|
||||||
if subTasks := task.subTasks; len(subTasks) > 0 {
|
|
||||||
w.collectWorker(loader, subTasks, iterate, seen)
|
|
||||||
}
|
|
||||||
iterate(task)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (w *filesParser) addIncludeReason(loader *fileLoader, task *parseTask, reason *fileIncludeReason) {
|
|
||||||
if task.redirectedParseTask != nil {
|
|
||||||
w.addIncludeReason(loader, task.redirectedParseTask, reason)
|
|
||||||
} else if task.loaded {
|
|
||||||
if existing, ok := loader.includeProcessor.fileIncludeReasons[task.path]; ok {
|
|
||||||
loader.includeProcessor.fileIncludeReasons[task.path] = append(existing, reason)
|
|
||||||
} else {
|
|
||||||
loader.includeProcessor.fileIncludeReasons[task.path] = []*fileIncludeReason{reason}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,88 +0,0 @@
|
|||||||
package compiler
|
|
||||||
|
|
||||||
import (
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/ast"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/core"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/parser"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/tsoptions"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/tspath"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/vfs"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/vfs/cachedvfs"
|
|
||||||
)
|
|
||||||
|
|
||||||
type CompilerHost interface {
|
|
||||||
FS() vfs.FS
|
|
||||||
DefaultLibraryPath() string
|
|
||||||
GetCurrentDirectory() string
|
|
||||||
Trace(msg string)
|
|
||||||
GetSourceFile(opts ast.SourceFileParseOptions) *ast.SourceFile
|
|
||||||
GetResolvedProjectReference(fileName string, path tspath.Path) *tsoptions.ParsedCommandLine
|
|
||||||
}
|
|
||||||
|
|
||||||
var _ CompilerHost = (*compilerHost)(nil)
|
|
||||||
|
|
||||||
type compilerHost struct {
|
|
||||||
currentDirectory string
|
|
||||||
fs vfs.FS
|
|
||||||
defaultLibraryPath string
|
|
||||||
extendedConfigCache tsoptions.ExtendedConfigCache
|
|
||||||
trace func(msg string)
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewCachedFSCompilerHost(
|
|
||||||
currentDirectory string,
|
|
||||||
fs vfs.FS,
|
|
||||||
defaultLibraryPath string,
|
|
||||||
extendedConfigCache tsoptions.ExtendedConfigCache,
|
|
||||||
trace func(msg string),
|
|
||||||
) CompilerHost {
|
|
||||||
return NewCompilerHost(currentDirectory, cachedvfs.From(fs), defaultLibraryPath, extendedConfigCache, trace)
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewCompilerHost(
|
|
||||||
currentDirectory string,
|
|
||||||
fs vfs.FS,
|
|
||||||
defaultLibraryPath string,
|
|
||||||
extendedConfigCache tsoptions.ExtendedConfigCache,
|
|
||||||
trace func(msg string),
|
|
||||||
) CompilerHost {
|
|
||||||
if trace == nil {
|
|
||||||
trace = func(msg string) {}
|
|
||||||
}
|
|
||||||
return &compilerHost{
|
|
||||||
currentDirectory: currentDirectory,
|
|
||||||
fs: fs,
|
|
||||||
defaultLibraryPath: defaultLibraryPath,
|
|
||||||
extendedConfigCache: extendedConfigCache,
|
|
||||||
trace: trace,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *compilerHost) FS() vfs.FS {
|
|
||||||
return h.fs
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *compilerHost) DefaultLibraryPath() string {
|
|
||||||
return h.defaultLibraryPath
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *compilerHost) GetCurrentDirectory() string {
|
|
||||||
return h.currentDirectory
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *compilerHost) Trace(msg string) {
|
|
||||||
h.trace(msg)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *compilerHost) GetSourceFile(opts ast.SourceFileParseOptions) *ast.SourceFile {
|
|
||||||
text, ok := h.FS().ReadFile(opts.FileName)
|
|
||||||
if !ok {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
return parser.ParseSourceFile(opts, text, core.GetScriptKindFromFileName(opts.FileName))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *compilerHost) GetResolvedProjectReference(fileName string, path tspath.Path) *tsoptions.ParsedCommandLine {
|
|
||||||
commandLine, _ := tsoptions.GetParsedCommandLineOfConfigFilePath(fileName, path, nil, h, h.extendedConfigCache)
|
|
||||||
return commandLine
|
|
||||||
}
|
|
||||||
@ -1,144 +0,0 @@
|
|||||||
package compiler
|
|
||||||
|
|
||||||
import (
|
|
||||||
"sync"
|
|
||||||
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/ast"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/collections"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/core"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/diagnostics"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/tsoptions"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/tspath"
|
|
||||||
)
|
|
||||||
|
|
||||||
type includeProcessor struct {
|
|
||||||
fileIncludeReasons map[tspath.Path][]*fileIncludeReason
|
|
||||||
processingDiagnostics []*processingDiagnostic
|
|
||||||
|
|
||||||
reasonToReferenceLocation collections.SyncMap[*fileIncludeReason, *referenceFileLocation]
|
|
||||||
includeReasonToRelatedInfo collections.SyncMap[*fileIncludeReason, *ast.Diagnostic]
|
|
||||||
redirectAndFileFormat collections.SyncMap[tspath.Path, []*ast.Diagnostic]
|
|
||||||
computedDiagnostics *ast.DiagnosticsCollection
|
|
||||||
computedDiagnosticsOnce sync.Once
|
|
||||||
compilerOptionsSyntax *ast.ObjectLiteralExpression
|
|
||||||
compilerOptionsSyntaxOnce sync.Once
|
|
||||||
}
|
|
||||||
|
|
||||||
func updateFileIncludeProcessor(p *Program) {
|
|
||||||
p.includeProcessor = &includeProcessor{
|
|
||||||
fileIncludeReasons: p.includeProcessor.fileIncludeReasons,
|
|
||||||
processingDiagnostics: p.includeProcessor.processingDiagnostics,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (i *includeProcessor) getDiagnostics(p *Program) *ast.DiagnosticsCollection {
|
|
||||||
i.computedDiagnosticsOnce.Do(func() {
|
|
||||||
i.computedDiagnostics = &ast.DiagnosticsCollection{}
|
|
||||||
for _, d := range i.processingDiagnostics {
|
|
||||||
i.computedDiagnostics.Add(d.toDiagnostic(p))
|
|
||||||
}
|
|
||||||
for _, resolutions := range p.resolvedModules {
|
|
||||||
for _, resolvedModule := range resolutions {
|
|
||||||
for _, diag := range resolvedModule.ResolutionDiagnostics {
|
|
||||||
i.computedDiagnostics.Add(diag)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
for _, typeResolutions := range p.typeResolutionsInFile {
|
|
||||||
for _, resolvedTypeRef := range typeResolutions {
|
|
||||||
for _, diag := range resolvedTypeRef.ResolutionDiagnostics {
|
|
||||||
i.computedDiagnostics.Add(diag)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
})
|
|
||||||
return i.computedDiagnostics
|
|
||||||
}
|
|
||||||
|
|
||||||
func (i *includeProcessor) addProcessingDiagnostic(d ...*processingDiagnostic) {
|
|
||||||
i.processingDiagnostics = append(i.processingDiagnostics, d...)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (i *includeProcessor) getReferenceLocation(r *fileIncludeReason, program *Program) *referenceFileLocation {
|
|
||||||
if existing, ok := i.reasonToReferenceLocation.Load(r); ok {
|
|
||||||
return existing
|
|
||||||
}
|
|
||||||
|
|
||||||
loc, _ := i.reasonToReferenceLocation.LoadOrStore(r, r.getReferencedLocation(program))
|
|
||||||
return loc
|
|
||||||
}
|
|
||||||
|
|
||||||
func (i *includeProcessor) getCompilerOptionsObjectLiteralSyntax(program *Program) *ast.ObjectLiteralExpression {
|
|
||||||
i.compilerOptionsSyntaxOnce.Do(func() {
|
|
||||||
configFile := program.opts.Config.ConfigFile
|
|
||||||
if configFile != nil {
|
|
||||||
if compilerOptionsProperty := tsoptions.ForEachTsConfigPropArray(configFile.SourceFile, "compilerOptions", core.Identity); compilerOptionsProperty != nil &&
|
|
||||||
compilerOptionsProperty.Initializer != nil &&
|
|
||||||
ast.IsObjectLiteralExpression(compilerOptionsProperty.Initializer) {
|
|
||||||
i.compilerOptionsSyntax = compilerOptionsProperty.Initializer.AsObjectLiteralExpression()
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
i.compilerOptionsSyntax = nil
|
|
||||||
}
|
|
||||||
})
|
|
||||||
return i.compilerOptionsSyntax
|
|
||||||
}
|
|
||||||
|
|
||||||
func (i *includeProcessor) getRelatedInfo(r *fileIncludeReason, program *Program) *ast.Diagnostic {
|
|
||||||
if existing, ok := i.includeReasonToRelatedInfo.Load(r); ok {
|
|
||||||
return existing
|
|
||||||
}
|
|
||||||
|
|
||||||
relatedInfo, _ := i.includeReasonToRelatedInfo.LoadOrStore(r, r.toRelatedInfo(program))
|
|
||||||
return relatedInfo
|
|
||||||
}
|
|
||||||
|
|
||||||
func (i *includeProcessor) explainRedirectAndImpliedFormat(
|
|
||||||
program *Program,
|
|
||||||
file *ast.SourceFile,
|
|
||||||
toFileName func(fileName string) string,
|
|
||||||
) []*ast.Diagnostic {
|
|
||||||
if existing, ok := i.redirectAndFileFormat.Load(file.Path()); ok {
|
|
||||||
return existing
|
|
||||||
}
|
|
||||||
var result []*ast.Diagnostic
|
|
||||||
if source := program.GetSourceOfProjectReferenceIfOutputIncluded(file); source != file.FileName() {
|
|
||||||
result = append(result, ast.NewCompilerDiagnostic(
|
|
||||||
diagnostics.File_is_output_of_project_reference_source_0,
|
|
||||||
toFileName(source),
|
|
||||||
))
|
|
||||||
}
|
|
||||||
// !!! redirects
|
|
||||||
// if (file.redirectInfo) {
|
|
||||||
// (result ??= []).push(chainDiagnosticMessages(
|
|
||||||
// /*details*/ undefined,
|
|
||||||
// Diagnostics.File_redirects_to_file_0,
|
|
||||||
// toFileName(file.redirectInfo.redirectTarget, fileNameConvertor),
|
|
||||||
// ));
|
|
||||||
// }
|
|
||||||
if ast.IsExternalOrCommonJSModule(file) {
|
|
||||||
metaData := program.GetSourceFileMetaData(file.Path())
|
|
||||||
switch program.GetImpliedNodeFormatForEmit(file) {
|
|
||||||
case core.ModuleKindESNext:
|
|
||||||
if metaData.PackageJsonType == "module" {
|
|
||||||
result = append(result, ast.NewCompilerDiagnostic(
|
|
||||||
diagnostics.File_is_ECMAScript_module_because_0_has_field_type_with_value_module,
|
|
||||||
toFileName(metaData.PackageJsonDirectory+"/package.json"),
|
|
||||||
))
|
|
||||||
}
|
|
||||||
case core.ModuleKindCommonJS:
|
|
||||||
if metaData.PackageJsonType != "" {
|
|
||||||
result = append(result, ast.NewCompilerDiagnostic(diagnostics.File_is_CommonJS_module_because_0_has_field_type_whose_value_is_not_module, toFileName(metaData.PackageJsonDirectory+"/package.json")))
|
|
||||||
} else if metaData.PackageJsonDirectory != "" {
|
|
||||||
if metaData.PackageJsonType == "" {
|
|
||||||
result = append(result, ast.NewCompilerDiagnostic(diagnostics.File_is_CommonJS_module_because_0_does_not_have_field_type, toFileName(metaData.PackageJsonDirectory+"/package.json")))
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
result = append(result, ast.NewCompilerDiagnostic(diagnostics.File_is_CommonJS_module_because_package_json_was_not_found))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
result, _ = i.redirectAndFileFormat.LoadOrStore(file.Path(), result)
|
|
||||||
return result
|
|
||||||
}
|
|
||||||
@ -1,53 +0,0 @@
|
|||||||
package compiler
|
|
||||||
|
|
||||||
import (
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/collections"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/tspath"
|
|
||||||
)
|
|
||||||
|
|
||||||
type knownDirectoryLink struct {
|
|
||||||
/**
|
|
||||||
* Matches the casing returned by `realpath`. Used to compute the `realpath` of children.
|
|
||||||
* Always has trailing directory separator
|
|
||||||
*/
|
|
||||||
Real string
|
|
||||||
/**
|
|
||||||
* toPath(real). Stored to avoid repeated recomputation.
|
|
||||||
* Always has trailing directory separator
|
|
||||||
*/
|
|
||||||
RealPath tspath.Path
|
|
||||||
}
|
|
||||||
|
|
||||||
type knownSymlinks struct {
|
|
||||||
directories collections.SyncMap[tspath.Path, *knownDirectoryLink]
|
|
||||||
files collections.SyncMap[tspath.Path, string]
|
|
||||||
}
|
|
||||||
|
|
||||||
/** Gets a map from symlink to realpath. Keys have trailing directory separators. */
|
|
||||||
func (cache *knownSymlinks) Directories() *collections.SyncMap[tspath.Path, *knownDirectoryLink] {
|
|
||||||
return &cache.directories
|
|
||||||
}
|
|
||||||
|
|
||||||
/** Gets a map from symlink to realpath */
|
|
||||||
func (cache *knownSymlinks) Files() *collections.SyncMap[tspath.Path, string] {
|
|
||||||
return &cache.files
|
|
||||||
}
|
|
||||||
|
|
||||||
// all callers should check !containsIgnoredPath(symlinkPath)
|
|
||||||
func (cache *knownSymlinks) SetDirectory(symlink string, symlinkPath tspath.Path, realDirectory *knownDirectoryLink) {
|
|
||||||
// Large, interconnected dependency graphs in pnpm will have a huge number of symlinks
|
|
||||||
// where both the realpath and the symlink path are inside node_modules/.pnpm. Since
|
|
||||||
// this path is never a candidate for a module specifier, we can ignore it entirely.
|
|
||||||
|
|
||||||
// !!!
|
|
||||||
// if realDirectory != nil {
|
|
||||||
// if _, ok := cache.directories.Load(symlinkPath); !ok {
|
|
||||||
// cache.directoriesByRealpath.Add(realDirectory.RealPath, symlink)
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
cache.directories.Store(symlinkPath, realDirectory)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (cache *knownSymlinks) SetFile(symlinkPath tspath.Path, realpath string) {
|
|
||||||
cache.files.Store(symlinkPath, realpath)
|
|
||||||
}
|
|
||||||
@ -1,2 +0,0 @@
|
|||||||
// Package compiler implements the TypeScript compiler.
|
|
||||||
package compiler
|
|
||||||
@ -1,134 +0,0 @@
|
|||||||
package compiler
|
|
||||||
|
|
||||||
import (
|
|
||||||
"strings"
|
|
||||||
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/ast"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/collections"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/core"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/diagnostics"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/tsoptions"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/tspath"
|
|
||||||
)
|
|
||||||
|
|
||||||
type processingDiagnosticKind int
|
|
||||||
|
|
||||||
const (
|
|
||||||
processingDiagnosticKindUnknownReference processingDiagnosticKind = iota
|
|
||||||
processingDiagnosticKindExplainingFileInclude
|
|
||||||
)
|
|
||||||
|
|
||||||
type processingDiagnostic struct {
|
|
||||||
kind processingDiagnosticKind
|
|
||||||
data any
|
|
||||||
}
|
|
||||||
|
|
||||||
func (d *processingDiagnostic) asFileIncludeReason() *fileIncludeReason {
|
|
||||||
return d.data.(*fileIncludeReason)
|
|
||||||
}
|
|
||||||
|
|
||||||
type includeExplainingDiagnostic struct {
|
|
||||||
file tspath.Path
|
|
||||||
diagnosticReason *fileIncludeReason
|
|
||||||
message *diagnostics.Message
|
|
||||||
args []any
|
|
||||||
}
|
|
||||||
|
|
||||||
func (d *processingDiagnostic) asIncludeExplainingDiagnostic() *includeExplainingDiagnostic {
|
|
||||||
return d.data.(*includeExplainingDiagnostic)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (d *processingDiagnostic) toDiagnostic(program *Program) *ast.Diagnostic {
|
|
||||||
switch d.kind {
|
|
||||||
case processingDiagnosticKindUnknownReference:
|
|
||||||
ref := d.asFileIncludeReason()
|
|
||||||
loc := ref.getReferencedLocation(program)
|
|
||||||
switch ref.kind {
|
|
||||||
case fileIncludeKindTypeReferenceDirective:
|
|
||||||
return loc.diagnosticAt(diagnostics.Cannot_find_type_definition_file_for_0, loc.ref.FileName)
|
|
||||||
case fileIncludeKindLibReferenceDirective:
|
|
||||||
libName := tspath.ToFileNameLowerCase(loc.ref.FileName)
|
|
||||||
unqualifiedLibName := strings.TrimSuffix(strings.TrimPrefix(libName, "lib."), ".d.ts")
|
|
||||||
suggestion := core.GetSpellingSuggestion(unqualifiedLibName, tsoptions.Libs, core.Identity)
|
|
||||||
return loc.diagnosticAt(core.IfElse(
|
|
||||||
suggestion != "",
|
|
||||||
diagnostics.Cannot_find_lib_definition_for_0_Did_you_mean_1,
|
|
||||||
diagnostics.Cannot_find_lib_definition_for_0,
|
|
||||||
), libName, suggestion)
|
|
||||||
default:
|
|
||||||
panic("unknown include kind")
|
|
||||||
}
|
|
||||||
case processingDiagnosticKindExplainingFileInclude:
|
|
||||||
return d.createDiagnosticExplainingFile(program)
|
|
||||||
default:
|
|
||||||
panic("unknown processingDiagnosticKind")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (d *processingDiagnostic) createDiagnosticExplainingFile(program *Program) *ast.Diagnostic {
|
|
||||||
diag := d.asIncludeExplainingDiagnostic()
|
|
||||||
var includeDetails []*ast.Diagnostic
|
|
||||||
var relatedInfo []*ast.Diagnostic
|
|
||||||
var redirectInfo []*ast.Diagnostic
|
|
||||||
var preferredLocation *fileIncludeReason
|
|
||||||
var seenReasons collections.Set[*fileIncludeReason]
|
|
||||||
if diag.diagnosticReason.isReferencedFile() && !program.includeProcessor.getReferenceLocation(diag.diagnosticReason, program).isSynthetic {
|
|
||||||
preferredLocation = diag.diagnosticReason
|
|
||||||
}
|
|
||||||
|
|
||||||
processRelatedInfo := func(includeReason *fileIncludeReason) {
|
|
||||||
if preferredLocation == nil && includeReason.isReferencedFile() && !program.includeProcessor.getReferenceLocation(includeReason, program).isSynthetic {
|
|
||||||
preferredLocation = includeReason
|
|
||||||
} else {
|
|
||||||
info := program.includeProcessor.getRelatedInfo(includeReason, program)
|
|
||||||
if info != nil {
|
|
||||||
relatedInfo = append(relatedInfo, info)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
processInclude := func(includeReason *fileIncludeReason) {
|
|
||||||
if !seenReasons.AddIfAbsent(includeReason) {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
includeDetails = append(includeDetails, includeReason.toDiagnostic(program, false))
|
|
||||||
processRelatedInfo(includeReason)
|
|
||||||
}
|
|
||||||
|
|
||||||
// !!! todo sheetal caching
|
|
||||||
|
|
||||||
if diag.file != "" {
|
|
||||||
reasons := program.includeProcessor.fileIncludeReasons[diag.file]
|
|
||||||
includeDetails = make([]*ast.Diagnostic, 0, len(reasons))
|
|
||||||
for _, reason := range reasons {
|
|
||||||
processInclude(reason)
|
|
||||||
}
|
|
||||||
redirectInfo = program.includeProcessor.explainRedirectAndImpliedFormat(program, program.GetSourceFileByPath(diag.file), func(fileName string) string { return fileName })
|
|
||||||
}
|
|
||||||
if diag.diagnosticReason != nil {
|
|
||||||
processInclude(diag.diagnosticReason)
|
|
||||||
}
|
|
||||||
var chain []*ast.Diagnostic
|
|
||||||
if includeDetails != nil && (preferredLocation == nil || seenReasons.Len() != 1) {
|
|
||||||
fileReason := ast.NewCompilerDiagnostic(diagnostics.The_file_is_in_the_program_because_Colon)
|
|
||||||
fileReason.SetMessageChain(includeDetails)
|
|
||||||
chain = []*ast.Diagnostic{fileReason}
|
|
||||||
}
|
|
||||||
if redirectInfo != nil {
|
|
||||||
chain = append(chain, redirectInfo...)
|
|
||||||
}
|
|
||||||
|
|
||||||
var result *ast.Diagnostic
|
|
||||||
if preferredLocation != nil {
|
|
||||||
result = program.includeProcessor.getReferenceLocation(preferredLocation, program).diagnosticAt(diag.message, diag.args...)
|
|
||||||
}
|
|
||||||
if result == nil {
|
|
||||||
result = ast.NewCompilerDiagnostic(diag.message, diag.args...)
|
|
||||||
}
|
|
||||||
if chain != nil {
|
|
||||||
result.SetMessageChain(chain)
|
|
||||||
}
|
|
||||||
if relatedInfo != nil {
|
|
||||||
result.SetRelatedInfo(relatedInfo)
|
|
||||||
}
|
|
||||||
return result
|
|
||||||
}
|
|
||||||
File diff suppressed because it is too large
Load Diff
@ -1,314 +0,0 @@
|
|||||||
package compiler_test
|
|
||||||
|
|
||||||
import (
|
|
||||||
"path/filepath"
|
|
||||||
"slices"
|
|
||||||
"strings"
|
|
||||||
"testing"
|
|
||||||
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/bundled"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/compiler"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/core"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/repo"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/tsoptions"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/tspath"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/vfs/osvfs"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/vfs/vfstest"
|
|
||||||
"gotest.tools/v3/assert"
|
|
||||||
)
|
|
||||||
|
|
||||||
type testFile struct {
|
|
||||||
fileName string
|
|
||||||
contents string
|
|
||||||
}
|
|
||||||
|
|
||||||
type programTest struct {
|
|
||||||
testName string
|
|
||||||
files []testFile
|
|
||||||
expectedFiles []string
|
|
||||||
target core.ScriptTarget
|
|
||||||
}
|
|
||||||
|
|
||||||
var esnextLibs = []string{
|
|
||||||
"lib.es5.d.ts",
|
|
||||||
"lib.es2015.d.ts",
|
|
||||||
"lib.es2016.d.ts",
|
|
||||||
"lib.es2017.d.ts",
|
|
||||||
"lib.es2018.d.ts",
|
|
||||||
"lib.es2019.d.ts",
|
|
||||||
"lib.es2020.d.ts",
|
|
||||||
"lib.es2021.d.ts",
|
|
||||||
"lib.es2022.d.ts",
|
|
||||||
"lib.es2023.d.ts",
|
|
||||||
"lib.es2024.d.ts",
|
|
||||||
"lib.esnext.d.ts",
|
|
||||||
"lib.dom.d.ts",
|
|
||||||
"lib.dom.iterable.d.ts",
|
|
||||||
"lib.dom.asynciterable.d.ts",
|
|
||||||
"lib.webworker.importscripts.d.ts",
|
|
||||||
"lib.scripthost.d.ts",
|
|
||||||
"lib.es2015.core.d.ts",
|
|
||||||
"lib.es2015.collection.d.ts",
|
|
||||||
"lib.es2015.generator.d.ts",
|
|
||||||
"lib.es2015.iterable.d.ts",
|
|
||||||
"lib.es2015.promise.d.ts",
|
|
||||||
"lib.es2015.proxy.d.ts",
|
|
||||||
"lib.es2015.reflect.d.ts",
|
|
||||||
"lib.es2015.symbol.d.ts",
|
|
||||||
"lib.es2015.symbol.wellknown.d.ts",
|
|
||||||
"lib.es2016.array.include.d.ts",
|
|
||||||
"lib.es2016.intl.d.ts",
|
|
||||||
"lib.es2017.arraybuffer.d.ts",
|
|
||||||
"lib.es2017.date.d.ts",
|
|
||||||
"lib.es2017.object.d.ts",
|
|
||||||
"lib.es2017.sharedmemory.d.ts",
|
|
||||||
"lib.es2017.string.d.ts",
|
|
||||||
"lib.es2017.intl.d.ts",
|
|
||||||
"lib.es2017.typedarrays.d.ts",
|
|
||||||
"lib.es2018.asyncgenerator.d.ts",
|
|
||||||
"lib.es2018.asynciterable.d.ts",
|
|
||||||
"lib.es2018.intl.d.ts",
|
|
||||||
"lib.es2018.promise.d.ts",
|
|
||||||
"lib.es2018.regexp.d.ts",
|
|
||||||
"lib.es2019.array.d.ts",
|
|
||||||
"lib.es2019.object.d.ts",
|
|
||||||
"lib.es2019.string.d.ts",
|
|
||||||
"lib.es2019.symbol.d.ts",
|
|
||||||
"lib.es2019.intl.d.ts",
|
|
||||||
"lib.es2020.bigint.d.ts",
|
|
||||||
"lib.es2020.date.d.ts",
|
|
||||||
"lib.es2020.promise.d.ts",
|
|
||||||
"lib.es2020.sharedmemory.d.ts",
|
|
||||||
"lib.es2020.string.d.ts",
|
|
||||||
"lib.es2020.symbol.wellknown.d.ts",
|
|
||||||
"lib.es2020.intl.d.ts",
|
|
||||||
"lib.es2020.number.d.ts",
|
|
||||||
"lib.es2021.promise.d.ts",
|
|
||||||
"lib.es2021.string.d.ts",
|
|
||||||
"lib.es2021.weakref.d.ts",
|
|
||||||
"lib.es2021.intl.d.ts",
|
|
||||||
"lib.es2022.array.d.ts",
|
|
||||||
"lib.es2022.error.d.ts",
|
|
||||||
"lib.es2022.intl.d.ts",
|
|
||||||
"lib.es2022.object.d.ts",
|
|
||||||
"lib.es2022.string.d.ts",
|
|
||||||
"lib.es2022.regexp.d.ts",
|
|
||||||
"lib.es2023.array.d.ts",
|
|
||||||
"lib.es2023.collection.d.ts",
|
|
||||||
"lib.es2023.intl.d.ts",
|
|
||||||
"lib.es2024.arraybuffer.d.ts",
|
|
||||||
"lib.es2024.collection.d.ts",
|
|
||||||
"lib.es2024.object.d.ts",
|
|
||||||
"lib.es2024.promise.d.ts",
|
|
||||||
"lib.es2024.regexp.d.ts",
|
|
||||||
"lib.es2024.sharedmemory.d.ts",
|
|
||||||
"lib.es2024.string.d.ts",
|
|
||||||
"lib.esnext.array.d.ts",
|
|
||||||
"lib.esnext.collection.d.ts",
|
|
||||||
"lib.esnext.intl.d.ts",
|
|
||||||
"lib.esnext.disposable.d.ts",
|
|
||||||
"lib.esnext.promise.d.ts",
|
|
||||||
"lib.esnext.decorators.d.ts",
|
|
||||||
"lib.esnext.iterator.d.ts",
|
|
||||||
"lib.esnext.float16.d.ts",
|
|
||||||
"lib.esnext.error.d.ts",
|
|
||||||
"lib.esnext.sharedmemory.d.ts",
|
|
||||||
"lib.decorators.d.ts",
|
|
||||||
"lib.decorators.legacy.d.ts",
|
|
||||||
"lib.esnext.full.d.ts",
|
|
||||||
}
|
|
||||||
|
|
||||||
var programTestCases = []programTest{
|
|
||||||
{
|
|
||||||
testName: "BasicFileOrdering",
|
|
||||||
files: []testFile{
|
|
||||||
{fileName: "c:/dev/src/index.ts", contents: "/// <reference path='c:/dev/src2/a/5.ts' />\n/// <reference path='c:/dev/src2/a/10.ts' />"},
|
|
||||||
{fileName: "c:/dev/src2/a/5.ts", contents: "/// <reference path='4.ts' />"},
|
|
||||||
{fileName: "c:/dev/src2/a/4.ts", contents: "/// <reference path='b/3.ts' />"},
|
|
||||||
{fileName: "c:/dev/src2/a/b/3.ts", contents: "/// <reference path='2.ts' />"},
|
|
||||||
{fileName: "c:/dev/src2/a/b/2.ts", contents: "/// <reference path='c/1.ts' />"},
|
|
||||||
{fileName: "c:/dev/src2/a/b/c/1.ts", contents: "console.log('hello');"},
|
|
||||||
{fileName: "c:/dev/src2/a/10.ts", contents: "/// <reference path='b/c/d/9.ts' />"},
|
|
||||||
{fileName: "c:/dev/src2/a/b/c/d/9.ts", contents: "/// <reference path='e/8.ts' />"},
|
|
||||||
{fileName: "c:/dev/src2/a/b/c/d/e/8.ts", contents: "/// <reference path='7.ts' />"},
|
|
||||||
{fileName: "c:/dev/src2/a/b/c/d/e/7.ts", contents: "/// <reference path='f/6.ts' />"},
|
|
||||||
{fileName: "c:/dev/src2/a/b/c/d/e/f/6.ts", contents: "console.log('world!');"},
|
|
||||||
},
|
|
||||||
expectedFiles: slices.Concat(esnextLibs,
|
|
||||||
[]string{
|
|
||||||
"c:/dev/src2/a/b/c/1.ts",
|
|
||||||
"c:/dev/src2/a/b/2.ts",
|
|
||||||
"c:/dev/src2/a/b/3.ts",
|
|
||||||
"c:/dev/src2/a/4.ts",
|
|
||||||
"c:/dev/src2/a/5.ts",
|
|
||||||
"c:/dev/src2/a/b/c/d/e/f/6.ts",
|
|
||||||
"c:/dev/src2/a/b/c/d/e/7.ts",
|
|
||||||
"c:/dev/src2/a/b/c/d/e/8.ts",
|
|
||||||
"c:/dev/src2/a/b/c/d/9.ts",
|
|
||||||
"c:/dev/src2/a/10.ts",
|
|
||||||
"c:/dev/src/index.ts",
|
|
||||||
}),
|
|
||||||
target: core.ScriptTargetESNext,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
testName: "FileOrderingImports",
|
|
||||||
files: []testFile{
|
|
||||||
{fileName: "c:/dev/src/index.ts", contents: "import * as five from '../src2/a/5.ts';\nimport * as ten from '../src2/a/10.ts';"},
|
|
||||||
{fileName: "c:/dev/src2/a/5.ts", contents: "import * as four from './4.ts';"},
|
|
||||||
{fileName: "c:/dev/src2/a/4.ts", contents: "import * as three from './b/3.ts';"},
|
|
||||||
{fileName: "c:/dev/src2/a/b/3.ts", contents: "import * as two from './2.ts';"},
|
|
||||||
{fileName: "c:/dev/src2/a/b/2.ts", contents: "import * as one from './c/1.ts';"},
|
|
||||||
{fileName: "c:/dev/src2/a/b/c/1.ts", contents: "console.log('hello');"},
|
|
||||||
{fileName: "c:/dev/src2/a/10.ts", contents: "import * as nine from './b/c/d/9.ts';"},
|
|
||||||
{fileName: "c:/dev/src2/a/b/c/d/9.ts", contents: "import * as eight from './e/8.ts';"},
|
|
||||||
{fileName: "c:/dev/src2/a/b/c/d/e/8.ts", contents: "import * as seven from './7.ts';"},
|
|
||||||
{fileName: "c:/dev/src2/a/b/c/d/e/7.ts", contents: "import * as six from './f/6.ts';"},
|
|
||||||
{fileName: "c:/dev/src2/a/b/c/d/e/f/6.ts", contents: "console.log('world!');"},
|
|
||||||
},
|
|
||||||
expectedFiles: slices.Concat(esnextLibs,
|
|
||||||
[]string{
|
|
||||||
"c:/dev/src2/a/b/c/1.ts",
|
|
||||||
"c:/dev/src2/a/b/2.ts",
|
|
||||||
"c:/dev/src2/a/b/3.ts",
|
|
||||||
"c:/dev/src2/a/4.ts",
|
|
||||||
"c:/dev/src2/a/5.ts",
|
|
||||||
"c:/dev/src2/a/b/c/d/e/f/6.ts",
|
|
||||||
"c:/dev/src2/a/b/c/d/e/7.ts",
|
|
||||||
"c:/dev/src2/a/b/c/d/e/8.ts",
|
|
||||||
"c:/dev/src2/a/b/c/d/9.ts",
|
|
||||||
"c:/dev/src2/a/10.ts",
|
|
||||||
"c:/dev/src/index.ts",
|
|
||||||
}),
|
|
||||||
target: core.ScriptTargetESNext,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
testName: "FileOrderingCycles",
|
|
||||||
files: []testFile{
|
|
||||||
{fileName: "c:/dev/src/index.ts", contents: "import * as five from '../src2/a/5.ts';\nimport * as ten from '../src2/a/10.ts';"},
|
|
||||||
{fileName: "c:/dev/src2/a/5.ts", contents: "import * as four from './4.ts';"},
|
|
||||||
{fileName: "c:/dev/src2/a/4.ts", contents: "import * as three from './b/3.ts';"},
|
|
||||||
{fileName: "c:/dev/src2/a/b/3.ts", contents: "import * as two from './2.ts';\nimport * as cycle from 'c:/dev/src/index.ts'; "},
|
|
||||||
{fileName: "c:/dev/src2/a/b/2.ts", contents: "import * as one from './c/1.ts';"},
|
|
||||||
{fileName: "c:/dev/src2/a/b/c/1.ts", contents: "console.log('hello');"},
|
|
||||||
{fileName: "c:/dev/src2/a/10.ts", contents: "import * as nine from './b/c/d/9.ts';"},
|
|
||||||
{fileName: "c:/dev/src2/a/b/c/d/9.ts", contents: "import * as eight from './e/8.ts';\nimport * as cycle from 'c:/dev/src/index.ts';"},
|
|
||||||
{fileName: "c:/dev/src2/a/b/c/d/e/8.ts", contents: "import * as seven from './7.ts';"},
|
|
||||||
{fileName: "c:/dev/src2/a/b/c/d/e/7.ts", contents: "import * as six from './f/6.ts';"},
|
|
||||||
{fileName: "c:/dev/src2/a/b/c/d/e/f/6.ts", contents: "console.log('world!');"},
|
|
||||||
},
|
|
||||||
expectedFiles: slices.Concat(esnextLibs,
|
|
||||||
[]string{
|
|
||||||
"c:/dev/src2/a/b/c/1.ts",
|
|
||||||
"c:/dev/src2/a/b/2.ts",
|
|
||||||
"c:/dev/src2/a/b/3.ts",
|
|
||||||
"c:/dev/src2/a/4.ts",
|
|
||||||
"c:/dev/src2/a/5.ts",
|
|
||||||
"c:/dev/src2/a/b/c/d/e/f/6.ts",
|
|
||||||
"c:/dev/src2/a/b/c/d/e/7.ts",
|
|
||||||
"c:/dev/src2/a/b/c/d/e/8.ts",
|
|
||||||
"c:/dev/src2/a/b/c/d/9.ts",
|
|
||||||
"c:/dev/src2/a/10.ts",
|
|
||||||
"c:/dev/src/index.ts",
|
|
||||||
}),
|
|
||||||
target: core.ScriptTargetESNext,
|
|
||||||
},
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestProgram(t *testing.T) {
|
|
||||||
t.Parallel()
|
|
||||||
|
|
||||||
if !bundled.Embedded {
|
|
||||||
// Without embedding, we'd need to read all of the lib files out from disk into the MapFS.
|
|
||||||
// Just skip this for now.
|
|
||||||
t.Skip("bundled files are not embedded")
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, testCase := range programTestCases {
|
|
||||||
t.Run(testCase.testName, func(t *testing.T) {
|
|
||||||
t.Parallel()
|
|
||||||
libPrefix := bundled.LibPath() + "/"
|
|
||||||
fs := vfstest.FromMap[any](nil, false /*useCaseSensitiveFileNames*/)
|
|
||||||
fs = bundled.WrapFS(fs)
|
|
||||||
|
|
||||||
for _, testFile := range testCase.files {
|
|
||||||
_ = fs.WriteFile(testFile.fileName, testFile.contents, false)
|
|
||||||
}
|
|
||||||
|
|
||||||
opts := core.CompilerOptions{Target: testCase.target}
|
|
||||||
|
|
||||||
program := compiler.NewProgram(compiler.ProgramOptions{
|
|
||||||
Config: &tsoptions.ParsedCommandLine{
|
|
||||||
ParsedConfig: &core.ParsedOptions{
|
|
||||||
FileNames: []string{"c:/dev/src/index.ts"},
|
|
||||||
CompilerOptions: &opts,
|
|
||||||
},
|
|
||||||
},
|
|
||||||
Host: compiler.NewCompilerHost("c:/dev/src", fs, bundled.LibPath(), nil, nil),
|
|
||||||
})
|
|
||||||
|
|
||||||
actualFiles := []string{}
|
|
||||||
for _, file := range program.GetSourceFiles() {
|
|
||||||
actualFiles = append(actualFiles, strings.TrimPrefix(file.FileName(), libPrefix))
|
|
||||||
}
|
|
||||||
|
|
||||||
assert.DeepEqual(t, testCase.expectedFiles, actualFiles)
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func BenchmarkNewProgram(b *testing.B) {
|
|
||||||
if !bundled.Embedded {
|
|
||||||
// Without embedding, we'd need to read all of the lib files out from disk into the MapFS.
|
|
||||||
// Just skip this for now.
|
|
||||||
b.Skip("bundled files are not embedded")
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, testCase := range programTestCases {
|
|
||||||
b.Run(testCase.testName, func(b *testing.B) {
|
|
||||||
fs := vfstest.FromMap[any](nil, false /*useCaseSensitiveFileNames*/)
|
|
||||||
fs = bundled.WrapFS(fs)
|
|
||||||
|
|
||||||
for _, testFile := range testCase.files {
|
|
||||||
_ = fs.WriteFile(testFile.fileName, testFile.contents, false)
|
|
||||||
}
|
|
||||||
|
|
||||||
opts := core.CompilerOptions{Target: testCase.target}
|
|
||||||
programOpts := compiler.ProgramOptions{
|
|
||||||
Config: &tsoptions.ParsedCommandLine{
|
|
||||||
ParsedConfig: &core.ParsedOptions{
|
|
||||||
FileNames: []string{"c:/dev/src/index.ts"},
|
|
||||||
CompilerOptions: &opts,
|
|
||||||
},
|
|
||||||
},
|
|
||||||
Host: compiler.NewCompilerHost("c:/dev/src", fs, bundled.LibPath(), nil, nil),
|
|
||||||
}
|
|
||||||
|
|
||||||
for b.Loop() {
|
|
||||||
compiler.NewProgram(programOpts)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
b.Run("compiler", func(b *testing.B) {
|
|
||||||
repo.SkipIfNoTypeScriptSubmodule(b)
|
|
||||||
|
|
||||||
rootPath := tspath.NormalizeSlashes(filepath.Join(repo.TypeScriptSubmodulePath, "src", "compiler"))
|
|
||||||
|
|
||||||
fs := osvfs.FS()
|
|
||||||
fs = bundled.WrapFS(fs)
|
|
||||||
|
|
||||||
host := compiler.NewCompilerHost(rootPath, fs, bundled.LibPath(), nil, nil)
|
|
||||||
|
|
||||||
parsed, errors := tsoptions.GetParsedCommandLineOfConfigFile(tspath.CombinePaths(rootPath, "tsconfig.json"), nil, host, nil)
|
|
||||||
assert.Equal(b, len(errors), 0, "Expected no errors in parsed command line")
|
|
||||||
|
|
||||||
opts := compiler.ProgramOptions{
|
|
||||||
Config: parsed,
|
|
||||||
Host: host,
|
|
||||||
}
|
|
||||||
|
|
||||||
for b.Loop() {
|
|
||||||
compiler.NewProgram(opts)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
@ -1,226 +0,0 @@
|
|||||||
package compiler
|
|
||||||
|
|
||||||
import (
|
|
||||||
"strings"
|
|
||||||
"time"
|
|
||||||
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/collections"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/core"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/module"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/tspath"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/vfs"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/vfs/cachedvfs"
|
|
||||||
)
|
|
||||||
|
|
||||||
type projectReferenceDtsFakingHost struct {
|
|
||||||
host CompilerHost
|
|
||||||
fs *cachedvfs.FS
|
|
||||||
}
|
|
||||||
|
|
||||||
var _ module.ResolutionHost = (*projectReferenceDtsFakingHost)(nil)
|
|
||||||
|
|
||||||
func newProjectReferenceDtsFakingHost(loader *fileLoader) module.ResolutionHost {
|
|
||||||
// Create a new host that will fake the dts files
|
|
||||||
host := &projectReferenceDtsFakingHost{
|
|
||||||
host: loader.opts.Host,
|
|
||||||
fs: cachedvfs.From(&projectReferenceDtsFakingVfs{
|
|
||||||
projectReferenceFileMapper: loader.projectReferenceFileMapper,
|
|
||||||
dtsDirectories: loader.dtsDirectories,
|
|
||||||
knownSymlinks: knownSymlinks{},
|
|
||||||
}),
|
|
||||||
}
|
|
||||||
return host
|
|
||||||
}
|
|
||||||
|
|
||||||
// FS implements module.ResolutionHost.
|
|
||||||
func (h *projectReferenceDtsFakingHost) FS() vfs.FS {
|
|
||||||
return h.fs
|
|
||||||
}
|
|
||||||
|
|
||||||
// GetCurrentDirectory implements module.ResolutionHost.
|
|
||||||
func (h *projectReferenceDtsFakingHost) GetCurrentDirectory() string {
|
|
||||||
return h.host.GetCurrentDirectory()
|
|
||||||
}
|
|
||||||
|
|
||||||
type projectReferenceDtsFakingVfs struct {
|
|
||||||
projectReferenceFileMapper *projectReferenceFileMapper
|
|
||||||
dtsDirectories collections.Set[tspath.Path]
|
|
||||||
knownSymlinks knownSymlinks
|
|
||||||
}
|
|
||||||
|
|
||||||
var _ vfs.FS = (*projectReferenceDtsFakingVfs)(nil)
|
|
||||||
|
|
||||||
// UseCaseSensitiveFileNames implements vfs.FS.
|
|
||||||
func (fs *projectReferenceDtsFakingVfs) UseCaseSensitiveFileNames() bool {
|
|
||||||
return fs.projectReferenceFileMapper.opts.Host.FS().UseCaseSensitiveFileNames()
|
|
||||||
}
|
|
||||||
|
|
||||||
// FileExists implements vfs.FS.
|
|
||||||
func (fs *projectReferenceDtsFakingVfs) FileExists(path string) bool {
|
|
||||||
if fs.projectReferenceFileMapper.opts.Host.FS().FileExists(path) {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
if !tspath.IsDeclarationFileName(path) {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
// Project references go to source file instead of .d.ts file
|
|
||||||
return fs.fileOrDirectoryExistsUsingSource(path /*isFile*/, true)
|
|
||||||
}
|
|
||||||
|
|
||||||
// ReadFile implements vfs.FS.
|
|
||||||
func (fs *projectReferenceDtsFakingVfs) ReadFile(path string) (contents string, ok bool) {
|
|
||||||
// Dont need to override as we cannot mimick read file
|
|
||||||
return fs.projectReferenceFileMapper.opts.Host.FS().ReadFile(path)
|
|
||||||
}
|
|
||||||
|
|
||||||
// WriteFile implements vfs.FS.
|
|
||||||
func (fs *projectReferenceDtsFakingVfs) WriteFile(path string, data string, writeByteOrderMark bool) error {
|
|
||||||
panic("should not be called by resolver")
|
|
||||||
}
|
|
||||||
|
|
||||||
// Remove implements vfs.FS.
|
|
||||||
func (fs *projectReferenceDtsFakingVfs) Remove(path string) error {
|
|
||||||
panic("should not be called by resolver")
|
|
||||||
}
|
|
||||||
|
|
||||||
// Chtimes implements vfs.FS.
|
|
||||||
func (fs *projectReferenceDtsFakingVfs) Chtimes(path string, aTime time.Time, mTime time.Time) error {
|
|
||||||
panic("should not be called by resolver")
|
|
||||||
}
|
|
||||||
|
|
||||||
// DirectoryExists implements vfs.FS.
|
|
||||||
func (fs *projectReferenceDtsFakingVfs) DirectoryExists(path string) bool {
|
|
||||||
if fs.projectReferenceFileMapper.opts.Host.FS().DirectoryExists(path) {
|
|
||||||
fs.handleDirectoryCouldBeSymlink(path)
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
return fs.fileOrDirectoryExistsUsingSource(path /*isFile*/, false)
|
|
||||||
}
|
|
||||||
|
|
||||||
// GetAccessibleEntries implements vfs.FS.
|
|
||||||
func (fs *projectReferenceDtsFakingVfs) GetAccessibleEntries(path string) vfs.Entries {
|
|
||||||
panic("should not be called by resolver")
|
|
||||||
}
|
|
||||||
|
|
||||||
// Stat implements vfs.FS.
|
|
||||||
func (fs *projectReferenceDtsFakingVfs) Stat(path string) vfs.FileInfo {
|
|
||||||
panic("should not be called by resolver")
|
|
||||||
}
|
|
||||||
|
|
||||||
// WalkDir implements vfs.FS.
|
|
||||||
func (fs *projectReferenceDtsFakingVfs) WalkDir(root string, walkFn vfs.WalkDirFunc) error {
|
|
||||||
panic("should not be called by resolver")
|
|
||||||
}
|
|
||||||
|
|
||||||
// Realpath implements vfs.FS.
|
|
||||||
func (fs *projectReferenceDtsFakingVfs) Realpath(path string) string {
|
|
||||||
result, ok := fs.knownSymlinks.Files().Load(fs.toPath(path))
|
|
||||||
if ok {
|
|
||||||
return result
|
|
||||||
}
|
|
||||||
return fs.projectReferenceFileMapper.opts.Host.FS().Realpath(path)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (fs *projectReferenceDtsFakingVfs) toPath(path string) tspath.Path {
|
|
||||||
return tspath.ToPath(path, fs.projectReferenceFileMapper.opts.Host.GetCurrentDirectory(), fs.UseCaseSensitiveFileNames())
|
|
||||||
}
|
|
||||||
|
|
||||||
func (fs *projectReferenceDtsFakingVfs) handleDirectoryCouldBeSymlink(directory string) {
|
|
||||||
if tspath.ContainsIgnoredPath(directory) {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// Because we already watch node_modules, handle symlinks in there
|
|
||||||
if !strings.Contains(directory, "/node_modules/") {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
directoryPath := tspath.Path(tspath.EnsureTrailingDirectorySeparator(string(fs.toPath(directory))))
|
|
||||||
if _, ok := fs.knownSymlinks.Directories().Load(directoryPath); ok {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
realDirectory := fs.Realpath(directory)
|
|
||||||
var realPath tspath.Path
|
|
||||||
if realDirectory == directory {
|
|
||||||
// not symlinked
|
|
||||||
return
|
|
||||||
}
|
|
||||||
if realPath = tspath.Path(tspath.EnsureTrailingDirectorySeparator(string(fs.toPath(realDirectory)))); realPath == directoryPath {
|
|
||||||
// not symlinked
|
|
||||||
return
|
|
||||||
}
|
|
||||||
fs.knownSymlinks.SetDirectory(directory, directoryPath, &knownDirectoryLink{
|
|
||||||
Real: tspath.EnsureTrailingDirectorySeparator(realDirectory),
|
|
||||||
RealPath: realPath,
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (fs *projectReferenceDtsFakingVfs) fileOrDirectoryExistsUsingSource(fileOrDirectory string, isFile bool) bool {
|
|
||||||
fileOrDirectoryExistsUsingSource := core.IfElse(isFile, fs.fileExistsIfProjectReferenceDts, fs.directoryExistsIfProjectReferenceDeclDir)
|
|
||||||
// Check current directory or file
|
|
||||||
result := fileOrDirectoryExistsUsingSource(fileOrDirectory)
|
|
||||||
if result != core.TSUnknown {
|
|
||||||
return result == core.TSTrue
|
|
||||||
}
|
|
||||||
|
|
||||||
knownDirectoryLinks := fs.knownSymlinks.Directories()
|
|
||||||
if knownDirectoryLinks.Size() == 0 {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
fileOrDirectoryPath := fs.toPath(fileOrDirectory)
|
|
||||||
if !strings.Contains(string(fileOrDirectoryPath), "/node_modules/") {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
if isFile {
|
|
||||||
_, ok := fs.knownSymlinks.Files().Load(fileOrDirectoryPath)
|
|
||||||
if ok {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// If it contains node_modules check if its one of the symlinked path we know of
|
|
||||||
var exists bool
|
|
||||||
knownDirectoryLinks.Range(func(directoryPath tspath.Path, knownDirectoryLink *knownDirectoryLink) bool {
|
|
||||||
relative, hasPrefix := strings.CutPrefix(string(fileOrDirectoryPath), string(directoryPath))
|
|
||||||
if !hasPrefix {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
if exists = fileOrDirectoryExistsUsingSource(string(knownDirectoryLink.RealPath) + relative).IsTrue(); exists {
|
|
||||||
if isFile {
|
|
||||||
// Store the real path for the file
|
|
||||||
absolutePath := tspath.GetNormalizedAbsolutePath(fileOrDirectory, fs.projectReferenceFileMapper.opts.Host.GetCurrentDirectory())
|
|
||||||
fs.knownSymlinks.SetFile(
|
|
||||||
fileOrDirectoryPath,
|
|
||||||
knownDirectoryLink.Real+absolutePath[len(directoryPath):],
|
|
||||||
)
|
|
||||||
}
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
return true
|
|
||||||
})
|
|
||||||
return exists
|
|
||||||
}
|
|
||||||
|
|
||||||
func (fs *projectReferenceDtsFakingVfs) fileExistsIfProjectReferenceDts(file string) core.Tristate {
|
|
||||||
source := fs.projectReferenceFileMapper.getProjectReferenceFromOutputDts(fs.toPath(file))
|
|
||||||
if source != nil {
|
|
||||||
return core.IfElse(fs.projectReferenceFileMapper.opts.Host.FS().FileExists(source.Source), core.TSTrue, core.TSFalse)
|
|
||||||
}
|
|
||||||
return core.TSUnknown
|
|
||||||
}
|
|
||||||
|
|
||||||
func (fs *projectReferenceDtsFakingVfs) directoryExistsIfProjectReferenceDeclDir(dir string) core.Tristate {
|
|
||||||
dirPath := fs.toPath(dir)
|
|
||||||
dirPathWithTrailingDirectorySeparator := dirPath + "/"
|
|
||||||
for declDirPath := range fs.dtsDirectories.Keys() {
|
|
||||||
if dirPath == declDirPath ||
|
|
||||||
// Any parent directory of declaration dir
|
|
||||||
strings.HasPrefix(string(declDirPath), string(dirPathWithTrailingDirectorySeparator)) ||
|
|
||||||
// Any directory inside declaration dir
|
|
||||||
strings.HasPrefix(string(dirPath), string(declDirPath)+"/") {
|
|
||||||
return core.TSTrue
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return core.TSUnknown
|
|
||||||
}
|
|
||||||
@ -1,166 +0,0 @@
|
|||||||
package compiler
|
|
||||||
|
|
||||||
import (
|
|
||||||
"strings"
|
|
||||||
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/ast"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/collections"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/core"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/module"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/tsoptions"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/tspath"
|
|
||||||
)
|
|
||||||
|
|
||||||
type projectReferenceFileMapper struct {
|
|
||||||
opts ProgramOptions
|
|
||||||
host module.ResolutionHost
|
|
||||||
loader *fileLoader // Only present during populating the mapper and parsing, released after that
|
|
||||||
|
|
||||||
configToProjectReference map[tspath.Path]*tsoptions.ParsedCommandLine // All the resolved references needed
|
|
||||||
referencesInConfigFile map[tspath.Path][]tspath.Path // Map of config file to its references
|
|
||||||
sourceToProjectReference map[tspath.Path]*tsoptions.SourceOutputAndProjectReference
|
|
||||||
outputDtsToProjectReference map[tspath.Path]*tsoptions.SourceOutputAndProjectReference
|
|
||||||
|
|
||||||
// Store all the realpath from dts in node_modules to source file from project reference needed during parsing so it can be used later
|
|
||||||
realpathDtsToSource collections.SyncMap[tspath.Path, *tsoptions.SourceOutputAndProjectReference]
|
|
||||||
}
|
|
||||||
|
|
||||||
func (mapper *projectReferenceFileMapper) getParseFileRedirect(file ast.HasFileName) string {
|
|
||||||
if mapper.opts.canUseProjectReferenceSource() {
|
|
||||||
// Map to source file from project reference
|
|
||||||
source := mapper.getProjectReferenceFromOutputDts(file.Path())
|
|
||||||
if source == nil {
|
|
||||||
source = mapper.getSourceToDtsIfSymlink(file)
|
|
||||||
}
|
|
||||||
if source != nil {
|
|
||||||
return source.Source
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
// Map to dts file from project reference
|
|
||||||
output := mapper.getProjectReferenceFromSource(file.Path())
|
|
||||||
if output != nil && output.OutputDts != "" {
|
|
||||||
return output.OutputDts
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return ""
|
|
||||||
}
|
|
||||||
|
|
||||||
func (mapper *projectReferenceFileMapper) getResolvedProjectReferences() []*tsoptions.ParsedCommandLine {
|
|
||||||
refs, ok := mapper.referencesInConfigFile[mapper.opts.Config.ConfigFile.SourceFile.Path()]
|
|
||||||
var result []*tsoptions.ParsedCommandLine
|
|
||||||
if ok {
|
|
||||||
result = make([]*tsoptions.ParsedCommandLine, 0, len(refs))
|
|
||||||
for _, refPath := range refs {
|
|
||||||
refConfig, _ := mapper.configToProjectReference[refPath]
|
|
||||||
result = append(result, refConfig)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return result
|
|
||||||
}
|
|
||||||
|
|
||||||
func (mapper *projectReferenceFileMapper) getProjectReferenceFromSource(path tspath.Path) *tsoptions.SourceOutputAndProjectReference {
|
|
||||||
return mapper.sourceToProjectReference[path]
|
|
||||||
}
|
|
||||||
|
|
||||||
func (mapper *projectReferenceFileMapper) getProjectReferenceFromOutputDts(path tspath.Path) *tsoptions.SourceOutputAndProjectReference {
|
|
||||||
return mapper.outputDtsToProjectReference[path]
|
|
||||||
}
|
|
||||||
|
|
||||||
func (mapper *projectReferenceFileMapper) isSourceFromProjectReference(path tspath.Path) bool {
|
|
||||||
return mapper.opts.canUseProjectReferenceSource() && mapper.getProjectReferenceFromSource(path) != nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (mapper *projectReferenceFileMapper) getCompilerOptionsForFile(file ast.HasFileName) *core.CompilerOptions {
|
|
||||||
redirect := mapper.getRedirectParsedCommandLineForResolution(file)
|
|
||||||
return module.GetCompilerOptionsWithRedirect(mapper.opts.Config.CompilerOptions(), redirect)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (mapper *projectReferenceFileMapper) getRedirectParsedCommandLineForResolution(file ast.HasFileName) *tsoptions.ParsedCommandLine {
|
|
||||||
redirect, _ := mapper.getRedirectForResolution(file)
|
|
||||||
return redirect
|
|
||||||
}
|
|
||||||
|
|
||||||
func (mapper *projectReferenceFileMapper) getRedirectForResolution(file ast.HasFileName) (*tsoptions.ParsedCommandLine, string) {
|
|
||||||
path := file.Path()
|
|
||||||
// Check if outputdts of source file from project reference
|
|
||||||
output := mapper.getProjectReferenceFromSource(path)
|
|
||||||
if output != nil {
|
|
||||||
return output.Resolved, output.Source
|
|
||||||
}
|
|
||||||
|
|
||||||
// Source file from project reference
|
|
||||||
resultFromDts := mapper.getProjectReferenceFromOutputDts(path)
|
|
||||||
if resultFromDts != nil {
|
|
||||||
return resultFromDts.Resolved, resultFromDts.Source
|
|
||||||
}
|
|
||||||
|
|
||||||
realpathDtsToSource := mapper.getSourceToDtsIfSymlink(file)
|
|
||||||
if realpathDtsToSource != nil {
|
|
||||||
return realpathDtsToSource.Resolved, realpathDtsToSource.Source
|
|
||||||
}
|
|
||||||
return nil, file.FileName()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (mapper *projectReferenceFileMapper) getResolvedReferenceFor(path tspath.Path) (*tsoptions.ParsedCommandLine, bool) {
|
|
||||||
config, ok := mapper.configToProjectReference[path]
|
|
||||||
return config, ok
|
|
||||||
}
|
|
||||||
|
|
||||||
func (mapper *projectReferenceFileMapper) forEachResolvedProjectReference(
|
|
||||||
fn func(path tspath.Path, config *tsoptions.ParsedCommandLine, parent *tsoptions.ParsedCommandLine, index int),
|
|
||||||
) {
|
|
||||||
if mapper.opts.Config.ConfigFile == nil {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
seenRef := collections.NewSetWithSizeHint[tspath.Path](len(mapper.referencesInConfigFile))
|
|
||||||
seenRef.Add(mapper.opts.Config.ConfigFile.SourceFile.Path())
|
|
||||||
refs := mapper.referencesInConfigFile[mapper.opts.Config.ConfigFile.SourceFile.Path()]
|
|
||||||
mapper.forEachResolvedReferenceWorker(refs, fn, mapper.opts.Config, seenRef)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (mapper *projectReferenceFileMapper) forEachResolvedReferenceWorker(
|
|
||||||
references []tspath.Path,
|
|
||||||
fn func(path tspath.Path, config *tsoptions.ParsedCommandLine, parent *tsoptions.ParsedCommandLine, index int),
|
|
||||||
parent *tsoptions.ParsedCommandLine,
|
|
||||||
seenRef *collections.Set[tspath.Path],
|
|
||||||
) {
|
|
||||||
for index, path := range references {
|
|
||||||
if !seenRef.AddIfAbsent(path) {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
config, _ := mapper.configToProjectReference[path]
|
|
||||||
fn(path, config, parent, index)
|
|
||||||
mapper.forEachResolvedReferenceWorker(mapper.referencesInConfigFile[path], fn, config, seenRef)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (mapper *projectReferenceFileMapper) getSourceToDtsIfSymlink(file ast.HasFileName) *tsoptions.SourceOutputAndProjectReference {
|
|
||||||
// If preserveSymlinks is true, module resolution wont jump the symlink
|
|
||||||
// but the resolved real path may be the .d.ts from project reference
|
|
||||||
// Note:: Currently we try the real path only if the
|
|
||||||
// file is from node_modules to avoid having to run real path on all file paths
|
|
||||||
path := file.Path()
|
|
||||||
realpathDtsToSource, ok := mapper.realpathDtsToSource.Load(path)
|
|
||||||
if ok {
|
|
||||||
return realpathDtsToSource
|
|
||||||
}
|
|
||||||
if mapper.loader != nil && mapper.opts.Config.CompilerOptions().PreserveSymlinks == core.TSTrue {
|
|
||||||
fileName := file.FileName()
|
|
||||||
if !strings.Contains(fileName, "/node_modules/") {
|
|
||||||
mapper.realpathDtsToSource.Store(path, nil)
|
|
||||||
} else {
|
|
||||||
realDeclarationPath := mapper.loader.toPath(mapper.host.FS().Realpath(fileName))
|
|
||||||
if realDeclarationPath == path {
|
|
||||||
mapper.realpathDtsToSource.Store(path, nil)
|
|
||||||
} else {
|
|
||||||
realpathDtsToSource := mapper.getProjectReferenceFromOutputDts(realDeclarationPath)
|
|
||||||
if realpathDtsToSource != nil {
|
|
||||||
mapper.realpathDtsToSource.Store(path, realpathDtsToSource)
|
|
||||||
return realpathDtsToSource
|
|
||||||
}
|
|
||||||
mapper.realpathDtsToSource.Store(path, nil)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
@ -1,111 +0,0 @@
|
|||||||
package compiler
|
|
||||||
|
|
||||||
import (
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/collections"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/core"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/tsoptions"
|
|
||||||
"efprojects.com/kitten-ipc/kitcom/internal/tsgo/tspath"
|
|
||||||
)
|
|
||||||
|
|
||||||
type projectReferenceParseTask struct {
|
|
||||||
configName string
|
|
||||||
resolved *tsoptions.ParsedCommandLine
|
|
||||||
subTasks []*projectReferenceParseTask
|
|
||||||
}
|
|
||||||
|
|
||||||
func (t *projectReferenceParseTask) parse(projectReferenceParser *projectReferenceParser) {
|
|
||||||
t.resolved = projectReferenceParser.loader.opts.Host.GetResolvedProjectReference(t.configName, projectReferenceParser.loader.toPath(t.configName))
|
|
||||||
if t.resolved == nil {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
t.resolved.ParseInputOutputNames()
|
|
||||||
if subReferences := t.resolved.ResolvedProjectReferencePaths(); len(subReferences) > 0 {
|
|
||||||
t.subTasks = createProjectReferenceParseTasks(subReferences)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func createProjectReferenceParseTasks(projectReferences []string) []*projectReferenceParseTask {
|
|
||||||
return core.Map(projectReferences, func(configName string) *projectReferenceParseTask {
|
|
||||||
return &projectReferenceParseTask{
|
|
||||||
configName: configName,
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
type projectReferenceParser struct {
|
|
||||||
loader *fileLoader
|
|
||||||
wg core.WorkGroup
|
|
||||||
tasksByFileName collections.SyncMap[tspath.Path, *projectReferenceParseTask]
|
|
||||||
}
|
|
||||||
|
|
||||||
func (p *projectReferenceParser) parse(tasks []*projectReferenceParseTask) {
|
|
||||||
p.loader.projectReferenceFileMapper.loader = p.loader
|
|
||||||
p.start(tasks)
|
|
||||||
p.wg.RunAndWait()
|
|
||||||
p.initMapper(tasks)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (p *projectReferenceParser) start(tasks []*projectReferenceParseTask) {
|
|
||||||
for i, task := range tasks {
|
|
||||||
path := p.loader.toPath(task.configName)
|
|
||||||
if loadedTask, loaded := p.tasksByFileName.LoadOrStore(path, task); loaded {
|
|
||||||
// dedup tasks to ensure correct file order, regardless of which task would be started first
|
|
||||||
tasks[i] = loadedTask
|
|
||||||
} else {
|
|
||||||
p.wg.Queue(func() {
|
|
||||||
task.parse(p)
|
|
||||||
p.start(task.subTasks)
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (p *projectReferenceParser) initMapper(tasks []*projectReferenceParseTask) {
|
|
||||||
totalReferences := p.tasksByFileName.Size() + 1
|
|
||||||
p.loader.projectReferenceFileMapper.configToProjectReference = make(map[tspath.Path]*tsoptions.ParsedCommandLine, totalReferences)
|
|
||||||
p.loader.projectReferenceFileMapper.referencesInConfigFile = make(map[tspath.Path][]tspath.Path, totalReferences)
|
|
||||||
p.loader.projectReferenceFileMapper.sourceToProjectReference = make(map[tspath.Path]*tsoptions.SourceOutputAndProjectReference)
|
|
||||||
p.loader.projectReferenceFileMapper.outputDtsToProjectReference = make(map[tspath.Path]*tsoptions.SourceOutputAndProjectReference)
|
|
||||||
p.loader.projectReferenceFileMapper.referencesInConfigFile[p.loader.opts.Config.ConfigFile.SourceFile.Path()] = p.initMapperWorker(tasks, &collections.Set[*projectReferenceParseTask]{})
|
|
||||||
if p.loader.projectReferenceFileMapper.opts.canUseProjectReferenceSource() && len(p.loader.projectReferenceFileMapper.outputDtsToProjectReference) != 0 {
|
|
||||||
p.loader.projectReferenceFileMapper.host = newProjectReferenceDtsFakingHost(p.loader)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (p *projectReferenceParser) initMapperWorker(tasks []*projectReferenceParseTask, seen *collections.Set[*projectReferenceParseTask]) []tspath.Path {
|
|
||||||
if len(tasks) == 0 {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
results := make([]tspath.Path, 0, len(tasks))
|
|
||||||
for _, task := range tasks {
|
|
||||||
path := p.loader.toPath(task.configName)
|
|
||||||
results = append(results, path)
|
|
||||||
// ensure we only walk each task once
|
|
||||||
if !seen.AddIfAbsent(task) {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
var referencesInConfig []tspath.Path
|
|
||||||
referencesInConfig = p.initMapperWorker(task.subTasks, seen)
|
|
||||||
p.loader.projectReferenceFileMapper.configToProjectReference[path] = task.resolved
|
|
||||||
p.loader.projectReferenceFileMapper.referencesInConfigFile[path] = referencesInConfig
|
|
||||||
if task.resolved == nil || p.loader.projectReferenceFileMapper.opts.Config.ConfigFile == task.resolved.ConfigFile {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
for key, value := range task.resolved.SourceToProjectReference() {
|
|
||||||
p.loader.projectReferenceFileMapper.sourceToProjectReference[key] = value
|
|
||||||
}
|
|
||||||
for key, value := range task.resolved.OutputDtsToProjectReference() {
|
|
||||||
p.loader.projectReferenceFileMapper.outputDtsToProjectReference[key] = value
|
|
||||||
}
|
|
||||||
if p.loader.projectReferenceFileMapper.opts.canUseProjectReferenceSource() {
|
|
||||||
declDir := task.resolved.CompilerOptions().DeclarationDir
|
|
||||||
if declDir == "" {
|
|
||||||
declDir = task.resolved.CompilerOptions().OutDir
|
|
||||||
}
|
|
||||||
if declDir != "" {
|
|
||||||
p.loader.dtsDirectories.Add(p.loader.toPath(declDir))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return results
|
|
||||||
}
|
|
||||||
Loading…
x
Reference in New Issue
Block a user