Method CreateProgram

internal/project/project.go:351–415

()

}

func (p *Project) CreateProgram() CreateProgramResult {
	updateKind := ProgramUpdateKindNewFiles
	var programCloned bool
	var newProgram *compiler.Program

	// Define a fresh CreateCheckerPool closure for this call. Each invocation of
	// CreateProgram must use its own closure so that concurrent goroutines cloning
	// the same project never share a captured variable through a stale closure
	// stored in the old program's options.
	createCheckerPool := func(program *compiler.Program) compiler.CheckerPool {
		return newCheckerPool(p.host.sessionOptions.CheckerPoolOptions, program, p.log)
	}

	// Create the command line, potentially augmented with typing files
	commandLine := p.getCommandLineWithTypingsFiles()

	if p.dirtyFilePath != "" && p.Program != nil && p.Program.CommandLine() == commandLine {
		var dirtyFile *ast.SourceFile
		newProgram, dirtyFile, programCloned = p.Program.UpdateProgram(p.dirtyFilePath, p.host, createCheckerPool)
		if programCloned {
			updateKind = ProgramUpdateKindCloned
			for _, file := range newProgram.SourceFiles() {
				// Use pointer identity: dirtyFile is the exact instance UpdateProgram acquired,
				// and it is the only file whose refcount is already accounted for.
				if file != dirtyFile {
					// UpdateProgram acquired the changed file only, so we need to ref everything else
					p.host.builder.parseCache.Ref(NewParseCacheKey(file.ParseOptions(), file.Hash, file.ScriptKind))
				}
			}
			for _, file := range newProgram.DuplicateSourceFiles() {
				p.host.builder.parseCache.Ref(NewParseCacheKey(file.ParseOptions, file.Hash, file.ScriptKind))
			}
		} else if dirtyFile != nil {
			// UpdateProgram always acquires the dirty file before deciding whether it can
			// reuse the old program. If it falls back to a full rebuild, release that
			// speculative acquire so the rebuilt program is the only remaining owner.
			p.host.builder.parseCache.Deref(NewParseCacheKey(dirtyFile.ParseOptions(), dirtyFile.Hash, dirtyFile.ScriptKind))
		}
	} else {
		var typingsLocation string
		if p.GetTypeAcquisition().Enable.IsTrue() {
			typingsLocation = p.host.sessionOptions.TypingsLocation
		}
		newProgram = compiler.NewProgram(
			compiler.ProgramOptions{
				Host:                        p.host,
				Config:                      commandLine,
				UseSourceOfProjectReference: true,
				TypingsLocation:             typingsLocation,
				CreateCheckerPool:           createCheckerPool,
			},
		)
	}

	if !programCloned && p.Program != nil && p.Program.HasSameFileNames(newProgram) {
		updateKind = ProgramUpdateKindSameFileNames
	}