Method getProcessedFiles

internal/compiler/filesparser.go:306–555

(loader *fileLoader)

}

func (w *filesParser) getProcessedFiles(loader *fileLoader) processedFiles {
	totalFileCount := int(loader.totalFileCount.Load())
	libFileCount := int(loader.libFileCount.Load())

	var missingFiles []string
	var duplicateSourceFiles []*DuplicateSourceFile
	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)
	// stores 'filename -> file association' ignoring case
	// used to track cases when two file names differ only in casing
	var tasksSeenByNameIgnoreCase map[string]*parseTask
	if loader.comparePathsOptions.UseCaseSensitiveFileNames {
		tasksSeenByNameIgnoreCase = make(map[string]*parseTask, totalFileCount)
	}

	includeProcessor := &includeProcessor{
		fileIncludeReasons: make(map[tspath.Path][]*FileIncludeReason, totalFileCount),
	}
	var outputFileToProjectReferenceSource map[tspath.Path]string
	if !loader.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.StringLiteralNode
	var sourceFilesFoundSearchingNodeModules collections.Set[tspath.Path]
	libFilesMap := make(map[tspath.Path]*LibFile, libFileCount)

	var redirectTargetsMap map[tspath.Path][]string
	var redirectFilesByPath map[tspath.Path]*redirectsFile
	var packageIdToSourceFile map[module.PackageId]*ast.SourceFile
	if !loader.opts.Config.CompilerOptions().DeduplicatePackages.IsFalse() {
		redirectTargetsMap = make(map[tspath.Path][]string)
		packageIdToSourceFile = make(map[module.PackageId]*ast.SourceFile)
	}

	var collectFiles func(tasks []*parseTask, seen map[*parseTaskData]string)
	// recordedDuplicates tracks, per task data, the set of file-name casings that
	// have already been recorded in duplicateSourceFiles. A file that is reached
	// from multiple import sites is walked once per site, but each distinct casing
	// is only parsed and acquired in the parse cache once. Recording the same casing
	// as a duplicate more than once would cause it to be released more times than it
	// was acquired when the snapshot is disposed, leaving a dangling cache entry that
	// panics the next time it is referenced.
	var recordedDuplicates map[*parseTaskData]*collections.Set[string]
	collectFiles = func(tasks []*parseTask, seen map[*parseTaskData]string) {
		for _, task := range tasks {
			includeReason := task.includeReason
			// 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 {
				if task.loadedTask != nil {
					task = task.loadedTask