Update dependencies (#5518)

vendor/github.com/open-policy-agent/opa/topdown/strings.go

@@ -112,16 +112,16 @@ func anyStartsWithAny(strs []string, prefixes []string) bool {
 	return false
 }
 
-func builtinFormatInt(a, b ast.Value) (ast.Value, error) {
+func builtinFormatInt(_ BuiltinContext, operands []*ast.Term, iter func(*ast.Term) error) error {
 
-	input, err := builtins.NumberOperand(a, 1)
+	input, err := builtins.NumberOperand(operands[0].Value, 1)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	base, err := builtins.NumberOperand(b, 2)
+	base, err := builtins.NumberOperand(operands[1].Value, 2)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	var format string
@@ -135,54 +135,54 @@ func builtinFormatInt(a, b ast.Value) (ast.Value, error) {
 	case ast.Number("16"):
 		format = "%x"
 	default:
-		return nil, builtins.NewOperandEnumErr(2, "2", "8", "10", "16")
+		return builtins.NewOperandEnumErr(2, "2", "8", "10", "16")
 	}
 
 	f := builtins.NumberToFloat(input)
 	i, _ := f.Int(nil)
 
-	return ast.String(fmt.Sprintf(format, i)), nil
+	return iter(ast.StringTerm(fmt.Sprintf(format, i)))
 }
 
-func builtinConcat(a, b ast.Value) (ast.Value, error) {
+func builtinConcat(_ BuiltinContext, operands []*ast.Term, iter func(*ast.Term) error) error {
 
-	join, err := builtins.StringOperand(a, 1)
+	join, err := builtins.StringOperand(operands[0].Value, 1)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	strs := []string{}
 
-	switch b := b.(type) {
+	switch b := operands[1].Value.(type) {
 	case *ast.Array:
 		err := b.Iter(func(x *ast.Term) error {
 			s, ok := x.Value.(ast.String)
 			if !ok {
-				return builtins.NewOperandElementErr(2, b, x.Value, "string")
+				return builtins.NewOperandElementErr(2, operands[1].Value, x.Value, "string")
 			}
 			strs = append(strs, string(s))
 			return nil
 		})
 		if err != nil {
-			return nil, err
+			return err
 		}
 	case ast.Set:
 		err := b.Iter(func(x *ast.Term) error {
 			s, ok := x.Value.(ast.String)
 			if !ok {
-				return builtins.NewOperandElementErr(2, b, x.Value, "string")
+				return builtins.NewOperandElementErr(2, operands[1].Value, x.Value, "string")
 			}
 			strs = append(strs, string(s))
 			return nil
 		})
 		if err != nil {
-			return nil, err
+			return err
 		}
 	default:
-		return nil, builtins.NewOperandTypeErr(2, b, "set", "array")
+		return builtins.NewOperandTypeErr(2, operands[1].Value, "set", "array")
 	}
 
-	return ast.String(strings.Join(strs, string(join))), nil
+	return iter(ast.StringTerm(strings.Join(strs, string(join))))
 }
 
 func runesEqual(a, b []rune) bool {
@@ -197,18 +197,18 @@ func runesEqual(a, b []rune) bool {
 	return true
 }
 
-func builtinIndexOf(a, b ast.Value) (ast.Value, error) {
-	base, err := builtins.StringOperand(a, 1)
+func builtinIndexOf(_ BuiltinContext, operands []*ast.Term, iter func(*ast.Term) error) error {
+	base, err := builtins.StringOperand(operands[0].Value, 1)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	search, err := builtins.StringOperand(b, 2)
+	search, err := builtins.StringOperand(operands[1].Value, 2)
 	if err != nil {
-		return nil, err
+		return err
 	}
 	if len(string(search)) == 0 {
-		return nil, fmt.Errorf("empty search character")
+		return fmt.Errorf("empty search character")
 	}
 
 	baseRunes := []rune(string(base))
@@ -218,28 +218,28 @@ func builtinIndexOf(a, b ast.Value) (ast.Value, error) {
 	for i, r := range baseRunes {
 		if len(baseRunes) >= i+searchLen {
 			if r == searchRunes[0] && runesEqual(baseRunes[i:i+searchLen], searchRunes) {
-				return ast.IntNumberTerm(i).Value, nil
+				return iter(ast.IntNumberTerm(i))
 			}
 		} else {
 			break
 		}
 	}
 
-	return ast.IntNumberTerm(-1).Value, nil
+	return iter(ast.IntNumberTerm(-1))
 }
 
-func builtinIndexOfN(a, b ast.Value) (ast.Value, error) {
-	base, err := builtins.StringOperand(a, 1)
+func builtinIndexOfN(_ BuiltinContext, operands []*ast.Term, iter func(*ast.Term) error) error {
+	base, err := builtins.StringOperand(operands[0].Value, 1)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	search, err := builtins.StringOperand(b, 2)
+	search, err := builtins.StringOperand(operands[1].Value, 2)
 	if err != nil {
-		return nil, err
+		return err
 	}
 	if len(string(search)) == 0 {
-		return nil, fmt.Errorf("empty search character")
+		return fmt.Errorf("empty search character")
 	}
 
 	baseRunes := []rune(string(base))
@@ -257,29 +257,29 @@ func builtinIndexOfN(a, b ast.Value) (ast.Value, error) {
 		}
 	}
 
-	return ast.NewArray(arr...), nil
+	return iter(ast.ArrayTerm(arr...))
 }
 
-func builtinSubstring(a, b, c ast.Value) (ast.Value, error) {
+func builtinSubstring(_ BuiltinContext, operands []*ast.Term, iter func(*ast.Term) error) error {
 
-	base, err := builtins.StringOperand(a, 1)
+	base, err := builtins.StringOperand(operands[0].Value, 1)
 	if err != nil {
-		return nil, err
+		return err
 	}
 	runes := []rune(base)
 
-	startIndex, err := builtins.IntOperand(b, 2)
+	startIndex, err := builtins.IntOperand(operands[1].Value, 2)
 	if err != nil {
-		return nil, err
+		return err
 	} else if startIndex >= len(runes) {
-		return ast.String(""), nil
+		return iter(ast.StringTerm(""))
 	} else if startIndex < 0 {
-		return nil, fmt.Errorf("negative offset")
+		return fmt.Errorf("negative offset")
 	}
 
-	length, err := builtins.IntOperand(c, 3)
+	length, err := builtins.IntOperand(operands[2].Value, 3)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	var s ast.String
@@ -293,229 +293,229 @@ func builtinSubstring(a, b, c ast.Value) (ast.Value, error) {
 		s = ast.String(runes[startIndex:upto])
 	}
 
-	return s, nil
+	return iter(ast.NewTerm(s))
 }
 
-func builtinContains(a, b ast.Value) (ast.Value, error) {
-	s, err := builtins.StringOperand(a, 1)
+func builtinContains(_ BuiltinContext, operands []*ast.Term, iter func(*ast.Term) error) error {
+	s, err := builtins.StringOperand(operands[0].Value, 1)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	substr, err := builtins.StringOperand(b, 2)
+	substr, err := builtins.StringOperand(operands[1].Value, 2)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	return ast.Boolean(strings.Contains(string(s), string(substr))), nil
+	return iter(ast.BooleanTerm(strings.Contains(string(s), string(substr))))
 }
 
-func builtinStartsWith(a, b ast.Value) (ast.Value, error) {
-	s, err := builtins.StringOperand(a, 1)
+func builtinStartsWith(_ BuiltinContext, operands []*ast.Term, iter func(*ast.Term) error) error {
+	s, err := builtins.StringOperand(operands[0].Value, 1)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	prefix, err := builtins.StringOperand(b, 2)
+	prefix, err := builtins.StringOperand(operands[1].Value, 2)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	return ast.Boolean(strings.HasPrefix(string(s), string(prefix))), nil
+	return iter(ast.BooleanTerm(strings.HasPrefix(string(s), string(prefix))))
 }
 
-func builtinEndsWith(a, b ast.Value) (ast.Value, error) {
-	s, err := builtins.StringOperand(a, 1)
+func builtinEndsWith(_ BuiltinContext, operands []*ast.Term, iter func(*ast.Term) error) error {
+	s, err := builtins.StringOperand(operands[0].Value, 1)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	suffix, err := builtins.StringOperand(b, 2)
+	suffix, err := builtins.StringOperand(operands[1].Value, 2)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	return ast.Boolean(strings.HasSuffix(string(s), string(suffix))), nil
+	return iter(ast.BooleanTerm(strings.HasSuffix(string(s), string(suffix))))
 }
 
-func builtinLower(a ast.Value) (ast.Value, error) {
-	s, err := builtins.StringOperand(a, 1)
+func builtinLower(_ BuiltinContext, operands []*ast.Term, iter func(*ast.Term) error) error {
+	s, err := builtins.StringOperand(operands[0].Value, 1)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	return ast.String(strings.ToLower(string(s))), nil
+	return iter(ast.StringTerm(strings.ToLower(string(s))))
 }
 
-func builtinUpper(a ast.Value) (ast.Value, error) {
-	s, err := builtins.StringOperand(a, 1)
+func builtinUpper(_ BuiltinContext, operands []*ast.Term, iter func(*ast.Term) error) error {
+	s, err := builtins.StringOperand(operands[0].Value, 1)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	return ast.String(strings.ToUpper(string(s))), nil
+	return iter(ast.StringTerm(strings.ToUpper(string(s))))
 }
 
-func builtinSplit(a, b ast.Value) (ast.Value, error) {
-	s, err := builtins.StringOperand(a, 1)
+func builtinSplit(_ BuiltinContext, operands []*ast.Term, iter func(*ast.Term) error) error {
+	s, err := builtins.StringOperand(operands[0].Value, 1)
 	if err != nil {
-		return nil, err
+		return err
 	}
-	d, err := builtins.StringOperand(b, 2)
+	d, err := builtins.StringOperand(operands[1].Value, 2)
 	if err != nil {
-		return nil, err
+		return err
 	}
 	elems := strings.Split(string(s), string(d))
 	arr := make([]*ast.Term, len(elems))
 	for i := range elems {
 		arr[i] = ast.StringTerm(elems[i])
 	}
-	return ast.NewArray(arr...), nil
+	return iter(ast.ArrayTerm(arr...))
 }
 
-func builtinReplace(a, b, c ast.Value) (ast.Value, error) {
-	s, err := builtins.StringOperand(a, 1)
+func builtinReplace(_ BuiltinContext, operands []*ast.Term, iter func(*ast.Term) error) error {
+	s, err := builtins.StringOperand(operands[0].Value, 1)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	old, err := builtins.StringOperand(b, 2)
+	old, err := builtins.StringOperand(operands[1].Value, 2)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	new, err := builtins.StringOperand(c, 3)
+	new, err := builtins.StringOperand(operands[2].Value, 3)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	return ast.String(strings.Replace(string(s), string(old), string(new), -1)), nil
+	return iter(ast.StringTerm(strings.Replace(string(s), string(old), string(new), -1)))
 }
 
-func builtinReplaceN(a, b ast.Value) (ast.Value, error) {
-	patterns, err := builtins.ObjectOperand(a, 1)
+func builtinReplaceN(_ BuiltinContext, operands []*ast.Term, iter func(*ast.Term) error) error {
+	patterns, err := builtins.ObjectOperand(operands[0].Value, 1)
 	if err != nil {
-		return nil, err
+		return err
 	}
 	keys := patterns.Keys()
 	sort.Slice(keys, func(i, j int) bool { return ast.Compare(keys[i].Value, keys[j].Value) < 0 })
 
-	s, err := builtins.StringOperand(b, 2)
+	s, err := builtins.StringOperand(operands[1].Value, 2)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	oldnewArr := make([]string, 0, len(keys)*2)
 	for _, k := range keys {
 		keyVal, ok := k.Value.(ast.String)
 		if !ok {
-			return nil, builtins.NewOperandErr(1, "non-string key found in pattern object")
+			return builtins.NewOperandErr(1, "non-string key found in pattern object")
 		}
 		val := patterns.Get(k) // cannot be nil
 		strVal, ok := val.Value.(ast.String)
 		if !ok {
-			return nil, builtins.NewOperandErr(1, "non-string value found in pattern object")
+			return builtins.NewOperandErr(1, "non-string value found in pattern object")
 		}
 		oldnewArr = append(oldnewArr, string(keyVal), string(strVal))
 	}
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	r := strings.NewReplacer(oldnewArr...)
 	replaced := r.Replace(string(s))
 
-	return ast.String(replaced), nil
+	return iter(ast.StringTerm(replaced))
 }
 
-func builtinTrim(a, b ast.Value) (ast.Value, error) {
-	s, err := builtins.StringOperand(a, 1)
+func builtinTrim(_ BuiltinContext, operands []*ast.Term, iter func(*ast.Term) error) error {
+	s, err := builtins.StringOperand(operands[0].Value, 1)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	c, err := builtins.StringOperand(b, 2)
+	c, err := builtins.StringOperand(operands[1].Value, 2)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	return ast.String(strings.Trim(string(s), string(c))), nil
+	return iter(ast.StringTerm(strings.Trim(string(s), string(c))))
 }
 
-func builtinTrimLeft(a, b ast.Value) (ast.Value, error) {
-	s, err := builtins.StringOperand(a, 1)
+func builtinTrimLeft(_ BuiltinContext, operands []*ast.Term, iter func(*ast.Term) error) error {
+	s, err := builtins.StringOperand(operands[0].Value, 1)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	c, err := builtins.StringOperand(b, 2)
+	c, err := builtins.StringOperand(operands[1].Value, 2)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	return ast.String(strings.TrimLeft(string(s), string(c))), nil
+	return iter(ast.StringTerm(strings.TrimLeft(string(s), string(c))))
 }
 
-func builtinTrimPrefix(a, b ast.Value) (ast.Value, error) {
-	s, err := builtins.StringOperand(a, 1)
+func builtinTrimPrefix(_ BuiltinContext, operands []*ast.Term, iter func(*ast.Term) error) error {
+	s, err := builtins.StringOperand(operands[0].Value, 1)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	pre, err := builtins.StringOperand(b, 2)
+	pre, err := builtins.StringOperand(operands[1].Value, 2)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	return ast.String(strings.TrimPrefix(string(s), string(pre))), nil
+	return iter(ast.StringTerm(strings.TrimPrefix(string(s), string(pre))))
 }
 
-func builtinTrimRight(a, b ast.Value) (ast.Value, error) {
-	s, err := builtins.StringOperand(a, 1)
+func builtinTrimRight(_ BuiltinContext, operands []*ast.Term, iter func(*ast.Term) error) error {
+	s, err := builtins.StringOperand(operands[0].Value, 1)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	c, err := builtins.StringOperand(b, 2)
+	c, err := builtins.StringOperand(operands[1].Value, 2)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	return ast.String(strings.TrimRight(string(s), string(c))), nil
+	return iter(ast.StringTerm(strings.TrimRight(string(s), string(c))))
 }
 
-func builtinTrimSuffix(a, b ast.Value) (ast.Value, error) {
-	s, err := builtins.StringOperand(a, 1)
+func builtinTrimSuffix(_ BuiltinContext, operands []*ast.Term, iter func(*ast.Term) error) error {
+	s, err := builtins.StringOperand(operands[0].Value, 1)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	suf, err := builtins.StringOperand(b, 2)
+	suf, err := builtins.StringOperand(operands[1].Value, 2)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	return ast.String(strings.TrimSuffix(string(s), string(suf))), nil
+	return iter(ast.StringTerm(strings.TrimSuffix(string(s), string(suf))))
 }
 
-func builtinTrimSpace(a ast.Value) (ast.Value, error) {
-	s, err := builtins.StringOperand(a, 1)
+func builtinTrimSpace(_ BuiltinContext, operands []*ast.Term, iter func(*ast.Term) error) error {
+	s, err := builtins.StringOperand(operands[0].Value, 1)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	return ast.String(strings.TrimSpace(string(s))), nil
+	return iter(ast.StringTerm(strings.TrimSpace(string(s))))
 }
 
-func builtinSprintf(a, b ast.Value) (ast.Value, error) {
-	s, err := builtins.StringOperand(a, 1)
+func builtinSprintf(_ BuiltinContext, operands []*ast.Term, iter func(*ast.Term) error) error {
+	s, err := builtins.StringOperand(operands[0].Value, 1)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	astArr, ok := b.(*ast.Array)
+	astArr, ok := operands[1].Value.(*ast.Array)
 	if !ok {
-		return nil, builtins.NewOperandTypeErr(2, b, "array")
+		return builtins.NewOperandTypeErr(2, operands[1].Value, "array")
 	}
 
 	args := make([]interface{}, astArr.Len())
@@ -539,10 +539,10 @@ func builtinSprintf(a, b ast.Value) (ast.Value, error) {
 		}
 	}
 
-	return ast.String(fmt.Sprintf(string(s), args...)), nil
+	return iter(ast.StringTerm(fmt.Sprintf(string(s), args...)))
 }
 
-func builtinReverse(bctx BuiltinContext, operands []*ast.Term, iter func(*ast.Term) error) error {
+func builtinReverse(_ BuiltinContext, operands []*ast.Term, iter func(*ast.Term) error) error {
 	s, err := builtins.StringOperand(operands[0].Value, 1)
 	if err != nil {
 		return err
@@ -552,7 +552,7 @@ func builtinReverse(bctx BuiltinContext, operands []*ast.Term, iter func(*ast.Te
 }
 
 func reverseString(str string) string {
-	sRunes := []rune(string(str))
+	sRunes := []rune(str)
 	length := len(sRunes)
 	reversedRunes := make([]rune, length)
 
@@ -564,26 +564,26 @@ func reverseString(str string) string {
 }
 
 func init() {
-	RegisterFunctionalBuiltin2(ast.FormatInt.Name, builtinFormatInt)
-	RegisterFunctionalBuiltin2(ast.Concat.Name, builtinConcat)
-	RegisterFunctionalBuiltin2(ast.IndexOf.Name, builtinIndexOf)
-	RegisterFunctionalBuiltin2(ast.IndexOfN.Name, builtinIndexOfN)
-	RegisterFunctionalBuiltin3(ast.Substring.Name, builtinSubstring)
-	RegisterFunctionalBuiltin2(ast.Contains.Name, builtinContains)
-	RegisterFunctionalBuiltin2(ast.StartsWith.Name, builtinStartsWith)
-	RegisterFunctionalBuiltin2(ast.EndsWith.Name, builtinEndsWith)
-	RegisterFunctionalBuiltin1(ast.Upper.Name, builtinUpper)
-	RegisterFunctionalBuiltin1(ast.Lower.Name, builtinLower)
-	RegisterFunctionalBuiltin2(ast.Split.Name, builtinSplit)
-	RegisterFunctionalBuiltin3(ast.Replace.Name, builtinReplace)
-	RegisterFunctionalBuiltin2(ast.ReplaceN.Name, builtinReplaceN)
-	RegisterFunctionalBuiltin2(ast.Trim.Name, builtinTrim)
-	RegisterFunctionalBuiltin2(ast.TrimLeft.Name, builtinTrimLeft)
-	RegisterFunctionalBuiltin2(ast.TrimPrefix.Name, builtinTrimPrefix)
-	RegisterFunctionalBuiltin2(ast.TrimRight.Name, builtinTrimRight)
-	RegisterFunctionalBuiltin2(ast.TrimSuffix.Name, builtinTrimSuffix)
-	RegisterFunctionalBuiltin1(ast.TrimSpace.Name, builtinTrimSpace)
-	RegisterFunctionalBuiltin2(ast.Sprintf.Name, builtinSprintf)
+	RegisterBuiltinFunc(ast.FormatInt.Name, builtinFormatInt)
+	RegisterBuiltinFunc(ast.Concat.Name, builtinConcat)
+	RegisterBuiltinFunc(ast.IndexOf.Name, builtinIndexOf)
+	RegisterBuiltinFunc(ast.IndexOfN.Name, builtinIndexOfN)
+	RegisterBuiltinFunc(ast.Substring.Name, builtinSubstring)
+	RegisterBuiltinFunc(ast.Contains.Name, builtinContains)
+	RegisterBuiltinFunc(ast.StartsWith.Name, builtinStartsWith)
+	RegisterBuiltinFunc(ast.EndsWith.Name, builtinEndsWith)
+	RegisterBuiltinFunc(ast.Upper.Name, builtinUpper)
+	RegisterBuiltinFunc(ast.Lower.Name, builtinLower)
+	RegisterBuiltinFunc(ast.Split.Name, builtinSplit)
+	RegisterBuiltinFunc(ast.Replace.Name, builtinReplace)
+	RegisterBuiltinFunc(ast.ReplaceN.Name, builtinReplaceN)
+	RegisterBuiltinFunc(ast.Trim.Name, builtinTrim)
+	RegisterBuiltinFunc(ast.TrimLeft.Name, builtinTrimLeft)
+	RegisterBuiltinFunc(ast.TrimPrefix.Name, builtinTrimPrefix)
+	RegisterBuiltinFunc(ast.TrimRight.Name, builtinTrimRight)
+	RegisterBuiltinFunc(ast.TrimSuffix.Name, builtinTrimSuffix)
+	RegisterBuiltinFunc(ast.TrimSpace.Name, builtinTrimSpace)
+	RegisterBuiltinFunc(ast.Sprintf.Name, builtinSprintf)
 	RegisterBuiltinFunc(ast.AnyPrefixMatch.Name, builtinAnyPrefixMatch)
 	RegisterBuiltinFunc(ast.AnySuffixMatch.Name, builtinAnySuffixMatch)
 	RegisterBuiltinFunc(ast.StringReverse.Name, builtinReverse)