Skip to content

Commit f5c2297

Browse files
ahejlsbergahejlsberg
committed
Keep all JS syntax checking in a single checkJSSyntax function
1 parent 2cb1765 commit f5c2297

File tree

1 file changed

+100
-86
lines changed

1 file changed

+100
-86
lines changed

‎internal/parser/parser.go‎

Lines changed: 100 additions & 86 deletions
Original file line numberDiff line numberDiff line change
@@ -1407,7 +1407,7 @@ func (p *Parser) parseVariableStatement(pos int, hasJSDoc bool, modifiers *ast.M
14071407
p.parseSemicolon()
14081408
result := p.finishNode(p.factory.NewVariableStatement(modifiers, declarationList), pos)
14091409
p.withJSDoc(result, hasJSDoc)
1410-
p.checkNoJSExtraModifiers(result)
1410+
p.checkJSSyntax(result)
14111411
return result
14121412
}
14131413

@@ -1478,13 +1478,14 @@ func (p *Parser) parseVariableDeclarationWorker(allowExclamation bool) *ast.Node
14781478
if allowExclamation && name.Kind == ast.KindIdentifier && p.token == ast.KindExclamationToken && !p.hasPrecedingLineBreak() {
14791479
exclamationToken = p.parseTokenNode()
14801480
}
1481-
typeNode := p.checkNoJSTypeAnnotation(p.parseTypeAnnotation())
1481+
typeNode := p.parseTypeAnnotation()
14821482
var initializer *ast.Expression
14831483
if p.token != ast.KindInKeyword && p.token != ast.KindOfKeyword {
14841484
initializer = p.parseInitializer()
14851485
}
14861486
result := p.finishNode(p.factory.NewVariableDeclaration(name, exclamationToken, typeNode, initializer), pos)
14871487
p.withJSDoc(result, hasJSDoc)
1488+
p.checkJSSyntax(result)
14881489
return result
14891490
}
14901491

@@ -1584,14 +1585,12 @@ func (p *Parser) parseFunctionDeclaration(pos int, hasJSDoc bool, modifiers *ast
15841585
p.setContextFlags(ast.NodeFlagsAwaitContext, true)
15851586
}
15861587
parameters := p.parseParameters(signatureFlags)
1587-
returnType := p.checkNoJSTypeAnnotation(p.parseReturnType(ast.KindColonToken, false /*isType*/))
1588+
returnType := p.parseReturnType(ast.KindColonToken, false /*isType*/)
15881589
body := p.parseFunctionBlockOrSemicolon(signatureFlags, diagnostics.X_or_expected)
15891590
p.contextFlags = saveContextFlags
15901591
result := p.finishNode(p.factory.NewFunctionDeclaration(modifiers, asteriskToken, name, typeParameters, parameters, returnType, nil /*fullSignature*/, body), pos)
15911592
p.withJSDoc(result, hasJSDoc)
1592-
p.checkNoJSExtraModifiers(result)
1593-
p.checkNoJSTypeParameters(result)
1594-
p.checkNoJSSignature(result)
1593+
p.checkJSSyntax(result)
15951594
return result
15961595
}
15971596

@@ -1636,13 +1635,12 @@ func (p *Parser) parseClassDeclarationOrExpression(pos int, hasJSDoc bool, modif
16361635
p.finishNode(result, pos)
16371636
p.withJSDoc(result, hasJSDoc)
16381637
if result.Flags&ast.NodeFlagsJavaScriptFile != 0 {
1639-
p.checkNoJSExtraModifiers(result)
1640-
p.checkNoJSTypeParameters(result)
1638+
p.checkJSSyntax(result)
16411639
if heritageClauses != nil {
16421640
for _, clause := range heritageClauses.Nodes {
16431641
if clause.AsHeritageClause().Token == ast.KindExtendsKeyword {
16441642
for _, expr := range clause.AsHeritageClause().Types.Nodes {
1645-
p.checkNoJSTypeArguments(expr)
1643+
p.checkJSSyntax(expr)
16461644
}
16471645
}
16481646
}
@@ -1735,7 +1733,7 @@ func (p *Parser) parseClassElement() *ast.Node {
17351733
}
17361734
}
17371735
if p.isIndexSignature() {
1738-
return p.checkNoJSSignature(p.parseIndexSignatureDeclaration(pos, hasJSDoc, modifiers))
1736+
return p.checkJSSyntax(p.parseIndexSignatureDeclaration(pos, hasJSDoc, modifiers))
17391737
}
17401738
// It is very important that we check this *after* checking indexers because
17411739
// the [ token can start an index signature or a computed property name
@@ -1784,21 +1782,14 @@ func (p *Parser) parseClassStaticBlockBody() *ast.Node {
17841782
func (p *Parser) tryParseConstructorDeclaration(pos int, hasJSDoc bool, modifiers *ast.ModifierList) *ast.Node {
17851783
state := p.mark()
17861784
if p.token == ast.KindConstructorKeyword || p.token == ast.KindStringLiteral && p.scanner.TokenValue() == "constructor" && p.lookAhead((*Parser).nextTokenIsOpenParen) {
1787-
errorRange := core.NewTextRange(p.scanner.TokenStart(), p.scanner.TokenEnd())
17881785
p.nextToken()
17891786
typeParameters := p.parseTypeParameters()
17901787
parameters := p.parseParameters(ParseFlagsNone)
1791-
returnType := p.checkNoJSTypeAnnotation(p.parseReturnType(ast.KindColonToken, false /*isType*/))
1788+
returnType := p.parseReturnType(ast.KindColonToken, false /*isType*/)
17921789
body := p.parseFunctionBlockOrSemicolon(ParseFlagsNone, diagnostics.X_or_expected)
17931790
result := p.finishNode(p.factory.NewConstructorDeclaration(modifiers, typeParameters, parameters, returnType, nil /*fullSignature*/, body), pos)
17941791
p.withJSDoc(result, hasJSDoc)
1795-
if result.Flags&ast.NodeFlagsJavaScriptFile != 0 {
1796-
p.checkNoJSExtraModifiers(result)
1797-
p.checkNoJSTypeParameters(result)
1798-
if result.Body() == nil {
1799-
p.jsErrorAtRange(errorRange, diagnostics.Signature_declarations_can_only_be_used_in_TypeScript_files)
1800-
}
1801-
}
1792+
p.checkJSSyntax(result)
18021793
return result
18031794
}
18041795
p.rewind(state)
@@ -1814,7 +1805,7 @@ func (p *Parser) parsePropertyOrMethodDeclaration(pos int, hasJSDoc bool, modifi
18141805
name := p.parsePropertyName()
18151806
// Note: this is not legal as per the grammar. But we allow it in the parser and
18161807
// report an error in the grammar checker.
1817-
questionToken := p.checkNoJSQuestionToken(p.parseOptionalToken(ast.KindQuestionToken))
1808+
questionToken := p.parseOptionalToken(ast.KindQuestionToken)
18181809
if asteriskToken != nil || p.token == ast.KindOpenParenToken || p.token == ast.KindLessThanToken {
18191810
return p.parseMethodDeclaration(pos, hasJSDoc, modifiers, asteriskToken, name, questionToken, diagnostics.X_or_expected)
18201811
}
@@ -1825,13 +1816,11 @@ func (p *Parser) parseMethodDeclaration(pos int, hasJSDoc bool, modifiers *ast.M
18251816
signatureFlags := core.IfElse(asteriskToken != nil, ParseFlagsYield, ParseFlagsNone) | core.IfElse(modifierListHasAsync(modifiers), ParseFlagsAwait, ParseFlagsNone)
18261817
typeParameters := p.parseTypeParameters()
18271818
parameters := p.parseParameters(signatureFlags)
1828-
typeNode := p.checkNoJSTypeAnnotation(p.parseReturnType(ast.KindColonToken, false /*isType*/))
1819+
typeNode := p.parseReturnType(ast.KindColonToken, false /*isType*/)
18291820
body := p.parseFunctionBlockOrSemicolon(signatureFlags, diagnosticMessage)
18301821
result := p.finishNode(p.factory.NewMethodDeclaration(modifiers, asteriskToken, name, questionToken, typeParameters, parameters, typeNode, nil /*fullSignature*/, body), pos)
18311822
p.withJSDoc(result, hasJSDoc)
1832-
p.checkNoJSExtraModifiers(result)
1833-
p.checkNoJSTypeParameters(result)
1834-
p.checkNoJSSignature(result)
1823+
p.checkJSSyntax(result)
18351824
return result
18361825
}
18371826

@@ -1844,12 +1833,12 @@ func (p *Parser) parsePropertyDeclaration(pos int, hasJSDoc bool, modifiers *ast
18441833
if postfixToken == nil && !p.hasPrecedingLineBreak() {
18451834
postfixToken = p.parseOptionalToken(ast.KindExclamationToken)
18461835
}
1847-
typeNode := p.checkNoJSTypeAnnotation(p.parseTypeAnnotation())
1836+
typeNode := p.parseTypeAnnotation()
18481837
initializer := doInContext(p, ast.NodeFlagsYieldContext|ast.NodeFlagsAwaitContext|ast.NodeFlagsDisallowInContext, false, (*Parser).parseInitializer)
18491838
p.parseSemicolonAfterPropertyName(name, typeNode, initializer)
18501839
result := p.finishNode(p.factory.NewPropertyDeclaration(modifiers, name, postfixToken, typeNode, initializer), pos)
18511840
p.withJSDoc(result, hasJSDoc)
1852-
p.checkNoJSExtraModifiers(result)
1841+
p.checkJSSyntax(result)
18531842
return result
18541843
}
18551844

@@ -3175,12 +3164,8 @@ func (p *Parser) parseParametersWorker(flags ParseFlags, allowAmbiguity bool) *a
31753164
p.setContextFlags(ast.NodeFlagsAwaitContext, flags&ParseFlagsAwait != 0)
31763165
parameters := p.parseDelimitedList(PCParameters, func(p *Parser) *ast.Node {
31773166
parameter := p.parseParameterEx(inAwaitContext, allowAmbiguity)
3178-
if parameter != nil && parameter.Flags&ast.NodeFlagsJavaScriptFile != 0 && parameter.Flags&ast.NodeFlagsJSDoc == 0 && flags&ParseFlagsType == 0 {
3179-
if core.Some(parameter.ModifierNodes(), ast.IsModifier) {
3180-
p.jsErrorAtRange(parameter.Modifiers().Loc, diagnostics.Parameter_modifiers_can_only_be_used_in_TypeScript_files)
3181-
}
3182-
p.checkNoJSQuestionToken(parameter.PostfixToken())
3183-
p.checkNoJSTypeAnnotation(parameter.Type())
3167+
if parameter != nil && flags&ParseFlagsType == 0 {
3168+
p.checkJSSyntax(parameter)
31843169
}
31853170
return parameter
31863171
})
@@ -3317,10 +3302,7 @@ func (p *Parser) parseAccessorDeclaration(pos int, hasJSDoc bool, modifiers *ast
33173302
}
33183303
p.withJSDoc(p.finishNode(result, pos), hasJSDoc)
33193304
if flags&ParseFlagsType == 0 {
3320-
p.checkNoJSExtraModifiers(result)
3321-
p.checkNoJSTypeParameters(result)
3322-
p.checkNoJSTypeAnnotation(returnType)
3323-
p.checkNoJSSignature(result)
3305+
p.checkJSSyntax(result)
33243306
}
33253307
return result
33263308
}
@@ -4313,9 +4295,7 @@ func (p *Parser) parseParenthesizedArrowFunctionExpression(allowAmbiguity bool,
43134295
}
43144296
result := p.finishNode(p.factory.NewArrowFunction(modifiers, typeParameters, parameters, returnType, nil /*fullSignature*/, equalsGreaterThanToken, body), pos)
43154297
p.withJSDoc(result, hasJSDoc)
4316-
p.checkNoJSExtraModifiers(result)
4317-
p.checkNoJSTypeParameters(result)
4318-
p.checkNoJSTypeAnnotation(returnType)
4298+
p.checkJSSyntax(result)
43194299
return result
43204300
}
43214301

@@ -5344,7 +5324,7 @@ func (p *Parser) parseCallExpressionRest(pos int, expression *ast.Expression) *a
53445324
inner := expression
53455325
argumentList := p.parseArgumentList()
53465326
isOptionalChain := questionDotToken != nil || p.tryReparseOptionalChain(expression)
5347-
expression = p.checkNoJSTypeArguments(p.finishNode(p.factory.NewCallExpression(expression, questionDotToken, typeArguments, argumentList, core.IfElse(isOptionalChain, ast.NodeFlagsOptionalChain, ast.NodeFlagsNone)), pos))
5327+
expression = p.checkJSSyntax(p.finishNode(p.factory.NewCallExpression(expression, questionDotToken, typeArguments, argumentList, core.IfElse(isOptionalChain, ast.NodeFlagsOptionalChain, ast.NodeFlagsNone)), pos))
53485328
p.unparseExpressionWithTypeArguments(inner, typeArguments, expression)
53495329
continue
53505330
}
@@ -5396,7 +5376,7 @@ func (p *Parser) parseTaggedTemplateRest(pos int, tag *ast.Expression, questionD
53965376
template = p.parseTemplateExpression(true /*isTaggedTemplate*/)
53975377
}
53985378
isOptionalChain := questionDotToken != nil || tag.Flags&ast.NodeFlagsOptionalChain != 0
5399-
return p.checkNoJSTypeArguments(p.finishNode(p.factory.NewTaggedTemplateExpression(tag, questionDotToken, typeArguments, template, core.IfElse(isOptionalChain, ast.NodeFlagsOptionalChain, ast.NodeFlagsNone)), pos))
5379+
return p.checkJSSyntax(p.finishNode(p.factory.NewTaggedTemplateExpression(tag, questionDotToken, typeArguments, template, core.IfElse(isOptionalChain, ast.NodeFlagsOptionalChain, ast.NodeFlagsNone)), pos))
54005380
}
54015381

54025382
func (p *Parser) parseTemplateExpression(isTaggedTemplate bool) *ast.Expression {
@@ -5581,14 +5561,13 @@ func (p *Parser) parseFunctionExpression() *ast.Expression {
55815561
}
55825562
typeParameters := p.parseTypeParameters()
55835563
parameters := p.parseParameters(signatureFlags)
5584-
returnType := p.checkNoJSTypeAnnotation(p.parseReturnType(ast.KindColonToken, false /*isType*/))
5564+
returnType := p.parseReturnType(ast.KindColonToken, false /*isType*/)
55855565
body := p.parseFunctionBlock(signatureFlags, nil /*diagnosticMessage*/)
55865566
p.contextFlags = saveContexFlags
55875567
result := p.factory.NewFunctionExpression(modifiers, asteriskToken, name, typeParameters, parameters, returnType, nil /*fullSignature*/, body)
55885568
p.finishNode(result, pos)
55895569
p.withJSDoc(result, hasJSDoc)
5590-
p.checkNoJSExtraModifiers(result)
5591-
p.checkNoJSTypeParameters(result)
5570+
p.checkJSSyntax(result)
55925571
return result
55935572
}
55945573

@@ -5644,7 +5623,7 @@ func (p *Parser) parseNewExpressionOrNewDotTarget() *ast.Node {
56445623
if p.token == ast.KindOpenParenToken {
56455624
argumentList = p.parseArgumentList()
56465625
}
5647-
result := p.checkNoJSTypeArguments(p.finishNode(p.factory.NewNewExpression(expression, typeArguments, argumentList), pos))
5626+
result := p.checkJSSyntax(p.finishNode(p.factory.NewNewExpression(expression, typeArguments, argumentList), pos))
56485627
p.unparseExpressionWithTypeArguments(expression, typeArguments, result)
56495628
return result
56505629
}
@@ -6531,58 +6510,93 @@ func parseResolutionMode(mode string, pos int, end int /*reportDiagnostic: Pragm
65316510
// return undefined;
65326511
}
65336512

6534-
func (p *Parser) checkNoJSExtraModifiers(node *ast.Node) *ast.Node {
6535-
if node.Flags&ast.NodeFlagsJavaScriptFile != 0 && node.Flags&ast.NodeFlagsJSDoc == 0 {
6513+
func (p *Parser) jsErrorAtRange(loc core.TextRange, message *diagnostics.Message, args ...any) {
6514+
p.jsDiagnostics = append(p.jsDiagnostics, ast.NewDiagnostic(nil, core.NewTextRange(scanner.SkipTrivia(p.sourceText, loc.Pos()), loc.End()), message, args...))
6515+
}
6516+
6517+
func (p *Parser) checkJSSyntax(node *ast.Node) *ast.Node {
6518+
if node.Flags&ast.NodeFlagsJavaScriptFile == 0 || node.Flags&(ast.NodeFlagsJSDoc|ast.NodeFlagsReparsed) != 0 {
6519+
return node
6520+
}
6521+
switch node.Kind {
6522+
case ast.KindParameter, ast.KindPropertyDeclaration, ast.KindMethodDeclaration:
6523+
if token := node.PostfixToken(); token != nil && token.Flags&ast.NodeFlagsReparsed == 0 && ast.IsQuestionToken(token) {
6524+
p.jsErrorAtRange(token.Loc, diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files, "?")
6525+
}
6526+
fallthrough
6527+
case ast.KindMethodSignature, ast.KindConstructor, ast.KindGetAccessor, ast.KindSetAccessor, ast.KindFunctionExpression,
6528+
ast.KindFunctionDeclaration, ast.KindArrowFunction, ast.KindVariableDeclaration, ast.KindIndexSignature:
6529+
if ast.IsFunctionLike(node) && node.Body() == nil {
6530+
p.jsErrorAtRange(node.Loc, diagnostics.Signature_declarations_can_only_be_used_in_TypeScript_files)
6531+
} else if t := node.Type(); t != nil && t.Flags&ast.NodeFlagsReparsed == 0 {
6532+
p.jsErrorAtRange(t.Loc, diagnostics.Type_annotations_can_only_be_used_in_TypeScript_files)
6533+
}
6534+
case ast.KindImportDeclaration:
6535+
if clause := node.AsImportDeclaration().ImportClause; clause != nil && clause.IsTypeOnly() {
6536+
p.jsErrorAtRange(node.Loc, diagnostics.X_0_declarations_can_only_be_used_in_TypeScript_files, "import type")
6537+
}
6538+
case ast.KindExportDeclaration:
6539+
if node.IsTypeOnly() {
6540+
p.jsErrorAtRange(node.Loc, diagnostics.X_0_declarations_can_only_be_used_in_TypeScript_files, "export type")
6541+
}
6542+
case ast.KindImportSpecifier:
6543+
if node.IsTypeOnly() {
6544+
p.jsErrorAtRange(node.Loc, diagnostics.X_0_declarations_can_only_be_used_in_TypeScript_files, "import...type")
6545+
}
6546+
case ast.KindExportSpecifier:
6547+
if node.IsTypeOnly() {
6548+
p.jsErrorAtRange(node.Loc, diagnostics.X_0_declarations_can_only_be_used_in_TypeScript_files, "export...type")
6549+
}
6550+
case ast.KindImportEqualsDeclaration:
6551+
p.jsErrorAtRange(node.Loc, diagnostics.X_import_can_only_be_used_in_TypeScript_files)
6552+
case ast.KindExportAssignment:
6553+
if node.AsExportAssignment().IsExportEquals {
6554+
p.jsErrorAtRange(node.Loc, diagnostics.X_export_can_only_be_used_in_TypeScript_files)
6555+
}
6556+
case ast.KindHeritageClause:
6557+
if node.AsHeritageClause().Token == ast.KindImplementsKeyword {
6558+
p.jsErrorAtRange(node.Loc, diagnostics.X_implements_clauses_can_only_be_used_in_TypeScript_files)
6559+
}
6560+
case ast.KindInterfaceDeclaration:
6561+
p.jsErrorAtRange(node.Loc, diagnostics.X_0_declarations_can_only_be_used_in_TypeScript_files, "interface")
6562+
case ast.KindModuleDeclaration:
6563+
p.jsErrorAtRange(node.Loc, diagnostics.X_0_declarations_can_only_be_used_in_TypeScript_files, scanner.TokenToString(node.AsModuleDeclaration().Keyword))
6564+
case ast.KindTypeAliasDeclaration:
6565+
p.jsErrorAtRange(node.Loc, diagnostics.Type_aliases_can_only_be_used_in_TypeScript_files)
6566+
case ast.KindEnumDeclaration:
6567+
p.jsErrorAtRange(node.Loc, diagnostics.X_0_declarations_can_only_be_used_in_TypeScript_files, "enum")
6568+
case ast.KindNonNullExpression:
6569+
p.jsErrorAtRange(node.Loc, diagnostics.Non_null_assertions_can_only_be_used_in_TypeScript_files)
6570+
case ast.KindAsExpression:
6571+
p.jsErrorAtRange(node.Type().Loc, diagnostics.Type_assertion_expressions_can_only_be_used_in_TypeScript_files)
6572+
case ast.KindSatisfiesExpression:
6573+
p.jsErrorAtRange(node.Type().Loc, diagnostics.Type_satisfaction_expressions_can_only_be_used_in_TypeScript_files)
6574+
}
6575+
// Check absence of type parameters, type arguments and non-JavaScript modifiers
6576+
switch node.Kind {
6577+
case ast.KindClassDeclaration, ast.KindClassExpression, ast.KindMethodDeclaration, ast.KindConstructor, ast.KindGetAccessor,
6578+
ast.KindSetAccessor, ast.KindFunctionExpression, ast.KindFunctionDeclaration, ast.KindArrowFunction:
6579+
if list := node.TypeParameterList(); list != nil && core.Some(list.Nodes, func(n *ast.Node) bool { return n.Flags&ast.NodeFlagsReparsed == 0 }) {
6580+
p.jsErrorAtRange(list.Loc, diagnostics.Type_parameter_declarations_can_only_be_used_in_TypeScript_files)
6581+
}
6582+
fallthrough
6583+
case ast.KindVariableStatement, ast.KindPropertyDeclaration:
65366584
if modifiers := node.Modifiers(); modifiers != nil {
65376585
for _, modifier := range modifiers.Nodes {
65386586
if modifier.Flags&ast.NodeFlagsReparsed == 0 && modifier.Kind != ast.KindDecorator && ast.ModifierToFlag(modifier.Kind)&ast.ModifierFlagsJavaScript == 0 {
65396587
p.jsErrorAtRange(modifier.Loc, diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files, scanner.TokenToString(modifier.Kind))
65406588
}
65416589
}
65426590
}
6543-
}
6544-
return node
6545-
}
6546-
6547-
func (p *Parser) checkNoJSQuestionToken(node *ast.Node) *ast.Node {
6548-
if node != nil && node.Flags&ast.NodeFlagsJavaScriptFile != 0 && node.Flags&ast.NodeFlagsJSDoc == 0 {
6549-
p.jsErrorAtRange(node.Loc, diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files, "?")
6550-
}
6551-
return node
6552-
}
6553-
6554-
func (p *Parser) checkNoJSTypeParameters(node *ast.Node) *ast.Node {
6555-
if node.Flags&ast.NodeFlagsJavaScriptFile != 0 && node.Flags&ast.NodeFlagsJSDoc == 0 && node.TypeParameterList() != nil {
6556-
if list := node.TypeParameterList(); list != nil && core.Some(list.Nodes, func(n *ast.Node) bool { return n.Flags&ast.NodeFlagsReparsed == 0 }) {
6557-
p.jsErrorAtRange(list.Loc, diagnostics.Type_parameter_declarations_can_only_be_used_in_TypeScript_files)
6591+
case ast.KindParameter:
6592+
if core.Some(node.ModifierNodes(), ast.IsModifier) {
6593+
p.jsErrorAtRange(node.Modifiers().Loc, diagnostics.Parameter_modifiers_can_only_be_used_in_TypeScript_files)
65586594
}
6559-
}
6560-
return node
6561-
}
6562-
6563-
func (p *Parser) checkNoJSTypeAnnotation(node *ast.Node) *ast.Node {
6564-
if node != nil && node.Flags&ast.NodeFlagsJavaScriptFile != 0 && node.Flags&ast.NodeFlagsJSDoc == 0 {
6565-
p.jsErrorAtRange(node.Loc, diagnostics.Type_annotations_can_only_be_used_in_TypeScript_files)
6566-
}
6567-
return node
6568-
}
6569-
6570-
func (p *Parser) checkNoJSTypeArguments(node *ast.Node) *ast.Node {
6571-
if node.Flags&ast.NodeFlagsJavaScriptFile != 0 && node.Flags&ast.NodeFlagsJSDoc == 0 && node.TypeArgumentList() != nil {
6595+
case ast.KindCallExpression, ast.KindNewExpression, ast.KindExpressionWithTypeArguments, ast.KindJsxSelfClosingElement,
6596+
ast.KindJsxOpeningElement, ast.KindTaggedTemplateExpression:
65726597
if list := node.TypeArgumentList(); list != nil && core.Some(list.Nodes, func(n *ast.Node) bool { return n.Flags&ast.NodeFlagsReparsed == 0 }) {
65736598
p.jsErrorAtRange(list.Loc, diagnostics.Type_arguments_can_only_be_used_in_TypeScript_files)
65746599
}
65756600
}
65766601
return node
65776602
}
6578-
6579-
func (p *Parser) checkNoJSSignature(node *ast.Node) *ast.Node {
6580-
if node.Flags&ast.NodeFlagsJavaScriptFile != 0 && node.Flags&ast.NodeFlagsJSDoc == 0 && node.Body() == nil {
6581-
p.jsErrorAtRange(core.OrElse(node.Name(), node).Loc, diagnostics.Signature_declarations_can_only_be_used_in_TypeScript_files)
6582-
}
6583-
return node
6584-
}
6585-
6586-
func (p *Parser) jsErrorAtRange(loc core.TextRange, message *diagnostics.Message, args ...any) {
6587-
p.jsDiagnostics = append(p.jsDiagnostics, ast.NewDiagnostic(nil, core.NewTextRange(scanner.SkipTrivia(p.sourceText, loc.Pos()), loc.End()), message, args...))
6588-
}

0 commit comments

Comments
 (0)