tint: Add 'chromium_experimental_full_ptr_parameters' extension

Removes validation around pointer parameters.

Bug: tint:1758
Change-Id: I3adc48f780fc8c6f5525f9ecc280e2a406069b49
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/112286
Reviewed-by: James Price <jrprice@google.com>
Kokoro: Kokoro <noreply+kokoro@google.com>
Commit-Queue: Ben Clayton <bclayton@google.com>

src/tint/resolver/call_validation_test.cc

@@ -114,11 +114,29 @@ TEST_F(ResolverCallValidationTest, PointerArgument_VariableIdentExpr) {
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 }
 
-TEST_F(ResolverCallValidationTest, PointerArgument_NotWholeVar) {
+TEST_F(ResolverCallValidationTest, PointerArgument_LetIdentExpr) {
+    // fn foo(p: ptr<function, i32>) {}
+    // fn main() {
+    //   let z: i32 = 1i;
+    //   foo(&z);
+    // }
+    auto* param = Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction));
+    Func("foo", utils::Vector{param}, ty.void_(), utils::Empty);
+    Func("main", utils::Empty, ty.void_(),
+         utils::Vector{
+             Decl(Let("z", ty.i32(), Expr(1_i))),
+             CallStmt(Call("foo", AddressOf(Expr(Source{{12, 34}}, "z")))),
+         });
+
+    EXPECT_FALSE(r()->Resolve());
+    EXPECT_EQ(r()->error(), "12:34 error: cannot take the address of expression");
+}
+
+TEST_F(ResolverCallValidationTest, PointerArgument_AddressOfFunctionMember) {
     // struct S { m: i32; };
     // fn foo(p: ptr<function, i32>) {}
     // fn main() {
-    //   var v: S;
+    //   var v : S;
     //   foo(&v.m);
     // }
     auto* S = Structure("S", utils::Vector{
@@ -138,6 +156,51 @@ TEST_F(ResolverCallValidationTest, PointerArgument_NotWholeVar) {
               "originating variable");
 }
 
+TEST_F(ResolverCallValidationTest,
+       PointerArgument_AddressOfFunctionMember_WithFullPtrParametersExt) {
+    // enable chromium_experimental_full_ptr_parameters;
+    // struct S { m: i32; };
+    // fn foo(p: ptr<function, i32>) {}
+    // fn main() {
+    //   var v : S;
+    //   foo(&v.m);
+    // }
+    Enable(ast::Extension::kChromiumExperimentalFullPtrParameters);
+    auto* S = Structure("S", utils::Vector{
+                                 Member("m", ty.i32()),
+                             });
+    auto* param = Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction));
+    Func("foo", utils::Vector{param}, ty.void_(), utils::Empty);
+    Func("main", utils::Empty, ty.void_(),
+         utils::Vector{
+             Decl(Var("v", ty.Of(S))),
+             CallStmt(Call("foo", AddressOf(Source{{12, 34}}, MemberAccessor("v", "m")))),
+         });
+
+    EXPECT_TRUE(r()->Resolve()) << r()->error();
+}
+TEST_F(ResolverCallValidationTest, PointerArgument_AddressOfLetMember) {
+    // struct S { m: i32; };
+    // fn foo(p: ptr<function, i32>) {}
+    // fn main() {
+    //   let v: S = S();
+    //   foo(&v.m);
+    // }
+    auto* S = Structure("S", utils::Vector{
+                                 Member("m", ty.i32()),
+                             });
+    auto* param = Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction));
+    Func("foo", utils::Vector{param}, ty.void_(), utils::Empty);
+    Func("main", utils::Empty, ty.void_(),
+         utils::Vector{
+             Decl(Let("v", ty.Of(S), Construct(ty.Of(S)))),
+             CallStmt(Call("foo", AddressOf(MemberAccessor(Source{{12, 34}}, "v", "m")))),
+         });
+
+    EXPECT_FALSE(r()->Resolve());
+    EXPECT_EQ(r()->error(), "12:34 error: cannot take the address of expression");
+}
+
 TEST_F(ResolverCallValidationTest, PointerArgument_FunctionParam) {
     // fn foo(p: ptr<function, i32>) {}
     // fn bar(p: ptr<function, i32>) {
@@ -181,12 +244,12 @@ TEST_F(ResolverCallValidationTest, PointerArgument_FunctionParamWithMain) {
          },
          ty.void_(),
          utils::Vector{
-             CallStmt(Call("foo", Expr("p"))),
+             CallStmt(Call("foo", "p")),
          });
     Func("main", utils::Empty, ty.void_(),
          utils::Vector{
              Decl(Var("v", ty.i32(), Expr(1_i))),
-             CallStmt(Call("foo", AddressOf(Expr("v")))),
+             CallStmt(Call("foo", AddressOf("v"))),
          },
          utils::Vector{
              Stage(ast::PipelineStage::kFragment),
@@ -195,40 +258,15 @@ TEST_F(ResolverCallValidationTest, PointerArgument_FunctionParamWithMain) {
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 }
 
-TEST_F(ResolverCallValidationTest, PointerArgument_FunctionParam_NotWholeVar) {
-    // fn foo(p: ptr<function, i32>) {}
-    // fn bar(p: ptr<function, array<i32, 4>>) {
-    //   foo(&(*p)[0]);
-    // }
-    Func("foo",
-         utils::Vector{
-             Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction)),
-         },
-         ty.void_(), utils::Empty);
-    Func("bar",
-         utils::Vector{
-             Param("p", ty.pointer(ty.array<i32, 4>(), ast::AddressSpace::kFunction)),
-         },
-         ty.void_(),
-         utils::Vector{
-             CallStmt(Call("foo", AddressOf(Source{{12, 34}}, IndexAccessor(Deref("p"), 0_a)))),
-         });
-
-    EXPECT_FALSE(r()->Resolve());
-    EXPECT_EQ(r()->error(),
-              "12:34 error: arguments of pointer type must not point to a subset of the "
-              "originating variable");
-}
-
 TEST_F(ResolverCallValidationTest, LetPointer) {
     // fn foo(p : ptr<function, i32>) {}
     // @fragment
     // fn main() {
     //   var v: i32;
     //   let p: ptr<function, i32> = &v;
-    //   foo(p);
+    //   x(p);
     // }
-    Func("foo",
+    Func("x",
          utils::Vector{
              Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction)),
          },
@@ -237,7 +275,7 @@ TEST_F(ResolverCallValidationTest, LetPointer) {
          utils::Vector{
              Decl(Var("v", ty.i32())),
              Decl(Let("p", ty.pointer(ty.i32(), ast::AddressSpace::kFunction), AddressOf("v"))),
-             CallStmt(Call("foo", Expr(Source{{12, 34}}, "p"))),
+             CallStmt(Call("x", "p")),
          },
          utils::Vector{
              Stage(ast::PipelineStage::kFragment),
@@ -247,10 +285,10 @@ TEST_F(ResolverCallValidationTest, LetPointer) {
 
 TEST_F(ResolverCallValidationTest, LetPointerPrivate) {
     // fn foo(p : ptr<private, i32>) {}
-    // var<private> v: i32;
+    // var v : i32;
     // @fragment
     // fn main() {
-    //   let p: ptr<private, i32> = &v;
+    //   let p : ptr<private, i32> = &v;
     //   foo(p);
     // }
     Func("foo",
@@ -299,6 +337,34 @@ TEST_F(ResolverCallValidationTest, LetPointer_NotWholeVar) {
               "originating variable");
 }
 
+TEST_F(ResolverCallValidationTest, LetPointer_NotWholeVar_WithFullPtrParametersExt) {
+    // enable chromium_experimental_full_ptr_parameters;
+    // fn foo(p : ptr<function, i32>) {}
+    // @fragment
+    // fn main() {
+    //   var v: array<i32, 4>;
+    //   let p: ptr<function, i32> = &(v[0]);
+    //   x(p);
+    // }
+    Enable(ast::Extension::kChromiumExperimentalFullPtrParameters);
+    Func("foo",
+         utils::Vector{
+             Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction)),
+         },
+         ty.void_(), utils::Empty);
+    Func("main", utils::Empty, ty.void_(),
+         utils::Vector{
+             Decl(Var("v", ty.array<i32, 4>())),
+             Decl(Let("p", ty.pointer(ty.i32(), ast::AddressSpace::kFunction),
+                      AddressOf(IndexAccessor("v", 0_a)))),
+             CallStmt(Call("foo", Expr(Source{{12, 34}}, "p"))),
+         },
+         utils::Vector{
+             Stage(ast::PipelineStage::kFragment),
+         });
+    EXPECT_TRUE(r()->Resolve());
+}
+
 TEST_F(ResolverCallValidationTest, ComplexPointerChain) {
     // fn foo(p : ptr<function, array<i32, 4>>) {}
     // @fragment
@@ -360,6 +426,37 @@ TEST_F(ResolverCallValidationTest, ComplexPointerChain_NotWholeVar) {
               "originating variable");
 }
 
+TEST_F(ResolverCallValidationTest, ComplexPointerChain_NotWholeVar_WithFullPtrParametersExt) {
+    // enable chromium_experimental_full_ptr_parameters;
+    // fn foo(p : ptr<function, i32>) {}
+    // @fragment
+    // fn main() {
+    //   var v: array<i32, 4>;
+    //   let p1 = &v;
+    //   let p2 = p1;
+    //   let p3 = &(*p2)[0];
+    //   foo(&*p);
+    // }
+    Enable(ast::Extension::kChromiumExperimentalFullPtrParameters);
+    Func("foo",
+         utils::Vector{
+             Param("p", ty.pointer<i32>(ast::AddressSpace::kFunction)),
+         },
+         ty.void_(), utils::Empty);
+    Func("main", utils::Empty, ty.void_(),
+         utils::Vector{
+             Decl(Var("v", ty.array<i32, 4>())),
+             Decl(Let("p1", AddressOf("v"))),
+             Decl(Let("p2", Expr("p1"))),
+             Decl(Let("p3", AddressOf(IndexAccessor(Deref("p2"), 0_a)))),
+             CallStmt(Call("foo", AddressOf(Source{{12, 34}}, Deref("p3")))),
+         },
+         utils::Vector{
+             Stage(ast::PipelineStage::kFragment),
+         });
+    EXPECT_TRUE(r()->Resolve());
+}
+
 TEST_F(ResolverCallValidationTest, CallVariable) {
     // var v : i32;
     // fn f() {

src/tint/resolver/function_validation_test.cc

@@ -1041,21 +1041,26 @@ TEST_F(ResolverFunctionValidationTest, ParameterMatrixNoType) {
     EXPECT_EQ(r()->error(), "12:34 error: missing matrix element type");
 }
 
+enum class Expectation {
+    kAlwaysPass,
+    kPassWithFullPtrParameterExtension,
+    kAlwaysFail,
+};
 struct TestParams {
     ast::AddressSpace address_space;
-    bool should_pass;
+    Expectation expectation;
 };
 
 struct TestWithParams : ResolverTestWithParam<TestParams> {};
 
 using ResolverFunctionParameterValidationTest = TestWithParams;
-TEST_P(ResolverFunctionParameterValidationTest, AddressSpace) {
+TEST_P(ResolverFunctionParameterValidationTest, AddressSpaceNoExtension) {
     auto& param = GetParam();
     auto* ptr_type = ty.pointer(Source{{12, 34}}, ty.i32(), param.address_space);
     auto* arg = Param(Source{{12, 34}}, "p", ptr_type);
     Func("f", utils::Vector{arg}, ty.void_(), utils::Empty);
 
-    if (param.should_pass) {
+    if (param.expectation == Expectation::kAlwaysPass) {
         ASSERT_TRUE(r()->Resolve()) << r()->error();
     } else {
         std::stringstream ss;
@@ -1065,17 +1070,36 @@ TEST_P(ResolverFunctionParameterValidationTest, AddressSpace) {
                                     ss.str() + "' address space");
     }
 }
-INSTANTIATE_TEST_SUITE_P(ResolverTest,
-                         ResolverFunctionParameterValidationTest,
-                         testing::Values(TestParams{ast::AddressSpace::kNone, false},
-                                         TestParams{ast::AddressSpace::kIn, false},
-                                         TestParams{ast::AddressSpace::kOut, false},
-                                         TestParams{ast::AddressSpace::kUniform, false},
-                                         TestParams{ast::AddressSpace::kWorkgroup, false},
-                                         TestParams{ast::AddressSpace::kHandle, false},
-                                         TestParams{ast::AddressSpace::kStorage, false},
-                                         TestParams{ast::AddressSpace::kPrivate, true},
-                                         TestParams{ast::AddressSpace::kFunction, true}));
+TEST_P(ResolverFunctionParameterValidationTest, AddressSpaceWithExtension) {
+    auto& param = GetParam();
+    auto* ptr_type = ty.pointer(Source{{12, 34}}, ty.i32(), param.address_space);
+    auto* arg = Param(Source{{12, 34}}, "p", ptr_type);
+    Enable(ast::Extension::kChromiumExperimentalFullPtrParameters);
+    Func("f", utils::Vector{arg}, ty.void_(), utils::Empty);
+
+    if (param.expectation != Expectation::kAlwaysFail) {
+        ASSERT_TRUE(r()->Resolve()) << r()->error();
+    } else {
+        std::stringstream ss;
+        ss << param.address_space;
+        EXPECT_FALSE(r()->Resolve());
+        EXPECT_EQ(r()->error(), "12:34 error: function parameter of pointer type cannot be in '" +
+                                    ss.str() + "' address space");
+    }
+}
+INSTANTIATE_TEST_SUITE_P(
+    ResolverTest,
+    ResolverFunctionParameterValidationTest,
+    testing::Values(
+        TestParams{ast::AddressSpace::kNone, Expectation::kAlwaysFail},
+        TestParams{ast::AddressSpace::kIn, Expectation::kAlwaysFail},
+        TestParams{ast::AddressSpace::kOut, Expectation::kAlwaysFail},
+        TestParams{ast::AddressSpace::kUniform, Expectation::kPassWithFullPtrParameterExtension},
+        TestParams{ast::AddressSpace::kWorkgroup, Expectation::kPassWithFullPtrParameterExtension},
+        TestParams{ast::AddressSpace::kHandle, Expectation::kAlwaysFail},
+        TestParams{ast::AddressSpace::kStorage, Expectation::kPassWithFullPtrParameterExtension},
+        TestParams{ast::AddressSpace::kPrivate, Expectation::kAlwaysPass},
+        TestParams{ast::AddressSpace::kFunction, Expectation::kAlwaysPass}));
 
 }  // namespace
 }  // namespace tint::resolver

src/tint/resolver/validator.cc

@@ -800,15 +800,31 @@ bool Validator::Parameter(const ast::Function* func, const sem::Variable* var) c
     }
 
     if (auto* ref = var->Type()->As<sem::Pointer>()) {
-        auto address_space = ref->AddressSpace();
-        if (!(address_space == ast::AddressSpace::kFunction ||
-              address_space == ast::AddressSpace::kPrivate) &&
-            IsValidationEnabled(decl->attributes, ast::DisabledValidation::kIgnoreAddressSpace)) {
-            std::stringstream ss;
-            ss << "function parameter of pointer type cannot be in '" << address_space
-               << "' address space";
-            AddError(ss.str(), decl->source);
-            return false;
+        if (IsValidationEnabled(decl->attributes, ast::DisabledValidation::kIgnoreAddressSpace)) {
+            bool ok = false;
+
+            auto sc = ref->AddressSpace();
+            switch (sc) {
+                case ast::AddressSpace::kFunction:
+                case ast::AddressSpace::kPrivate:
+                    ok = true;
+                    break;
+                case ast::AddressSpace::kStorage:
+                case ast::AddressSpace::kUniform:
+                case ast::AddressSpace::kWorkgroup:
+                    ok = enabled_extensions_.Contains(
+                        ast::Extension::kChromiumExperimentalFullPtrParameters);
+                    break;
+                default:
+                    break;
+            }
+            if (!ok) {
+                std::stringstream ss;
+                ss << "function parameter of pointer type cannot be in '" << sc
+                   << "' address space";
+                AddError(ss.str(), decl->source);
+                return false;
+            }
         }
     }
 
@@ -1654,7 +1670,8 @@ bool Validator::FunctionCall(const sem::Call* call, sem::Statement* current_stat
             return false;
         }
 
-        if (param_type->Is<sem::Pointer>()) {
+        if (param_type->Is<sem::Pointer>() &&
+            !enabled_extensions_.Contains(ast::Extension::kChromiumExperimentalFullPtrParameters)) {
             // https://gpuweb.github.io/gpuweb/wgsl/#function-restriction
             // Each argument of pointer type to a user-defined function must have the same memory
             // view as its root identifier.