no_invalid_regexp

var NoInvalidRegexpRule = rule.Rule{
	Name: "no-invalid-regexp",
	Run: func(ctx rule.RuleContext, options any) rule.RuleListeners {
		opts := parseOptions(options)

		report := func(node *ast.Node, msg string) {
			ctx.ReportNode(node, rule.RuleMessage{
				Id:          "regexMessage",
				Description: msg + ".",
			})
		}

		check := func(node *ast.Node, callee *ast.Node, args *ast.NodeList) {
			callee = ast.SkipParentheses(callee)
			if callee == nil || callee.Kind != ast.KindIdentifier {
				return
			}
			if callee.AsIdentifier().Text != "RegExp" {
				return
			}

			if args == nil || len(args.Nodes) == 0 {
				return
			}

			// Get flags (second argument)
			var flags *string // nil means unknown (non-literal)
			if len(args.Nodes) >= 2 {
				flagsNode := args.Nodes[1]
				if flagsNode.Kind == ast.KindStringLiteral {
					f := flagsNode.AsStringLiteral().Text
					flags = &f
				}
			} else {
				empty := ""
				flags = &empty
			}

			if flags != nil {
				if msg := validateFlags(*flags, opts.allowConstructorFlags); msg != "" {
					report(node, msg)
					return
				}
			}

			patternNode := args.Nodes[0]
			if patternNode.Kind != ast.KindStringLiteral {
				return
			}
			pattern := patternNode.AsStringLiteral().Text

			if flags != nil {

				if msg := validatePattern(pattern, *flags); msg != "" {
					report(node, msg)
				}
			} else {

				msg1 := validatePattern(pattern, "u")
				msg2 := validatePattern(pattern, "v")
				msg3 := validatePattern(pattern, "")
				if msg1 != "" && msg2 != "" && msg3 != "" {
					report(node, msg3)
				}
			}
		}

		return rule.RuleListeners{
			ast.KindCallExpression: func(node *ast.Node) {
				callExpr := node.AsCallExpression()
				check(node, callExpr.Expression, callExpr.Arguments)
			},
			ast.KindNewExpression: func(node *ast.Node) {
				newExpr := node.AsNewExpression()
				check(node, newExpr.Expression, newExpr.Arguments)
			},
		}
	},
}