deps(deps): bump microsoft/typescript-go from dc6ce07 to 7c2dab6 (#38)

* deps(deps): bump microsoft/typescript-go from `dc6ce07` to `7c2dab6`

Bumps [microsoft/typescript-go](https://github.com/microsoft/typescript-go) from `dc6ce07` to `7c2dab6`.
- [Commits](microsoft/typescript-go@dc6ce07...7c2dab6)

---
updated-dependencies:
- dependency-name: microsoft/typescript-go
  dependency-version: 7c2dab6c4248845a1dde0693a6609bf2655e8463
  dependency-type: direct:production
...

Signed-off-by: dependabot[bot] <support@github.com>

* chore(sync): mirror internal packages into pkg/ (auto) (#39)

Co-authored-by: buke <1013738+buke@users.noreply.github.com>

---------

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: buke <1013738+buke@users.noreply.github.com>

Author: 3 people

microsoft/typescript-go

@@ -127,6 +127,7 @@ func (api *API) ParseConfigFile(configFileName string) (*ConfigFileResponse, err
 		api.session,
 		configDir,
 		nil, /*existingOptions*/
+		nil, /*existingOptionsRaw*/
 		configFileName,
 		nil, /*resolutionStack*/
 		nil, /*extraFileExtensions*/

pkg/api/api.go

@@ -26600,11 +26600,6 @@ func (c *Checker) isAssignmentToReadonlyEntity(expr *ast.Node, symbol *ast.Symbo
 			if expressionSymbol.Flags&ast.SymbolFlagsModuleExports != 0 {
 				return false
 			}
-			// references through namespace import should be readonly
-			if expressionSymbol.Flags&ast.SymbolFlagsAlias != 0 {
-				declaration := c.getDeclarationOfAliasSymbol(expressionSymbol)
-				return declaration != nil && ast.IsNamespaceImport(declaration)
-			}
 		}
 	}
 	if c.isReadonlySymbol(symbol) {
@@ -26627,6 +26622,17 @@ func (c *Checker) isAssignmentToReadonlyEntity(expr *ast.Node, symbol *ast.Symbo
 		}
 		return true
 	}
+	if ast.IsAccessExpression(expr) {
+		// references through namespace import should be readonly
+		node := ast.SkipParentheses(expr.Expression())
+		if ast.IsIdentifier(node) {
+			expressionSymbol := c.getResolvedSymbol(node)
+			if expressionSymbol.Flags&ast.SymbolFlagsAlias != 0 {
+				declaration := c.getDeclarationOfAliasSymbol(expressionSymbol)
+				return declaration != nil && ast.IsNamespaceImport(declaration)
+			}
+		}
+	}
 	return false
 }
 

pkg/checker/checker.go

@@ -38,7 +38,7 @@ foo.bar;`
 	cd := "/"
 	host := compiler.NewCompilerHost(cd, fs, bundled.LibPath(), nil, nil)
 
-	parsed, errors := tsoptions.GetParsedCommandLineOfConfigFile("/tsconfig.json", &core.CompilerOptions{}, host, nil)
+	parsed, errors := tsoptions.GetParsedCommandLineOfConfigFile("/tsconfig.json", &core.CompilerOptions{}, nil, host, nil)
 	assert.Equal(t, len(errors), 0, "Expected no errors in parsed command line")
 
 	p := compiler.NewProgram(compiler.ProgramOptions{
@@ -71,7 +71,7 @@ func TestCheckSrcCompiler(t *testing.T) {
 	rootPath := tspath.CombinePaths(tspath.NormalizeSlashes(repo.TypeScriptSubmodulePath), "src", "compiler")
 
 	host := compiler.NewCompilerHost(rootPath, fs, bundled.LibPath(), nil, nil)
-	parsed, errors := tsoptions.GetParsedCommandLineOfConfigFile(tspath.CombinePaths(rootPath, "tsconfig.json"), &core.CompilerOptions{}, host, nil)
+	parsed, errors := tsoptions.GetParsedCommandLineOfConfigFile(tspath.CombinePaths(rootPath, "tsconfig.json"), &core.CompilerOptions{}, nil, host, nil)
 	assert.Equal(t, len(errors), 0, "Expected no errors in parsed command line")
 	p := compiler.NewProgram(compiler.ProgramOptions{
 		Config: parsed,
@@ -88,7 +88,7 @@ func BenchmarkNewChecker(b *testing.B) {
 	rootPath := tspath.CombinePaths(tspath.NormalizeSlashes(repo.TypeScriptSubmodulePath), "src", "compiler")
 
 	host := compiler.NewCompilerHost(rootPath, fs, bundled.LibPath(), nil, nil)
-	parsed, errors := tsoptions.GetParsedCommandLineOfConfigFile(tspath.CombinePaths(rootPath, "tsconfig.json"), &core.CompilerOptions{}, host, nil)
+	parsed, errors := tsoptions.GetParsedCommandLineOfConfigFile(tspath.CombinePaths(rootPath, "tsconfig.json"), &core.CompilerOptions{}, nil, host, nil)
 	assert.Equal(b, len(errors), 0, "Expected no errors in parsed command line")
 	p := compiler.NewProgram(compiler.ProgramOptions{
 		Config: parsed,

pkg/checker/checker_test.go

@@ -32,7 +32,16 @@ type checkerPool struct {
 
 var _ CheckerPool = (*checkerPool)(nil)
 
-func newCheckerPool(checkerCount int, program *Program) *checkerPool {
+func newCheckerPool(program *Program) *checkerPool {
+	checkerCount := 4
+	if program.SingleThreaded() {
+		checkerCount = 1
+	} else if c := program.Options().Checkers; c != nil {
+		checkerCount = *c
+	}
+
+	checkerCount = max(min(checkerCount, len(program.files), 256), 1)
+
 	pool := &checkerPool{
 		program:      program,
 		checkerCount: checkerCount,

pkg/compiler/checkerpool.go

@@ -69,6 +69,7 @@ type processedFiles struct {
 	// 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
+	finishedProcessing                 bool
 }
 
 type jsxRuntimeImportSpecifier struct {

pkg/compiler/fileloader.go

@@ -372,6 +372,7 @@ func (w *filesParser) getProcessedFiles(loader *fileLoader) processedFiles {
 	}
 
 	return processedFiles{
+		finishedProcessing:                   true,
 		resolver:                             loader.resolver,
 		files:                                allFiles,
 		filesByPath:                          filesByPath,

pkg/compiler/filesparser.go

@@ -84,6 +84,6 @@ func (h *compilerHost) GetSourceFile(opts ast.SourceFileParseOptions) *ast.Sourc
 }
 
 func (h *compilerHost) GetResolvedProjectReference(fileName string, path tspath.Path) *tsoptions.ParsedCommandLine {
-	commandLine, _ := tsoptions.GetParsedCommandLineOfConfigFilePath(fileName, path, nil, h, h.extendedConfigCache)
+	commandLine, _ := tsoptions.GetParsedCommandLineOfConfigFilePath(fileName, path, nil, nil /*optionsRaw*/, h, h.extendedConfigCache)
 	return commandLine
 }

pkg/compiler/host.go

@@ -222,8 +222,8 @@ func (p *Program) GetSourceFileFromReference(origin *ast.SourceFile, ref *ast.Fi
 
 func NewProgram(opts ProgramOptions) *Program {
 	p := &Program{opts: opts}
-	p.initCheckerPool()
 	p.processedFiles = processAllProgramFiles(p.opts, p.SingleThreaded())
+	p.initCheckerPool()
 	p.verifyCompilerOptions()
 	return p
 }
@@ -259,16 +259,14 @@ func (p *Program) UpdateProgram(changedFilePath tspath.Path, newHost CompilerHos
 }
 
 func (p *Program) initCheckerPool() {
+	if !p.finishedProcessing {
+		panic("Program must finish processing files before initializing checker pool")
+	}
+
 	if p.opts.CreateCheckerPool != nil {
 		p.checkerPool = p.opts.CreateCheckerPool(p)
 	} else {
-		checkers := 4
-		if p.SingleThreaded() {
-			checkers = 1
-		} else if p.Options().Checkers != nil {
-			checkers = min(max(*p.Options().Checkers, 1), 256)
-		}
-		p.checkerPool = newCheckerPool(checkers, p)
+		p.checkerPool = newCheckerPool(p)
 	}
 }
 

pkg/compiler/program.go

@@ -299,7 +299,7 @@ func BenchmarkNewProgram(b *testing.B) {
 
 		host := compiler.NewCompilerHost(rootPath, fs, bundled.LibPath(), nil, nil)
 
-		parsed, errors := tsoptions.GetParsedCommandLineOfConfigFile(tspath.CombinePaths(rootPath, "tsconfig.json"), nil, host, nil)
+		parsed, errors := tsoptions.GetParsedCommandLineOfConfigFile(tspath.CombinePaths(rootPath, "tsconfig.json"), nil, nil, host, nil)
 		assert.Equal(b, len(errors), 0, "Expected no errors in parsed command line")
 
 		opts := compiler.ProgramOptions{