diff --git a/tests/simple/testdata/optionals.textproto b/tests/simple/testdata/optionals.textproto index 508b49e..eada47b 100644 --- a/tests/simple/testdata/optionals.textproto +++ b/tests/simple/testdata/optionals.textproto @@ -598,4 +598,64 @@ section: { expr: "[?optional.of(optional.none()), ?optional.none(), ?optional.of(optional.of(1))] == [optional.none(), optional.of(1)]" value: { bool_value: true } } + test { + name: "dyn_optional_or_value" + expr: "dyn(optional.of('foo')).orValue(1)" + value: { string_value: "foo" } + } + test { + name: "dyn_optional_nested_or_value_index" + expr: "dyn(optional.of(optional.of([2]))).orValue([1])[0] == optional.of(2)" + value: { bool_value: true } + } + test { + name: "dyn_optional_or_value_map_index" + expr: "dyn(optional.of(['a'])).orValue({0: 1})[0]" + value: { string_value: "a" } + } + test { + name: "dyn_optional_or_value_optional_index" + expr: "dyn(optional.of([2])).orValue(optional.of([1]))[0]" + value: { int64_value: 2 } + } + test { + name: "dyn_optional_or_value_optindex" + expr: "dyn(optional.of(optional.of(['a']))).orValue([1])[?0] == optional.of('a')" + value: { bool_value: true } + } + test { + name: "dyn_optional_or_value_size" + expr: "dyn(optional.of('foo')).orValue(1).size()" + value: { int64_value: 3 } + } + test { + name: "optional_none_optmap_or_value" + expr: "optional.none().optMap(v, v).orValue('1')" + value: { string_value: "1" } + } + test { + name: "dyn_optional_none_optmap_or_value" + expr: "dyn(optional.none()).optMap(v, v).orValue('1')" + value: { string_value: "1" } + } + test { + name: "dyn_optional_of_optmap_or_value" + expr: "dyn(optional.of(1)).optMap(v, v).orValue('1')" + value: { int64_value: 1 } + } + test { + name: "optional_none_optflatmap_or_value" + expr: "optional.none().optFlatMap(v, optional.of(v)).orValue('1')" + value: { string_value: "1" } + } + test { + name: "dyn_optional_of_optflatmap_or_value" + expr: "dyn(optional.of(1)).optFlatMap(v, optional.of(v)).orValue('1')" + value: { int64_value: 1 } + } + test { + name: "dyn_optional_nested_optflatmap_or_value" + expr: "dyn(optional.of(optional.of(1))).optFlatMap(v, v).orValue('1')" + value: { int64_value: 1 } + } } diff --git a/tests/simple/testdata/type_deduction.textproto b/tests/simple/testdata/type_deduction.textproto index 702b08e..ee31b79 100644 --- a/tests/simple/testdata/type_deduction.textproto +++ b/tests/simple/testdata/type_deduction.textproto @@ -679,6 +679,42 @@ section { } } } + test { + name: "wrapper_ternary_parameter_assignment_3" + type_env { + name: "msg" + ident { + type { + message_type: "cel.expr.conformance.proto3.TestAllTypes" + } + } + } + expr: "false ? null : msg.single_int64_wrapper" + check_only: true + typed_result { + deduced_type { + wrapper: INT64 + } + } + } + test { + name: "wrapper_ternary_parameter_assignment_4" + type_env { + name: "msg" + ident { + type { + message_type: "cel.expr.conformance.proto3.TestAllTypes" + } + } + } + expr: "true ? 42 : msg.single_int64_wrapper" + check_only: true + typed_result { + deduced_type { + wrapper: INT64 + } + } + } } section { @@ -1355,3 +1391,216 @@ section { } } } + +section { + name: "dyn_type_parameter_unification" + description: + "Tests that unifying dyn with parameterized types binds or widens inner " + "type parameters to dyn, and that asymmetric parameterized dyn joins " + "compute a sound least upper bound." + test { + name: "dyn_optional_or_value" + expr: "dyn(optional.of('foo')).orValue(1)" + check_only: true + typed_result { + deduced_type { + dyn {} + } + } + } + test { + name: "dyn_optional_nested_or_value_index" + expr: "dyn(optional.of(optional.of([2]))).orValue([1])[0]" + check_only: true + typed_result { + deduced_type { + dyn {} + } + } + } + test { + name: "dyn_optional_or_value_map_index" + expr: "dyn(optional.of(['a'])).orValue({0: 1})[0]" + check_only: true + typed_result { + deduced_type { + dyn {} + } + } + } + test { + name: "dyn_optional_or_value_optional_index" + expr: "dyn(optional.of([2])).orValue(optional.of([1]))[0]" + check_only: true + typed_result { + deduced_type { + dyn {} + } + } + } + test { + name: "dyn_optional_or_value_optindex" + expr: "dyn(optional.of(optional.of(['a']))).orValue([1])[?0]" + check_only: true + typed_result { + deduced_type { + abstract_type { + name: "optional_type" + parameter_types { dyn {} } + } + } + } + } + test { + name: "list_concat_dyn_rhs" + expr: "['a'] + dyn([1])" + typed_result { + result { + list_value { + values { + string_value: "a" + } + values { + int64_value: 1 + } + } + } + deduced_type { + list_type { + elem_type { dyn {} } + } + } + } + } + test { + name: "list_concat_dyn_lhs" + expr: "dyn([1]) + ['a']" + typed_result { + result { + list_value { + values { + int64_value: 1 + } + values { + string_value: "a" + } + } + } + deduced_type { + list_type { + elem_type { dyn {} } + } + } + } + } + test { + name: "dyn_optional_or_value_size" + expr: "dyn(optional.of('foo')).orValue(1).size()" + check_only: true + typed_result { + deduced_type { + primitive: INT64 + } + } + } + test { + name: "ternary_asymmetric_dyn_maps" + expr: "false ? {dyn(1): 1} : {'b': dyn('c')}" + typed_result { + result { + map_value { + entries { + key { string_value: "b" } + value { string_value: "c" } + } + } + } + deduced_type { + map_type { + key_type { dyn {} } + value_type { dyn {} } + } + } + } + } + test { + name: "ternary_asymmetric_dyn_maps_reverse" + expr: "true ? {'b': dyn('c')} : {dyn(1): 1}" + typed_result { + result { + map_value { + entries { + key { string_value: "b" } + value { string_value: "c" } + } + } + } + deduced_type { + map_type { + key_type { dyn {} } + value_type { dyn {} } + } + } + } + } + test { + name: "optional_none_optmap_or_value" + expr: "optional.none().optMap(v, v).orValue('1')" + check_only: true + typed_result { + deduced_type { + primitive: STRING + } + } + } + test { + name: "dyn_optional_none_optmap_or_value" + expr: "dyn(optional.none()).optMap(v, v).orValue('1')" + check_only: true + typed_result { + deduced_type { + dyn {} + } + } + } + test { + name: "dyn_optional_of_optmap_or_value" + expr: "dyn(optional.of(1)).optMap(v, v).orValue('1')" + check_only: true + typed_result { + deduced_type { + dyn {} + } + } + } + test { + name: "optional_none_optflatmap_or_value" + expr: "optional.none().optFlatMap(v, optional.of(v)).orValue('1')" + check_only: true + typed_result { + deduced_type { + primitive: STRING + } + } + } + test { + name: "dyn_optional_of_optflatmap_or_value" + expr: "dyn(optional.of(1)).optFlatMap(v, optional.of(v)).orValue('1')" + check_only: true + typed_result { + deduced_type { + dyn {} + } + } + } + test { + name: "dyn_optional_nested_optflatmap_or_value" + expr: "dyn(optional.of(optional.of(1))).optFlatMap(v, v).orValue('1')" + check_only: true + typed_result { + deduced_type { + dyn {} + } + } + } +}