| // Copyright (c) 2013 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "gn/scope.h" |
| |
| #include "gn/input_file.h" |
| #include "gn/parse_tree.h" |
| #include "gn/source_file.h" |
| #include "gn/template.h" |
| #include "gn/test_with_scope.h" |
| #include "util/test/test.h" |
| |
| namespace { |
| |
| bool HasStringValueEqualTo(const Scope* scope, |
| const char* name, |
| const char* expected_value) { |
| const Value* value = scope->GetValue(name); |
| if (!value) |
| return false; |
| if (value->type() != Value::STRING) |
| return false; |
| return value->string_value() == expected_value; |
| } |
| |
| bool ContainsBuildDependencyFile(const Scope* scope, |
| const SourceFile& source_file) { |
| const auto& build_dependency_files = scope->build_dependency_files(); |
| return build_dependency_files.end() != |
| build_dependency_files.find(source_file); |
| } |
| |
| } // namespace |
| |
| TEST(Scope, InheritBuildDependencyFilesFromParent) { |
| TestWithScope setup; |
| SourceFile source_file = SourceFile("//a/BUILD.gn"); |
| setup.scope()->AddBuildDependencyFile(source_file); |
| |
| Scope new_scope(setup.scope()); |
| EXPECT_EQ(1U, new_scope.build_dependency_files().size()); |
| EXPECT_TRUE(ContainsBuildDependencyFile(&new_scope, source_file)); |
| } |
| |
| TEST(Scope, NonRecursiveMergeTo) { |
| TestWithScope setup; |
| |
| // Make a pretend parse node with proper tracking that we can blame for the |
| // given value. |
| InputFile input_file(SourceFile("//foo")); |
| Token assignment_token(Location(&input_file, 1, 1, 1), Token::STRING, |
| "\"hello\""); |
| LiteralNode assignment; |
| assignment.set_value(assignment_token); |
| |
| // Add some values to the scope. |
| Value old_value(&assignment, "hello"); |
| setup.scope()->SetValue("v", old_value, &assignment); |
| std::string_view private_var_name("_private"); |
| setup.scope()->SetValue(private_var_name, old_value, &assignment); |
| |
| // Add some templates to the scope. |
| FunctionCallNode templ_definition; |
| scoped_refptr<Template> templ(new Template(setup.scope(), &templ_definition)); |
| setup.scope()->AddTemplate("templ", templ.get()); |
| scoped_refptr<Template> private_templ( |
| new Template(setup.scope(), &templ_definition)); |
| setup.scope()->AddTemplate("_templ", private_templ.get()); |
| |
| // Detect collisions of values' values. |
| { |
| Scope new_scope(setup.settings()); |
| Value new_value(&assignment, "goodbye"); |
| new_scope.SetValue("v", new_value, &assignment); |
| |
| Err err; |
| EXPECT_FALSE(setup.scope()->NonRecursiveMergeTo( |
| &new_scope, Scope::MergeOptions(), &assignment, "error", &err)); |
| EXPECT_TRUE(err.has_error()); |
| } |
| |
| // Template name collisions. |
| { |
| Scope new_scope(setup.settings()); |
| |
| scoped_refptr<Template> new_templ( |
| new Template(&new_scope, &templ_definition)); |
| new_scope.AddTemplate("templ", new_templ.get()); |
| |
| Err err; |
| EXPECT_FALSE(setup.scope()->NonRecursiveMergeTo( |
| &new_scope, Scope::MergeOptions(), &assignment, "error", &err)); |
| EXPECT_TRUE(err.has_error()); |
| } |
| |
| // The clobber flag should just overwrite colliding values. |
| { |
| Scope new_scope(setup.settings()); |
| Value new_value(&assignment, "goodbye"); |
| new_scope.SetValue("v", new_value, &assignment); |
| |
| Err err; |
| Scope::MergeOptions options; |
| options.clobber_existing = true; |
| EXPECT_TRUE(setup.scope()->NonRecursiveMergeTo(&new_scope, options, |
| &assignment, "error", &err)); |
| EXPECT_FALSE(err.has_error()); |
| |
| const Value* found_value = new_scope.GetValue("v"); |
| ASSERT_TRUE(found_value); |
| EXPECT_TRUE(old_value == *found_value); |
| } |
| |
| // Clobber flag for templates. |
| { |
| Scope new_scope(setup.settings()); |
| |
| scoped_refptr<Template> new_templ( |
| new Template(&new_scope, &templ_definition)); |
| new_scope.AddTemplate("templ", new_templ.get()); |
| Scope::MergeOptions options; |
| options.clobber_existing = true; |
| |
| Err err; |
| EXPECT_TRUE(setup.scope()->NonRecursiveMergeTo(&new_scope, options, |
| &assignment, "error", &err)); |
| EXPECT_FALSE(err.has_error()); |
| |
| const Template* found_value = new_scope.GetTemplate("templ"); |
| ASSERT_TRUE(found_value); |
| EXPECT_TRUE(templ.get() == found_value); |
| } |
| |
| // Don't flag values that technically collide but have the same value. |
| { |
| Scope new_scope(setup.settings()); |
| Value new_value(&assignment, "hello"); |
| new_scope.SetValue("v", new_value, &assignment); |
| |
| Err err; |
| EXPECT_TRUE(setup.scope()->NonRecursiveMergeTo( |
| &new_scope, Scope::MergeOptions(), &assignment, "error", &err)); |
| EXPECT_FALSE(err.has_error()); |
| } |
| |
| // Templates that technically collide but are the same. |
| { |
| Scope new_scope(setup.settings()); |
| |
| scoped_refptr<Template> new_templ( |
| new Template(&new_scope, &templ_definition)); |
| new_scope.AddTemplate("templ", templ.get()); |
| |
| Err err; |
| EXPECT_TRUE(setup.scope()->NonRecursiveMergeTo( |
| &new_scope, Scope::MergeOptions(), &assignment, "error", &err)); |
| EXPECT_FALSE(err.has_error()); |
| } |
| |
| // Copy private values and templates. |
| { |
| Scope new_scope(setup.settings()); |
| |
| Err err; |
| EXPECT_TRUE(setup.scope()->NonRecursiveMergeTo( |
| &new_scope, Scope::MergeOptions(), &assignment, "error", &err)); |
| EXPECT_FALSE(err.has_error()); |
| EXPECT_TRUE(new_scope.GetValue(private_var_name)); |
| EXPECT_TRUE(new_scope.GetTemplate("_templ")); |
| } |
| |
| // Skip private values and templates. |
| { |
| Scope new_scope(setup.settings()); |
| |
| Err err; |
| Scope::MergeOptions options; |
| options.skip_private_vars = true; |
| EXPECT_TRUE(setup.scope()->NonRecursiveMergeTo(&new_scope, options, |
| &assignment, "error", &err)); |
| EXPECT_FALSE(err.has_error()); |
| EXPECT_FALSE(new_scope.GetValue(private_var_name)); |
| EXPECT_FALSE(new_scope.GetTemplate("_templ")); |
| } |
| |
| // Don't mark used. |
| { |
| Scope new_scope(setup.settings()); |
| |
| Err err; |
| Scope::MergeOptions options; |
| EXPECT_TRUE(setup.scope()->NonRecursiveMergeTo(&new_scope, options, |
| &assignment, "error", &err)); |
| EXPECT_FALSE(err.has_error()); |
| EXPECT_FALSE(new_scope.CheckForUnusedVars(&err)); |
| EXPECT_TRUE(err.has_error()); |
| } |
| |
| // Mark dest used. |
| { |
| Scope new_scope(setup.settings()); |
| |
| Err err; |
| Scope::MergeOptions options; |
| options.mark_dest_used = true; |
| EXPECT_TRUE(setup.scope()->NonRecursiveMergeTo(&new_scope, options, |
| &assignment, "error", &err)); |
| EXPECT_FALSE(err.has_error()); |
| EXPECT_TRUE(new_scope.CheckForUnusedVars(&err)); |
| EXPECT_FALSE(err.has_error()); |
| } |
| |
| // Build dependency files are merged. |
| { |
| Scope from_scope(setup.settings()); |
| SourceFile source_file = SourceFile("//a/BUILD.gn"); |
| from_scope.AddBuildDependencyFile(source_file); |
| |
| Scope to_scope(setup.settings()); |
| EXPECT_FALSE(ContainsBuildDependencyFile(&to_scope, source_file)); |
| |
| Scope::MergeOptions options; |
| Err err; |
| EXPECT_TRUE(from_scope.NonRecursiveMergeTo(&to_scope, options, &assignment, |
| "error", &err)); |
| EXPECT_FALSE(err.has_error()); |
| EXPECT_EQ(1U, to_scope.build_dependency_files().size()); |
| EXPECT_TRUE(ContainsBuildDependencyFile(&to_scope, source_file)); |
| } |
| } |
| |
| TEST(Scope, MakeClosure) { |
| // Create 3 nested scopes [const root from setup] <- nested1 <- nested2. |
| TestWithScope setup; |
| |
| // Make a pretend parse node with proper tracking that we can blame for the |
| // given value. |
| InputFile input_file(SourceFile("//foo")); |
| Token assignment_token(Location(&input_file, 1, 1, 1), Token::STRING, |
| "\"hello\""); |
| LiteralNode assignment; |
| assignment.set_value(assignment_token); |
| setup.scope()->SetValue("on_root", Value(&assignment, "on_root"), |
| &assignment); |
| |
| // Root scope should be const from the nested caller's perspective. |
| Scope nested1(static_cast<const Scope*>(setup.scope())); |
| nested1.SetValue("on_one", Value(&assignment, "on_one"), &assignment); |
| |
| Scope nested2(&nested1); |
| nested2.SetValue("on_one", Value(&assignment, "on_two"), &assignment); |
| nested2.SetValue("on_two", Value(&assignment, "on_two2"), &assignment); |
| |
| // Making a closure from the root scope. |
| std::unique_ptr<Scope> result = setup.scope()->MakeClosure(); |
| EXPECT_FALSE(result->containing()); // Should have no containing scope. |
| EXPECT_TRUE(result->GetValue("on_root")); // Value should be copied. |
| |
| // Making a closure from the second nested scope. |
| result = nested2.MakeClosure(); |
| EXPECT_EQ(setup.scope(), |
| result->containing()); // Containing scope should be the root. |
| EXPECT_TRUE(HasStringValueEqualTo(result.get(), "on_root", "on_root")); |
| EXPECT_TRUE(HasStringValueEqualTo(result.get(), "on_one", "on_two")); |
| EXPECT_TRUE(HasStringValueEqualTo(result.get(), "on_two", "on_two2")); |
| } |
| |
| TEST(Scope, GetMutableValue) { |
| TestWithScope setup; |
| |
| // Make a pretend parse node with proper tracking that we can blame for the |
| // given value. |
| InputFile input_file(SourceFile("//foo")); |
| Token assignment_token(Location(&input_file, 1, 1, 1), Token::STRING, |
| "\"hello\""); |
| LiteralNode assignment; |
| assignment.set_value(assignment_token); |
| |
| const char kOnConst[] = "on_const"; |
| const char kOnMutable1[] = "on_mutable1"; |
| const char kOnMutable2[] = "on_mutable2"; |
| |
| Value value(&assignment, "hello"); |
| |
| // Create a root scope with one value. |
| Scope root_scope(setup.settings()); |
| root_scope.SetValue(kOnConst, value, &assignment); |
| |
| // Create a first nested scope with a different value. |
| const Scope* const_root_scope = &root_scope; |
| Scope mutable_scope1(const_root_scope); |
| mutable_scope1.SetValue(kOnMutable1, value, &assignment); |
| |
| // Create a second nested scope with a different value. |
| Scope mutable_scope2(&mutable_scope1); |
| mutable_scope2.SetValue(kOnMutable2, value, &assignment); |
| |
| // Check getting root scope values. |
| EXPECT_TRUE(mutable_scope2.GetValue(kOnConst, true)); |
| EXPECT_FALSE( |
| mutable_scope2.GetMutableValue(kOnConst, Scope::SEARCH_NESTED, true)); |
| |
| // Test reading a value from scope 1. |
| Value* mutable1_result = |
| mutable_scope2.GetMutableValue(kOnMutable1, Scope::SEARCH_NESTED, false); |
| ASSERT_TRUE(mutable1_result); |
| EXPECT_TRUE(*mutable1_result == value); |
| |
| // Make sure CheckForUnusedVars works on scope1 (we didn't mark the value as |
| // used in the previous step). |
| Err err; |
| EXPECT_FALSE(mutable_scope1.CheckForUnusedVars(&err)); |
| mutable1_result = |
| mutable_scope2.GetMutableValue(kOnMutable1, Scope::SEARCH_NESTED, true); |
| EXPECT_TRUE(mutable1_result); |
| err = Err(); |
| EXPECT_TRUE(mutable_scope1.CheckForUnusedVars(&err)); |
| |
| // Test reading a value from scope 2. |
| Value* mutable2_result = |
| mutable_scope2.GetMutableValue(kOnMutable2, Scope::SEARCH_NESTED, true); |
| ASSERT_TRUE(mutable2_result); |
| EXPECT_TRUE(*mutable2_result == value); |
| } |
| |
| TEST(Scope, RemovePrivateIdentifiers) { |
| TestWithScope setup; |
| setup.scope()->SetValue("a", Value(nullptr, true), nullptr); |
| setup.scope()->SetValue("_b", Value(nullptr, true), nullptr); |
| |
| setup.scope()->RemovePrivateIdentifiers(); |
| EXPECT_TRUE(setup.scope()->GetValue("a")); |
| EXPECT_FALSE(setup.scope()->GetValue("_b")); |
| } |