Make the parser agnostic to the TokenStream implementation. This is the first step towards compacti…

vm/class_finalizer.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/class_finalizer.h"
 
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
@@ skipping 307 matching lines @@
   if (super_type.IsNull()) {
     return;
   }
   // Resolve failures lead to a longjmp.
   ResolveType(cls, super_type, kFinalizeWellFormed);
   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, cls.token_index(),
+    ReportError(script, cls.token_pos(),
                 "class '%s' and superclass '%s' are not "
                 "both classes or both interfaces",
                 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 35 matching lines @@
         (super_class.raw() == object_store->external_float32_array_class()) ||
         (super_class.raw() == object_store->external_float64_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, cls.token_index(),
+      ReportError(script, cls.token_pos(),
                   "'%s' is not allowed to extend '%s'",
                   String::Handle(cls.Name()).ToCString(),
                   String::Handle(super_class.Name()).ToCString());
     }
   }
   return;
 }
 
 
 void ClassFinalizer::ResolveFactoryClass(const Class& interface) {
   ASSERT(interface.is_interface());
   if (interface.is_finalized() ||
       !interface.HasFactoryClass() ||
       interface.HasResolvedFactoryClass()) {
     return;
   }
   const UnresolvedClass& unresolved_factory_class =
       UnresolvedClass::Handle(interface.UnresolvedFactoryClass());
 
   // Lookup the factory class.
   const Class& factory_class =
       Class::Handle(ResolveClass(interface, unresolved_factory_class));
   if (factory_class.IsNull()) {
     const Script& script = Script::Handle(interface.script());
-    ReportError(script, unresolved_factory_class.token_index(),
+    ReportError(script, unresolved_factory_class.token_pos(),
                 "cannot resolve factory class name '%s' from '%s'",
                 String::Handle(unresolved_factory_class.Name()).ToCString(),
                 String::Handle(interface.Name()).ToCString());
   }
   if (factory_class.is_interface()) {
     const String& interface_name = String::Handle(interface.Name());
     const String& factory_name = String::Handle(factory_class.Name());
     const Script& script = Script::Handle(interface.script());
-    ReportError(script, unresolved_factory_class.token_index(),
+    ReportError(script, unresolved_factory_class.token_pos(),
                 "default clause of interface '%s' names non-class '%s'",
                 interface_name.ToCString(),
                 factory_name.ToCString());
   }
   interface.set_factory_class(factory_class);
   // It is not necessary to finalize the bounds before comparing them between
   // the expected and actual factory class.
   const Class& factory_signature_class = Class::Handle(
       unresolved_factory_class.factory_signature_class());
   ASSERT(!factory_signature_class.IsNull());
   // If a type parameter list is included in the default factory clause (it
   // can be omitted), verify that it matches the list of type parameters of
   // the factory class in number, names, and bounds.
   if (factory_signature_class.NumTypeParameters() > 0) {
     const TypeArguments& expected_type_parameters =
         TypeArguments::Handle(factory_signature_class.type_parameters());
     const TypeArguments& actual_type_parameters =
         TypeArguments::Handle(factory_class.type_parameters());
     const TypeArguments& expected_type_parameter_bounds =
         TypeArguments::Handle(factory_signature_class.type_parameter_bounds());
     const TypeArguments& actual_type_parameter_bounds =
         TypeArguments::Handle(factory_class.type_parameter_bounds());
     if (!AbstractTypeArguments::AreIdentical(expected_type_parameters,
                                              actual_type_parameters) ||
         !AbstractTypeArguments::AreIdentical(expected_type_parameter_bounds,
                                              actual_type_parameter_bounds)) {
       const String& interface_name = String::Handle(interface.Name());
       const String& factory_name = String::Handle(factory_class.Name());
       const Script& script = Script::Handle(interface.script());
-      ReportError(script, unresolved_factory_class.token_index(),
+      ReportError(script, unresolved_factory_class.token_pos(),
                   "mismatch in number, names, or bounds of type parameters "
                   "between default clause of interface '%s' and actual factory "
                   "class '%s'",
                   interface_name.ToCString(),
                   factory_name.ToCString());
     }
   }
   // Verify that the type parameters of the factory class and of the interface
   // have identical names.
   const TypeArguments& interface_type_parameters =
       TypeArguments::Handle(interface.type_parameters());
   const TypeArguments& factory_type_parameters =
       TypeArguments::Handle(factory_class.type_parameters());
   if (!AbstractTypeArguments::AreIdentical(interface_type_parameters,
                                            factory_type_parameters)) {
     const String& interface_name = String::Handle(interface.Name());
     const String& factory_name = String::Handle(factory_class.Name());
     const Script& script = Script::Handle(interface.script());
-    ReportError(script, unresolved_factory_class.token_index(),
+    ReportError(script, unresolved_factory_class.token_pos(),
                 "mismatch in number or names of type parameters between "
                 "interface '%s' and default factory class '%s'",
                 interface_name.ToCString(),
                 factory_name.ToCString());
   }
 }
 
 
 void ClassFinalizer::ResolveType(const Class& cls,
                                  const AbstractType& type,
@@ skipping 467 matching lines @@
     type = field.type();
     ResolveType(cls, type, kFinalize);
     type = FinalizeType(cls, type, kFinalize);
     field.set_type(type);
     name = field.name();
     super_class = FindSuperOwnerOfInstanceMember(cls, name);
     if (!super_class.IsNull()) {
       const String& class_name = String::Handle(cls.Name());
       const String& super_class_name = String::Handle(super_class.Name());
       const Script& script = Script::Handle(cls.script());
-      ReportError(script, field.token_index(),
+      ReportError(script, field.token_pos(),
                   "field '%s' of class '%s' conflicts with instance "
                   "member '%s' of super class '%s'",
                   name.ToCString(),
                   class_name.ToCString(),
                   name.ToCString(),
                   super_class_name.ToCString());
     }
   }
   // Collect interfaces, super interfaces, and super classes of this class.
   const GrowableObjectArray& interfaces =
@@ skipping 15 matching lines @@
   for (intptr_t i = 0; i < num_functions; i++) {
     function ^= array.At(i);
     ResolveAndFinalizeSignature(cls, function);
     function_name = function.name();
     if (function.is_static()) {
       super_class = FindSuperOwnerOfInstanceMember(cls, function_name);
       if (!super_class.IsNull()) {
         const String& class_name = String::Handle(cls.Name());
         const String& super_class_name = String::Handle(super_class.Name());
         const Script& script = Script::Handle(cls.script());
-        ReportError(script, function.token_index(),
+        ReportError(script, function.token_pos(),
                     "static function '%s' of class '%s' conflicts with "
                     "instance member '%s' of super class '%s'",
                     function_name.ToCString(),
                     class_name.ToCString(),
                     function_name.ToCString(),
                     super_class_name.ToCString());
       }
     } else {
       for (int i = 0; i < interfaces.Length(); i++) {
         super_class ^= interfaces.At(i);
         overridden_function = super_class.LookupDynamicFunction(function_name);
         if (!overridden_function.IsNull() &&
             !function.HasCompatibleParametersWith(overridden_function)) {
           // Function types are purposely not checked for subtyping.
           const String& class_name = String::Handle(cls.Name());
           const String& super_class_name = String::Handle(super_class.Name());
           const Script& script = Script::Handle(cls.script());
-          ReportError(script, function.token_index(),
+          ReportError(script, function.token_pos(),
                       "class '%s' overrides function '%s' of %s '%s' "
                       "with incompatible parameters",
                       class_name.ToCString(),
                       function_name.ToCString(),
                       super_class.is_interface() ? "interface" : "super class",
                       super_class_name.ToCString());
         }
       }
     }
     if (function.kind() == RawFunction::kGetterFunction) {
       name = Field::NameFromGetter(function_name);
       super_class = FindSuperOwnerOfFunction(cls, name);
       if (!super_class.IsNull()) {
         const String& class_name = String::Handle(cls.Name());
         const String& super_class_name = String::Handle(super_class.Name());
         const Script& script = Script::Handle(cls.script());
-        ReportError(script, function.token_index(),
+        ReportError(script, function.token_pos(),
                     "getter '%s' of class '%s' conflicts with "
                     "function '%s' of super class '%s'",
                     name.ToCString(),
                     class_name.ToCString(),
                     name.ToCString(),
                     super_class_name.ToCString());
       }
     } else if (function.kind() == RawFunction::kSetterFunction) {
       name = Field::NameFromSetter(function_name);
       super_class = FindSuperOwnerOfFunction(cls, name);
       if (!super_class.IsNull()) {
         const String& class_name = String::Handle(cls.Name());
         const String& super_class_name = String::Handle(super_class.Name());
         const Script& script = Script::Handle(cls.script());
-        ReportError(script, function.token_index(),
+        ReportError(script, function.token_pos(),
                     "setter '%s' of class '%s' conflicts with "
                     "function '%s' of super class '%s'",
                     name.ToCString(),
                     class_name.ToCString(),
                     name.ToCString(),
                     super_class_name.ToCString());
       }
     } else {
       name = Field::GetterName(function_name);
       super_class = FindSuperOwnerOfFunction(cls, name);
       if (!super_class.IsNull()) {
         const String& class_name = String::Handle(cls.Name());
         const String& super_class_name = String::Handle(super_class.Name());
         const Script& script = Script::Handle(cls.script());
-        ReportError(script, function.token_index(),
+        ReportError(script, function.token_pos(),
                     "function '%s' of class '%s' conflicts with "
                     "getter '%s' of super class '%s'",
                     function_name.ToCString(),
                     class_name.ToCString(),
                     function_name.ToCString(),
                     super_class_name.ToCString());
       }
       name = Field::SetterName(function_name);
       super_class = FindSuperOwnerOfFunction(cls, name);
       if (!super_class.IsNull()) {
         const String& class_name = String::Handle(cls.Name());
         const String& super_class_name = String::Handle(super_class.Name());
         const Script& script = Script::Handle(cls.script());
-        ReportError(script, function.token_index(),
+        ReportError(script, function.token_pos(),
                     "function '%s' of class '%s' conflicts with "
                     "setter '%s' of super class '%s'",
                     function_name.ToCString(),
                     class_name.ToCString(),
                     function_name.ToCString(),
                     super_class_name.ToCString());
       }
     }
   }
 }
 
 
 void ClassFinalizer::FinalizeClass(const Class& cls, bool generating_snapshot) {
   if (cls.is_finalized()) {
     return;
   }
   if (FLAG_trace_class_finalization) {
     OS::Print("Finalize %s\n", cls.ToCString());
   }
   if (!IsSuperCycleFree(cls)) {
     const String& name = String::Handle(cls.Name());
     const Script& script = Script::Handle(cls.script());
-    ReportError(script, cls.token_index(),
+    ReportError(script, cls.token_pos(),
                 "class '%s' has a cycle in its superclass relationship",
                 name.ToCString());
   }
   GrowableArray<intptr_t> visited_interfaces;
   ResolveInterfaces(cls, &visited_interfaces);
   // Finalize super class.
   const Class& super_class = Class::Handle(cls.SuperClass());
   if (!super_class.IsNull()) {
     FinalizeClass(super_class, generating_snapshot);
   }
   // Finalize type parameters before finalizing the super type.
   FinalizeTypeParameters(cls);
   // Finalize super type.
   Type& super_type = Type::Handle(cls.super_type());
   if (!super_type.IsNull()) {
     super_type ^= FinalizeType(cls, super_type, kFinalizeWellFormed);
     cls.set_super_type(super_type);
   }
   // Signature classes are finalized upon creation, except function type
   // aliases.
   if (cls.IsSignatureClass()) {
     ASSERT(!cls.IsCanonicalSignatureClass());
     // Check for illegal self references.
     GrowableArray<intptr_t> visited_aliases;
     if (!IsAliasCycleFree(cls, &visited_aliases)) {
       const String& name = String::Handle(cls.Name());
       const Script& script = Script::Handle(cls.script());
-      ReportError(script, cls.token_index(),
+      ReportError(script, cls.token_pos(),
                   "typedef '%s' illegally refers to itself",
                   name.ToCString());
     }
     cls.Finalize();
     return;
   }
   // Finalize factory class, if any.
   if (cls.is_interface()) {
     if (cls.HasFactoryClass()) {
       const Class& factory_class = Class::Handle(cls.FactoryClass());
@@ skipping 24 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, cls.token_index(),
+      ReportError(script, cls.token_pos(),
                   "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 108 matching lines @@
 // we found a loop.
 void ClassFinalizer::ResolveInterfaces(const Class& cls,
                                        GrowableArray<intptr_t>* visited) {
   ASSERT(visited != NULL);
   const intptr_t cls_index = cls.id();
   for (int i = 0; i < visited->length(); i++) {
     if ((*visited)[i] == cls_index) {
       // 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, cls.token_index(),
+      ReportError(script, cls.token_pos(),
                   "cyclic reference found for interface '%s'",
                   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_index);
   AbstractType& interface = AbstractType::Handle();
   Class& interface_class = Class::Handle();
   for (intptr_t i = 0; i < super_interfaces.Length(); i++) {
     interface ^= super_interfaces.At(i);
     ResolveType(cls, interface, kFinalizeWellFormed);
     if (interface.IsTypeParameter()) {
       const Script& script = Script::Handle(cls.script());
-      ReportError(script, cls.token_index(),
+      ReportError(script, cls.token_pos(),
                   "type parameter '%s' cannot be used as interface",
                   String::Handle(interface.Name()).ToCString());
     }
     interface_class = interface.type_class();
     if (interface_class.IsSignatureClass()) {
       const Script& script = Script::Handle(cls.script());
-      ReportError(script, cls.token_index(),
+      ReportError(script, cls.token_pos(),
                   "'%s' is used where an interface or class name is expected",
                   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, cls.token_index(),
+        ReportError(script, cls.token_pos(),
                     "'%s' is not allowed to extend or implement '%s'",
                     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, cls.token_index(),
+    ReportError(script, cls.token_pos(),
                 "superclass '%s' must be const", 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());
       const Script& script = Script::Handle(cls.script());
-      ReportError(script, field.token_index(),
+      ReportError(script, field.token_pos(),
                   "const class '%s' has non-final field '%s'",
                   class_name.ToCString(), field_name.ToCString());
     }
   }
 }
 
 
 void ClassFinalizer::PrintClassInformation(const Class& cls) {
   HANDLESCOPE(Isolate::Current());
   const String& class_name = String::Handle(cls.Name());
@@ skipping 50 matching lines @@
                                            const char* format, ...) {
   va_list args;
   va_start(args, format);
   LanguageError& error = LanguageError::Handle();
   if (FLAG_enable_type_checks ||
       !type.HasResolvedTypeClass() ||
       (finalization == kFinalizeWellFormed)) {
     const Script& script = Script::Handle(cls.script());
     if (prev_error.IsNull()) {
       error ^= Parser::FormatError(
-          script, type.token_index(), "Error", format, args);
+          script, type.token_pos(), "Error", format, args);
     } else {
       error ^= Parser::FormatErrorWithAppend(
-          prev_error, script, type.token_index(), "Error", format, args);
+          prev_error, script, type.token_pos(), "Error", format, args);
     }
     if (finalization == kFinalizeWellFormed) {
       ReportError(error);
     }
   }
   if (FLAG_enable_type_checks || !type.HasResolvedTypeClass()) {
     // In check mode, always mark the type as malformed.
     // In production mode, mark the type as malformed only if its type class is
     // not resolved.
     type.set_malformed_error(error);
@@ skipping 14 matching lines @@
 }
 
 
 void ClassFinalizer::ReportError(const Error& error) {
   Isolate::Current()->long_jump_base()->Jump(1, error);
   UNREACHABLE();
 }
 
 
 void ClassFinalizer::ReportError(const Script& script,
-                                 intptr_t token_index,
+                                 intptr_t token_pos,
                                  const char* format, ...) {
   va_list args;
   va_start(args, format);
   const Error& error = Error::Handle(
-      Parser::FormatError(script, token_index, "Error", format, args));
+      Parser::FormatError(script, token_pos, "Error", format, args));
   ReportError(error);
 }
 
 
 void ClassFinalizer::ReportError(const char* format, ...) {
   va_list args;
   va_start(args, format);
   const Error& error = Error::Handle(
       Parser::FormatError(Script::Handle(), -1, "Error", format, args));
   va_end(args);
   ReportError(error);
 }
 
 }  // namespace dart