Rename some of the enum definitions inside classes to avoid conflict with the ObjectKind enum.

vm/object_test.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/isolate.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
@@ skipping 11 matching lines @@
   // Class has no fields.
   const Array& no_fields = Array::Handle(Array::Empty());
   cls.SetFields(no_fields);
 
   // Create and populate the function arrays.
   const Array& functions = Array::Handle(Array::New(6));
   Function& function = Function::Handle();
   String& function_name = String::Handle();
   function_name = String::NewSymbol("foo");
   function = Function::New(
-      function_name, RawFunction::kFunction, false, false, 0);
+      function_name, RawFunction::kRegularFunction, false, false, 0);
   functions.SetAt(0, function);
   function_name = String::NewSymbol("bar");
   function = Function::New(
-      function_name, RawFunction::kFunction, false, false, 0);
+      function_name, RawFunction::kRegularFunction, false, false, 0);
 
   const int kNumFixedParameters = 2;
   const int kNumOptionalParameters = 3;
   function.set_num_fixed_parameters(kNumFixedParameters);
   function.set_num_optional_parameters(kNumOptionalParameters);
   functions.SetAt(1, function);
 
   function_name = String::NewSymbol("baz");
   function = Function::New(
-      function_name, RawFunction::kFunction, false, false, 0);
+      function_name, RawFunction::kRegularFunction, false, false, 0);
   functions.SetAt(2, function);
 
   function_name = String::NewSymbol("Foo");
   function = Function::New(
-      function_name, RawFunction::kFunction, true, false, 0);
+      function_name, RawFunction::kRegularFunction, true, false, 0);
   functions.SetAt(3, function);
   function_name = String::NewSymbol("Bar");
   function = Function::New(
-      function_name, RawFunction::kFunction, true, false, 0);
+      function_name, RawFunction::kRegularFunction, true, false, 0);
   functions.SetAt(4, function);
   function_name = String::NewSymbol("BaZ");
   function = Function::New(
-      function_name, RawFunction::kFunction, true, false, 0);
+      function_name, RawFunction::kRegularFunction, true, false, 0);
   functions.SetAt(5, function);
 
   // Setup the functions in the class.
   cls.SetFunctions(functions);
 
   function_name = String::New("Foo");
   function = cls.LookupDynamicFunction(function_name);
   EXPECT(function.IsNull());
   function = cls.LookupStaticFunction(function_name);
   EXPECT(!function.IsNull());
@@ skipping 2105 matching lines @@
 }
 
 
 TEST_CASE(Script) {
   const char* url_chars = "builtin:test-case";
   const char* source_chars = "This will not compile.";
   const String& url = String::Handle(String::New(url_chars));
   const String& source = String::Handle(String::New(source_chars));
   const Script& script = Script::Handle(Script::New(url,
                                                     source,
-                                                    RawScript::kSource));
+                                                    RawScript::kSourceTag));
   EXPECT(!script.IsNull());
   EXPECT(script.IsScript());
   String& str = String::Handle(script.url());
   EXPECT_EQ(17, str.Length());
   EXPECT_EQ('b', str.CharAt(0));
   EXPECT_EQ(':', str.CharAt(7));
   EXPECT_EQ('e', str.CharAt(16));
   str = script.Source();
   EXPECT_EQ(22, str.Length());
   EXPECT_EQ('T', str.CharAt(0));
@@ skipping 120 matching lines @@
   // Allocate the class first.
   const String& class_name = String::Handle(String::NewSymbol("MyClass"));
   const Script& script = Script::Handle();
   const Class& cls =
       Class::Handle(Class::New(class_name, script, Scanner::kDummyTokenIndex));
   const Array& functions = Array::Handle(Array::New(1));
 
   const Context& context = Context::Handle(Context::New(0));
   Function& parent = Function::Handle();
   const String& parent_name = String::Handle(String::NewSymbol("foo_papa"));
-  parent = Function::New(parent_name, RawFunction::kFunction, false, false, 0);
+  parent = Function::New(parent_name, RawFunction::kRegularFunction,
+                         false, false, 0);
   functions.SetAt(0, parent);
   cls.SetFunctions(functions);
 
   Function& function = Function::Handle();
   const String& function_name = String::Handle(String::NewSymbol("foo"));
   function = Function::NewClosureFunction(function_name, parent, 0);
   const Class& signature_class = Class::Handle(
       Class::NewSignatureClass(function_name, function, script));
   const Closure& closure = Closure::Handle(Closure::New(function, context));
   const Class& closure_class = Class::Handle(closure.clazz());
@@ skipping 48 matching lines @@
   EXPECT(!str3.IsOneByteString());
 }
 
 
 // only ia32 and x64 can run execution tests.
 #if defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64)
 
 static Function* CreateFunction(const char* name) {
   const String& function_name = String::ZoneHandle(String::NewSymbol(name));
   Function& function = Function::ZoneHandle(
-      Function::New(function_name, RawFunction::kFunction, true, false, 0));
+      Function::New(function_name, RawFunction::kRegularFunction,
+                    true, false, 0));
   return &function;
 }
 
 // Test for Code and Instruction object creation.
 TEST_CASE(Code) {
   extern void GenerateIncrement(Assembler* assembler);
   Assembler _assembler_;
   GenerateIncrement(&_assembler_);
   Code& code = Code::Handle(Code::FinalizeCode(
       *CreateFunction("Test_Code"), &_assembler_));
@@ skipping 163 matching lines @@
   }
   ASSERT(count == 2);
 }
 
 
 static RawFunction* GetDummyTarget(const char* name) {
   const String& function_name = String::Handle(String::NewSymbol(name));
   const bool is_static = false;
   const bool is_const = false;
   return Function::New(function_name,
-                       RawFunction::kFunction,
+                       RawFunction::kRegularFunction,
                        is_static,
                        is_const,
                        0);
 }
 
 
 TEST_CASE(ICData) {
   Function& function = Function::Handle(GetDummyTarget("Bern"));
   const intptr_t id = 12;
   const intptr_t num_args_tested = 1;
@@ skipping 187 matching lines @@
   // Named double-private constructor mismatch.
   mangled_name = OneByteString::New("foo@12345.named@12345");
   bare_name = OneByteString::New("foo.name");
   EXPECT(!mangled_name.EqualsIgnoringPrivateKey(bare_name));
 }
 
 
 #endif  // defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64).
 
 }  // namespace dart