param_names

var ParamNamesRule = rule.Rule{
	Name: "promise/param-names",
	Run: func(ctx rule.RuleContext, options any) rule.RuleListeners {
		opts := parseOptions(options)
		// ECMAScript + Unicode flags mirror ESLint's `new RegExp(pattern, 'u')`
		// so user patterns using lookaround, backreferences, or `\p{...}` work
		// identically to the original rule (Go's standard `regexp` / RE2 does not).
		const reOpts = regexp2.ECMAScript | regexp2.Unicode
		resolveRe, err := regexp2.Compile(opts.ResolvePattern, reOpts)
		if err != nil {
			return rule.RuleListeners{}
		}
		rejectRe, err := regexp2.Compile(opts.RejectPattern, reOpts)
		if err != nil {
			return rule.RuleListeners{}
		}

		return rule.RuleListeners{
			ast.KindNewExpression: func(node *ast.Node) {
				callee := ast.SkipOuterExpressions(node.AsNewExpression().Expression, skipTransparent)
				if callee == nil || !ast.IsIdentifier(callee) || callee.AsIdentifier().Text != "Promise" {
					return
				}
				args := node.Arguments()
				if len(args) != 1 {
					return
				}
				executor := ast.SkipOuterExpressions(args[0], skipTransparent)
				if executor == nil || !ast.IsFunctionExpressionOrArrowFunction(executor) {
					return
				}

				params := make([]*ast.Node, 0, len(executor.Parameters()))
				for _, p := range executor.Parameters() {
					if !ast.IsThisParameter(p) {
						params = append(params, p)
					}
				}
				if len(params) == 0 {
					return
				}

				if resolveName := paramName(params[0]); resolveName != "" && !regexMatch(resolveRe, resolveName) {
					ctx.ReportNode(params[0], buildResolveParamNamesMessage(opts.ResolvePattern))
				}
				if len(params) >= 2 {
					if rejectName := paramName(params[1]); rejectName != "" && !regexMatch(rejectRe, rejectName) {
						ctx.ReportNode(params[1], buildRejectParamNamesMessage(opts.RejectPattern))
					}
				}
			},
		}
	},
}