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

runtime/vm/object.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 "vm/object.h"
 
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 364 matching lines @@
   unwind_error_class_ = cls.raw();
 
   ASSERT(class_class() != null_);
 }
 
 
 RawClass* Object::CreateAndRegisterInterface(const char* cname,
                                              const Script& script,
                                              const Library& lib) {
   const String& name = String::Handle(String::NewSymbol(cname));
-  const Class& cls = Class::Handle(Class::NewInterface(name, script));
+  const intptr_t kPos = 0;  // Dummy token index for unspecified position.
+  const Class& cls = Class::Handle(Class::NewInterface(name, script, kPos));
   lib.AddClass(cls);
   return cls.raw();
 }
 
 
 void Object::RegisterClass(const Class& cls,
                            const char* cname,
                            const Script& script,
                            const Library& lib) {
   const String& name = String::Handle(String::NewSymbol(cname));
@@ skipping 418 matching lines @@
   // A signature class extends class Instance and is parameterized in the same
   // way as the owner class of its non-static signature function.
   // It is not type parameterized if its signature function is static.
   // See Class::NewSignatureClass() for the setup of its type parameters.
   // During type finalization, the type arguments of the super class of the
   // owner class of its signature function will be prepended to the type
   // argument vector. Therefore, we only need to set the type arguments
   // matching the type parameters here.
   if (num_type_params > 0) {
     const Array& type_params = Array::Handle(type_parameters());
+    // TODO(regis): Simply use the type parameters as type arguments, once type
+    // parameters are stored as an array of TypeParameter, rather than String.
     signature_type_arguments = TypeArguments::New(num_type_params);
     String& type_param_name = String::Handle();
     AbstractType& type_param = AbstractType::Handle();
     for (int i = 0; i < num_type_params; i++) {
       type_param_name ^= type_params.At(i);
-      type_param = AbstractType::NewTypeParameter(i, type_param_name);
+      // TODO(regis): Use dummy token index 1 for now; see TODO above.

[siva, 2012/02/06 18:13:08]

The comment says use dummy token index 1 but in the function
CreateAndRegisterInterface there is a comment stating dummy token index as 0.
Maybe you should have a const kDummyTokenIndex or something like that and use it
consistentnly here and in the other test case file too.

[regis, 2012/02/06 19:43:16]

I tried to use 0 for a non-existing source and 1 for an unknown source position.
But this is unnecessary and confusing. I now always use 0 as defined by
Scanner::kDummyTokenIndex.

+      type_param = AbstractType::NewTypeParameter(i, type_param_name, 1);
       signature_type_arguments.SetTypeAt(i, type_param);
     }
   }
   const Type& signature_type = Type::Handle(
-      Type::New(*this, signature_type_arguments));
+      Type::New(*this, signature_type_arguments, token_index()));
 
   // Return the still unfinalized signature type.
   ASSERT(!signature_type.IsFinalized());
   return signature_type.raw();
 }
 
 
 template <class FakeObject>
 RawClass* Class::New() {
   Class& class_class = Class::Handle(Object::class_class());
@@ skipping 15 matching lines @@
   result.set_instance_size(FakeObject::InstanceSize());
   result.set_next_field_offset(FakeObject::InstanceSize());
   result.set_instance_kind(FakeObject::kInstanceKind);
   result.raw_ptr()->is_const_ = false;
   result.raw_ptr()->is_interface_ = false;
   // VM backed classes are almost ready: run checks and resolve class
   // references, but do not recompute size.
   result.raw_ptr()->class_state_ = RawClass::kPreFinalized;
   result.raw_ptr()->type_arguments_instance_field_offset_ = kNoTypeArguments;
   result.raw_ptr()->num_native_fields_ = 0;
+  const intptr_t kPos = 0;  // Dummy token index for unspecified position.

[siva, 2012/02/06 18:13:08]

Ditto comment regarding dummy token index.

[regis, 2012/02/06 19:43:16]

Done.

+  result.raw_ptr()->token_index_ = kPos;
   result.InitEmptyFields();
   return result.raw();
 }
 
 
 // Initialize class fields of type Array with empty array.
 void Class::InitEmptyFields() {
   const Array& empty_array = Array::Handle(Array::Empty());
   if (empty_array.IsNull()) {
     // The empty array has not been initialized yet.
@@ skipping 137 matching lines @@
 }
 
 
 void Class::set_factory_class(const Object& value) const {
   StorePointer(&raw_ptr()->factory_class_, value.raw());
 }
 
 
 // Return a TypeParameter if the type_name is a type parameter of this class.
 // Return null otherwise.
-RawTypeParameter* Class::LookupTypeParameter(const String& type_name) const {
+RawTypeParameter* Class::LookupTypeParameter(const String& type_name,
+                                             intptr_t token_index) const {
   ASSERT(!type_name.IsNull());
   const Array& type_params = Array::Handle(type_parameters());
   if (!type_params.IsNull()) {
     intptr_t num_type_params = type_params.Length();
     String& type_param = String::Handle();
     for (intptr_t i = 0; i < num_type_params; i++) {
       type_param ^= type_params.At(i);
       if (type_param.Equals(type_name)) {
-        return TypeParameter::New(i, type_name);
+        return TypeParameter::New(i, type_name, token_index);
       }
     }
   }
   return TypeParameter::null();
 }
 
 
 void Class::CalculateFieldOffsets() const {
   Array& flds = Array::Handle(fields());
   const Class& super = Class::Handle(SuperClass());
@@ skipping 60 matching lines @@
     // Only static const fields may contain the Object::sentinel value.
     ASSERT(!(field.is_static() && field.is_final()) ||
            (field.value() == Object::sentinel()));
   }
   // The value of static fields is already initialized to null.
   StorePointer(&raw_ptr()->fields_, value.raw());
 }
 
 
 template <class FakeInstance>
-RawClass* Class::New(const String& name, const Script& script) {
+RawClass* Class::New(const String& name,
+                     const Script& script,
+                     intptr_t token_index) {
+  ASSERT(token_index >= 0);
   Class& class_class = Class::Handle(Object::class_class());
   Class& result = Class::Handle();
   {
     RawObject* raw = Object::Allocate(class_class,
                                       Class::InstanceSize(),
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
   }
   FakeInstance fake;
   ASSERT(fake.IsInstance());
   result.set_handle_vtable(fake.vtable());
   result.set_instance_size(FakeInstance::InstanceSize());
   result.set_next_field_offset(FakeInstance::InstanceSize());
   result.set_instance_kind(FakeInstance::kInstanceKind);
   result.set_name(name);
   result.set_script(script);
+  result.set_token_index(token_index);
   result.raw_ptr()->is_const_ = false;
   result.raw_ptr()->is_interface_ = false;
   result.raw_ptr()->class_state_ = RawClass::kAllocated;
   result.raw_ptr()->type_arguments_instance_field_offset_ = kNoTypeArguments;
   result.raw_ptr()->num_native_fields_ = 0;
   result.InitEmptyFields();
   return result.raw();
 }
 
 
-RawClass* Class::New(const String& name, const Script& script) {
-  Class& result = Class::Handle(New<Instance>(name, script));
+RawClass* Class::New(const String& name,
+                     const Script& script,
+                     intptr_t token_index) {
+  Class& result = Class::Handle(New<Instance>(name, script, token_index));
   return result.raw();
 }
 
 
-RawClass* Class::NewInterface(const String& name, const Script& script) {
-  Class& result = Class::Handle(New<Instance>(name, script));
+RawClass* Class::NewInterface(const String& name,
+                              const Script& script,
+                              intptr_t token_index) {
+  Class& result = Class::Handle(New<Instance>(name, script, token_index));
   result.set_is_interface();
   return result.raw();
 }
 
 
 RawClass* Class::NewSignatureClass(const String& name,
                                    const Function& signature_function,
                                    const Script& script) {
   ASSERT(!signature_function.IsNull());
   const Class& owner_class = Class::Handle(signature_function.owner());
   ASSERT(!owner_class.IsNull());
   Array& type_parameters = Array::Handle();
   TypeArguments& type_parameter_extends = TypeArguments::Handle();
   // A signature class extends class Instance and is parameterized in the same
   // way as the owner class of its non-static signature function.
   // It is not type parameterized if its signature function is static.
   if (!signature_function.is_static()) {
     if ((owner_class.NumTypeParameters() > 0) &&
         !signature_function.HasInstantiatedSignature()) {
       type_parameters = owner_class.type_parameters();
       type_parameter_extends = owner_class.type_parameter_extends();
     }
   }
-  Class& result = Class::Handle(New<Closure>(name, script));
+  const intptr_t token_index = signature_function.token_index();
+  Class& result = Class::Handle(New<Closure>(name, script, token_index));
   const Type& super_type = Type::Handle(Type::ObjectType());
   ASSERT(!super_type.IsNull());
   result.set_super_type(super_type);
   result.set_signature_function(signature_function);
   result.set_type_parameters(type_parameters);
   result.set_type_parameter_extends(type_parameter_extends);
   result.SetFields(Array::Handle(Array::Empty()));
   result.SetFunctions(Array::Handle(Array::Empty()));
   // Implements interface "Function".
   const Type& function_interface = Type::Handle(Type::FunctionInterface());
@@ skipping 82 matching lines @@
   }
   return Class::null();
 }
 
 
 RawClass* Class::NewNativeWrapper(Library* library,
                                   const String& name,
                                   int field_count) {
   Class& cls = Class::Handle(library->LookupClass(name));
   if (cls.IsNull()) {
-    cls = New<Instance>(name, Script::Handle());
+    const intptr_t kPos = 0;  // Dummy token index for unspecified position.

[siva, 2012/02/06 18:13:08]

Ditto comment (0 or 1)?

[regis, 2012/02/06 19:43:16]

Done.

+    cls = New<Instance>(name, Script::Handle(), kPos);
     cls.SetFields(Array::Handle(Array::Empty()));
     cls.SetFunctions(Array::Handle(Array::Empty()));
     // Set super class to Object.
     cls.set_super_type(Type::Handle(Type::ObjectType()));
     // Compute instance size.
     intptr_t instance_size = (field_count * kWordSize) + sizeof(RawObject);
     cls.set_instance_size(RoundedAllocationSize(instance_size));
     cls.set_next_field_offset(instance_size);
     cls.set_num_native_fields(field_count);
     cls.set_is_finalized();
     library->AddClass(cls);
     return cls.raw();
   } else {
     return Class::null();
   }
 }
 
 
 void Class::set_name(const String& value) const {
   ASSERT(value.IsSymbol());
   StorePointer(&raw_ptr()->name_, value.raw());
 }
 
 
 void Class::set_script(const Script& value) const {
   StorePointer(&raw_ptr()->script_, value.raw());
 }
 
 
+void Class::set_token_index(intptr_t token_index) const {
+  ASSERT(token_index >= 0);
+  raw_ptr()->token_index_ = token_index;
+}
+
+
 void Class::set_is_interface() const {
   raw_ptr()->is_interface_ = true;
 }
 
 
 void Class::set_is_const() const {
   raw_ptr()->is_const_ = true;
 }
 
 
@@ skipping 430 matching lines @@
     const Array& new_canonical_list =
         Array::Handle(Array::Grow(canonical_list, new_length, Heap::kOld));
     set_constants(new_canonical_list);
     new_canonical_list.SetAt(index, constant);
   } else {
     canonical_list.SetAt(index, constant);
   }
 }
 
 
-RawUnresolvedClass* UnresolvedClass::New(intptr_t token_index,
-                                         const LibraryPrefix& library_prefix,
-                                         const String& ident) {
+RawUnresolvedClass* UnresolvedClass::New(const LibraryPrefix& library_prefix,
+                                         const String& ident,
+                                         intptr_t token_index) {
   const UnresolvedClass& type = UnresolvedClass::Handle(UnresolvedClass::New());
-  type.set_token_index(token_index);
   type.set_library_prefix(library_prefix);
   type.set_ident(ident);
+  type.set_token_index(token_index);
   return type.raw();
 }
 
 
 RawUnresolvedClass* UnresolvedClass::New() {
   const Class& unresolved_class_class =
       Class::Handle(Object::unresolved_class_class());
   RawObject* raw = Object::Allocate(unresolved_class_class,
                                     UnresolvedClass::InstanceSize(),
                                     Heap::kNew);
   return reinterpret_cast<RawUnresolvedClass*>(raw);
 }
 
 
 void UnresolvedClass::set_token_index(intptr_t token_index) const {
+  ASSERT(token_index >= 0);
   raw_ptr()->token_index_ = token_index;
 }
 
 
 void UnresolvedClass::set_ident(const String& ident) const {
   StorePointer(&raw_ptr()->ident_, ident.raw());
 }
 
 
 void UnresolvedClass::set_library_prefix(
@@ skipping 57 matching lines @@
 }
 
 
 RawAbstractTypeArguments* AbstractType::arguments() const  {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return NULL;
 }
 
 
+intptr_t AbstractType::token_index() const {
+  // AbstractType is an abstract class.
+  UNREACHABLE();
+  return -1;
+}
+
+
 bool AbstractType::IsInstantiated() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return false;
 }
 
 
 bool AbstractType::IsFinalized() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
@@ skipping 196 matching lines @@
                             AbstractTypeArguments::Handle(other.arguments()));
   } else {
     ASSERT(test == kIsAssignableTo);
     return cls.IsAssignableTo(AbstractTypeArguments::Handle(arguments()),
                               Class::Handle(other.type_class()),
                               AbstractTypeArguments::Handle(other.arguments()));
   }
 }
 
 RawAbstractType* AbstractType::NewTypeParameter(
-    intptr_t index, const String& name) {
-  return TypeParameter::New(index, name);
+    intptr_t index, const String& name, intptr_t token_index) {
+  return TypeParameter::New(index, name, token_index);
 }
 
 
 RawAbstractType* AbstractType::NewInstantiatedType(
     const AbstractType& uninstantiated_type,
     const AbstractTypeArguments& instantiator_type_arguments) {
   return InstantiatedType::New(uninstantiated_type,
                                instantiator_type_arguments);
 }
 
@@ skipping 53 matching lines @@
 RawType* Type::FunctionInterface() {
   return Isolate::Current()->object_store()->function_interface();
 }
 
 
 RawType* Type::ListInterface() {
   return Isolate::Current()->object_store()->list_interface();
 }
 
 
-RawType* Type::NewRawType(const Class& type_class) {
+RawType* Type::NewRawType(const Class& type_class, intptr_t token_index) {
   const AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::Handle(type_class.type_parameter_extends());
-  return New(Object::Handle(type_class.raw()), type_arguments);
+  return New(Object::Handle(type_class.raw()), type_arguments, token_index);
 }
 
 
 RawType* Type::NewNonParameterizedType(
     const Class& type_class) {
   ASSERT(!type_class.HasTypeArguments());
   const TypeArguments& no_type_arguments = TypeArguments::Handle();
+  const intptr_t kPos = 0;  // Dummy token index for unspecified position.
   Type& type = Type::Handle();
-  type ^= Type::New(
-      Object::Handle(type_class.raw()), no_type_arguments);
+  type ^= Type::New(Object::Handle(type_class.raw()), no_type_arguments, kPos);
   type.set_is_finalized();
   type ^= type.Canonicalize();
   return type.raw();
 }
 
 
 void Type::set_is_finalized() const {
   ASSERT(!IsFinalized());
   set_type_state(RawType::kFinalized);
 }
@@ skipping 55 matching lines @@
 
 RawAbstractType* Type::InstantiateFrom(
     const AbstractTypeArguments& instantiator_type_arguments) const {
   ASSERT(IsFinalized());
   ASSERT(!IsInstantiated());
   AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::Handle(arguments());
   type_arguments = type_arguments.InstantiateFrom(instantiator_type_arguments);
   const Class& cls = Class::Handle(type_class());
   ASSERT(cls.is_finalized());
-  Type& instantiated_type = Type::Handle(Type::New(cls, type_arguments));
+  Type& instantiated_type = Type::Handle(
+      Type::New(cls, type_arguments, token_index()));
   ASSERT(type_arguments.IsNull() ||
          (type_arguments.Length() == cls.NumTypeArguments()));
   instantiated_type.set_is_finalized();
   return instantiated_type.raw();
 }
 
 
 bool Type::Equals(const AbstractType& other) const {
   ASSERT(IsFinalized() && other.IsFinalized());
   if (raw() == other.raw()) {
@@ skipping 75 matching lines @@
 RawType* Type::New() {
   const Class& type_class = Class::Handle(Object::type_class());
   RawObject* raw = Object::Allocate(type_class,
                                     Type::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawType*>(raw);
 }
 
 
 RawType* Type::New(const Object& clazz,
-                   const AbstractTypeArguments& arguments) {
+                   const AbstractTypeArguments& arguments,
+                   intptr_t token_index) {
   const Type& result = Type::Handle(Type::New());
   result.set_type_class(clazz);
   result.set_arguments(arguments);
+  result.set_token_index(token_index);
   result.raw_ptr()->type_state_ = RawType::kAllocated;
   return result.raw();
 }
 
 
+void Type::set_token_index(intptr_t token_index) const {
+  ASSERT(token_index >= 0);
+  raw_ptr()->token_index_ = token_index;
+}
+
+
 void Type::set_type_state(int8_t state) const {
   ASSERT(state == RawType::kAllocated ||
          state == RawType::kBeingFinalized ||
          state == RawType::kFinalized);
   raw_ptr()->type_state_ = state;
 }
 
 
 const char* Type::ToCString() const {
   if (IsResolved()) {
@@ skipping 70 matching lines @@
 RawTypeParameter* TypeParameter::New() {
   const Class& type_parameter_class =
       Class::Handle(Object::type_parameter_class());
   RawObject* raw = Object::Allocate(type_parameter_class,
                                     TypeParameter::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawTypeParameter*>(raw);
 }
 
 
-RawTypeParameter* TypeParameter::New(intptr_t index, const String& name) {
+RawTypeParameter* TypeParameter::New(
+    intptr_t index, const String& name, intptr_t token_index) {
   const TypeParameter& result = TypeParameter::Handle(TypeParameter::New());
   result.set_index(index);
   result.set_name(name);
+  result.set_token_index(token_index);
   result.raw_ptr()->type_state_ = RawTypeParameter::kAllocated;
   return result.raw();
 }
 
 
+void TypeParameter::set_token_index(intptr_t token_index) const {
+  ASSERT(token_index >= 0);
+  raw_ptr()->token_index_ = token_index;
+}
+
+
 void TypeParameter::set_type_state(int8_t state) const {
   ASSERT(state == RawTypeParameter::kAllocated ||
          state == RawTypeParameter::kBeingFinalized ||
          state == RawTypeParameter::kFinalized);
   raw_ptr()->type_state_ = state;
 }
 
 
 const char* TypeParameter::ToCString() const {
   const char* format = "TypeParameter: name %s; index: %d";
@@ skipping 12 matching lines @@
 
 
 RawAbstractTypeArguments* InstantiatedType::arguments() const {
   return InstantiatedTypeArguments::New(
       AbstractTypeArguments::Handle(AbstractType::Handle(
           uninstantiated_type()).arguments()),
       AbstractTypeArguments::Handle(instantiator_type_arguments()));
 }
 
 
+intptr_t InstantiatedType::token_index() const {
+  return AbstractType::Handle(uninstantiated_type()).token_index();
+}
+
+
 void InstantiatedType::set_uninstantiated_type(
     const AbstractType& value) const {
   StorePointer(&raw_ptr()->uninstantiated_type_, value.raw());
 }
 
 
 void InstantiatedType::set_instantiator_type_arguments(
     const AbstractTypeArguments& value) const {
   StorePointer(&raw_ptr()->instantiator_type_arguments_, value.raw());
 }
@@ skipping 915 matching lines @@
     const Script& script = Script::Handle(owner_class.script());
     signature_class = Class::NewSignatureClass(signature,
                                                closure_function,
                                                script);
     library.AddClass(signature_class);
   } else {
     closure_function.set_signature_class(signature_class);
   }
   const Type& signature_type = Type::Handle(signature_class.SignatureType());
   if (!signature_type.IsFinalized()) {
-    Error& error = Error::Handle();
-    ClassFinalizer::FinalizeAndCanonicalizeType(signature_class,
-                                                signature_type,
-                                                &error);
-    ASSERT(error.IsNull());
+    ClassFinalizer::FinalizeType(signature_class, signature_type);
   }
   ASSERT(closure_function.signature_class() == signature_class.raw());
   set_implicit_closure_function(closure_function);
   ASSERT(closure_function.IsImplicitClosureFunction());
   return closure_function.raw();
 }
 
 
 template<typename T>
 static RawArray* NewArray(const GrowableArray<T*>& objs) {
@@ skipping 2086 matching lines @@
 
 RawType* Instance::GetType() const {
   if (IsNull()) {
     return Type::NullType();
   }
   const Class& cls = Class::Handle(clazz());
   AbstractTypeArguments& type_arguments = AbstractTypeArguments::Handle();
   if (cls.HasTypeArguments()) {
     type_arguments = GetTypeArguments();
   }
-  const Type& type = Type::Handle(Type::New(cls, type_arguments));
+  const intptr_t kPos = 0;  // Dummy token index for unspecified position.
+  const Type& type = Type::Handle(Type::New(cls, type_arguments, kPos));
   type.set_is_finalized();
   return type.raw();
 }
 
 
 RawAbstractTypeArguments* Instance::GetTypeArguments() const {
   const Class& cls = Class::Handle(clazz());
   intptr_t field_offset = cls.type_arguments_instance_field_offset();
   ASSERT(field_offset != Class::kNoTypeArguments);
   AbstractTypeArguments& type_arguments = AbstractTypeArguments::Handle();
@@ skipping 120 matching lines @@
     // Can occur when running disassembler.
     return "Instance";
   } else {
     const char* kFormat = "Instance of '%s'";
     Class& cls = Class::Handle(clazz());
     AbstractTypeArguments& type_arguments = AbstractTypeArguments::Handle();
     const intptr_t num_type_arguments = cls.NumTypeArguments();
     if (num_type_arguments > 0) {
       type_arguments = GetTypeArguments();
     }
-    const Type& type = Type::Handle(Type::New(cls, type_arguments));
+    const intptr_t kPos = 0;  // Dummy token index for unspecified position.
+    const Type& type = Type::Handle(Type::New(cls, type_arguments, kPos));
     const String& type_name = String::Handle(type.Name());
     // Calculate the size of the string.
     intptr_t len = OS::SNPrint(NULL, 0, kFormat, type_name.ToCString()) + 1;
     char* chars = reinterpret_cast<char*>(
         Isolate::Current()->current_zone()->Allocate(len));
     OS::SNPrint(chars, len, kFormat, type_name.ToCString());
     return chars;
   }
 }
 
@@ skipping 2264 matching lines @@
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart