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

runtime/vm/parser.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/parser.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 861 matching lines @@
                                                    signature_function,
                                                    script_);
         // Record the function signature class in the current library.
         library_.AddClass(signature_class);
       } else {
         signature_function.set_signature_class(signature_class);
       }
       ASSERT(signature_function.signature_class() == signature_class.raw());
       Type& signature_type = Type::ZoneHandle(signature_class.SignatureType());
       if (!is_top_level_ && !signature_type.IsFinalized()) {
-        Error& error = Error::Handle();
         signature_type ^=
-            ClassFinalizer::FinalizeAndCanonicalizeType(signature_class,
-                                                        signature_type,
-                                                        &error);
-        if (!error.IsNull()) {
-          ErrorMsg(error.ToErrorCString());
-        }
+            ClassFinalizer::FinalizeType(signature_class, signature_type);
       }
       // The type of the parameter is now the signature type.
       parameter.type = &signature_type;
     }
   }
 
   if (CurrentToken() == Token::kASSIGN) {
     if (!params->has_named_optional_parameters ||
         !allow_explicit_default_value) {
       ErrorMsg("parameter must not specify a default value");
@@ skipping 1018 matching lines @@
         !ResolveIdentInLocalScope(qual_ident->ident_pos,
                                   *(qual_ident->ident),
                                   NULL)) {
       LibraryPrefix& lib_prefix = LibraryPrefix::ZoneHandle();
       lib_prefix = current_class().LookupLibraryPrefix(*(qual_ident->ident));
       if (!lib_prefix.IsNull()) {
         // We have a library prefix qualified identifier, unless the prefix is
         // shadowed by a type parameter in scope.
         const Class& scope_class = Class::Handle(TypeParametersScopeClass());
         if (scope_class.IsNull() ||
-            (scope_class.LookupTypeParameter(*(qual_ident->ident)) ==
+            (scope_class.LookupTypeParameter(*(qual_ident->ident),
+                                             token_index_) ==
              TypeParameter::null())) {
           ConsumeToken();  // Consume the kPERIOD token.
           qual_ident->lib_prefix = &lib_prefix;
           qual_ident->ident_pos = token_index_;
           qual_ident->ident =
               ExpectIdentifier("identifier expected after '.'");
         }
       }
     }
   }
@@ skipping 390 matching lines @@
     if (member.has_factory) {
       // The factory name may be qualified.
       QualIdent factory_name;
       ParseQualIdent(&factory_name);
       member.name_pos = factory_name.ident_pos;
       member.name = factory_name.ident;  // Unqualified identifier.
       // The class of the factory result type is specified by the factory name.
       const Object& result_type_class = Object::Handle(
           LookupTypeClass(factory_name, kCanResolve));
       // The type arguments of the result type are set during finalization.
-      member.type = &Type::ZoneHandle(
-          Type::New(result_type_class, TypeArguments::Handle()));
+      member.type = &Type::ZoneHandle(Type::New(result_type_class,
+                                                TypeArguments::Handle(),
+                                                factory_name.ident_pos));
     } else {
       member.name_pos = token_index_;
       member.name = CurrentLiteral();
       ConsumeToken();
     }
     // We must be dealing with a constructor or named constructor.
     member.kind = RawFunction::kConstructor;
     String& ctor_suffix = String::ZoneHandle(String::NewSymbol("."));
     if (CurrentToken() == Token::kPERIOD) {
       // Named constructor.
@@ skipping 110 matching lines @@
   const intptr_t class_pos = token_index_;
   ExpectToken(Token::kCLASS);
   const intptr_t classname_pos = token_index_;
   String& class_name = *ExpectTypeIdentifier("class name expected");
   if (FLAG_trace_parser) {
     OS::Print("TopLevel parsing class '%s'\n", class_name.ToCString());
   }
   Class& cls = Class::ZoneHandle();
   Object& obj = Object::Handle(library_.LookupObject(class_name));
   if (obj.IsNull()) {
-    cls = Class::New(class_name, script_);
+    cls = Class::New(class_name, script_, classname_pos);
     library_.AddClass(cls);
   } else {
     if (!obj.IsClass()) {
       ErrorMsg(classname_pos, "'%s' is already defined",
                class_name.ToCString());
     }
     cls ^= obj.raw();
     if (cls.is_interface()) {
       ErrorMsg(classname_pos, "'%s' is already defined as interface",
                class_name.ToCString());
@@ skipping 138 matching lines @@
 
 
 void Parser::ParseFunctionTypeAlias(GrowableArray<const Class*>* classes) {
   TRACE_PARSER("ParseFunctionTypeAlias");
   ExpectToken(Token::kTYPEDEF);
 
   // Allocate an interface to hold the type parameters and their 'extends'
   // constraints. Make it the owner of the function type descriptor.
   const Class& alias_owner = Class::Handle(
       Class::New(String::Handle(String::NewSymbol(":alias_owner")),
-                 Script::Handle()));
+                 Script::Handle(),
+                 token_index_));
   alias_owner.set_is_interface();
   alias_owner.set_library(library_);
   set_current_class(alias_owner);
 
   // Parse the result type of the function type.
   AbstractType& result_type = Type::Handle(Type::DynamicType());
-  const intptr_t result_type_pos = token_index_;
   if (CurrentToken() == Token::kVOID) {
     ConsumeToken();
     result_type = Type::VoidType();
   } else if (!IsFunctionTypeAliasName()) {
     // Type annotations in typedef are never ignored, even in unchecked mode.
     // Wait until we have an owner class before resolving the result type.
     result_type = ParseType(kDoNotResolve);
   }
 
   const intptr_t alias_name_pos = token_index_;
   const String* alias_name =
       ExpectTypeIdentifier("function alias name expected");
 
   // Parse the type parameters of the function type.
   ParseTypeParameters(alias_owner);
   // At this point, the type parameters have been parsed, so we can resolve the
   // result type.
   if (!result_type.IsNull()) {
-    ResolveTypeFromClass(result_type_pos,
-                         alias_owner,
-                         kCanResolve,
-                         &result_type);
+    ResolveTypeFromClass(alias_owner, kCanResolve, &result_type);
   }
   // Parse the formal parameters of the function type.
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg("formal parameter list expected");
   }
   ParamList func_params;
   const bool no_explicit_default_values = false;
   ParseFormalParameterList(no_explicit_default_values, &func_params);
   // The field 'is_static' has no meaning for signature functions.
   Function& signature_function = Function::Handle(
@@ skipping 50 matching lines @@
   const intptr_t interface_pos = token_index_;
   ExpectToken(Token::kINTERFACE);
   const intptr_t interfacename_pos = token_index_;
   String& interface_name = *ExpectTypeIdentifier("interface name expected");
   if (FLAG_trace_parser) {
     OS::Print("TopLevel parsing interface '%s'\n", interface_name.ToCString());
   }
   Class& interface = Class::ZoneHandle();
   Object& obj = Object::Handle(library_.LookupObject(interface_name));
   if (obj.IsNull()) {
-    interface = Class::NewInterface(interface_name, script_);
+    interface = Class::NewInterface(interface_name, script_, interfacename_pos);
     library_.AddClass(interface);
   } else {
     if (!obj.IsClass()) {
       ErrorMsg(interfacename_pos, "'%s' is already defined",
                interface_name.ToCString());
     }
     interface ^= obj.raw();
     if (!interface.is_interface()) {
       ErrorMsg(interfacename_pos,
                "'%s' is already defined as class",
@@ skipping 14 matching lines @@
     const intptr_t interfaces_pos = token_index_;
     interfaces = ParseInterfaceList();
     AddInterfaces(interfaces_pos, interface, interfaces);
   }
 
   if (CurrentToken() == Token::kDEFAULT) {
     ConsumeToken();
     if (CurrentToken() != Token::kIDENT) {
       ErrorMsg("class name expected");
     }
-    const intptr_t factory_pos = token_index_;
     QualIdent factory_name;
     ParseQualIdent(&factory_name);
     LibraryPrefix& lib_prefix = LibraryPrefix::Handle();
     if (factory_name.lib_prefix != NULL) {
       lib_prefix = factory_name.lib_prefix->raw();
     }
     const UnresolvedClass& unresolved_factory_class = UnresolvedClass::Handle(
-        UnresolvedClass::New(factory_pos, lib_prefix, *factory_name.ident));
+        UnresolvedClass::New(lib_prefix,
+                             *factory_name.ident,
+                             factory_name.ident_pos));
     const Class& factory_class = Class::Handle(
         Class::New(String::Handle(String::NewSymbol(":factory_signature")),
-                   script_));
+                   script_,
+                   factory_name.ident_pos));
     factory_class.set_library(library_);
     factory_class.set_is_finalized();
     ParseTypeParameters(factory_class);
     unresolved_factory_class.set_factory_signature_class(factory_class);
     interface.set_factory_class(unresolved_factory_class);
     // 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 interface in number and names.
     const intptr_t num_default_type_params = factory_class.NumTypeParameters();
     if (num_default_type_params > 0) {
       String& interface_type_param_name = String::Handle();
       String& factory_type_param_name = String::Handle();
       const Array& interface_type_param_names =
           Array::Handle(interface.type_parameters());
       const Array& factory_type_param_names =
           Array::Handle(factory_class.type_parameters());
       bool mismatch = interface.NumTypeParameters() != num_default_type_params;
       for (intptr_t i = 0; !mismatch && (i < num_default_type_params); i++) {
         interface_type_param_name ^= interface_type_param_names.At(i);
         factory_type_param_name ^= factory_type_param_names.At(i);
         if (!interface_type_param_name.Equals(factory_type_param_name)) {
           mismatch = true;
         }
       }
       if (mismatch) {
         const String& interface_name = String::Handle(interface.Name());
-        const String& factory_name = String::Handle(factory_class.Name());
-        ErrorMsg(factory_pos,
+        ErrorMsg(factory_name.ident_pos,
                  "mismatch in number or names of type parameters between "
                  "interface '%s' and default factory class '%s'.\n",
                  interface_name.ToCString(),
-                 factory_name.ToCString());
+                 factory_name.ident->ToCString());
       }
     }
   }
 
   ExpectToken(Token::kLBRACE);
   ClassDesc members(interface, interface_name, true, interface_pos);
   while (CurrentToken() != Token::kRBRACE) {
     ParseClassMemberDefinition(&members);
   }
   ExpectToken(Token::kRBRACE);
@@ skipping 50 matching lines @@
       ConsumeToken();
       ExpectIdentifier("name expected");
     }
     SkipTypeArguments();
   }
 }
 
 
 void Parser::ParseTypeParameters(const Class& cls) {
   if (CurrentToken() == Token::kLT) {
-    const intptr_t type_pos = token_index_;
     GrowableArray<String*> type_parameters;
     GrowableArray<AbstractType*> type_parameter_extends;
     do {
       ConsumeToken();
       if (CurrentToken() != Token::kIDENT) {
         ErrorMsg("type parameter name expected");
       }
       String& type_parameter_name = *CurrentLiteral();
       ConsumeToken();
       AbstractType& type_extends = Type::ZoneHandle(Type::DynamicType());
@@ skipping 13 matching lines @@
     cls.set_type_parameters(Array::Handle(NewArray<String>(type_parameters)));
     const TypeArguments& extends_array =
         TypeArguments::Handle(NewTypeArguments(type_parameter_extends));
     cls.set_type_parameter_extends(extends_array);
     // Try to resolve the upper bounds, which will at least resolve the
     // referenced type parameters.
     AbstractType& type_extends = AbstractType::Handle();
     const intptr_t num_types = extends_array.Length();
     for (intptr_t i = 0; i < num_types; i++) {
       type_extends = extends_array.TypeAt(i);
-      ResolveTypeFromClass(type_pos, cls, kCanResolve, &type_extends);
+      ResolveTypeFromClass(cls, kCanResolve, &type_extends);
       extends_array.SetTypeAt(i, type_extends);
     }
   }
 }
 
 
 RawAbstractTypeArguments* Parser::ParseTypeArguments(
     TypeResolution type_resolution) {
   if (CurrentToken() == Token::kLT) {
     GrowableArray<AbstractType*> types;
@@ skipping 420 matching lines @@
 
 void Parser::ParseTopLevel() {
   // Collect the classes found at the top level in this growable array.
   // They need to be registered with class finalization after parsing
   // has been completed.
   GrowableArray<const Class*> classes;
   SetPosition(0);
   is_top_level_ = true;
   TopLevel top_level;
   Class& toplevel_class = Class::ZoneHandle(
-      Class::New(String::ZoneHandle(String::NewSymbol("::")), script_));
+      Class::New(String::ZoneHandle(String::NewSymbol("::")),
+                 script_,
+                 token_index_));
   toplevel_class.set_library(library_);
 
   if (is_library_source()) {
     ParseLibraryDefinition();
   }
 
   while (true) {
     set_current_class(Class::Handle());  // No current class.
     if (CurrentToken() == Token::kCLASS) {
       ParseClassDefinition(&classes);
@@ skipping 381 matching lines @@
   LocalVariable* function_variable = NULL;
   Type& function_type = Type::ZoneHandle();
   if (variable_name != NULL) {
     // Since the function type depends on the signature of the closure function,
     // it cannot be determined before the formal parameter list of the closure
     // function is parsed. Therefore, we set the function type to a new
     // parameterized type to be patched after the actual type is known.
     // We temporarily use the class of the Function interface.
     const Class& unknown_signature_class = Class::Handle(
         Type::Handle(Type::FunctionInterface()).type_class());
-    function_type = Type::New(unknown_signature_class, TypeArguments::Handle());
+    function_type = Type::New(
+        unknown_signature_class, TypeArguments::Handle(), ident_pos);
     function_type.set_is_finalized();  // No real finalization needed.
 
     // Add the function variable to the scope before parsing the function in
     // order to allow self reference from inside the function.
     function_variable = new LocalVariable(ident_pos,
                                           *variable_name,
                                           function_type);
     function_variable->set_is_final();
     ASSERT(current_block_ != NULL);
     ASSERT(current_block_->scope != NULL);
@@ skipping 38 matching lines @@
     // Patch the function type now that the signature is known.
     // We need to create a new type for proper finalization, since the existing
     // type is already marked as finalized.
     Type& signature_type = Type::Handle(signature_class.SignatureType());
     const AbstractTypeArguments& signature_type_arguments =
         AbstractTypeArguments::Handle(signature_type.arguments());
 
     // Since the signature type is cached by the signature class, it may have
     // been finalized already.
     if (!signature_type.IsFinalized()) {
-      Error& error = Error::Handle();
       signature_type ^=
-          ClassFinalizer::FinalizeAndCanonicalizeType(signature_class,
-                                                      signature_type,
-                                                      &error);
-      if (!error.IsNull()) {
-        ErrorMsg(error.ToErrorCString());
-      }
-      // The call to ClassFinalizer::FinalizeAndCanonicalizeType may have
+          ClassFinalizer::FinalizeType(signature_class, signature_type);
+      // The call to ClassFinalizer::FinalizeType may have
       // extended the vector of type arguments.
       ASSERT(signature_type_arguments.IsNull() ||
              (signature_type_arguments.Length() ==
               signature_class.NumTypeArguments()));
       // The signature_class should not have changed.
       ASSERT(signature_type.type_class() == signature_class.raw());
     }
 
     // Now patch the function type of the variable.
     function_type.set_type_class(signature_class);
@@ skipping 2317 matching lines @@
 }
 
 
 // Resolve the given type and its type arguments from the given scope class
 // according to the given type_resolution.
 // If the given scope class is null, use the current library, but do not try to
 // resolve type parameters.
 // Not all involved type classes may get resolved yet, but at least the type
 // parameters of the given class will get resolved, thereby relieving the class
 // finalizer from resolving type parameters out of context.
-void Parser::ResolveTypeFromClass(intptr_t type_pos,
-                                  const Class& scope_class,
+void Parser::ResolveTypeFromClass(const Class& scope_class,
                                   TypeResolution type_resolution,
                                   AbstractType* type) {
   ASSERT((type_resolution == kCanResolve) || (type_resolution == kMustResolve));
   ASSERT(type != NULL);
   // Resolve class.
   if (!type->HasResolvedTypeClass()) {
     const UnresolvedClass& unresolved_class =
         UnresolvedClass::Handle(type->unresolved_class());
     const String& unresolved_class_name =
         String::Handle(unresolved_class.ident());
     // First resolve library prefix if any.
     Library& lib = Library::Handle();
     if (unresolved_class.library_prefix() == LibraryPrefix::null()) {
       if (scope_class.IsNull()) {
         lib = library_.raw();
       } else {
         lib = scope_class.library();
         // First check if the type is a type parameter of the given scope class.
         const TypeParameter& type_parameter = TypeParameter::Handle(
-            scope_class.LookupTypeParameter(unresolved_class_name));
+            scope_class.LookupTypeParameter(unresolved_class_name,
+                                            type->token_index()));
         if (!type_parameter.IsNull()) {
           // A type parameter cannot be parameterized, so report an error if
           // type arguments have previously been parsed.
           if (!AbstractTypeArguments::Handle(type->arguments()).IsNull()) {
-            ErrorMsg(type_pos, "type parameter '%s' cannot be parameterized",
+            ErrorMsg(type_parameter.token_index(),
+                     "type parameter '%s' cannot be parameterized",
                      String::Handle(type_parameter.Name()).ToCString());
           }
           *type = type_parameter.raw();
           return;
         }
       }
     } else {
       LibraryPrefix& lib_prefix =
           LibraryPrefix::Handle(unresolved_class.library_prefix());
       lib = lib_prefix.library();
     }
     if (!lib.IsNull()) {
       const Class& resolved_type_class = Class::Handle(
           lib.LookupLocalClass(unresolved_class_name));
       if (!resolved_type_class.IsNull()) {
         Object& type_class = Object::Handle(resolved_type_class.raw());
         ASSERT(type->IsType());
         // Replace unresolved class with resolved type class.
         Type& parameterized_type = Type::Handle();
         parameterized_type ^= type->raw();
         parameterized_type.set_type_class(type_class);
       } else if (type_resolution == kMustResolve) {
-        ErrorMsg(type_pos, "type '%s' is not loaded",
+        ErrorMsg(type->token_index(), "type '%s' is not loaded",
                  String::Handle(type->Name()).ToCString());
       }
     }
   }
   // Resolve type arguments, if any.
   const AbstractTypeArguments& arguments =
       AbstractTypeArguments::Handle(type->arguments());
   if (!arguments.IsNull()) {
     const intptr_t num_arguments = arguments.Length();
     for (intptr_t i = 0; i < num_arguments; i++) {
       AbstractType& type_argument = AbstractType::Handle(arguments.TypeAt(i));
-      ResolveTypeFromClass(type_pos,
-                           scope_class,
+      ResolveTypeFromClass(scope_class,
                            type_resolution,
                            &type_argument);
       arguments.SetTypeAt(i, type_argument);
     }
   }
 }
 
 
 // Return class for type name. If the name cannot be resolved (yet), give an
 // error (if type_resolution == kMustResolve) or return the unresolved name.
@@ skipping 15 matching lines @@
   if (type_resolution == kMustResolve) {
     ErrorMsg(type_name.ident_pos, "type '%s' is not loaded",
              type_name.ident->ToCString());
     return Object::null_class();
   }
   // We have an unresolved name, create an UnresolvedClass object for this case.
   LibraryPrefix& lib_prefix = LibraryPrefix::Handle();
   if (type_name.lib_prefix != NULL) {
     lib_prefix = type_name.lib_prefix->raw();
   }
-  return UnresolvedClass::New(type_name.ident_pos,
-                              lib_prefix,
-                              *type_name.ident);
+  return UnresolvedClass::New(lib_prefix,
+                              *type_name.ident,
+                              type_name.ident_pos);
 }
 
 
 LocalVariable* Parser::LookupLocalScope(const String& ident) {
   if (current_block_ == NULL) {
     return NULL;
   }
   // A found name is treated as accessed and possibly marked as captured.
   const bool kTestOnly = false;
   return current_block_->scope->LookupVariable(ident, kTestOnly);
@@ skipping 386 matching lines @@
 
 // Parses type = [ident "."] ident ["<" type { "," type } ">"].
 // Returns the class object if the type can be resolved. Otherwise, either give
 // an error if type resolution was required, or return the unresolved name as a
 // string object.
 RawAbstractType* Parser::ParseType(TypeResolution type_resolution) {
   if (CurrentToken() != Token::kIDENT) {
     ErrorMsg("type name expected");
   }
   QualIdent type_name;
-  const intptr_t type_pos = token_index_;
   if (type_resolution == kIgnore) {
     SkipQualIdent();
   } else {
     ParseQualIdent(&type_name);
     // An identifier cannot be resolved in a local scope when top level parsing.
     if (!is_top_level_ &&
         (type_name.lib_prefix == NULL) &&
-        ResolveIdentInLocalScope(type_pos, *type_name.ident, NULL)) {
-      ErrorMsg(type_pos, "using '%s' in this context is invalid",
+        ResolveIdentInLocalScope(type_name.ident_pos, *type_name.ident, NULL)) {
+      ErrorMsg(type_name.ident_pos, "using '%s' in this context is invalid",
                type_name.ident->ToCString());
     }
   }
   Class& scope_class = Class::Handle();
   Object& type_class = Object::Handle();
   if (type_resolution == kIgnore) {
     // Leave type_class as null.
   } else if (type_resolution == kDoNotResolve) {
     LibraryPrefix& lib_prefix = LibraryPrefix::Handle();
     if (type_name.lib_prefix != NULL) {
       lib_prefix = type_name.lib_prefix->raw();
     }
-    type_class = UnresolvedClass::New(type_pos, lib_prefix, *type_name.ident);
+    type_class = UnresolvedClass::New(lib_prefix,
+                                      *type_name.ident,
+                                      type_name.ident_pos);
   } else {
     // TODO(regis): Use ResolveTypeFromClass().
     ASSERT((type_resolution == kCanResolve) ||
            (type_resolution == kMustResolve));
     scope_class = TypeParametersScopeClass();
     if (!scope_class.IsNull()) {
       if (type_name.lib_prefix == NULL) {
         // Check if ident is a type parameter in scope.
         TypeParameter& type_parameter = TypeParameter::Handle(
-            scope_class.LookupTypeParameter(*type_name.ident));
+            scope_class.LookupTypeParameter(*type_name.ident,
+                                            type_name.ident_pos));
         if (!type_parameter.IsNull()) {
           if (CurrentToken() == Token::kLT) {
             // A type parameter cannot be parameterized.
-            ErrorMsg(type_pos, "type parameter '%s' cannot be parameterized",
+            ErrorMsg(type_parameter.token_index(),
+                     "type parameter '%s' cannot be parameterized",
                      String::Handle(type_parameter.Name()).ToCString());
           }
           if (type_resolution == kMustResolve) {
-            Error& error = Error::Handle();
             type_parameter ^=
-                ClassFinalizer::FinalizeAndCanonicalizeType(scope_class,
-                                                            type_parameter,
-                                                            &error);
-            if (!error.IsNull()) {
-              ErrorMsg(error.ToErrorCString());
-            }
+                ClassFinalizer::FinalizeType(current_class(), type_parameter);
           }
           return type_parameter.raw();
         }
       }
     }
     // Try to resolve the type class.
     type_class = LookupTypeClass(type_name, type_resolution);
   }
   AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::Handle(ParseTypeArguments(type_resolution));
   if (type_resolution == kIgnore) {
     return Type::DynamicType();
   }
-  Type& type = Type::Handle(Type::New(type_class, type_arguments));
+  Type& type = Type::Handle(
+      Type::New(type_class, type_arguments, type_name.ident_pos));
   if (type_resolution == kMustResolve) {
     ASSERT(type_class.IsClass());  // Must be resolved.
-    Error& error = Error::Handle();
-    type ^= ClassFinalizer::FinalizeAndCanonicalizeType(scope_class,
-                                                        type,
-                                                        &error);
-    if (!error.IsNull()) {
-      ErrorMsg(error.ToErrorCString());
-    }
+    type ^= ClassFinalizer::FinalizeType(current_class(), type);
   }
   return type.raw();
 }
 
 
 void Parser::CheckConstructorCallTypeArguments(
     intptr_t pos, Function& constructor,
     const AbstractTypeArguments& type_arguments) {
   if (!type_arguments.IsNull()) {
     const Class& constructor_class = Class::Handle(constructor.owner());
@@ skipping 381 matching lines @@
   const intptr_t new_pos = token_index_;
   ASSERT((CurrentToken() == Token::kNEW) || (CurrentToken() == Token::kCONST));
   bool is_const = (CurrentToken() == Token::kCONST);
   ConsumeToken();
   if (!IsIdentifier()) {
     ErrorMsg("type name expected");
   }
 
   const AbstractType& type = AbstractType::Handle(ParseType(kMustResolve));
   if (type.IsTypeParameter()) {
-    // TODO(regis): Use type position once supported.
-    ErrorMsg(new_pos, "type parameter '%s' cannot be instantiated",
+    ErrorMsg(type.token_index(),
+             "type parameter '%s' cannot be instantiated",
              String::Handle(type.Name()).ToCString());
   }
   Class& type_class = Class::Handle(type.type_class());
   String& type_class_name = String::Handle(type_class.Name());
   AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::ZoneHandle(type.arguments());
 
   // The constructor class and its name are those of the parsed type, unless the
   // parsed type is an interface and a default factory class is specified, in
   // which case constructor_class and constructor_class_name are modified below.
@@ skipping 24 matching lines @@
   if (type_class.is_interface()) {
     // We need to make sure that an appropriate constructor is
     // declared in the interface.
     const String& constructor_name =
         BuildConstructorName(type_class_name, named_constructor);
     const String& external_constructor_name =
         (named_constructor ? constructor_name : type_class_name);
     Function& constructor = Function::ZoneHandle(
         type_class.LookupConstructor(constructor_name));
     if (constructor.IsNull()) {
-      ErrorMsg(new_pos, "interface '%s' has no constructor named '%s'",
+      ErrorMsg(type.token_index(),
+               "interface '%s' has no constructor named '%s'",
                type_class_name.ToCString(),
                external_constructor_name.ToCString());
     }
     if (!constructor.AreValidArguments(arguments_length, arguments->names())) {
-      ErrorMsg(new_pos, "invalid arguments passed to constructor '%s' "
+      ErrorMsg(type.token_index(),
+               "invalid arguments passed to constructor '%s' "
                "for interface '%s'",
                external_constructor_name.ToCString(),
                type_class_name.ToCString());
     }
     if (!type_class.HasFactoryClass()) {
       ErrorMsg("cannot allocate interface '%s' without factory class",
                type_class_name.ToCString());
     }
     if (!type_class.HasResolvedFactoryClass()) {
       // This error can occur only with bootstrap classes.
@@ skipping 24 matching lines @@
   Function& constructor = Function::ZoneHandle(
       constructor_class.LookupConstructor(constructor_name));
   if (constructor.IsNull()) {
     constructor = constructor_class.LookupFactory(constructor_name);
     // A factory does not have the implicit 'phase' parameter.
     arguments_length -= 1;
   }
   if (constructor.IsNull()) {
     const String& external_constructor_name =
         (named_constructor ? constructor_name : constructor_class_name);
-    ErrorMsg(new_pos, "class '%s' has no constructor or factory named '%s'",
+    ErrorMsg(type.token_index(),
+             "class '%s' has no constructor or factory named '%s'",
              String::Handle(constructor_class.Name()).ToCString(),
              external_constructor_name.ToCString());
   }
   if (!constructor.AreValidArguments(arguments_length, arguments->names())) {
     const String& external_constructor_name =
         (named_constructor ? constructor_name : constructor_class_name);
-    ErrorMsg(new_pos, "invalid arguments passed to constructor '%s' "
-             "for class '%s'",
+    ErrorMsg(type.token_index(),
+             "invalid arguments passed to constructor '%s' for class '%s'",
              external_constructor_name.ToCString(),
              String::Handle(constructor_class.Name()).ToCString());
   }
 
   // Now that the constructor to be called is identified, finalize the type
   // argument vector to be passed.
   // The type argument vector of the parsed type was finalized in ParseType.
   // If the constructor class was changed from the interface class to the
   // factory class, we need to finalize the type argument vector again, because
   // it may be longer due to the factory class extending a class, or/and because
@@ skipping 13 matching lines @@
         if (i < num_type_arguments) {
           type_argument = type_arguments.TypeAt(i);
         } else {
           type_argument = Type::DynamicType();
         }
         temp_type_arguments.SetTypeAt(i, type_argument);
       }
     }
     // TODO(regis): Temporary type should be allocated in new gen heap.
     Type& temp_type = Type::Handle(
-        Type::New(constructor_class, temp_type_arguments));
-    Error& error = Error::Handle();
-    const Class& scope_class = Class::Handle(TypeParametersScopeClass());
-    temp_type ^= ClassFinalizer::FinalizeAndCanonicalizeType(scope_class,
-                                                             temp_type,
-                                                             &error);
-    if (!error.IsNull()) {
-      ErrorMsg(error.ToErrorCString());
-    }
+        Type::New(constructor_class, temp_type_arguments, type.token_index()));
+    temp_type ^= ClassFinalizer::FinalizeType(current_class(), temp_type);
     // The type argument vector may have been expanded with the type arguments
     // of the super type when finalizing the temporary type.
     type_arguments = temp_type.arguments();
   }
 
   type_arguments ^= type_arguments.Canonicalize();
   // Make the constructor call.
   AstNode* new_object = NULL;
   if (is_const) {
     if (!constructor.is_const()) {
@@ skipping 485 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart