Merge branch 'main' into feat/2280

Author: a-tarasyuk

internal/fourslash/tests/autoImportCJSWithNodeModuleKind_test.go

@@ -0,0 +1,105 @@
+package fourslash_test
+
+import (
+	"testing"
+
+	"github.com/microsoft/typescript-go/internal/fourslash"
+	"github.com/microsoft/typescript-go/internal/testutil"
+)
+
+// TestAutoImportCJSWithNodeModuleKind verifies that auto-imports use require()
+// syntax in CJS files when using node16/node20/nodenext module kinds with a
+// package.json that has "type": "commonjs".
+func TestAutoImportCJSWithNodeModuleKind(t *testing.T) {
+	t.Parallel()
+	defer testutil.RecoverAndFail(t, "Panic on fourslash test")
+	const content = `// @Filename: /tsconfig.json
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "module": "node20",
+    "checkJs": true,
+    "noEmit": true
+  }
+}
+// @Filename: /package.json
+{ "type": "commonjs" }
+// @Filename: /lib.js
+module.exports = { LIB_VERSION: 1 };
+// @Filename: /main.js
+module.exports.foo = 0;
+LIB_VERSION/**/`
+	f, done := fourslash.NewFourslash(t, nil /*capabilities*/, content)
+	defer done()
+
+	f.GoToMarker(t, "")
+	f.VerifyImportFixAtPosition(t, []string{
+		`const { LIB_VERSION } = require("./lib");
+
+module.exports.foo = 0;
+LIB_VERSION`,
+	}, nil /*preferences*/)
+}
+
+// TestAutoImportCJSWithNodeModuleKindEmptyFile verifies that auto-imports use
+// require() syntax even in empty CJS files when using node module kinds.
+func TestAutoImportCJSWithNodeModuleKindEmptyFile(t *testing.T) {
+	t.Parallel()
+	defer testutil.RecoverAndFail(t, "Panic on fourslash test")
+	const content = `// @Filename: /tsconfig.json
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "module": "node20",
+    "checkJs": true,
+    "noEmit": true
+  }
+}
+// @Filename: /package.json
+{ "type": "commonjs" }
+// @Filename: /lib.js
+module.exports = { LIB_VERSION: 1 };
+// @Filename: /main.js
+LIB_VERSION/**/`
+	f, done := fourslash.NewFourslash(t, nil /*capabilities*/, content)
+	defer done()
+
+	f.GoToMarker(t, "")
+	f.VerifyImportFixAtPosition(t, []string{
+		`const { LIB_VERSION } = require("./lib");
+
+LIB_VERSION`,
+	}, nil /*preferences*/)
+}
+
+// TestAutoImportCJSWithModuleDetectionForce verifies that auto-imports use
+// require() syntax in JS files with CJS syntax when moduleDetection is "force",
+// even with --module preserve where GetImpliedNodeFormatForEmit won't help.
+func TestAutoImportCJSWithModuleDetectionForce(t *testing.T) {
+	t.Parallel()
+	defer testutil.RecoverAndFail(t, "Panic on fourslash test")
+	const content = `// @Filename: /tsconfig.json
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "module": "preserve",
+    "moduleDetection": "force",
+    "checkJs": true,
+    "noEmit": true
+  }
+}
+// @Filename: /lib.js
+export const LIB_VERSION = 1;
+// @Filename: /main.js
+const path = require("path");
+LIB_VERSION/**/`
+	f, done := fourslash.NewFourslash(t, nil /*capabilities*/, content)
+	defer done()
+
+	f.GoToMarker(t, "")
+	f.VerifyImportFixAtPosition(t, []string{
+		`const path = require("path");
+const { LIB_VERSION } = require("./lib");
+LIB_VERSION`,
+	}, nil /*preferences*/)
+}

internal/ls/autoimport/fix.go

@@ -859,27 +859,84 @@ func (v *View) shouldUseRequire() bool {
 	return shouldUseRequire
 }
 
+// fileSyntaxKind represents the detected module syntax of a source file.
+type fileSyntaxKind int
+
+const (
+	fileSyntaxKindAmbiguous fileSyntaxKind = iota
+	fileSyntaxKindESM
+	fileSyntaxKindCJS
+)
+
+// detectSyntax returns whether a source file has unambiguous ESM or CJS syntax.
+// When moduleDetection is "force", ExternalModuleIndicator may be set to the
+// source file node itself rather than a genuine syntax indicator, so we fall back
+// to inspecting the file's Imports() to find actual import/export declarations.
+func detectSyntax(file *ast.SourceFile, options *core.CompilerOptions) fileSyntaxKind {
+	hasESM, hasCJS := detectSyntaxIndicators(file, options)
+	switch {
+	case hasCJS && !hasESM:
+		return fileSyntaxKindCJS
+	case hasESM && !hasCJS:
+		return fileSyntaxKindESM
+	default:
+		return fileSyntaxKindAmbiguous
+	}
+}
+
+// detectSyntaxIndicators checks whether a source file contains genuine ESM
+// and/or CJS syntax. Under moduleDetection "force", the cached
+// ExternalModuleIndicator may be the source file itself rather than a real
+// statement, so we look at Imports() for actual import/export declarations.
+func detectSyntaxIndicators(file *ast.SourceFile, options *core.CompilerOptions) (hasESM bool, hasCJS bool) {
+	hasCJS = file.CommonJSModuleIndicator != nil
+	if options.GetEmitModuleDetectionKind() != core.ModuleDetectionKindForce {
+		// ExternalModuleIndicator is reliable when moduleDetection is not "force"
+		hasESM = file.ExternalModuleIndicator != nil
+		return hasESM, hasCJS
+	}
+	// Under moduleDetection "force", ExternalModuleIndicator is set to
+	// file.AsNode() when there is no genuine ESM syntax, so only trust it
+	// when it points to a real statement node.
+	if file.ExternalModuleIndicator != nil && file.ExternalModuleIndicator != file.AsNode() {
+		return true, hasCJS
+	}
+	// Fall back to scanning Imports() for actual import/export declarations
+	// (not require() calls or dynamic imports).
+	for _, imp := range file.Imports() {
+		if imp.Flags&ast.NodeFlagsSynthesized != 0 {
+			continue
+		}
+		parent := imp.Parent
+		if parent == nil {
+			continue
+		}
+		switch parent.Kind {
+		case ast.KindImportDeclaration, ast.KindJSImportDeclaration, ast.KindExportDeclaration:
+			return true, hasCJS
+		case ast.KindExternalModuleReference:
+			// import x = require("...") — this is ESM-ish syntax
+			return true, hasCJS
+		}
+	}
+	return hasESM, hasCJS
+}
+
 func (v *View) computeShouldUseRequire() bool {
 	// 1. TypeScript files don't use require variable declarations
 	if !tspath.HasJSFileExtension(v.importingFile.FileName()) {
 		return false
 	}
 
 	// 2. If the current source file is unambiguously CJS or ESM, go with that
-	switch {
-	case v.importingFile.CommonJSModuleIndicator != nil && v.importingFile.ExternalModuleIndicator == nil:
+	switch detectSyntax(v.importingFile, v.program.Options()) {
+	case fileSyntaxKindCJS:
 		return true
-	case v.importingFile.ExternalModuleIndicator != nil && v.importingFile.CommonJSModuleIndicator == nil:
+	case fileSyntaxKindESM:
 		return false
 	}
 
-	// 3. If there's a tsconfig/jsconfig, use its module setting
-	if v.program.Options().ConfigFilePath != "" {
-		return v.program.Options().GetEmitModuleKind() < core.ModuleKindES2015
-	}
-
-	// 4. In --module nodenext, assume we're not emitting JS -> JS, so use
-	//    whatever syntax Node expects based on the detected module kind
+	// 3. Use the implied node format to determine CJS vs ESM
 	//    TODO: consider removing `impliedNodeFormatForEmit`
 	switch v.program.GetImpliedNodeFormatForEmit(v.importingFile) {
 	case core.ModuleKindCommonJS:
@@ -888,14 +945,21 @@ func (v *View) computeShouldUseRequire() bool {
 		return false
 	}
 
+	// 4. If there's a tsconfig/jsconfig, use its module setting
+	if v.program.Options().ConfigFilePath != "" {
+		return v.program.Options().GetEmitModuleKind() < core.ModuleKindES2015
+	}
+
 	// 5. Match the first other JS file in the program that's unambiguously CJS or ESM
 	for _, otherFile := range v.program.GetSourceFiles() {
 		switch {
 		case otherFile == v.importingFile, !ast.IsSourceFileJS(otherFile), v.program.IsSourceFileFromExternalLibrary(otherFile):
 			continue
-		case otherFile.CommonJSModuleIndicator != nil && otherFile.ExternalModuleIndicator == nil:
+		}
+		switch detectSyntax(otherFile, v.program.Options()) {
+		case fileSyntaxKindCJS:
 			return true
-		case otherFile.ExternalModuleIndicator != nil && otherFile.CommonJSModuleIndicator == nil:
+		case fileSyntaxKindESM:
 			return false
 		}
 	}

internal/lsp/server.go

@@ -1101,17 +1101,17 @@ func (s *Server) handleInitialize(ctx context.Context, params *lsproto.Initializ
 					},
 				},
 			},
-			// SemanticTokensProvider: &lsproto.SemanticTokensOptionsOrRegistrationOptions{
-			// 	Options: &lsproto.SemanticTokensOptions{
-			// 		Legend: ls.SemanticTokensLegend(s.clientCapabilities.TextDocument.SemanticTokens),
-			// 		Full: &lsproto.BooleanOrSemanticTokensFullDelta{
-			// 			Boolean: new(true),
-			// 		},
-			// 		Range: &lsproto.BooleanOrEmptyObject{
-			// 			Boolean: new(true),
-			// 		},
-			// 	},
-			// },
+			SemanticTokensProvider: &lsproto.SemanticTokensOptionsOrRegistrationOptions{
+				Options: &lsproto.SemanticTokensOptions{
+					Legend: ls.SemanticTokensLegend(s.clientCapabilities.TextDocument.SemanticTokens),
+					Full: &lsproto.BooleanOrSemanticTokensFullDelta{
+						Boolean: new(true),
+					},
+					Range: &lsproto.BooleanOrEmptyObject{
+						Boolean: new(true),
+					},
+				},
+			},
 		},
 	}
 

internal/tsoptions/parsinghelpers.go

@@ -63,6 +63,10 @@ func parseNumber(value any) *int {
 	if num, ok := value.(int); ok {
 		return &num
 	}
+	if num, ok := value.(float64); ok {
+		n := int(num)
+		return &n
+	}
 	return nil
 }
 

testdata/baselines/reference/config/tsconfigParsing/parses tsconfig with compilerOptions, files, include, and exclude with json api.js

@@ -49,6 +49,7 @@ CompilerOptions::
   },
   "strict": true,
   "target": 4,
+  "maxNodeModuleJsDepth": 1,
   "configFilePath": "/apath/tsconfig.json",
   "pathsBasePath": "/apath"
 }

testdata/baselines/reference/config/tsconfigParsing/parses tsconfig with compilerOptions, files, include, and exclude with jsonSourceFile api.js

@@ -49,6 +49,7 @@ CompilerOptions::
   },
   "strict": true,
   "target": 4,
+  "maxNodeModuleJsDepth": 1,
   "configFilePath": "/apath/tsconfig.json",
   "pathsBasePath": "/apath"
 }