src/tint/reader/wgsl/parser_impl_enable_directive_test.cc

// Copyright 2022 The Tint Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "src/tint/reader/wgsl/parser_impl_test_helper.h"

#include "src/tint/ast/enable.h"

namespace tint::reader::wgsl {
namespace {

using EnableDirectiveTest = ParserImplTest;

// Test a valid enable directive.
TEST_F(EnableDirectiveTest, Valid) {
    auto p = parser("enable InternalExtensionForTesting;");
    p->enable_directive();
    EXPECT_FALSE(p->has_error()) << p->error();
    auto program = p->program();
    auto& ast = program.AST();
    EXPECT_EQ(ast.Extensions(),
              ast::ExtensionSet{ast::Enable::ExtensionKind::kInternalExtensionForTesting});
    EXPECT_EQ(ast.GlobalDeclarations().size(), 1u);
    auto* node = ast.GlobalDeclarations()[0]->As<ast::Enable>();
    EXPECT_TRUE(node != nullptr);
    EXPECT_EQ(node->name, "InternalExtensionForTesting");
    EXPECT_EQ(node->kind, ast::Enable::ExtensionKind::kInternalExtensionForTesting);
}

// Test multiple enable directives for a same extension.
TEST_F(EnableDirectiveTest, EnableMultipleTime) {
    auto p = parser(R"(
enable InternalExtensionForTesting;
enable InternalExtensionForTesting;
)");
    p->translation_unit();
    EXPECT_FALSE(p->has_error()) << p->error();
    auto program = p->program();
    auto& ast = program.AST();
    EXPECT_EQ(ast.Extensions(),
              ast::ExtensionSet{ast::Enable::ExtensionKind::kInternalExtensionForTesting});
    EXPECT_EQ(ast.GlobalDeclarations().size(), 2u);
    auto* node1 = ast.GlobalDeclarations()[0]->As<ast::Enable>();
    EXPECT_TRUE(node1 != nullptr);
    EXPECT_EQ(node1->name, "InternalExtensionForTesting");
    EXPECT_EQ(node1->kind, ast::Enable::ExtensionKind::kInternalExtensionForTesting);
    auto* node2 = ast.GlobalDeclarations()[1]->As<ast::Enable>();
    EXPECT_TRUE(node2 != nullptr);
    EXPECT_EQ(node2->name, "InternalExtensionForTesting");
    EXPECT_EQ(node2->kind, ast::Enable::ExtensionKind::kInternalExtensionForTesting);
}

// Test an unknown extension identifier.
TEST_F(EnableDirectiveTest, InvalidIdentifier) {
    auto p = parser("enable NotAValidExtensionName;");
    p->enable_directive();
    // Error when unknown extension found
    EXPECT_TRUE(p->has_error());
    EXPECT_EQ(p->error(), "1:8: unsupported extension: 'NotAValidExtensionName'");
    auto program = p->program();
    auto& ast = program.AST();
    EXPECT_EQ(ast.Extensions().size(), 0u);
    EXPECT_EQ(ast.GlobalDeclarations().size(), 0u);
}

// Test an enable directive missing ending semiclon.
TEST_F(EnableDirectiveTest, MissingEndingSemiclon) {
    auto p = parser("enable InternalExtensionForTesting");
    p->translation_unit();
    EXPECT_TRUE(p->has_error());
    EXPECT_EQ(p->error(), "1:35: expected ';' for enable directive");
    auto program = p->program();
    auto& ast = program.AST();
    EXPECT_EQ(ast.Extensions().size(), 0u);
    EXPECT_EQ(ast.GlobalDeclarations().size(), 0u);
}

// Test using invalid tokens in an enable directive.
TEST_F(EnableDirectiveTest, InvalidTokens) {
    {
        auto p = parser("enable InternalExtensionForTesting<;");
        p->translation_unit();
        EXPECT_TRUE(p->has_error());
        EXPECT_EQ(p->error(), "1:35: expected ';' for enable directive");
        auto program = p->program();
        auto& ast = program.AST();
        EXPECT_EQ(ast.Extensions().size(), 0u);
        EXPECT_EQ(ast.GlobalDeclarations().size(), 0u);
    }
    {
        auto p = parser("enable <InternalExtensionForTesting;");
        p->translation_unit();
        EXPECT_TRUE(p->has_error());
        EXPECT_EQ(p->error(), "1:8: invalid extension name");
        auto program = p->program();
        auto& ast = program.AST();
        EXPECT_EQ(ast.Extensions().size(), 0u);
        EXPECT_EQ(ast.GlobalDeclarations().size(), 0u);
    }
    {
        auto p = parser("enable =;");
        p->translation_unit();
        EXPECT_TRUE(p->has_error());
        EXPECT_EQ(p->error(), "1:8: invalid extension name");
        auto program = p->program();
        auto& ast = program.AST();
        EXPECT_EQ(ast.Extensions().size(), 0u);
        EXPECT_EQ(ast.GlobalDeclarations().size(), 0u);
    }
    {
        auto p = parser("enable vec4;");
        p->translation_unit();
        EXPECT_TRUE(p->has_error());
        EXPECT_EQ(p->error(), "1:8: invalid extension name");
        auto program = p->program();
        auto& ast = program.AST();
        EXPECT_EQ(ast.Extensions().size(), 0u);
        EXPECT_EQ(ast.GlobalDeclarations().size(), 0u);
    }
}

// Test an enable directive go after other global declarations.
TEST_F(EnableDirectiveTest, FollowingOtherGlobalDecl) {
    auto p = parser(R"(
var<private> t: f32 = 0f;
enable InternalExtensionForTesting;
)");
    p->translation_unit();
    EXPECT_TRUE(p->has_error());
    EXPECT_EQ(p->error(), "3:1: enable directives must come before all global declarations");
    auto program = p->program();
    auto& ast = program.AST();
    // Accept the enable directive although it cause an error
    EXPECT_EQ(ast.Extensions(),
              ast::ExtensionSet{ast::Enable::ExtensionKind::kInternalExtensionForTesting});
    EXPECT_EQ(ast.GlobalDeclarations().size(), 2u);
}

// Test an enable directive go after an empty semiclon.
TEST_F(EnableDirectiveTest, FollowingEmptySemiclon) {
    auto p = parser(R"(
;
enable InternalExtensionForTesting;
)");
    p->translation_unit();
    // An empty semiclon is treated as a global declaration
    EXPECT_TRUE(p->has_error());
    EXPECT_EQ(p->error(), "3:1: enable directives must come before all global declarations");
    auto program = p->program();
    auto& ast = program.AST();
    // Accept the enable directive although it cause an error
    EXPECT_EQ(ast.Extensions(),
              ast::ExtensionSet{ast::Enable::ExtensionKind::kInternalExtensionForTesting});
    EXPECT_EQ(ast.GlobalDeclarations().size(), 1u);
}

}  // namespace
}  // namespace tint::reader::wgsl