Implement getJSSyntacticDiagnosticsForFile for TypeScript-only construct detection in JavaScript files

internal/ast/ast.go

@@ -10049,6 +10049,7 @@ type SourceFile struct {
 	// Fields set by parser
 	diagnostics                 []*Diagnostic
 	jsdocDiagnostics            []*Diagnostic
+	jsSyntacticDiagnostics      []*Diagnostic
 	LanguageVariant             core.LanguageVariant
 	ScriptKind                  core.ScriptKind
 	IsDeclarationFile           bool
@@ -10147,6 +10148,14 @@ func (node *SourceFile) SetJSDocDiagnostics(diags []*Diagnostic) {
 	node.jsdocDiagnostics = diags
 }
 
+func (node *SourceFile) JSSyntacticDiagnostics() []*Diagnostic {
+	return node.jsSyntacticDiagnostics
+}
+
+func (node *SourceFile) SetJSSyntacticDiagnostics(diags []*Diagnostic) {
+	node.jsSyntacticDiagnostics = diags
+}
+
 func (node *SourceFile) JSDocCache() map[*Node][]*Node {
 	return node.jsdocCache
 }

internal/binder/binder.go

@@ -2758,7 +2758,7 @@ func (b *Binder) errorOrSuggestionOnRange(isError bool, startNode *ast.Node, end
 // If so, the node _must_ be in the current file (as that's the only way anything could have traversed to it to yield it as the error node)
 // This version of `createDiagnosticForNode` uses the binder's context to account for this, and always yields correct diagnostics even in these situations.
 func (b *Binder) createDiagnosticForNode(node *ast.Node, message *diagnostics.Message, args ...any) *ast.Diagnostic {
-	return ast.NewDiagnostic(b.file, GetErrorRangeForNode(b.file, node), message, args...)
+	return ast.NewDiagnostic(b.file, scanner.GetErrorRangeForNode(b.file, node), message, args...)
 }
 
 func (b *Binder) addDiagnostic(diagnostic *ast.Diagnostic) {
@@ -2855,83 +2855,3 @@ func isAssignmentDeclaration(decl *ast.Node) bool {
 func isEffectiveModuleDeclaration(node *ast.Node) bool {
 	return ast.IsModuleDeclaration(node) || ast.IsIdentifier(node)
 }
-
-func getErrorRangeForArrowFunction(sourceFile *ast.SourceFile, node *ast.Node) core.TextRange {
-	pos := scanner.SkipTrivia(sourceFile.Text(), node.Pos())
-	body := node.AsArrowFunction().Body
-	if body != nil && body.Kind == ast.KindBlock {
-		startLine, _ := scanner.GetLineAndCharacterOfPosition(sourceFile, body.Pos())
-		endLine, _ := scanner.GetLineAndCharacterOfPosition(sourceFile, body.End())
-		if startLine < endLine {
-			// The arrow function spans multiple lines,
-			// make the error span be the first line, inclusive.
-			return core.NewTextRange(pos, scanner.GetEndLinePosition(sourceFile, startLine))
-		}
-	}
-	return core.NewTextRange(pos, node.End())
-}
-
-func GetErrorRangeForNode(sourceFile *ast.SourceFile, node *ast.Node) core.TextRange {
-	errorNode := node
-	switch node.Kind {
-	case ast.KindSourceFile:
-		pos := scanner.SkipTrivia(sourceFile.Text(), 0)
-		if pos == len(sourceFile.Text()) {
-			return core.NewTextRange(0, 0)
-		}
-		return scanner.GetRangeOfTokenAtPosition(sourceFile, pos)
-	// This list is a work in progress. Add missing node kinds to improve their error spans
-	case ast.KindFunctionDeclaration, ast.KindMethodDeclaration:
-		if node.Flags&ast.NodeFlagsReparsed != 0 {
-			errorNode = node
-			break
-		}
-		fallthrough
-	case ast.KindVariableDeclaration, ast.KindBindingElement, ast.KindClassDeclaration, ast.KindClassExpression, ast.KindInterfaceDeclaration,
-		ast.KindModuleDeclaration, ast.KindEnumDeclaration, ast.KindEnumMember, ast.KindFunctionExpression,
-		ast.KindGetAccessor, ast.KindSetAccessor, ast.KindTypeAliasDeclaration, ast.KindJSTypeAliasDeclaration, ast.KindPropertyDeclaration,
-		ast.KindPropertySignature, ast.KindNamespaceImport:
-		errorNode = ast.GetNameOfDeclaration(node)
-	case ast.KindArrowFunction:
-		return getErrorRangeForArrowFunction(sourceFile, node)
-	case ast.KindCaseClause, ast.KindDefaultClause:
-		start := scanner.SkipTrivia(sourceFile.Text(), node.Pos())
-		end := node.End()
-		statements := node.AsCaseOrDefaultClause().Statements.Nodes
-		if len(statements) != 0 {
-			end = statements[0].Pos()
-		}
-		return core.NewTextRange(start, end)
-	case ast.KindReturnStatement, ast.KindYieldExpression:
-		pos := scanner.SkipTrivia(sourceFile.Text(), node.Pos())
-		return scanner.GetRangeOfTokenAtPosition(sourceFile, pos)
-	case ast.KindSatisfiesExpression:
-		pos := scanner.SkipTrivia(sourceFile.Text(), node.AsSatisfiesExpression().Expression.End())
-		return scanner.GetRangeOfTokenAtPosition(sourceFile, pos)
-	case ast.KindConstructor:
-		if node.Flags&ast.NodeFlagsReparsed != 0 {
-			errorNode = node
-			break
-		}
-		scanner := scanner.GetScannerForSourceFile(sourceFile, node.Pos())
-		start := scanner.TokenStart()
-		for scanner.Token() != ast.KindConstructorKeyword && scanner.Token() != ast.KindStringLiteral && scanner.Token() != ast.KindEndOfFile {
-			scanner.Scan()
-		}
-		return core.NewTextRange(start, scanner.TokenEnd())
-		// !!!
-		// case KindJSDocSatisfiesTag:
-		// 	pos := scanner.SkipTrivia(sourceFile.Text(), node.tagName.pos)
-		// 	return scanner.GetRangeOfTokenAtPosition(sourceFile, pos)
-	}
-	if errorNode == nil {
-		// If we don't have a better node, then just set the error on the first token of
-		// construct.
-		return scanner.GetRangeOfTokenAtPosition(sourceFile, node.Pos())
-	}
-	pos := errorNode.Pos()
-	if !ast.NodeIsMissing(errorNode) && !ast.IsJsxText(errorNode) {
-		pos = scanner.SkipTrivia(sourceFile.Text(), pos)
-	}
-	return core.NewTextRange(pos, errorNode.End())
-}

internal/checker/utilities.go

@@ -23,7 +23,7 @@ func NewDiagnosticForNode(node *ast.Node, message *diagnostics.Message, args ...
 	var loc core.TextRange
 	if node != nil {
 		file = ast.GetSourceFileOfNode(node)
-		loc = binder.GetErrorRangeForNode(file, node)
+		loc = scanner.GetErrorRangeForNode(file, node)
 	}
 	return ast.NewDiagnostic(file, loc, message, args...)
 }

internal/compiler/program.go

@@ -865,6 +865,11 @@ func (p *Program) getOptionsDiagnosticsOfConfigFile() []*ast.Diagnostic {
 }
 
 func (p *Program) getSyntacticDiagnosticsForFile(ctx context.Context, sourceFile *ast.SourceFile) []*ast.Diagnostic {
+	// For JavaScript files, we report semantic errors for using TypeScript-only
+	// constructs from within a JavaScript file as syntactic errors.
+	if jsSyntacticDiagnostics := sourceFile.JSSyntacticDiagnostics(); len(jsSyntacticDiagnostics) > 0 {
+		return slices.Concat(jsSyntacticDiagnostics, sourceFile.Diagnostics())
+	}
 	return sourceFile.Diagnostics()
 }