Add token index position to classes and types for more accurate error reporting.

runtime/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"
 #include "vm/unit_test.h"
 
 namespace dart {
 
 TEST_CASE(Class) {
   // 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));
+  const Class& cls = Class::Handle(
+      Class::New(class_name, script, Scanner::kDummyTokenIndex));
 
   // 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");
@@ skipping 57 matching lines @@
   function_name = String::New("bar");
   function = cls.LookupDynamicFunction(function_name);
   EXPECT(!function.IsNull());
   EXPECT_EQ(kNumFixedParameters, function.num_fixed_parameters());
   EXPECT_EQ(kNumOptionalParameters, function.num_optional_parameters());
 
   const Array& interfaces = Array::Handle(Array::New(2));
   Class& interface = Class::Handle();
   String& interface_name = String::Handle();
   interface_name = String::NewSymbol("Harley");
-  interface = Class::New(interface_name, script);
+  interface = Class::New(interface_name, script, Scanner::kDummyTokenIndex);
   interfaces.SetAt(0, Type::Handle(Type::NewNonParameterizedType(interface)));
   interface_name = String::NewSymbol("Norton");
-  interface = Class::New(interface_name, script);
+  interface = Class::New(interface_name, script, Scanner::kDummyTokenIndex);
   interfaces.SetAt(1, Type::Handle(Type::NewNonParameterizedType(interface)));
   cls.set_interfaces(interfaces);
   cls.Finalize();
 
   const Array& array = Array::Handle(cls.functions_cache());
   array.SetAt(0, function_name);
   cls.set_functions_cache(array);
   String& test_name = String::Handle();
   test_name ^= Array::Handle(cls.functions_cache()).At(0);
   EXPECT(test_name.Equals(function_name));
@@ skipping 34 matching lines @@
   EXPECT_EQ(Token::kLPAREN, token_stream.KindAt(1));
   EXPECT_EQ(Token::kPERIOD, token_stream.KindAt(4));
   EXPECT_EQ(Token::kEOS, token_stream.KindAt(5));
 }
 
 
 TEST_CASE(InstanceClass) {
   // Allocate the class first.
   String& class_name = String::Handle(String::NewSymbol("EmptyClass"));
   Script& script = Script::Handle();
-  const Class& empty_class = Class::Handle(Class::New(class_name, script));
+  const Class& empty_class =
+      Class::Handle(Class::New(class_name, script, Scanner::kDummyTokenIndex));
 
   // No functions and no super class for the EmptyClass.
   const Array& no_fields = Array::Handle(Array::Empty());
   empty_class.SetFields(no_fields);
   empty_class.Finalize();
   EXPECT_EQ(kObjectAlignment, empty_class.instance_size());
   Instance& instance = Instance::Handle(Instance::New(empty_class));
   EXPECT_EQ(empty_class.raw(), instance.clazz());
 
   class_name = String::NewSymbol("OneFieldClass");
-  const Class& one_field_class = Class::Handle(Class::New(class_name, script));
+  const Class& one_field_class =
+      Class::Handle(Class::New(class_name, script, Scanner::kDummyTokenIndex));
 
   // No functions and no super class for the OneFieldClass.
   const Array& one_fields = Array::Handle(Array::New(1));
   const String& field_name = String::Handle(String::NewSymbol("the_field"));
   const Field& field = Field::Handle(Field::New(field_name, false, false, 0));
   one_fields.SetAt(0, field);
   one_field_class.SetFields(one_fields);
   one_field_class.Finalize();
   intptr_t header_size = sizeof(RawObject);
   EXPECT_EQ(Utils::RoundUp((header_size + (1 * kWordSize)), kObjectAlignment),
             one_field_class.instance_size());
   EXPECT_EQ(header_size, field.Offset());
 }
 
 
 TEST_CASE(Interface) {
   String& class_name = String::Handle(String::NewSymbol("EmptyClass"));
   Script& script = Script::Handle();
-  const Class& factory_class = Class::Handle(Class::New(class_name, script));
+  const Class& factory_class =
+      Class::Handle(Class::New(class_name, script, Scanner::kDummyTokenIndex));
   const Array& no_fields = Array::Handle(Array::Empty());
   // Finalizes the class.
   factory_class.SetFields(no_fields);
 
   String& interface_name = String::Handle(String::NewSymbol("MyInterface"));
-  const Class& interface =
-      Class::Handle(Class::NewInterface(interface_name, script));
+  const Class& interface = Class::Handle(
+      Class::NewInterface(interface_name, script, Scanner::kDummyTokenIndex));
   EXPECT(interface.is_interface());
   EXPECT(!factory_class.is_interface());
   EXPECT(!interface.HasFactoryClass());
   interface.set_factory_class(factory_class);
   EXPECT_EQ(factory_class.raw(), interface.FactoryClass());
 }
 
 
 TEST_CASE(Smi) {
   const Smi& smi = Smi::Handle(Smi::New(5));
@@ skipping 1845 matching lines @@
   context.SetAt(2, Smi::Handle(Smi::New(3)));
   Smi& smi = Smi::Handle();
   smi ^= context.At(0);
   EXPECT_EQ(2, smi.Value());
   smi ^= context.At(2);
   EXPECT_EQ(3, smi.Value());
 }
 
 
 TEST_CASE(ContextScope) {
-  const intptr_t kPos = 1;  // Dummy token index in non-existing source.
   const intptr_t parent_scope_function_level = 0;
   LocalScope* parent_scope =
       new LocalScope(NULL, parent_scope_function_level, 0);
 
   const intptr_t local_scope_function_level = 1;
   LocalScope* local_scope =
       new LocalScope(parent_scope, local_scope_function_level, 0);
 
   const Type& dynamic_type = Type::ZoneHandle(Type::DynamicType());
   const String& a = String::ZoneHandle(String::New("a"));
-  LocalVariable* var_a = new LocalVariable(kPos, a, dynamic_type);
+  LocalVariable* var_a =
+      new LocalVariable(Scanner::kDummyTokenIndex, a, dynamic_type);
   parent_scope->AddVariable(var_a);
 
   const String& b = String::ZoneHandle(String::New("b"));
-  LocalVariable* var_b = new LocalVariable(kPos, b, dynamic_type);
+  LocalVariable* var_b =
+      new LocalVariable(Scanner::kDummyTokenIndex, b, dynamic_type);
   local_scope->AddVariable(var_b);
 
   const String& c = String::ZoneHandle(String::New("c"));
-  LocalVariable* var_c = new LocalVariable(kPos, c, dynamic_type);
+  LocalVariable* var_c =
+      new LocalVariable(Scanner::kDummyTokenIndex, c, dynamic_type);
   parent_scope->AddVariable(var_c);
 
   bool test_only = false;  // Please, insert alias.
   var_a = local_scope->LookupVariable(a, test_only);
   EXPECT(var_a->is_captured());
   EXPECT_EQ(parent_scope_function_level, var_a->owner()->function_level());
   EXPECT(local_scope->LocalLookupVariable(a) == var_a);  // Alias.
 
   var_b = local_scope->LookupVariable(b, test_only);
   EXPECT(!var_b->is_captured());
@@ skipping 49 matching lines @@
   EXPECT_EQ(1, var_c->index());
   EXPECT_EQ(parent_scope_context_level - local_scope_context_level,
             var_c->owner()->context_level());  // Adjusted context level.
 }
 
 
 TEST_CASE(Closure) {
   // 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));
+  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);
   functions.SetAt(0, parent);
   cls.SetFunctions(functions);
 
   Function& function = Function::Handle();
@@ skipping 184 matching lines @@
   EXPECT_EQ(3, pc_descs.TryIndex(5));
   EXPECT_EQ(static_cast<uword>(80), pc_descs.PC(5));
   EXPECT_EQ(150, pc_descs.TokenIndex(5));
   EXPECT_EQ(PcDescriptors::kOther, pc_descs.DescriptorKind(0));
   EXPECT_EQ(PcDescriptors::kDeopt, pc_descs.DescriptorKind(1));
 }
 
 
 static RawClass* CreateTestClass(const char* name) {
   const String& class_name = String::Handle(String::NewSymbol(name));
-  const Class& cls = Class::Handle(Class::New(class_name, Script::Handle()));
+  const Class& cls = Class::Handle(
+      Class::New(class_name, Script::Handle(), Scanner::kDummyTokenIndex));
   return cls.raw();
 }
 
 
 static RawField* CreateTestField(const char* name) {
   const Class& cls = Class::Handle(CreateTestClass("global:"));
   const String& field_name = String::Handle(String::NewSymbol(name));
   const Field& field = Field::Handle(Field::New(field_name, true, false, 0));
   field.set_owner(cls);
   return field.raw();
@@ skipping 18 matching lines @@
     cls = iterator.GetNextClass();
     ASSERT((cls.raw() == ae66.raw()) || (cls.raw() == re44.raw()));
     count++;
   }
   ASSERT(count == 2);
 }
 
 #endif  // defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64).
 
 }  // namespace dart