Update types.Unknown with attribute trails

cel/cel_test.go

@@ -1438,21 +1438,21 @@ func TestPartialVars(t *testing.T) {
 				interpreter.NewAttributePattern("x"),
 				interpreter.NewAttributePattern("y"),
 			},
-			out: types.Unknown{1},
+			out: types.NewUnknown(1, types.NewAttributeTrail("x")),
 		},
 		{
 			in: map[string]any{"x": "10"},
 			unk: []*interpreter.AttributePattern{
 				interpreter.NewAttributePattern("y"),
 			},
-			out: types.Unknown{4},
+			out: types.NewUnknown(4, types.NewAttributeTrail("y")),
 		},
 		{
 			in: map[string]any{"y": 10},
 			unk: []*interpreter.AttributePattern{
 				interpreter.NewAttributePattern("x"),
 			},
-			out: types.Unknown{1},
+			out: types.NewUnknown(1, types.NewAttributeTrail("x")),
 		},
 		{
 			in:  map[string]any{"x": "10", "y": 10},
@@ -1468,19 +1468,19 @@ func TestPartialVars(t *testing.T) {
 			in:         map[string]any{"y": 10},
 			unk:        []*interpreter.AttributePattern{},
 			out:        types.NewErr("no such attribute: x"),
-			partialOut: types.Unknown{1},
+			partialOut: types.NewUnknown(1, types.NewAttributeTrail("x")),
 		},
 		{
 			in:         map[string]any{"x": "10"},
 			unk:        []*interpreter.AttributePattern{},
 			out:        types.NewErr("no such attribute: y"),
-			partialOut: types.Unknown{4},
+			partialOut: types.NewUnknown(4, types.NewAttributeTrail("y")),
 		},
 		{
 			in:         map[string]any{},
 			unk:        []*interpreter.AttributePattern{},
 			out:        types.NewErr("no such attribute: x"),
-			partialOut: types.Unknown{1},
+			partialOut: types.NewUnknown(1, types.NewAttributeTrail("x")),
 		},
 	}
 	for i, tst := range tests {

cel/decls_test.go

@@ -72,11 +72,11 @@ var dispatchTests = []struct {
 	},
 	{
 		expr: "max(unk, unk)",
-		out:  types.Unknown{42},
+		out:  types.NewUnknown(42, nil),
 	},
 	{
 		expr: "max(unk, unk, unk)",
-		out:  types.Unknown{42},
+		out:  types.NewUnknown(42, nil),
 	},
 }
 
@@ -395,11 +395,11 @@ func TestUnaryBinding(t *testing.T) {
 	if err != nil {
 		t.Fatalf("Program() failed: %v", err)
 	}
-	out, _, err := prg.Eval(map[string]any{"x": types.Unknown{1}})
+	out, _, err := prg.Eval(map[string]any{"x": types.NewUnknown(1, nil)})
 	if err != nil {
 		t.Fatalf("prg.Eval(x=unk) failed: %v", err)
 	}
-	if !reflect.DeepEqual(out, types.Unknown{1}) {
+	if !types.NewUnknown(1, nil).Contains(out.(*types.Unknown)) {
 		t.Errorf("prg.Eval(x=unk) returned %v, wanted unknown{1}", out)
 	}
 }
@@ -439,14 +439,14 @@ func TestBinaryBinding(t *testing.T) {
 	if err != nil {
 		t.Fatalf("Program() failed: %v", err)
 	}
-	out, _, err := prg.Eval(map[string]any{"x": types.Unknown{1}, "y": 1})
+	out, _, err := prg.Eval(map[string]any{"x": types.NewUnknown(1, nil), "y": 1})
 	if err != nil {
 		t.Fatalf("prg.Eval(x=unk) failed: %v", err)
 	}
 	if !reflect.DeepEqual(out, types.IntOne) {
 		t.Errorf("prg.Eval(x=unk, y=1) returned %v, wanted 1", out)
 	}
-	out, _, err = prg.Eval(map[string]any{"x": 2, "y": types.Unknown{2}})
+	out, _, err = prg.Eval(map[string]any{"x": 2, "y": types.NewUnknown(2, nil)})
 	if err != nil {
 		t.Fatalf("prg.Eval(x=2, y=unk) failed: %v", err)
 	}
@@ -790,10 +790,10 @@ func testParse(t testing.TB, env *Env, expr string, want any) {
 	if err != nil {
 		t.Fatalf("env.Program() failed: %v", err)
 	}
-	out, _, err := prg.Eval(map[string]any{"err": types.NewErr("error argument"), "unk": types.Unknown{42}})
+	out, _, err := prg.Eval(map[string]any{"err": types.NewErr("error argument"), "unk": types.NewUnknown(42, nil)})
 	switch want := want.(type) {
-	case types.Unknown:
-		if !reflect.DeepEqual(want, out.(types.Unknown)) {
+	case *types.Unknown:
+		if !want.Contains(out.(*types.Unknown)) {
 			t.Errorf("prg.Eval() got %v, wanted %v", out, want)
 		}
 	case ref.Val:
@@ -817,10 +817,10 @@ func testCompile(t testing.TB, env *Env, expr string, want any) {
 	if err != nil {
 		t.Fatalf("env.Program() failed: %v", err)
 	}
-	out, _, err := prg.Eval(map[string]any{"err": types.NewErr("error argument"), "unk": types.Unknown{42}})
+	out, _, err := prg.Eval(map[string]any{"err": types.NewErr("error argument"), "unk": types.NewUnknown(42, nil)})
 	switch want := want.(type) {
-	case types.Unknown:
-		if !reflect.DeepEqual(want, out.(types.Unknown)) {
+	case *types.Unknown:
+		if !want.Contains(out.(*types.Unknown)) {
 			t.Errorf("prg.Eval() got %v, wanted %v", out, want)
 		}
 	case ref.Val:

common/decls/decls.go

@@ -275,17 +275,17 @@ func (f *FunctionDecl) Bindings() ([]*functions.Overload, error) {
 // to return an unknown set, or to produce a new error for a missing function signature.
 func MaybeNoSuchOverload(funcName string, args ...ref.Val) ref.Val {
 	argTypes := make([]string, len(args))
-	var unk types.Unknown
+	var unk *types.Unknown = nil
 	for i, arg := range args {
 		if types.IsError(arg) {
 			return arg
 		}
 		if types.IsUnknown(arg) {
-			unk = append(unk, arg.(types.Unknown)...)
+			unk = types.MergeUnknowns(arg.(*types.Unknown), unk)
 		}
 		argTypes[i] = arg.Type().TypeName()
 	}
-	if len(unk) != 0 {
+	if unk != nil {
 		return unk
 	}
 	signature := strings.Join(argTypes, ", ")

common/decls/decls_test.go

@@ -142,7 +142,7 @@ func TestFunctionVariableArgBindings(t *testing.T) {
 			if !types.IsError(celErr) || !strings.Contains(celErr.(*types.Err).String(), "no such overload") {
 				t.Errorf("binding.Binary(bytes, string) got %v, wanted no such overload", celErr)
 			}
-			celUnk := binding.Binary(types.Bytes("hi"), types.Unknown{1})
+			celUnk := binding.Binary(types.Bytes("hi"), types.NewUnknown(1, types.NewAttributeTrail("x")))
 			if !types.IsUnknown(celUnk) {
 				t.Errorf("binding.Binary(bytes, unk) got %v, wanted unknown{1}", celUnk)
 			}