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

runtime/vm/class_finalizer.h

 // 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.
 
 #ifndef VM_CLASS_FINALIZER_H_
 #define VM_CLASS_FINALIZER_H_
 
 #include "vm/allocation.h"
 #include "vm/growable_array.h"
 
@@ skipping 24 matching lines @@
   // return true. Also return true if 'interface' is not added, because it is
   // not unique, i.e. it is already in the list.
   // Return false if 'interface' conflicts with an interface already in the list
   // with the same class, but different type arguments.
   // In the case of a conflict, set 'conflicting' to the existing interface.
   static bool AddInterfaceIfUnique(GrowableArray<AbstractType*>* interface_list,
                                    AbstractType* interface,
                                    AbstractType* conflicting);
 
   // Finalize and canonicalize type while parsing class cls.
-  // Set the error message on failure (to Error::null() if no error).
-  static RawAbstractType* FinalizeAndCanonicalizeType(const Class& cls,
-                                                      const AbstractType& type,
-                                                      Error* error);
+  static RawAbstractType* FinalizeType(const Class& cls,
+                                       const AbstractType& type);

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

Why not call it FinalizeAndCanonicalizeType ?

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

Not all types are canonicalized (e.g. ParameterType is not). The
"AndCanonicalize" suffix was used to differentiate the public version from the
private version of FinalizeType. We need only one version now and I picked the
more readable name. I have modified the comment about canonicalization. 

 
   // Pending classes are classes that need to be finalized.
   static void AddPendingClasses(const GrowableArray<const Class*>& classes);
 
   // Return false if we still have classes pending to be finalized.
   static bool AllClassesFinalized();
 
   // Return whether class finalization failed.
   // The function returns true if the finalization was successful.
   // If finalization fails, an error message is set in the sticky error field
@@ skipping 16 matching lines @@
   static void CheckForLegalConstClass(const Class& cls);
   static RawClass* ResolveClass(const Class& cls,
                                 const UnresolvedClass& unresolved_class);
   static void ResolveSuperType(const Class& cls);
   static void ResolveDefaultClass(const Class& cls);
   static void ResolveInterfaces(const Class& cls,
                                 GrowableArray<const Class*>* visited);
   static void FinalizeTypeArguments(const Class& cls,
                                     const AbstractTypeArguments& arguments);
   static void ResolveType(const Class& cls, const AbstractType& type);
-  static RawAbstractType* FinalizeType(const Class& cls,
-                                       const AbstractType& type);
   static void ResolveAndFinalizeUpperBounds(const Class& cls);
   static void VerifyUpperBounds(const Class& cls,
                                 const AbstractTypeArguments& arguments);
   static void ResolveAndFinalizeSignature(const Class& cls,
                                           const Function& function);
   static void ResolveAndFinalizeMemberTypes(const Class& cls);
   static void PrintClassInformation(const Class& cls);
   static void VerifyClassImplements(const Class& cls);
   static void CollectInterfaces(const Class& cls,
                                 GrowableArray<const Class*>* interfaces);
   static void ReportError(const Script& script,
                           intptr_t token_index,
                           const char* format, ...);
   static void ReportError(const char* format, ...);
   static void ReportWarning(const Script& script,
                             intptr_t token_index,
                             const char* format, ...);
 };
 
 }  // namespace dart
 
 #endif  // VM_CLASS_FINALIZER_H_