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

runtime/vm/class_finalizer.cc

 // Copyright (c) 2011, 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/class_finalizer.h"
 
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
@@ skipping 281 matching lines @@
   if (super_type.IsNull()) {
     return;
   }
   // Resolve failures lead to a longjmp.
   ResolveType(cls, super_type);
   const Class& super_class = Class::Handle(super_type.type_class());
   if (cls.is_interface() != super_class.is_interface()) {
     String& class_name = String::Handle(cls.Name());
     String& super_class_name = String::Handle(super_class.Name());
     const Script& script = Script::Handle(cls.script());
-    ReportError(script, -1,
+    ReportError(script, cls.token_index(),
                 "class '%s' and superclass '%s' are not "
                 "both classes or both interfaces.\n",
                 class_name.ToCString(),
                 super_class_name.ToCString());
   }
   // If cls belongs to core lib or to core lib's implementation, restrictions
   // about allowed interfaces are lifted.
   if ((cls.library() != Library::CoreLibrary()) &&
       (cls.library() != Library::CoreImplLibrary())) {
     // Prevent extending core implementation classes Bool, Double, ObjectArray,
@@ skipping 17 matching lines @@
         (super_class.raw() == object_store->internal_byte_array_class()) ||
         (super_class.raw() == object_store->external_byte_array_class()) ||
         (super_class.raw() == integer_implementation_class.raw()) ||
         (super_class.raw() == object_store->smi_class()) ||
         (super_class.raw() == object_store->mint_class()) ||
         (super_class.raw() == object_store->bigint_class()) ||
         (super_class.raw() == object_store->one_byte_string_class()) ||
         (super_class.raw() == object_store->two_byte_string_class()) ||
         (super_class.raw() == object_store->four_byte_string_class())) {
       const Script& script = Script::Handle(cls.script());
-      ReportError(script, -1,
+      ReportError(script, cls.token_index(),
                   "'%s' is not allowed to extend '%s'\n",
                   String::Handle(cls.Name()).ToCString(),
                   String::Handle(super_class.Name()).ToCString());
     }
   }
   return;
 }
 
 
 void ClassFinalizer::ResolveDefaultClass(const Class& interface) {
@@ skipping 203 matching lines @@
         if (!type_extends.IsInstantiated()) {
           type_extends = type_extends.InstantiateFrom(arguments);
         }
         // TODO(regis): Where do we check the constraints when the type is
         // generic?
         if (!type.IsSubtypeOf(type_extends)) {
           const String& type_argument_name = String::Handle(type.Name());
           const String& class_name = String::Handle(cls.Name());
           const String& extends_name = String::Handle(type_extends.Name());
           const Script& script = Script::Handle(cls.script());
-          ReportError(script, -1,
+          ReportError(script, type.token_index(),
                       "type argument '%s' of class '%s' "
                       "does not extend type '%s'\n",
                       type_argument_name.ToCString(),
                       class_name.ToCString(),
                       extends_name.ToCString());
         }
       }
     }
   }
   const Type& super_type = Type::Handle(cls.super_type());
@@ skipping 28 matching lines @@
     type_parameter.set_is_finalized();
     // We do not canonicalize type parameters.
     return type_parameter.raw();
   }
 
   // At this point, we can only have a parameterized_type.
   Type& parameterized_type = Type::Handle();
   parameterized_type ^= type.raw();
 
   if (parameterized_type.IsBeingFinalized()) {
-    ReportError("type '%s' illegally refers to itself\n",
+    const Script& script = Script::Handle(cls.script());
+    ReportError(script, parameterized_type.token_index(),
+                "type '%s' illegally refers to itself\n",
                 String::Handle(parameterized_type.Name()).ToCString());
   }
 
   // Mark type as being finalized in order to detect illegal self reference.
   parameterized_type.set_is_being_finalized();
 
   // Finalize the current type arguments of the type, which are still the
   // parsed type arguments.
   AbstractTypeArguments& arguments =
       AbstractTypeArguments::Handle(parameterized_type.arguments());
@@ skipping 28 matching lines @@
   // The finalized type argument vector needs num_type_arguments types.
   const intptr_t num_type_arguments = type_class.NumTypeArguments();
   // The type class has num_type_parameters type parameters.
   const intptr_t num_type_parameters = type_class.NumTypeParameters();
 
   // Initialize the type argument vector.
   // Check the number of parsed type arguments, if any.
   // Specifying no type arguments indicates a raw type, which is not an error.
   // However, subtyping constraints are checked below, even for a raw type.
   if (!arguments.IsNull() && (arguments.Length() != num_type_parameters)) {
-    // TODO(regis): We need to store the token_index in each type.
-    ReportError("wrong number of type arguments in type '%s'\n",
+    const Script& script = Script::Handle(cls.script());
+    ReportError(script, type.token_index(),
+                "wrong number of type arguments in type '%s'\n",
                 String::Handle(type.Name()).ToCString());
   }
   // The full type argument vector consists of the type arguments of the
   // super types of type_class, which may be initialized from the parsed
   // type arguments, followed by the parsed type arguments.
   if (num_type_arguments > 0) {
     TypeArguments& full_arguments = TypeArguments::Handle(
         TypeArguments::New(num_type_arguments));
     // Copy the parsed type arguments at the correct offset in the full type
     // argument vector.
@@ skipping 29 matching lines @@
     if (FLAG_enable_type_checks) {
       VerifyUpperBounds(type_class, full_arguments);
     }
   } else {
     parameterized_type.set_is_finalized();
   }
   return parameterized_type.Canonicalize();
 }
 
 
-RawAbstractType* ClassFinalizer::FinalizeAndCanonicalizeType(
-    const Class& cls,
-    const AbstractType& type,
-    Error* error) {
-  Isolate* isolate = Isolate::Current();
-  ASSERT(isolate != NULL);
-  LongJump* base = isolate->long_jump_base();
-  LongJump jump;
-  isolate->set_long_jump_base(&jump);
-  if (setjmp(*jump.Set()) == 0) {
-    const AbstractType& finalized_type =
-        AbstractType::Handle(FinalizeType(cls, type));
-    isolate->set_long_jump_base(base);
-    *error = Error::null();
-    return finalized_type.raw();
-  } else {
-    // Error occured: Get the error message.
-    isolate->set_long_jump_base(base);
-    *error = isolate->object_store()->sticky_error();
-    return type.raw();
-  }
-  UNREACHABLE();
-  return NULL;
-}
-
-
 void ClassFinalizer::ResolveAndFinalizeSignature(const Class& cls,
                                                  const Function& function) {
   // Resolve result type.
   AbstractType& type = AbstractType::Handle(function.result_type());
   ResolveType(cls, type);
   type = FinalizeType(cls, type);
   function.set_result_type(type);
   // Resolve formal parameter types.
   const intptr_t num_parameters = function.NumberOfParameters();
   for (intptr_t i = 0; i < num_parameters; i++) {
@@ skipping 215 matching lines @@
     return;
   }
   if (FLAG_trace_class_finalization) {
     OS::Print("Finalize %s\n", cls.ToCString());
   }
   // Signature classes are finalized upon creation.
   ASSERT(!cls.IsSignatureClass());
   if (!IsSuperCycleFree(cls)) {
     const String& name = String::Handle(cls.Name());
     const Script& script = Script::Handle(cls.script());
-    ReportError(script, -1,
+    ReportError(script, cls.token_index(),
                 "class '%s' has a cycle in its superclass relationship.\n",
                 name.ToCString());
   }
   GrowableArray<const Class*> visited;
   ResolveInterfaces(cls, &visited);
   Type& super_type = Type::Handle(cls.super_type());
   if (!super_type.IsNull()) {
     const Class& super_class = Class::Handle(super_type.type_class());
     // Finalize super class and super type.
     FinalizeClass(super_class, generating_snapshot);
@@ skipping 31 matching lines @@
     CheckForLegalConstClass(cls);
   }
   // Check to ensure we don't have classes with native fields in libraries
   // which do not have a native resolver.
   if (!generating_snapshot && cls.num_native_fields() != 0) {
     const Library& lib = Library::Handle(cls.library());
     if (lib.native_entry_resolver() == NULL) {
       const String& cls_name = String::Handle(cls.Name());
       const String& lib_name = String::Handle(lib.url());
       const Script& script = Script::Handle(cls.script());
-      ReportError(script, -1,
+      ReportError(script, cls.token_index(),
                   "class '%s' is trying to extend a native fields class, "
                   "but library '%s' has no native resolvers",
                   cls_name.ToCString(), lib_name.ToCString());
     }
   }
 }
 
 
 bool ClassFinalizer::IsSuperCycleFree(const Class& cls) {
   Class& test1 = Class::Handle(cls.raw());
@@ skipping 62 matching lines @@
 // graph. If we visit an interface a second time on a given path,
 // we found a loop.
 void ClassFinalizer::ResolveInterfaces(const Class& cls,
                                        GrowableArray<const Class*>* visited) {
   ASSERT(visited != NULL);
   for (int i = 0; i < visited->length(); i++) {
     if ((*visited)[i]->raw() == cls.raw()) {
       // We have already visited interface class 'cls'. We found a cycle.
       const String& interface_name = String::Handle(cls.Name());
       const Script& script = Script::Handle(cls.script());
-      ReportError(script, -1,
+      ReportError(script, cls.token_index(),
                   "Cyclic reference found for interface '%s'\n",
                   interface_name.ToCString());
     }
   }
 
   // If the class/interface has no explicit interfaces, we are done.
   Array& super_interfaces = Array::Handle(cls.interfaces());
   if (super_interfaces.Length() == 0) {
     return;
   }
 
   // If cls belongs to core lib or to core lib's implementation, restrictions
   // about allowed interfaces are lifted.
   const bool cls_belongs_to_core_lib =
       (cls.library() == Library::CoreLibrary()) ||
       (cls.library() == Library::CoreImplLibrary());
 
   // Resolve and check the interfaces of cls.
   visited->Add(&cls);
   AbstractType& interface = AbstractType::Handle();
   for (intptr_t i = 0; i < super_interfaces.Length(); i++) {
     interface ^= super_interfaces.At(i);
     ResolveType(cls, interface);
     if (interface.IsTypeParameter()) {
       const Script& script = Script::Handle(cls.script());
-      ReportError(script, -1,
+      ReportError(script, cls.token_index(),
                   "Type parameter '%s' cannot be used as interface\n",
                   String::Handle(interface.Name()).ToCString());
     }
     const Class& interface_class = Class::Handle(interface.type_class());
     if (!interface_class.is_interface()) {
       const Script& script = Script::Handle(cls.script());
-      ReportError(script, -1,
+      ReportError(script, cls.token_index(),
                   "Class '%s' is used where an interface is expected\n",
                   String::Handle(interface_class.Name()).ToCString());
     }
     // Verify that unless cls belongs to core lib, it cannot extend or implement
     // any of bool, num, int, double, String, Function, Dynamic.
     // The exception is signature classes, which are compiler generated and
     // represent a function type, therefore implementing the Function interface.
     if (!cls_belongs_to_core_lib) {
       if (interface.IsBoolInterface() ||
           interface.IsNumberInterface() ||
           interface.IsIntInterface() ||
           interface.IsDoubleInterface() ||
           interface.IsStringInterface() ||
           (interface.IsFunctionInterface() && !cls.IsSignatureClass()) ||
           interface.IsDynamicType()) {
         const Script& script = Script::Handle(cls.script());
-        ReportError(script, -1,
+        ReportError(script, cls.token_index(),
                     "'%s' is not allowed to extend or implement '%s'\n",
                     String::Handle(cls.Name()).ToCString(),
                     String::Handle(interface_class.Name()).ToCString());
       }
     }
     // Now resolve the super interfaces.
     ResolveInterfaces(interface_class, visited);
   }
   visited->RemoveLast();
 }
 
 
 // A class is marked as constant if it has one constant constructor.
 // A constant class:
 // - may extend only const classes.
 // - has only const instance fields.
 // Note: we must check for cycles before checking for const properties.
 void ClassFinalizer::CheckForLegalConstClass(const Class& cls) {
   ASSERT(cls.is_const());
   const Class& super = Class::Handle(cls.SuperClass());
   if (!super.IsNull() && !super.is_const()) {
     String& name = String::Handle(super.Name());
     const Script& script = Script::Handle(cls.script());
-    ReportError(script, -1,
+    ReportError(script, cls.token_index(),
                 "superclass '%s' must be const.\n", name.ToCString());
   }
   const Array& fields_array = Array::Handle(cls.fields());
   intptr_t len = fields_array.Length();
   Field& field = Field::Handle();
   for (intptr_t i = 0; i < len; i++) {
     field ^= fields_array.At(i);
     if (!field.is_static() && !field.is_final()) {
       const String& class_name = String::Handle(cls.Name());
       const String& field_name = String::Handle(field.name());
@@ skipping 78 matching lines @@
   va_end(args);
   if (FLAG_warning_as_error) {
     Isolate::Current()->long_jump_base()->Jump(1, error);
     UNREACHABLE();
   } else {
     OS::Print("%s", error.ToErrorCString());
   }
 }
 
 }  // namespace dart