Port Regular Expressions checking

internal/checker/checker.go

@@ -680,6 +680,7 @@ type Checker struct {
 	markedAssignmentSymbolLinks                 core.LinkStore[*ast.Symbol, MarkedAssignmentSymbolLinks]
 	symbolContainerLinks                        core.LinkStore[*ast.Symbol, ContainingSymbolLinks]
 	sourceFileLinks                             core.LinkStore[*ast.SourceFile, SourceFileLinks]
+	regExpScanner                               *scanner.Scanner
 	patternForType                              map[*Type]*ast.Node
 	contextFreeTypes                            map[*ast.Node]*Type
 	anyType                                     *Type

internal/checker/grammarchecks.go

@@ -54,43 +54,34 @@ func (c *Checker) grammarErrorOnNodeSkippedOnNoEmit(node *ast.Node, message *dia
 	return false
 }
 
-func (c *Checker) checkGrammarRegularExpressionLiteral(_ *ast.RegularExpressionLiteral) bool {
-	// !!!
-	// Unclear if this is needed until regular expression parsing is more thoroughly implemented.
+func (c *Checker) checkGrammarRegularExpressionLiteral(node *ast.RegularExpressionLiteral) bool {
+	sourceFile := ast.GetSourceFileOfNode(node.AsNode())
+	if !c.hasParseDiagnostics(sourceFile) {
+		var lastError *ast.Diagnostic
+		if c.regExpScanner == nil {
+			c.regExpScanner = scanner.NewScanner()
+		}
+		c.regExpScanner.SetScriptTarget(c.languageVersion)
+		c.regExpScanner.SetLanguageVariant(sourceFile.LanguageVariant)
+		c.regExpScanner.SetOnError(func(message *diagnostics.Message, start int, length int, args ...any) {
+			if message.Category() == diagnostics.CategoryMessage && lastError != nil && start == lastError.Pos() && length == lastError.Len() {
+				err := ast.NewDiagnostic(nil, core.NewTextRange(start, start+length), message, args...)
+				lastError.AddRelatedInfo(err)
+			} else if lastError == nil || start != lastError.Pos() {
+				lastError = ast.NewDiagnostic(sourceFile, core.NewTextRange(start, start+length), message, args...)
+				c.diagnostics.Add(lastError)
+			}
+		})
+		c.regExpScanner.SetText(sourceFile.Text())
+		c.regExpScanner.ResetTokenState(node.AsNode().Pos())
+		c.regExpScanner.Scan()
+		tokenIsRegularExpressionLiteral := c.regExpScanner.ReScanSlashToken(true) == ast.KindRegularExpressionLiteral
+		c.regExpScanner.SetText("")
+		c.regExpScanner.SetOnError(nil)
+		debug.Assert(tokenIsRegularExpressionLiteral)
+		return lastError != nil
+	}
 	return false
-	// sourceFile := ast.GetSourceFileOfNode(node.AsNode())
-	// if !c.hasParseDiagnostics(sourceFile) && !node.IsUnterminated {
-	// 	var lastError *ast.Diagnostic
-	// 	scanner := NewScanner()
-	// 	scanner.skipTrivia = true
-	// 	scanner.SetScriptTarget(sourceFile.LanguageVersion)
-	// 	scanner.SetLanguageVariant(sourceFile.LanguageVariant)
-	// 	scanner.SetOnError(func(message *diagnostics.Message, start int, length int, args ...any) {
-	// 		// !!!
-	// 		// Original uses `tokenEnd()` - unclear if this is the same as the `start` passed in here.
-	// 		// const start = scanner.TokenEnd()
-
-	// 		// The scanner is operating on a slice of the original source text, so we need to adjust the start
-	// 		// for error reporting.
-	// 		start = start + node.Pos()
-
-	// 		// For providing spelling suggestions
-	// 		if message.Category() == diagnostics.CategoryMessage && lastError != nil && start == lastError.Pos() && length == lastError.Len() {
-	// 			err := ast.NewDiagnostic(sourceFile, core.NewTextRange(start, start+length), message, args)
-	// 			lastError.AddRelatedInfo(err)
-	// 		} else if !(lastError != nil) || start != lastError.Pos() {
-	// 			lastError = ast.NewDiagnostic(sourceFile, core.NewTextRange(start, start+length), message, args)
-	// 			c.diagnostics.Add(lastError)
-	// 		}
-	// 	})
-	// 	scanner.SetText(sourceFile.Text[node.Pos():node.Loc.Len()])
-	// 	scanner.Scan()
-	// 	if scanner.ReScanSlashToken() != ast.KindRegularExpressionLiteral {
-	// 		panic("Expected to rescan RegularExpressionLiteral")
-	// 	}
-	// 	return lastError != nil
-	// }
-	// return false
 }
 
 func (c *Checker) checkGrammarPrivateIdentifierExpression(privId *ast.PrivateIdentifier) bool {

internal/checker/types.go

@@ -1256,6 +1256,8 @@ const (
 type TypeComparer func(s *Type, t *Type, reportErrors bool) Ternary
 
 type LanguageFeatureMinimumTargetMap struct {
+	RegularExpressionFlagsUnicode     core.ScriptTarget
+	RegularExpressionFlagsSticky      core.ScriptTarget
 	Exponentiation                    core.ScriptTarget
 	AsyncFunctions                    core.ScriptTarget
 	ForAwaitOf                        core.ScriptTarget
@@ -1279,6 +1281,8 @@ type LanguageFeatureMinimumTargetMap struct {
 }
 
 var LanguageFeatureMinimumTarget = LanguageFeatureMinimumTargetMap{
+	RegularExpressionFlagsUnicode:     core.ScriptTargetES2015,
+	RegularExpressionFlagsSticky:      core.ScriptTargetES2015,
 	Exponentiation:                    core.ScriptTargetES2016,
 	AsyncFunctions:                    core.ScriptTargetES2017,
 	ForAwaitOf:                        core.ScriptTargetES2018,

internal/parser/parser.go

@@ -254,6 +254,13 @@ func (p *Parser) scanError(message *diagnostics.Message, pos int, length int, ar
 	p.parseErrorAtRange(core.NewTextRange(pos, pos+length), message, args...)
 }
 
+func (p *Parser) lastDiagnostic() *ast.Diagnostic {
+	if len(p.diagnostics) > 0 {
+		return p.diagnostics[len(p.diagnostics)-1]
+	}
+	return nil
+}
+
 func (p *Parser) parseErrorAt(pos int, end int, message *diagnostics.Message, args ...any) *ast.Diagnostic {
 	return p.parseErrorAtRange(core.NewTextRange(pos, end), message, args...)
 }