// Copyright 2023 The Dawn & Tint Authors
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this
//    list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice,
//    this list of conditions and the following disclaimer in the documentation
//    and/or other materials provided with the distribution.
//
// 3. Neither the name of the copyright holder nor the names of its
//    contributors may be used to endorse or promote products derived from
//    this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#include "src/tint/lang/wgsl/resolver/resolver.h"

#include "gmock/gmock.h"
#include "src/tint/lang/core/fluent_types.h"
#include "src/tint/lang/wgsl/resolver/resolver_helper_test.h"

using namespace tint::core::number_suffixes;  // NOLINT
using namespace tint::core::fluent_types;     // NOLINT

namespace tint::resolver {
namespace {

enum class Def {
    kAccess,
    kAddressSpace,
    kBuiltinFunction,
    kBuiltinType,
    kBuiltinValue,
    kFunction,
    kInterpolationSampling,
    kInterpolationType,
    kParameter,
    kStruct,
    kTexelFormat,
    kTypeAlias,
    kVariable,
};

std::ostream& operator<<(std::ostream& out, Def def) {
    switch (def) {
        case Def::kAccess:
            return out << "Def::kAccess";
        case Def::kAddressSpace:
            return out << "Def::kAddressSpace";
        case Def::kBuiltinFunction:
            return out << "Def::kBuiltinFunction";
        case Def::kBuiltinType:
            return out << "Def::kBuiltinType";
        case Def::kBuiltinValue:
            return out << "Def::kBuiltinValue";
        case Def::kFunction:
            return out << "Def::kFunction";
        case Def::kInterpolationSampling:
            return out << "Def::kInterpolationSampling";
        case Def::kInterpolationType:
            return out << "Def::kInterpolationType";
        case Def::kParameter:
            return out << "Def::kParameter";
        case Def::kStruct:
            return out << "Def::kStruct";
        case Def::kTexelFormat:
            return out << "Def::kTexelFormat";
        case Def::kTypeAlias:
            return out << "Def::kTypeAlias";
        case Def::kVariable:
            return out << "Def::kVariable";
    }
    return out << "<unknown>";
}

enum class Use {
    kAccess,
    kAddressSpace,
    kBinaryOp,
    kBuiltinValue,
    kCallExpr,
    kCallStmt,
    kFunctionReturnType,
    kInterpolationSampling,
    kInterpolationType,
    kMemberType,
    kTexelFormat,
    kValueExpression,
    kVariableType,
    kUnaryOp
};

std::ostream& operator<<(std::ostream& out, Use use) {
    switch (use) {
        case Use::kAccess:
            return out << "Use::kAccess";
        case Use::kAddressSpace:
            return out << "Use::kAddressSpace";
        case Use::kBinaryOp:
            return out << "Use::kBinaryOp";
        case Use::kBuiltinValue:
            return out << "Use::kBuiltinValue";
        case Use::kCallExpr:
            return out << "Use::kCallExpr";
        case Use::kCallStmt:
            return out << "Use::kCallStmt";
        case Use::kFunctionReturnType:
            return out << "Use::kFunctionReturnType";
        case Use::kInterpolationSampling:
            return out << "Use::kInterpolationSampling";
        case Use::kInterpolationType:
            return out << "Use::kInterpolationType";
        case Use::kMemberType:
            return out << "Use::kMemberType";
        case Use::kTexelFormat:
            return out << "Use::kTexelFormat";
        case Use::kValueExpression:
            return out << "Use::kValueExpression";
        case Use::kVariableType:
            return out << "Use::kVariableType";
        case Use::kUnaryOp:
            return out << "Use::kUnaryOp";
    }
    return out << "<unknown>";
}

struct Case {
    Def def;
    Use use;
    const char* error;
};

std::ostream& operator<<(std::ostream& out, Case c) {
    return out << "{" << c.def << ", " << c.use << "}";
}

static const char* kPass = "<pass>";

static const Source kDefSource{Source::Range{{1, 2}, {3, 4}}};
static const Source kUseSource{Source::Range{{5, 6}, {7, 8}}};

using ResolverExpressionKindTest = ResolverTestWithParam<Case>;

TEST_P(ResolverExpressionKindTest, Test) {
    Symbol sym;
    std::function<void(const sem::Expression*)> check_expr;

    Vector<const ast::Parameter*, 2> fn_params;
    Vector<const ast::Statement*, 2> fn_stmts;
    Vector<const ast::Attribute*, 2> fn_attrs;

    switch (GetParam().def) {
        case Def::kAccess: {
            sym = Sym("write");
            check_expr = [](const sem::Expression* expr) {
                ASSERT_NE(expr, nullptr);
                auto* enum_expr = expr->As<sem::BuiltinEnumExpression<core::Access>>();
                ASSERT_NE(enum_expr, nullptr);
                EXPECT_EQ(enum_expr->Value(), core::Access::kWrite);
            };
            break;
        }
        case Def::kAddressSpace: {
            sym = Sym("workgroup");
            check_expr = [](const sem::Expression* expr) {
                ASSERT_NE(expr, nullptr);
                auto* enum_expr = expr->As<sem::BuiltinEnumExpression<core::AddressSpace>>();
                ASSERT_NE(enum_expr, nullptr);
                EXPECT_EQ(enum_expr->Value(), core::AddressSpace::kWorkgroup);
            };
            break;
        }
        case Def::kBuiltinFunction: {
            sym = Sym("workgroupBarrier");
            check_expr = [](const sem::Expression* expr) {
                ASSERT_NE(expr, nullptr);
                auto* fn_expr = expr->As<sem::BuiltinEnumExpression<wgsl::BuiltinFn>>();
                ASSERT_NE(fn_expr, nullptr);
                EXPECT_EQ(fn_expr->Value(), wgsl::BuiltinFn::kWorkgroupBarrier);
            };
            break;
        }
        case Def::kBuiltinType: {
            sym = Sym("vec4f");
            check_expr = [](const sem::Expression* expr) {
                ASSERT_NE(expr, nullptr);
                auto* ty_expr = expr->As<sem::TypeExpression>();
                ASSERT_NE(ty_expr, nullptr);
                EXPECT_TRUE(ty_expr->Type()->Is<core::type::Vector>());
            };
            break;
        }
        case Def::kBuiltinValue: {
            sym = Sym("position");
            check_expr = [](const sem::Expression* expr) {
                ASSERT_NE(expr, nullptr);
                auto* enum_expr = expr->As<sem::BuiltinEnumExpression<core::BuiltinValue>>();
                ASSERT_NE(enum_expr, nullptr);
                EXPECT_EQ(enum_expr->Value(), core::BuiltinValue::kPosition);
            };
            break;
        }
        case Def::kFunction: {
            sym = Sym("FUNCTION");
            auto* fn = Func(kDefSource, sym, tint::Empty, ty.i32(), Return(1_i));
            check_expr = [fn](const sem::Expression* expr) {
                ASSERT_NE(expr, nullptr);
                auto* fn_expr = expr->As<sem::FunctionExpression>();
                ASSERT_NE(fn_expr, nullptr);
                EXPECT_EQ(fn_expr->Function()->Declaration(), fn);
            };
            break;
        }
        case Def::kInterpolationSampling: {
            sym = Sym("center");
            check_expr = [](const sem::Expression* expr) {
                ASSERT_NE(expr, nullptr);
                auto* enum_expr =
                    expr->As<sem::BuiltinEnumExpression<core::InterpolationSampling>>();
                ASSERT_NE(enum_expr, nullptr);
                EXPECT_EQ(enum_expr->Value(), core::InterpolationSampling::kCenter);
            };
            break;
        }
        case Def::kInterpolationType: {
            sym = Sym("linear");
            check_expr = [](const sem::Expression* expr) {
                ASSERT_NE(expr, nullptr);
                auto* enum_expr = expr->As<sem::BuiltinEnumExpression<core::InterpolationType>>();
                ASSERT_NE(enum_expr, nullptr);
                EXPECT_EQ(enum_expr->Value(), core::InterpolationType::kLinear);
            };
            break;
        }
        case Def::kParameter: {
            sym = Sym("PARAMETER");
            auto* param = Param(kDefSource, sym, ty.i32());
            fn_params.Push(param);
            check_expr = [param](const sem::Expression* expr) {
                ASSERT_NE(expr, nullptr);
                auto* user = expr->As<sem::VariableUser>();
                ASSERT_NE(user, nullptr);
                EXPECT_EQ(user->Variable()->Declaration(), param);
            };
            break;
        }
        case Def::kStruct: {
            sym = Sym("STRUCT");
            auto* s = Structure(kDefSource, sym, Vector{Member("m", ty.i32())});
            check_expr = [s](const sem::Expression* expr) {
                ASSERT_NE(expr, nullptr);
                auto* ty_expr = expr->As<sem::TypeExpression>();
                ASSERT_NE(ty_expr, nullptr);
                auto* got = ty_expr->Type()->As<sem::Struct>();
                ASSERT_NE(got, nullptr);
                EXPECT_EQ(got->Declaration(), s);
            };
            break;
        }
        case Def::kTexelFormat: {
            sym = Sym("rgba8unorm");
            check_expr = [](const sem::Expression* expr) {
                ASSERT_NE(expr, nullptr);
                auto* enum_expr = expr->As<sem::BuiltinEnumExpression<core::TexelFormat>>();
                ASSERT_NE(enum_expr, nullptr);
                EXPECT_EQ(enum_expr->Value(), core::TexelFormat::kRgba8Unorm);
            };
            break;
        }
        case Def::kTypeAlias: {
            sym = Sym("ALIAS");
            Alias(kDefSource, sym, ty.i32());
            check_expr = [](const sem::Expression* expr) {
                ASSERT_NE(expr, nullptr);
                auto* ty_expr = expr->As<sem::TypeExpression>();
                ASSERT_NE(ty_expr, nullptr);
                EXPECT_TRUE(ty_expr->Type()->Is<core::type::I32>());
            };
            break;
        }
        case Def::kVariable: {
            sym = Sym("VARIABLE");
            auto* c = GlobalConst(kDefSource, sym, Expr(1_i));
            check_expr = [c](const sem::Expression* expr) {
                ASSERT_NE(expr, nullptr);
                auto* var_expr = expr->As<sem::VariableUser>();
                ASSERT_NE(var_expr, nullptr);
                EXPECT_EQ(var_expr->Variable()->Declaration(), c);
            };
            break;
        }
    }

    auto* expr = Expr(Ident(kUseSource, sym));
    switch (GetParam().use) {
        case Use::kAccess:
            GlobalVar("v", ty("texture_storage_2d", "rgba8unorm", expr), Group(0_u), Binding(0_u));
            break;
        case Use::kAddressSpace:
            Enable(wgsl::Extension::kChromiumExperimentalFullPtrParameters);
            Func(Symbols().New(), Vector{Param("p", ty("ptr", expr, ty.f32()))}, ty.void_(),
                 tint::Empty);
            break;
        case Use::kCallExpr:
            fn_stmts.Push(Decl(Var("v", Call(expr))));
            break;
        case Use::kCallStmt:
            fn_stmts.Push(CallStmt(Call(expr)));
            break;
        case Use::kBinaryOp:
            fn_stmts.Push(Decl(Var("v", Mul(1_a, expr))));
            break;
        case Use::kBuiltinValue:
            Func(Symbols().New(), Vector{Param("p", ty.vec4<f32>(), Vector{Builtin(expr)})},
                 ty.void_(), tint::Empty, Vector{Stage(ast::PipelineStage::kFragment)});
            break;
        case Use::kFunctionReturnType:
            Func(Symbols().New(), tint::Empty, ty(expr), Return(Call(sym)));
            break;
        case Use::kInterpolationSampling: {
            fn_params.Push(Param("p", ty.vec4<f32>(),
                                 Vector{
                                     Location(0_a),
                                     Interpolate(core::InterpolationType::kLinear, expr),
                                 }));
            fn_attrs.Push(Stage(ast::PipelineStage::kFragment));
            break;
        }
        case Use::kInterpolationType: {
            fn_params.Push(Param("p", ty.vec4<f32>(),
                                 Vector{
                                     Location(0_a),
                                     Interpolate(expr, core::InterpolationSampling::kCenter),
                                 }));
            fn_attrs.Push(Stage(ast::PipelineStage::kFragment));
            break;
        }
        case Use::kMemberType:
            Structure(Symbols().New(), Vector{Member("m", ty(expr))});
            break;
        case Use::kTexelFormat:
            GlobalVar(Symbols().New(), ty("texture_storage_2d", ty(expr), "write"), Group(0_u),
                      Binding(0_u));
            break;
        case Use::kValueExpression:
            fn_stmts.Push(Decl(Var("v", expr)));
            break;
        case Use::kVariableType:
            fn_stmts.Push(Decl(Var("v", ty(expr))));
            break;
        case Use::kUnaryOp:
            fn_stmts.Push(Assign(Phony(), Negation(expr)));
            break;
    }

    if (!fn_params.IsEmpty() || !fn_stmts.IsEmpty()) {
        Func(Symbols().New(), std::move(fn_params), ty.void_(), std::move(fn_stmts),
             std::move(fn_attrs));
    }

    if (GetParam().error == kPass) {
        EXPECT_TRUE(r()->Resolve());
        EXPECT_EQ(r()->error(), "");
        check_expr(Sem().Get(expr));
    } else {
        EXPECT_FALSE(r()->Resolve());
        EXPECT_EQ(r()->error(), GetParam().error);
    }
}

INSTANTIATE_TEST_SUITE_P(
    ,
    ResolverExpressionKindTest,
    testing::ValuesIn(std::vector<Case>{
        {Def::kAccess, Use::kAccess, kPass},
        {Def::kAccess, Use::kAddressSpace,
         R"(5:6 error: cannot use access 'write' as address space)"},
        {Def::kAccess, Use::kBinaryOp, R"(5:6 error: cannot use access 'write' as value)"},
        {Def::kAccess, Use::kBuiltinValue,
         R"(5:6 error: cannot use access 'write' as builtin value)"},
        {Def::kAccess, Use::kCallExpr, R"(5:6 error: cannot use access 'write' as call target)"},
        {Def::kAccess, Use::kCallStmt, R"(5:6 error: cannot use access 'write' as call target)"},
        {Def::kAccess, Use::kFunctionReturnType, R"(5:6 error: cannot use access 'write' as type)"},
        {Def::kAccess, Use::kInterpolationSampling,
         R"(5:6 error: cannot use access 'write' as interpolation sampling)"},
        {Def::kAccess, Use::kInterpolationType,
         R"(5:6 error: cannot use access 'write' as interpolation type)"},
        {Def::kAccess, Use::kMemberType, R"(5:6 error: cannot use access 'write' as type)"},
        {Def::kAccess, Use::kTexelFormat,
         R"(5:6 error: cannot use access 'write' as texel format)"},
        {Def::kAccess, Use::kValueExpression, R"(5:6 error: cannot use access 'write' as value)"},
        {Def::kAccess, Use::kVariableType, R"(5:6 error: cannot use access 'write' as type)"},
        {Def::kAccess, Use::kUnaryOp, R"(5:6 error: cannot use access 'write' as value)"},

        {Def::kAddressSpace, Use::kAccess,
         R"(5:6 error: cannot use address space 'workgroup' as access)"},
        {Def::kAddressSpace, Use::kAddressSpace, kPass},
        {Def::kAddressSpace, Use::kBinaryOp,
         R"(5:6 error: cannot use address space 'workgroup' as value)"},
        {Def::kAddressSpace, Use::kBuiltinValue,
         R"(5:6 error: cannot use address space 'workgroup' as builtin value)"},
        {Def::kAddressSpace, Use::kCallExpr,
         R"(5:6 error: cannot use address space 'workgroup' as call target)"},
        {Def::kAddressSpace, Use::kCallStmt,
         R"(5:6 error: cannot use address space 'workgroup' as call target)"},
        {Def::kAddressSpace, Use::kFunctionReturnType,
         R"(5:6 error: cannot use address space 'workgroup' as type)"},
        {Def::kAddressSpace, Use::kInterpolationSampling,
         R"(5:6 error: cannot use address space 'workgroup' as interpolation sampling)"},
        {Def::kAddressSpace, Use::kInterpolationType,
         R"(5:6 error: cannot use address space 'workgroup' as interpolation type)"},
        {Def::kAddressSpace, Use::kMemberType,
         R"(5:6 error: cannot use address space 'workgroup' as type)"},
        {Def::kAddressSpace, Use::kTexelFormat,
         R"(5:6 error: cannot use address space 'workgroup' as texel format)"},
        {Def::kAddressSpace, Use::kValueExpression,
         R"(5:6 error: cannot use address space 'workgroup' as value)"},
        {Def::kAddressSpace, Use::kVariableType,
         R"(5:6 error: cannot use address space 'workgroup' as type)"},
        {Def::kAddressSpace, Use::kUnaryOp,
         R"(5:6 error: cannot use address space 'workgroup' as value)"},

        {Def::kBuiltinFunction, Use::kAccess,
         R"(5:6 error: cannot use builtin function 'workgroupBarrier' as access)"},
        {Def::kBuiltinFunction, Use::kAddressSpace,
         R"(5:6 error: cannot use builtin function 'workgroupBarrier' as address space)"},
        {Def::kBuiltinFunction, Use::kBinaryOp,
         R"(5:6 error: cannot use builtin function 'workgroupBarrier' as value
7:8 note: are you missing '()'?)"},
        {Def::kBuiltinFunction, Use::kBuiltinValue,
         R"(5:6 error: cannot use builtin function 'workgroupBarrier' as builtin value)"},
        {Def::kBuiltinFunction, Use::kCallStmt, kPass},
        {Def::kBuiltinFunction, Use::kFunctionReturnType,
         R"(5:6 error: cannot use builtin function 'workgroupBarrier' as type)"},
        {Def::kBuiltinFunction, Use::kInterpolationSampling,
         R"(5:6 error: cannot use builtin function 'workgroupBarrier' as interpolation sampling)"},
        {Def::kBuiltinFunction, Use::kInterpolationType,
         R"(5:6 error: cannot use builtin function 'workgroupBarrier' as interpolation type)"},
        {Def::kBuiltinFunction, Use::kMemberType,
         R"(5:6 error: cannot use builtin function 'workgroupBarrier' as type)"},
        {Def::kBuiltinFunction, Use::kTexelFormat,
         R"(5:6 error: cannot use builtin function 'workgroupBarrier' as texel format)"},
        {Def::kBuiltinFunction, Use::kValueExpression,
         R"(5:6 error: cannot use builtin function 'workgroupBarrier' as value
7:8 note: are you missing '()'?)"},
        {Def::kBuiltinFunction, Use::kVariableType,
         R"(5:6 error: cannot use builtin function 'workgroupBarrier' as type)"},
        {Def::kBuiltinFunction, Use::kUnaryOp,
         R"(5:6 error: cannot use builtin function 'workgroupBarrier' as value
7:8 note: are you missing '()'?)"},

        {Def::kBuiltinType, Use::kAccess, R"(5:6 error: cannot use type 'vec4<f32>' as access)"},
        {Def::kBuiltinType, Use::kAddressSpace,
         R"(5:6 error: cannot use type 'vec4<f32>' as address space)"},
        {Def::kBuiltinType, Use::kBinaryOp,
         R"(5:6 error: cannot use type 'vec4<f32>' as value
7:8 note: are you missing '()'?)"},
        {Def::kBuiltinType, Use::kBuiltinValue,
         R"(5:6 error: cannot use type 'vec4<f32>' as builtin value)"},
        {Def::kBuiltinType, Use::kCallExpr, kPass},
        {Def::kBuiltinType, Use::kFunctionReturnType, kPass},
        {Def::kBuiltinType, Use::kInterpolationSampling,
         R"(5:6 error: cannot use type 'vec4<f32>' as interpolation sampling)"},
        {Def::kBuiltinType, Use::kInterpolationType,
         R"(5:6 error: cannot use type 'vec4<f32>' as interpolation type)"},
        {Def::kBuiltinType, Use::kMemberType, kPass},
        {Def::kBuiltinType, Use::kTexelFormat,
         R"(5:6 error: cannot use type 'vec4<f32>' as texel format)"},
        {Def::kBuiltinType, Use::kValueExpression,
         R"(5:6 error: cannot use type 'vec4<f32>' as value
7:8 note: are you missing '()'?)"},
        {Def::kBuiltinType, Use::kVariableType, kPass},
        {Def::kBuiltinType, Use::kUnaryOp,
         R"(5:6 error: cannot use type 'vec4<f32>' as value
7:8 note: are you missing '()'?)"},

        {Def::kBuiltinValue, Use::kAccess,
         R"(5:6 error: cannot use builtin value 'position' as access)"},
        {Def::kBuiltinValue, Use::kAddressSpace,
         R"(5:6 error: cannot use builtin value 'position' as address space)"},
        {Def::kBuiltinValue, Use::kBinaryOp,
         R"(5:6 error: cannot use builtin value 'position' as value)"},
        {Def::kBuiltinValue, Use::kBuiltinValue, kPass},
        {Def::kBuiltinValue, Use::kCallStmt,
         R"(5:6 error: cannot use builtin value 'position' as call target)"},
        {Def::kBuiltinValue, Use::kCallExpr,
         R"(5:6 error: cannot use builtin value 'position' as call target)"},
        {Def::kBuiltinValue, Use::kFunctionReturnType,
         R"(5:6 error: cannot use builtin value 'position' as type)"},
        {Def::kBuiltinValue, Use::kInterpolationSampling,
         R"(5:6 error: cannot use builtin value 'position' as interpolation sampling)"},
        {Def::kBuiltinValue, Use::kInterpolationType,
         R"(5:6 error: cannot use builtin value 'position' as interpolation type)"},
        {Def::kBuiltinValue, Use::kMemberType,
         R"(5:6 error: cannot use builtin value 'position' as type)"},
        {Def::kBuiltinValue, Use::kTexelFormat,
         R"(5:6 error: cannot use builtin value 'position' as texel format)"},
        {Def::kBuiltinValue, Use::kValueExpression,
         R"(5:6 error: cannot use builtin value 'position' as value)"},
        {Def::kBuiltinValue, Use::kVariableType,
         R"(5:6 error: cannot use builtin value 'position' as type)"},
        {Def::kBuiltinValue, Use::kUnaryOp,
         R"(5:6 error: cannot use builtin value 'position' as value)"},

        {Def::kFunction, Use::kAccess, R"(5:6 error: cannot use function 'FUNCTION' as access
1:2 note: function 'FUNCTION' declared here)"},
        {Def::kFunction, Use::kAddressSpace,
         R"(5:6 error: cannot use function 'FUNCTION' as address space
1:2 note: function 'FUNCTION' declared here)"},
        {Def::kFunction, Use::kBinaryOp, R"(5:6 error: cannot use function 'FUNCTION' as value
1:2 note: function 'FUNCTION' declared here
7:8 note: are you missing '()'?)"},
        {Def::kFunction, Use::kBuiltinValue,
         R"(5:6 error: cannot use function 'FUNCTION' as builtin value
1:2 note: function 'FUNCTION' declared here)"},
        {Def::kFunction, Use::kCallExpr, kPass},
        {Def::kFunction, Use::kCallStmt, kPass},
        {Def::kFunction, Use::kFunctionReturnType,
         R"(5:6 error: cannot use function 'FUNCTION' as type
1:2 note: function 'FUNCTION' declared here)"},
        {Def::kFunction, Use::kInterpolationSampling,
         R"(5:6 error: cannot use function 'FUNCTION' as interpolation sampling
1:2 note: function 'FUNCTION' declared here)"},
        {Def::kFunction, Use::kInterpolationType,
         R"(5:6 error: cannot use function 'FUNCTION' as interpolation type
1:2 note: function 'FUNCTION' declared here)"},
        {Def::kFunction, Use::kMemberType,
         R"(5:6 error: cannot use function 'FUNCTION' as type
1:2 note: function 'FUNCTION' declared here)"},
        {Def::kFunction, Use::kTexelFormat,
         R"(5:6 error: cannot use function 'FUNCTION' as texel format
1:2 note: function 'FUNCTION' declared here)"},
        {Def::kFunction, Use::kValueExpression,
         R"(5:6 error: cannot use function 'FUNCTION' as value
1:2 note: function 'FUNCTION' declared here
7:8 note: are you missing '()'?)"},
        {Def::kFunction, Use::kVariableType,
         R"(5:6 error: cannot use function 'FUNCTION' as type
1:2 note: function 'FUNCTION' declared here)"},
        {Def::kFunction, Use::kUnaryOp, R"(5:6 error: cannot use function 'FUNCTION' as value
1:2 note: function 'FUNCTION' declared here
7:8 note: are you missing '()'?)"},

        {Def::kInterpolationSampling, Use::kAccess,
         R"(5:6 error: cannot use interpolation sampling 'center' as access)"},
        {Def::kInterpolationSampling, Use::kAddressSpace,
         R"(5:6 error: cannot use interpolation sampling 'center' as address space)"},
        {Def::kInterpolationSampling, Use::kBinaryOp,
         R"(5:6 error: cannot use interpolation sampling 'center' as value)"},
        {Def::kInterpolationSampling, Use::kBuiltinValue,
         R"(5:6 error: cannot use interpolation sampling 'center' as builtin value)"},
        {Def::kInterpolationSampling, Use::kCallStmt,
         R"(5:6 error: cannot use interpolation sampling 'center' as call target)"},
        {Def::kInterpolationSampling, Use::kCallExpr,
         R"(5:6 error: cannot use interpolation sampling 'center' as call target)"},
        {Def::kInterpolationSampling, Use::kFunctionReturnType,
         R"(5:6 error: cannot use interpolation sampling 'center' as type)"},
        {Def::kInterpolationSampling, Use::kInterpolationSampling, kPass},
        {Def::kInterpolationSampling, Use::kInterpolationType,
         R"(5:6 error: cannot use interpolation sampling 'center' as interpolation type)"},
        {Def::kInterpolationSampling, Use::kMemberType,
         R"(5:6 error: cannot use interpolation sampling 'center' as type)"},
        {Def::kInterpolationSampling, Use::kTexelFormat,
         R"(5:6 error: cannot use interpolation sampling 'center' as texel format)"},
        {Def::kInterpolationSampling, Use::kValueExpression,
         R"(5:6 error: cannot use interpolation sampling 'center' as value)"},
        {Def::kInterpolationSampling, Use::kVariableType,
         R"(5:6 error: cannot use interpolation sampling 'center' as type)"},
        {Def::kInterpolationSampling, Use::kUnaryOp,
         R"(5:6 error: cannot use interpolation sampling 'center' as value)"},

        {Def::kInterpolationType, Use::kAccess,
         R"(5:6 error: cannot use interpolation type 'linear' as access)"},
        {Def::kInterpolationType, Use::kAddressSpace,
         R"(5:6 error: cannot use interpolation type 'linear' as address space)"},
        {Def::kInterpolationType, Use::kBinaryOp,
         R"(5:6 error: cannot use interpolation type 'linear' as value)"},
        {Def::kInterpolationType, Use::kBuiltinValue,
         R"(5:6 error: cannot use interpolation type 'linear' as builtin value)"},
        {Def::kInterpolationType, Use::kCallStmt,
         R"(5:6 error: cannot use interpolation type 'linear' as call target)"},
        {Def::kInterpolationType, Use::kCallExpr,
         R"(5:6 error: cannot use interpolation type 'linear' as call target)"},
        {Def::kInterpolationType, Use::kFunctionReturnType,
         R"(5:6 error: cannot use interpolation type 'linear' as type)"},
        {Def::kInterpolationType, Use::kInterpolationSampling,
         R"(5:6 error: cannot use interpolation type 'linear' as interpolation sampling)"},
        {Def::kInterpolationType, Use::kInterpolationType, kPass},
        {Def::kInterpolationType, Use::kMemberType,
         R"(5:6 error: cannot use interpolation type 'linear' as type)"},
        {Def::kInterpolationType, Use::kTexelFormat,
         R"(5:6 error: cannot use interpolation type 'linear' as texel format)"},
        {Def::kInterpolationType, Use::kValueExpression,
         R"(5:6 error: cannot use interpolation type 'linear' as value)"},
        {Def::kInterpolationType, Use::kVariableType,
         R"(5:6 error: cannot use interpolation type 'linear' as type)"},
        {Def::kInterpolationType, Use::kUnaryOp,
         R"(5:6 error: cannot use interpolation type 'linear' as value)"},

        {Def::kParameter, Use::kBinaryOp, kPass},
        {Def::kParameter, Use::kCallStmt,
         R"(5:6 error: cannot use parameter 'PARAMETER' as call target
1:2 note: parameter 'PARAMETER' declared here)"},
        {Def::kParameter, Use::kCallExpr,
         R"(5:6 error: cannot use parameter 'PARAMETER' as call target
1:2 note: parameter 'PARAMETER' declared here)"},
        {Def::kParameter, Use::kValueExpression, kPass},
        {Def::kParameter, Use::kVariableType,
         R"(5:6 error: cannot use parameter 'PARAMETER' as type
1:2 note: parameter 'PARAMETER' declared here)"},
        {Def::kParameter, Use::kUnaryOp, kPass},

        {Def::kStruct, Use::kAccess, R"(5:6 error: cannot use type 'STRUCT' as access
1:2 note: struct 'STRUCT' declared here)"},
        {Def::kStruct, Use::kAddressSpace,
         R"(5:6 error: cannot use type 'STRUCT' as address space
1:2 note: struct 'STRUCT' declared here)"},
        {Def::kStruct, Use::kBinaryOp, R"(5:6 error: cannot use type 'STRUCT' as value
1:2 note: struct 'STRUCT' declared here
7:8 note: are you missing '()'?)"},
        {Def::kStruct, Use::kBuiltinValue,
         R"(5:6 error: cannot use type 'STRUCT' as builtin value
1:2 note: struct 'STRUCT' declared here)"},
        {Def::kStruct, Use::kFunctionReturnType, kPass},
        {Def::kStruct, Use::kInterpolationSampling,
         R"(5:6 error: cannot use type 'STRUCT' as interpolation sampling
1:2 note: struct 'STRUCT' declared here)"},
        {Def::kStruct, Use::kInterpolationType,
         R"(5:6 error: cannot use type 'STRUCT' as interpolation type
1:2 note: struct 'STRUCT' declared here)"},
        {Def::kStruct, Use::kMemberType, kPass},
        {Def::kStruct, Use::kTexelFormat, R"(5:6 error: cannot use type 'STRUCT' as texel format
1:2 note: struct 'STRUCT' declared here)"},
        {Def::kStruct, Use::kValueExpression,
         R"(5:6 error: cannot use type 'STRUCT' as value
1:2 note: struct 'STRUCT' declared here
7:8 note: are you missing '()'?)"},
        {Def::kStruct, Use::kVariableType, kPass},
        {Def::kStruct, Use::kUnaryOp,
         R"(5:6 error: cannot use type 'STRUCT' as value
1:2 note: struct 'STRUCT' declared here
7:8 note: are you missing '()'?)"},

        {Def::kTexelFormat, Use::kAccess,
         R"(5:6 error: cannot use texel format 'rgba8unorm' as access)"},
        {Def::kTexelFormat, Use::kAddressSpace,
         R"(5:6 error: cannot use texel format 'rgba8unorm' as address space)"},
        {Def::kTexelFormat, Use::kBinaryOp,
         R"(5:6 error: cannot use texel format 'rgba8unorm' as value)"},
        {Def::kTexelFormat, Use::kBuiltinValue,
         R"(5:6 error: cannot use texel format 'rgba8unorm' as builtin value)"},
        {Def::kTexelFormat, Use::kCallExpr,
         R"(5:6 error: cannot use texel format 'rgba8unorm' as call target)"},
        {Def::kTexelFormat, Use::kCallStmt,
         R"(5:6 error: cannot use texel format 'rgba8unorm' as call target)"},
        {Def::kTexelFormat, Use::kFunctionReturnType,
         R"(5:6 error: cannot use texel format 'rgba8unorm' as type)"},
        {Def::kTexelFormat, Use::kInterpolationSampling,
         R"(5:6 error: cannot use texel format 'rgba8unorm' as interpolation sampling)"},
        {Def::kTexelFormat, Use::kInterpolationType,
         R"(5:6 error: cannot use texel format 'rgba8unorm' as interpolation type)"},
        {Def::kTexelFormat, Use::kMemberType,
         R"(5:6 error: cannot use texel format 'rgba8unorm' as type)"},
        {Def::kTexelFormat, Use::kTexelFormat, kPass},
        {Def::kTexelFormat, Use::kValueExpression,
         R"(5:6 error: cannot use texel format 'rgba8unorm' as value)"},
        {Def::kTexelFormat, Use::kVariableType,
         R"(5:6 error: cannot use texel format 'rgba8unorm' as type)"},
        {Def::kTexelFormat, Use::kUnaryOp,
         R"(5:6 error: cannot use texel format 'rgba8unorm' as value)"},

        {Def::kTypeAlias, Use::kAccess, R"(5:6 error: cannot use type 'i32' as access)"},
        {Def::kTypeAlias, Use::kAddressSpace,
         R"(5:6 error: cannot use type 'i32' as address space)"},
        {Def::kTypeAlias, Use::kBinaryOp,
         R"(5:6 error: cannot use type 'i32' as value
7:8 note: are you missing '()'?)"},
        {Def::kTypeAlias, Use::kBuiltinValue,
         R"(5:6 error: cannot use type 'i32' as builtin value)"},
        {Def::kTypeAlias, Use::kCallExpr, kPass},
        {Def::kTypeAlias, Use::kFunctionReturnType, kPass},
        {Def::kTypeAlias, Use::kInterpolationSampling,
         R"(5:6 error: cannot use type 'i32' as interpolation sampling)"},
        {Def::kTypeAlias, Use::kInterpolationType,
         R"(5:6 error: cannot use type 'i32' as interpolation type)"},
        {Def::kTypeAlias, Use::kMemberType, kPass},
        {Def::kTypeAlias, Use::kTexelFormat, R"(5:6 error: cannot use type 'i32' as texel format)"},
        {Def::kTypeAlias, Use::kValueExpression,
         R"(5:6 error: cannot use type 'i32' as value
7:8 note: are you missing '()'?)"},
        {Def::kTypeAlias, Use::kVariableType, kPass},
        {Def::kTypeAlias, Use::kUnaryOp,
         R"(5:6 error: cannot use type 'i32' as value
7:8 note: are you missing '()'?)"},

        {Def::kVariable, Use::kAccess, R"(5:6 error: cannot use const 'VARIABLE' as access
1:2 note: const 'VARIABLE' declared here)"},
        {Def::kVariable, Use::kAddressSpace,
         R"(5:6 error: cannot use const 'VARIABLE' as address space
1:2 note: const 'VARIABLE' declared here)"},
        {Def::kVariable, Use::kBinaryOp, kPass},
        {Def::kVariable, Use::kBuiltinValue,
         R"(5:6 error: cannot use const 'VARIABLE' as builtin value
1:2 note: const 'VARIABLE' declared here)"},
        {Def::kVariable, Use::kCallStmt,
         R"(5:6 error: cannot use const 'VARIABLE' as call target
1:2 note: const 'VARIABLE' declared here)"},
        {Def::kVariable, Use::kCallExpr,
         R"(5:6 error: cannot use const 'VARIABLE' as call target
1:2 note: const 'VARIABLE' declared here)"},
        {Def::kVariable, Use::kFunctionReturnType,
         R"(5:6 error: cannot use const 'VARIABLE' as type
1:2 note: const 'VARIABLE' declared here)"},
        {Def::kVariable, Use::kInterpolationSampling,
         R"(5:6 error: cannot use const 'VARIABLE' as interpolation sampling
1:2 note: const 'VARIABLE' declared here)"},
        {Def::kVariable, Use::kInterpolationType,
         R"(5:6 error: cannot use const 'VARIABLE' as interpolation type
1:2 note: const 'VARIABLE' declared here)"},
        {Def::kVariable, Use::kMemberType,
         R"(5:6 error: cannot use const 'VARIABLE' as type
1:2 note: const 'VARIABLE' declared here)"},
        {Def::kVariable, Use::kTexelFormat,
         R"(5:6 error: cannot use const 'VARIABLE' as texel format
1:2 note: const 'VARIABLE' declared here)"},
        {Def::kVariable, Use::kValueExpression, kPass},
        {Def::kVariable, Use::kVariableType,
         R"(5:6 error: cannot use const 'VARIABLE' as type
1:2 note: const 'VARIABLE' declared here)"},
        {Def::kVariable, Use::kUnaryOp, kPass},
    }));

}  // namespace
}  // namespace tint::resolver