Support correct factory syntax in the VM as decribed in the spec.

runtime/vm/parser.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/parser.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
 #include "vm/flags.h"
 #include "vm/growable_array.h"
 #include "vm/longjump.h"
 #include "vm/native_entry.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/resolver.h"
 #include "vm/scopes.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, enable_asserts, false, "Enable assert statements.");
 DEFINE_FLAG(bool, enable_type_checks, false, "Enable type checks.");
 DEFINE_FLAG(bool, trace_parser, false, "Trace parser operations.");
 DEFINE_FLAG(bool, warning_as_error, false, "Treat warnings as errors.");
-DEFINE_FLAG(bool, silent_warnings, true, "Silence warnings.");
+DEFINE_FLAG(bool, silent_warnings, false, "Silence warnings.");
 
 // All references to Dart names are listed here.
 static const char* kAssertionErrorName = "AssertionError";
 static const char* kFallThroughErrorName = "FallThroughError";
 static const char* kThrowNewName = "throwNew";
 static const char* kGrowableObjectArrayFromArrayName =
     "GrowableObjectArray._usingArray";
 static const char* kGrowableObjectArrayName = "GrowableObjectArray";
 static const char* kMutableMapName = "MutableMap";
 static const char* kMutableMapFromLiteralName = "fromLiteral";
@@ skipping 234 matching lines @@
   return &result;
 }
 
 
 // A QualIdent is an optionally qualified identifier.
 struct QualIdent {
   QualIdent() {
     Clear();
   }
   void Clear() {
-    local_scope_ident = false;
+    is_local_scope_ident = false;
     lib_prefix = NULL;
     qualifier = NULL;
     ident_pos = 0;
     ident = NULL;
   }
-  bool local_scope_ident;
+  bool is_local_scope_ident;
   LibraryPrefix* lib_prefix;
   String* qualifier;
   intptr_t ident_pos;
   String* ident;
 };
 
 
 struct ParamDesc {
   ParamDesc()
       : type(NULL),
@@ skipping 265 matching lines @@
     CompilerStats::parser_timer.Start();
   }
   SequenceNode* node_sequence = NULL;
   Array& default_parameter_values = Array::Handle();
   switch (func.kind()) {
     case RawFunction::kFunction:
     case RawFunction::kClosureFunction:
     case RawFunction::kGetterFunction:
     case RawFunction::kSetterFunction:
     case RawFunction::kConstructor:
+      ASSERT(!func.IsFactory() || (func.signature_class() != Class::null()));
       node_sequence = parser.ParseFunc(func, default_parameter_values);
       break;
     case RawFunction::kImplicitGetter:
       ASSERT(!func.is_static());
       node_sequence = parser.ParseInstanceGetter(func);
       break;
     case RawFunction::kImplicitSetter:
       ASSERT(!func.is_static());
       node_sequence = parser.ParseInstanceSetter(func);
       break;
@@ skipping 49 matching lines @@
 
   // Static const fields must have an initializer.
   ExpectToken(Token::kIDENT);
   ExpectToken(Token::kASSIGN);
 
   // We don't want to use ParseConstExpr() here because we don't want
   // the constant folding code to create, compile and execute a code
   // fragment to evaluate the expression. Instead, we just make sure
   // the static const field initializer is a constant expression and
   // leave the evaluation to the getter function.
-  intptr_t expr_pos = token_index_;
+  const intptr_t expr_pos = token_index_;
   AstNode* expr = ParseExpr(kAllowConst);
   if (expr->EvalConstExpr() == NULL) {
     ErrorMsg(expr_pos, "initializer must be a compile time constant");
   }
   ReturnNode* return_node = new ReturnNode(token_index_, expr);
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
 
@@ skipping 69 matching lines @@
 
   current_block_->statements->Add(store_field);
   current_block_->statements->Add(new ReturnNode(token_index_));
   return CloseBlock();
 }
 
 
 void Parser::SkipBlock() {
   ASSERT(CurrentToken() == Token::kLBRACE);
   GrowableArray<Token::Kind> token_stack(8);
-  intptr_t block_start_pos = token_index_;
+  const intptr_t block_start_pos = token_index_;
   bool is_match = true;
   bool unexpected_token_found = false;
   Token::Kind token;
   intptr_t token_index;
   do {
     token = CurrentToken();
     token_index = token_index_;
     switch (token) {
       case Token::kLBRACE:
       case Token::kLPAREN:
@@ skipping 620 matching lines @@
 struct FieldInitExpression {
   Field* inst_field;
   AstNode* expr;
 };
 
 
 void Parser::ParseInitializedInstanceFields(const Class& cls,
                  GrowableArray<FieldInitExpression>* initializers) {
   const Array& fields = Array::Handle(cls.fields());
   Field& f = Field::Handle();
-  intptr_t saved_pos = token_index_;
+  const intptr_t saved_pos = token_index_;
   for (int i = 0; i < fields.Length(); i++) {
     f ^= fields.At(i);
     if (!f.is_static() && f.has_initializer()) {
       Field& field = Field::ZoneHandle();
       field ^= fields.At(i);
       intptr_t field_pos = field.token_index();
       SetPosition(field_pos);
       ASSERT(CurrentToken() == Token::kIDENT);
       ConsumeToken();
       ExpectToken(Token::kASSIGN);
@@ skipping 23 matching lines @@
       // guarantee that.
       ConsumeToken();  // Colon.
       ParseConstructorRedirection(cls, receiver);
       return;
     }
     do {
       ConsumeToken();  // Colon or comma.
       AstNode* init_statement;
       if (CurrentToken() == Token::kSUPER) {
         if (super_init_seen) {
-          ErrorMsg("Duplicate call to super constructor");
+          ErrorMsg("duplicate call to super constructor");
         }
         init_statement = ParseSuperInitializer(cls, receiver);
         super_init_seen = true;
       } else {
         init_statement = ParseInitializer(cls, receiver);
       }
       current_block_->statements->Add(init_statement);
     } while (CurrentToken() == Token::kCOMMA);
   }
   if (!super_init_seen) {
     // Generate implicit super() if we haven't seen an explicit super call
     // or constructor redirection.
     GenerateSuperConstructorCall(cls, receiver);
   }
   CheckConstFieldsInitialized(cls);
 }
 
 
 void Parser::ParseConstructorRedirection(const Class& cls,
                                          LocalVariable* receiver) {
   ASSERT(CurrentToken() == Token::kTHIS);
-  intptr_t call_pos = token_index_;
+  const intptr_t call_pos = token_index_;
   ConsumeToken();
   String& ctor_name = String::Handle(cls.Name());
   String& ctor_suffix = String::Handle(String::NewSymbol("."));
 
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();
     ctor_suffix = String::Concat(
         ctor_suffix, *ExpectIdentifier("constructor name expected"));
   }
   ctor_name = String::Concat(ctor_name, ctor_suffix);
@@ skipping 22 matching lines @@
              ctor_name.ToCString());
   }
   CheckFunctionIsCallable(call_pos, redirect_ctor);
   current_block_->statements->Add(
       new StaticCallNode(call_pos, redirect_ctor, arguments));
 }
 
 
 SequenceNode* Parser::MakeImplicitConstructor(const Function& func) {
   ASSERT(func.IsConstructor());
-  intptr_t ctor_pos = token_index_;
+  const intptr_t ctor_pos = token_index_;
 
   // Implicit 'this' is the only parameter/local variable.
   OpenFunctionBlock(func);
 
   // Parse expressions of instance fields that have an explicit
   // initializers.
   GrowableArray<FieldInitExpression> initializers;
   Class& cls = Class::Handle(func.owner());
   ParseInitializedInstanceFields(cls, &initializers);
 
@@ skipping 341 matching lines @@
       CaptureReceiver();
     }
   }
 
   if (CurrentToken() == Token::kLBRACE) {
     ConsumeToken();
     ParseStatementSequence();
     ExpectToken(Token::kRBRACE);
   } else if (CurrentToken() == Token::kARROW) {
     ConsumeToken();
-    intptr_t expr_pos = token_index_;
+    const intptr_t expr_pos = token_index_;
     AstNode* expr = ParseExpr(kAllowConst);
     ASSERT(expr != NULL);
     current_block_->statements->Add(new ReturnNode(expr_pos, expr));
   } else if (IsLiteral("native")) {
     ParseNativeFunctionBlock(&params, func);
   } else {
     UnexpectedToken();
   }
 
   SequenceNode* statements = CloseBlock();
@@ skipping 46 matching lines @@
       SkipExpr();
       SetAllowFunctionLiterals(true);
     }
   } while (CurrentToken() == Token::kCOMMA);
 }
 
 
 void Parser::ParseQualIdent(QualIdent* qual_ident) {
   ASSERT(CurrentToken() == Token::kIDENT);
   if (!is_top_level_) {
-    bool local_ident = ResolveIdentInLocalScope(token_index_,
-                                                *CurrentLiteral(),
-                                                NULL);
+    bool is_local_ident = ResolveIdentInLocalScope(token_index_,
+                                                   *CurrentLiteral(),
+                                                   NULL);
     qual_ident->ident_pos = token_index_;
     qual_ident->ident = CurrentLiteral();
     qual_ident->lib_prefix = NULL;
     qual_ident->qualifier = NULL;
-    qual_ident->local_scope_ident = local_ident;
+    qual_ident->is_local_scope_ident = is_local_ident;
     ConsumeToken();
-    if (!local_ident && (CurrentToken() == Token::kPERIOD)) {
+    if (!is_local_ident && (CurrentToken() == Token::kPERIOD)) {
       LibraryPrefix& lib_prefix = LibraryPrefix::ZoneHandle();
       lib_prefix = current_class().LookupLibraryPrefix(*(qual_ident->ident));
       if (!lib_prefix.IsNull()) {
         // We have a library prefix qualified identifier.
         ConsumeToken();  // Consume the kPERIOD token.
         qual_ident->lib_prefix = &lib_prefix;
         qual_ident->qualifier = qual_ident->ident;
         qual_ident->ident_pos = token_index_;
         qual_ident->ident = ExpectIdentifier("identifier expected after '.'");
       }
     }
   } else {
     qual_ident->ident_pos = token_index_;
     qual_ident->ident = CurrentLiteral();
     qual_ident->lib_prefix = NULL;
     qual_ident->qualifier = NULL;
-    qual_ident->local_scope_ident = false;
+    qual_ident->is_local_scope_ident = false;
     ConsumeToken();
     if (CurrentToken() == Token::kPERIOD) {
       ConsumeToken();  // Consume the kPERIOD token.
       qual_ident->qualifier = qual_ident->ident;
       qual_ident->ident_pos = token_index_;
       qual_ident->ident = ExpectIdentifier("identifier expected after '.'");
     }
   }
 }
 
@@ skipping 334 matching lines @@
       ErrorMsg("identifier expected after 'final'");
     }
     ConsumeToken();
     member.has_var = true;
     // The member type is the 'Dynamic' type.
     member.type = &Type::ZoneHandle(Type::DynamicType());
   } else if (CurrentToken() == Token::kFACTORY) {
     ConsumeToken();
     member.has_factory = true;
     member.has_static = true;
-    // The member result type is the type of this class.
-    // TODO(regis): What are the type arguments?
-    member.type =
-        &Type::ZoneHandle(Type::NewRawType(Class::Handle(members->clazz())));
+    // The result type depends on the name of the factory method.
   }
   // Optionally parse a type.
   if (CurrentToken() == Token::kVOID) {
     if (member.has_var || member.has_factory) {
       ErrorMsg("void not expected");
     }
     ConsumeToken();
     ASSERT(member.type == NULL);
     member.type = &Type::ZoneHandle(Type::VoidType());
   } else if (CurrentToken() == Token::kIDENT) {
     // This is either a type name or the name of a method/constructor/field.
-    if (member.type == NULL) {
+    if ((member.type == NULL) && !member.has_factory) {
       // We have not seen a member type yet, so we check if the next
       // identifier could represent a type before parsing it.
       Token::Kind follower = LookaheadToken(1);
       // We have an identifier followed by a 'follower' token.
       // We either parse a type or assume that no type is specified.
       if ((follower == Token::kLT) ||  // Parameterized type.
           (follower == Token::kGET) ||  // Getter following a type.
           (follower == Token::kSET) ||  // Setter following a type.
           (follower == Token::kOPERATOR) ||  // Operator following a type.
           (follower == Token::kIDENT)  ||  // Member name following a type.
           ((follower == Token::kPERIOD) &&    // Qualified class name of type,
            (LookaheadToken(3) != Token::kLPAREN))) {  // but not a named constr.
         ASSERT(is_top_level_);
         member.type = &Type::ZoneHandle(ParseType(kCanResolve));
       }
     }
   }
   // Optionally parse a (possibly named) constructor name or factory.
   if ((CurrentToken() == Token::kIDENT) &&
       (CurrentLiteral()->Equals(members->class_name()) || member.has_factory)) {
     member.name = CurrentLiteral();
     member.name_pos = this->token_index_;
-    // Factory result type is the same as the type name of the factory.
-    // TODO(srdjan): Implement checks in class finalization when all types have
-    // been resolved.
-    if (member.has_factory && !member.name->Equals(members->class_name())) {
-      const UnresolvedClass& type =
+    ConsumeToken();
+    // Resolution of the factory result type is always postponed until class
+    // finalization, so that the list of type parameters in the factory
+    // signature can be checked at the same time.
+    if (member.has_factory) {
+      const UnresolvedClass& unresolved_factory_class =
           UnresolvedClass::Handle(UnresolvedClass::New(member.name_pos,
                                                        String::Handle(),
                                                        *(member.name)));
+      const Class& signature_class = Class::Handle(
+          Class::New(String::Handle(String::NewSymbol(":factory_signature")),
+                     Script::Handle()));
+      signature_class.set_is_finalized();
+      unresolved_factory_class.set_factory_signature_class(signature_class);
+      // The type arguments of the result type are set during finalization.
       const TypeArguments& args = TypeArguments::Handle();
-      member.type = &Type::ZoneHandle(Type::NewParameterizedType(type, args));
+      member.type = &Type::ZoneHandle(
+          Type::NewParameterizedType(unresolved_factory_class, args));
+      ParseTypeParameters(signature_class);
     }
-    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.
       ConsumeToken();
       const String* name = ExpectIdentifier("identifier expected");
       ctor_suffix = String::Concat(ctor_suffix, *name);
     }
     *member.name = String::Concat(*member.name, ctor_suffix);
     // Ensure that names are symbols.
     *member.name = String::NewSymbol(*member.name);
     if (member.type == NULL) {
-      // TODO(regis): What are the type arguments?
-      member.type =
-          &Type::ZoneHandle(Type::NewRawType(Class::Handle(members->clazz())));
+      ASSERT(!member.has_factory);
+      // The body of the constructor cannot modify the type arguments of the
+      // constructed instance, which is passed in as a hidden parameter.
+      // Therefore, there is no need to set the result type to be checked.
+      member.type = &Type::ZoneHandle(Type::DynamicType());
     } else {
       // The type can only be already set in the factory case.
       if (!member.has_factory) {
         ErrorMsg(member.name_pos, "constructor must not specify return type");
       }
     }
     if (CurrentToken() != Token::kLPAREN) {
       ErrorMsg("left parenthesis expected");
     }
   } else if (CurrentToken() == Token::kGET) {
@@ skipping 65 matching lines @@
   } else {
     UnexpectedToken();
   }
   current_member_ = NULL;
   members->AddMember(member);
 }
 
 
 void Parser::ParseClassDefinition(GrowableArray<const Class*>* classes) {
   TRACE_PARSER("ParseClassDefinition");
-  intptr_t class_pos = token_index_;
+  const intptr_t class_pos = token_index_;
   ExpectToken(Token::kCLASS);
-  intptr_t classname_pos = token_index_;
+  const intptr_t classname_pos = token_index_;
   String& class_name = *ExpectIdentifier("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_);
     library_.AddClass(cls);
   } else {
@@ skipping 72 matching lines @@
                       /* is_const = */ false,
                       class_desc->token_pos()));
     ParamList params;
     // Add implicit 'this' parameter.
     params.AddReceiver(token_index_);
     // Add implicit parameter for construction phase.
     params.AddFinalParameter(token_index_, kPhaseParameterName,
                              &Type::ZoneHandle(Type::DynamicType()));
 
     AddFormalParamsToFunction(&params, ctor);
-    // TODO(regis): What are the type arguments?
-    Type& result_type = Type::ZoneHandle(
-        Type::NewRawType(Class::Handle(class_desc->clazz())));
+    // The body of the constructor cannot modify the type arguments of the
+    // constructed instance, which is passed in as a hidden parameter.
+    // Therefore, there is no need to set the result type to be checked.
+    const Type& result_type = Type::ZoneHandle(Type::DynamicType());
     ctor.set_result_type(result_type);
     class_desc->AddFunction(&ctor);
   }
 
   // Check for cycles in constructor redirection.
   const GrowableArray<MemberDesc>& members = class_desc->members();
   for (int i = 0; i < members.length(); i++) {
     MemberDesc* member = &members[i];
     GrowableArray<MemberDesc*> ctors;
     while ((member != NULL) && (member->redirect_name != NULL)) {
@@ skipping 38 matching lines @@
   SetPosition(saved_pos);
   return is_alias_name;
 }
 
 
 void Parser::ParseFunctionTypeAlias(GrowableArray<const Class*>* classes) {
   TRACE_PARSER("ParseFunctionTypeAlias");
   ExpectToken(Token::kTYPEDEF);
 
   Type& result_type = Type::Handle(Type::DynamicType());
-  intptr_t result_type_pos = token_index_;
+  const intptr_t result_type_pos = token_index_;
   if (CurrentToken() == Token::kVOID) {
     ConsumeToken();
     result_type = Type::VoidType();
   } else if (!IsFunctionTypeAliasName()) {
     result_type = ParseType(kDoNotResolve);  // No owner class yet.
   }
 
   if (CurrentToken() != Token::kIDENT) {
     ErrorMsg("function alias name expected");
   }
   const intptr_t alias_name_pos = token_index_;
   const String* alias_name = CurrentLiteral();
   ConsumeToken();
 
   // 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()));
   alias_owner.set_is_interface();
   set_current_class(alias_owner);
   ParseTypeParameters(alias_owner);
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg("formal parameter list expected");
   }
 
   // At this point, the type parameters have been parsed, so we can resolve the
   // result type.
-  if (!result_type.IsNull() && !result_type.IsResolved()) {
-    ResolveTypeFromClass(result_type_pos, alias_owner, &result_type);
+  if (!result_type.IsNull()) {
+    TryResolveTypeFromClass(result_type_pos, alias_owner, &result_type);
   }
   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(
       Function::New(*alias_name,
                     RawFunction::kSignatureFunction,
                     /* is_static = */ false,
                     /* is_const = */ false,
@@ skipping 36 matching lines @@
         "'%s' is already defined" : "'%s' is already defined as class";
     ErrorMsg(alias_name_pos, format, alias_name->ToCString());
   }
   ExpectSemicolon();
   classes->Add(&function_type_alias);
 }
 
 
 void Parser::ParseInterfaceDefinition(GrowableArray<const Class*>* classes) {
   TRACE_PARSER("ParseInterfaceDefinition");
-  intptr_t interface_pos = token_index_;
+  const intptr_t interface_pos = token_index_;
   ExpectToken(Token::kINTERFACE);
-  intptr_t interfacename_pos = token_index_;
+  const intptr_t interfacename_pos = token_index_;
   String& interface_name = *ExpectIdentifier("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_);
     library_.AddClass(interface);
   } else {
@@ skipping 19 matching lines @@
 
   if (CurrentToken() == Token::kEXTENDS) {
     Array& interfaces = Array::Handle();
     const intptr_t interfaces_pos = token_index_;
     interfaces = ParseInterfaceList();
     AddInterfaces(interfaces_pos, interface, interfaces);
   }
 
   if (CurrentToken() == Token::kFACTORY) {
     ConsumeToken();
-    Type& factory_type = Type::Handle();
-    const intptr_t factory_type_pos = token_index_;
-    factory_type = ParseType(kCanResolve);
-    if (factory_type.IsInterfaceType()) {
-      ErrorMsg(factory_type_pos,
-               "interface '%s' must have a factory class "
-               "but '%s' is an interface",
-               interface_name.ToCString(),
-               String::Handle(factory_type.Name()).ToCString());
+    const intptr_t factory_pos = token_index_;
+    QualIdent factory_name;
+    ParseQualIdent(&factory_name);
+    if (factory_name.is_local_scope_ident) {
+      ErrorMsg(factory_pos,
+               "using '%s' in this context is invalid",
+               factory_name.ident->ToCString());
     }
-    interface.set_factory_type(factory_type);
+    String& qualifier = String::Handle();
+    if (factory_name.qualifier != NULL) {
+      qualifier ^= factory_name.qualifier->raw();
+    }
+    const UnresolvedClass& unresolved_factory_class = UnresolvedClass::Handle(
+        UnresolvedClass::New(factory_pos, qualifier, *(factory_name.ident)));
+    const Class& signature_class = Class::Handle(
+        Class::New(String::Handle(String::NewSymbol(":factory_signature")),
+                   Script::Handle()));
+    signature_class.set_is_finalized();
+    ParseTypeParameters(signature_class);
+    unresolved_factory_class.set_factory_signature_class(signature_class);
+    interface.set_factory_class(unresolved_factory_class);
   }
 
   ExpectToken(Token::kLBRACE);
   ClassDesc members(interface, interface_name, true, interface_pos);
   while (CurrentToken() != Token::kRBRACE) {
     ParseClassMemberDefinition(&members);
   }
   ExpectToken(Token::kRBRACE);
 
   interface.SetFields(Array::Handle(NewArray<Field>(members.fields())));
@@ skipping 52 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<Type*> type_parameter_extends;
     do {
       ConsumeToken();
       if (CurrentToken() != Token::kIDENT) {
         ErrorMsg("type parameter name expected");
       }
       String& type_parameter_name = *CurrentLiteral();
       ConsumeToken();
       Type& type_extends = Type::ZoneHandle(Type::DynamicType());
       if (CurrentToken() == Token::kEXTENDS) {
         ConsumeToken();
         type_extends = ParseType(kCanResolve);
       }
       type_parameters.Add(&type_parameter_name);
       type_parameter_extends.Add(&type_extends);
     } while (CurrentToken() == Token::kCOMMA);
     Token::Kind token = CurrentToken();
     if ((token == Token::kGT) ||
         (token == Token::kSAR) ||
         (token == Token::kSHR)) {
       ConsumeRightAngleBracket();
     } else {
       ErrorMsg("right angle bracket expected");
     }
     cls.set_type_parameters(Array::Handle(NewArray<String>(type_parameters)));
-    cls.set_type_parameter_extends(
-        TypeArray::Handle(NewTypeArray(type_parameter_extends)));
+    const TypeArray& extends_array =
+        TypeArray::Handle(NewTypeArray(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.
+    Type& type_extends = Type::Handle();
+    const intptr_t num_types = extends_array.Length();
+    for (intptr_t i = 0; i < num_types; i++) {
+      type_extends = extends_array.TypeAt(i);
+      TryResolveTypeFromClass(type_pos, cls, &type_extends);
+      extends_array.SetTypeAt(i, type_extends);
+    }
   }
 }
 
 
 RawTypeArguments* Parser::ParseTypeArguments(TypeResolution type_resolution) {
   if (CurrentToken() == Token::kLT) {
     GrowableArray<Type*> types;
     do {
       ConsumeToken();
       Type& type = Type::ZoneHandle(ParseType(type_resolution));
@@ skipping 168 matching lines @@
     } else {
       result_type = ParseType(kCanResolve);
     }
     is_getter = (CurrentToken() == Token::kGET);
     if (CurrentToken() == Token::kGET || CurrentToken() == Token::kSET) {
       ConsumeToken();
     } else {
       UnexpectedToken();
     }
   }
-  intptr_t name_pos = token_index_;
+  const intptr_t name_pos = token_index_;
   const String* field_name = ExpectIdentifier("accessor name expected");
 
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg("'(' expected");
   }
-  intptr_t accessor_pos = token_index_;
+  const intptr_t accessor_pos = token_index_;
   ParamList params;
   const bool allow_explicit_default_values = true;
   ParseFormalParameterList(allow_explicit_default_values, &params);
   String& accessor_name = String::ZoneHandle();
   int expected_num_parameters = -1;
   if (is_getter) {
     expected_num_parameters = 0;
     accessor_name = Field::GetterName(*field_name);
   } else {
     expected_num_parameters = 1;
@@ skipping 61 matching lines @@
                                Api::NewLocalHandle(url));
   if (Dart_IsError(result)) {
     ErrorMsg(token_pos, "library handler failed: %s", Dart_GetError(result));
   }
   return result;
 }
 
 
 void Parser::ParseLibraryImport() {
   while (CurrentToken() == Token::kIMPORT) {
-    intptr_t import_pos = token_index_;
+    const intptr_t import_pos = token_index_;
     ConsumeToken();
     ExpectToken(Token::kLPAREN);
     if (CurrentToken() != Token::kSTRING) {
       ErrorMsg("library url expected");
     }
     const String& url = *CurrentLiteral();
     ConsumeToken();
     String& prefix = String::Handle();
     if (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
@@ skipping 36 matching lines @@
       const LibraryPrefix& library_prefix =
           LibraryPrefix::Handle(LibraryPrefix::New(prefix, library));
       library_.AddObject(library_prefix, prefix);
     }
   }
 }
 
 
 void Parser::ParseLibraryInclude() {
   while (CurrentToken() == Token::kSOURCE) {
-    intptr_t source_pos = token_index_;
+    const intptr_t source_pos = token_index_;
     ConsumeToken();
     ExpectToken(Token::kLPAREN);
     if (CurrentToken() != Token::kSTRING) {
       ErrorMsg("source url expected");
     }
     const String& url = *CurrentLiteral();
     ConsumeToken();
     ExpectToken(Token::kRPAREN);
     ExpectToken(Token::kSEMICOLON);
     Dart_Handle handle = CallLibraryTagHandler(kCanonicalizeUrl,
@@ skipping 193 matching lines @@
 }
 
 
 // Builds ReturnNode/NativeBodyNode for a native function.
 void Parser::ParseNativeFunctionBlock(const ParamList* params,
                                       const Function& func) {
   const Class& cls = Class::Handle(func.owner());
   const int num_parameters = params->parameters->length();
 
   // Parse the function name out.
-  intptr_t native_pos = token_index_;
+  const intptr_t native_pos = token_index_;
   const String& native_name = ParseNativeDeclaration();
 
   // Now resolve the native function to the corresponding native entrypoint.
   NativeFunction native_function = NativeEntry::ResolveNative(cls,
                                                               native_name,
                                                               num_parameters);
   if (native_function == NULL) {
     ErrorMsg(native_pos, "native function '%s' cannot be found",
         native_name.ToCString());
   }
@@ skipping 173 matching lines @@
   const String* function_name = NULL;
 
   result_type = Type::DynamicType();
   if (CurrentToken() == Token::kVOID) {
     ConsumeToken();
     result_type = Type::VoidType();
   } else if ((CurrentToken() == Token::kIDENT) &&
              (LookaheadToken(1) != Token::kLPAREN)) {
     result_type = ParseType(kMustResolve);
   }
-  intptr_t ident_pos = token_index_;
+  const intptr_t ident_pos = token_index_;
   if (CurrentToken() == Token::kIDENT) {
     variable_name = CurrentLiteral();
     function_name = variable_name;
     ConsumeToken();
   } else {
     if (!is_literal) {
       ErrorMsg("function name expected");
     }
     const String& anonymous_function_name =
         String::ZoneHandle(String::NewSymbol("function"));
@@ skipping 179 matching lines @@
 
 
 // Returns true if the next tokens can be parsed as a type with optional
 // type parameters. Current token position is not restored.
 bool Parser::IsOptionalType() {
   if (CurrentToken() == Token::kIDENT) {
     QualIdent type_name;
     ParseQualIdent(&type_name);
     // Check if the type_name has been defined as a variable in a local scope,
     // hiding the type.
-    if (type_name.local_scope_ident) {
+    if (type_name.is_local_scope_ident) {
       return false;
     }
     if (CurrentToken() == Token::kLT && !IsTypeParameter()) {
       return false;
     }
   }
   return true;
 }
 
 
@@ skipping 16 matching lines @@
 // ('var' | 'final' | type ident (';' | '=' | ','))
 // Token position remains unchanged.
 bool Parser::IsVariableDeclaration() {
   if ((CurrentToken() == Token::kVAR) ||
       (CurrentToken() == Token::kFINAL)) {
     return true;
   }
   if (CurrentToken() != Token::kIDENT) {
     return false;
   }
-  intptr_t saved_pos = token_index_;
+  const intptr_t saved_pos = token_index_;
   bool is_var_decl = false;
   if (IsOptionalType()) {
     if (CurrentToken() == Token::kIDENT) {
       ConsumeToken();
       if ((CurrentToken() == Token::kSEMICOLON) ||
           (CurrentToken() == Token::kCOMMA) ||
           (CurrentToken() == Token::kASSIGN)) {
         is_var_decl = true;
       }
     }
@@ skipping 16 matching lines @@
   return ((CurrentToken() == Token::kIDENT) &&
       (LookaheadToken(1) == Token::kLPAREN)) ||
       IsFunctionDeclaration();
 }
 
 
 bool Parser::IsTopLevelAccessor() {
   if ((CurrentToken() == Token::kGET) || (CurrentToken() == Token::kSET)) {
     return true;
   }
-  intptr_t saved_pos = token_index_;
+  const intptr_t saved_pos = token_index_;
   if (IsReturnType()) {
     if ((CurrentToken() == Token::kGET) || (CurrentToken() == Token::kSET)) {
       if (LookaheadToken(1) == Token::kIDENT) {  // Accessor name.
         SetPosition(saved_pos);
         return true;
       }
     }
   }
   SetPosition(saved_pos);
   return false;
 }
 
 
 bool Parser::IsFunctionLiteral() {
   if (!allow_function_literals_) {
     return false;
   }
-  intptr_t saved_pos = token_index_;
+  const intptr_t saved_pos = token_index_;
   bool is_function_literal = false;
   if ((CurrentToken() == Token::kIDENT) &&
       (LookaheadToken(1) == Token::kLPAREN)) {
     ConsumeToken();  // Consume function identifier.
   } else if (IsReturnType()) {
     if (CurrentToken() != Token::kIDENT) {
       SetPosition(saved_pos);
       return false;
     }
     ConsumeToken();  // Comsume function identifier.
   }
   if (CurrentToken() == Token::kLPAREN) {
     SkipToMatchingParenthesis();
     if ((CurrentToken() == Token::kLBRACE) ||
         (CurrentToken() == Token::kARROW)) {
       is_function_literal = true;
     }
   }
   SetPosition(saved_pos);
   return is_function_literal;
 }
 
 
 // Current token position is the token after the opening ( of the for
 // statement. Returns true if we recognize a for ( .. in expr)
 // statement.
 bool Parser::IsForInStatement() {
-  intptr_t saved_pos = token_index_;
+  const intptr_t saved_pos = token_index_;
   bool result = false;
   if (CurrentToken() == Token::kVAR || CurrentToken() == Token::kFINAL) {
     ConsumeToken();
   }
   if (CurrentToken() == Token::kIDENT) {
     if (LookaheadToken(1) == Token::kIN) {
       result = true;
     } else if (IsOptionalType()) {
       if (CurrentToken() == Token::kIDENT) {
         ConsumeToken();
@@ skipping 25 matching lines @@
   }
   return false;
 }
 
 
 void Parser::ParseStatementSequence() {
   TRACE_PARSER("ParseStatementSequence");
   const bool dead_code_allowed = true;
   bool abrupt_completing_seen = false;
   while (CurrentToken() != Token::kRBRACE) {
-    intptr_t statement_pos = token_index_;
+    const intptr_t statement_pos = token_index_;
     AstNode* statement = ParseStatement();
     if (statement != NULL) {
       if (!dead_code_allowed && abrupt_completing_seen) {
         ErrorMsg(statement_pos, "dead code after abrupt completing statement");
       }
       current_block_->statements->Add(statement);
       abrupt_completing_seen |= IsAbruptCompleting(statement);
     }
   }
 }
@@ skipping 24 matching lines @@
     }
   }
   SequenceNode* sequence = CloseBlock();
   return sequence;
 }
 
 
 AstNode* Parser::ParseIfStatement(String* label_name) {
   TRACE_PARSER("ParseIfStatement");
   ASSERT(CurrentToken() == Token::kIF);
-  intptr_t if_pos = token_index_;
+  const intptr_t if_pos = token_index_;
   SourceLabel* label = NULL;
   if (label_name != NULL) {
     label = SourceLabel::New(if_pos, label_name, SourceLabel::kStatement);
     OpenBlock();
     current_block_->scope->AddLabel(label);
   }
   ConsumeToken();
   ExpectToken(Token::kLPAREN);
   AstNode* cond_expr = ParseExpr(kAllowConst);
   ExpectToken(Token::kRPAREN);
@@ skipping 12 matching lines @@
     if_node = sequence;
   }
   return if_node;
 }
 
 
 CaseNode* Parser::ParseCaseClause(LocalVariable* switch_expr_value,
                                   SourceLabel* case_label) {
   TRACE_PARSER("ParseCaseStatement");
   bool default_seen = false;
-  intptr_t case_pos = token_index_;
+  const intptr_t case_pos = token_index_;
   SequenceNode* case_expressions =
       new SequenceNode(case_pos, current_block_->scope);
   while (CurrentToken() == Token::kCASE || CurrentToken() == Token::kDEFAULT) {
     if (CurrentToken() == Token::kCASE) {
       if (default_seen) {
         ErrorMsg("default clause must be last case");
       }
       ConsumeToken();  // Keyword case.
-      intptr_t expr_pos = token_index_;
+      const intptr_t expr_pos = token_index_;
       AstNode* expr = ParseExpr(kAllowConst);
       AstNode* switch_expr_load = new LoadLocalNode(case_pos,
                                                     *switch_expr_value);
       AstNode* case_comparison = new ComparisonNode(expr_pos,
                                                     Token::kEQ,
                                                     expr,
                                                     switch_expr_load);
       case_expressions->Add(case_comparison);
     } else {
       if (default_seen) {
@@ skipping 44 matching lines @@
   }
   SequenceNode* statements = CloseBlock();
   return new CaseNode(case_pos, case_label,
       case_expressions, default_seen, switch_expr_value, statements);
 }
 
 
 AstNode* Parser::ParseSwitchStatement(String* label_name) {
   TRACE_PARSER("ParseSwitchStatement");
   ASSERT(CurrentToken() == Token::kSWITCH);
-  intptr_t switch_pos = token_index_;
+  const intptr_t switch_pos = token_index_;
   SourceLabel* label =
       SourceLabel::New(switch_pos, label_name, SourceLabel::kSwitch);
   ConsumeToken();
   const bool parens_are_mandatory = false;
   bool paren_found = false;
   if (CurrentToken() == Token::kLPAREN) {
     paren_found = true;
     ConsumeToken();
   } else if (parens_are_mandatory) {
     ErrorMsg("'(' expected");
   }
-  intptr_t expr_pos = token_index_;
+  const intptr_t expr_pos = token_index_;
   AstNode* switch_expr = ParseExpr(kAllowConst);
   if (paren_found) {
     ExpectToken(Token::kRPAREN);
   }
   ExpectToken(Token::kLBRACE);
   OpenBlock();
   current_block_->scope->AddLabel(label);
 
   // Store switch expression in temporary local variable.
   LocalVariable* temp_variable =
       new LocalVariable(expr_pos,
                         String::ZoneHandle(String::NewSymbol(":switch_expr")),
                         Type::ZoneHandle(Type::DynamicType()));
   current_block_->scope->AddVariable(temp_variable);
   AstNode* save_switch_expr =
       new StoreLocalNode(expr_pos, *temp_variable, switch_expr);
   current_block_->statements->Add(save_switch_expr);
 
   // Parse case clauses
   bool default_seen = false;
   while (true) {
     // Check for statement label
     SourceLabel* case_label = NULL;
     if (CurrentToken() == Token::kIDENT &&
         LookaheadToken(1) == Token::kCOLON) {
       // Case statements start with a label.
       String* label_name = CurrentLiteral();
-      intptr_t label_pos = token_index_;
+      const intptr_t label_pos = token_index_;
       ConsumeToken();  // Consume label identifier.
       ConsumeToken();  // Consume colon.
       case_label = current_block_->scope->LocalLookupLabel(*label_name);
       if (case_label == NULL) {
         // Label does not exist yet. Add it to scope of switch statement.
         case_label =
             new SourceLabel(label_pos, *label_name, SourceLabel::kCase);
         current_block_->scope->AddLabel(case_label);
       } else if (case_label->kind() == SourceLabel::kForward) {
         // We have seen a 'continue' with this label name. Resolve
@@ skipping 31 matching lines @@
   }
 
   SequenceNode* switch_body = CloseBlock();
   ExpectToken(Token::kRBRACE);
   return new SwitchNode(switch_pos, label, switch_body);
 }
 
 
 AstNode* Parser::ParseWhileStatement(String* label_name) {
   TRACE_PARSER("ParseWhileStatement");
-  intptr_t while_pos = token_index_;
+  const intptr_t while_pos = token_index_;
   SourceLabel* label =
       SourceLabel::New(while_pos, label_name, SourceLabel::kWhile);
   ConsumeToken();
   ExpectToken(Token::kLPAREN);
   AstNode* cond_expr = ParseExpr(kAllowConst);
   ExpectToken(Token::kRPAREN);
   const bool parsing_loop_body =  true;
   SequenceNode* while_body = ParseNestedStatement(parsing_loop_body, label);
   return new WhileNode(while_pos, label, cond_expr, while_body);
 }
 
 
 AstNode* Parser::ParseDoWhileStatement(String* label_name) {
   TRACE_PARSER("ParseDoWhileStatement");
-  intptr_t do_pos = token_index_;
+  const intptr_t do_pos = token_index_;
   SourceLabel* label =
       SourceLabel::New(do_pos, label_name, SourceLabel::kDoWhile);
   ConsumeToken();
   const bool parsing_loop_body =  true;
   SequenceNode* dowhile_body = ParseNestedStatement(parsing_loop_body, label);
   ExpectToken(Token::kWHILE);
   ExpectToken(Token::kLPAREN);
   AstNode* cond_expr = ParseExpr(kAllowConst);
   ExpectToken(Token::kRPAREN);
   ExpectSemicolon();
@@ skipping 15 matching lines @@
     const Type& type = Type::ZoneHandle(
         ParseFinalVarOrType(kIsMandatory, kMustResolve));
     loop_var_pos = token_index_;
     loop_var_name = ExpectIdentifier("variable name expected");
     loop_var = new LocalVariable(loop_var_pos, *loop_var_name, type);
     if (is_final) {
       loop_var->set_is_final();
     }
   }
   ExpectToken(Token::kIN);
-  intptr_t collection_pos = token_index_;
+  const intptr_t collection_pos = token_index_;
   AstNode* collection_expr = ParseExpr(kAllowConst);
   ExpectToken(Token::kRPAREN);
 
   OpenBlock();  // Implicit block around while loop.
 
   // Generate implicit iterator variable and add to scope.
   const String& iterator_name =
       String::ZoneHandle(String::NewSymbol(":for-in-iter"));
   // We could set the type of the implicit iterator variable to Iterator<T>
   // where T is the type of the for loop variable. However, the type error
@@ skipping 71 matching lines @@
   AstNode* while_statement =
       new WhileNode(forin_pos, label, iterator_has_next, for_loop_statement);
   current_block_->statements->Add(while_statement);
 
   return CloseBlock();  // Implicit block around while loop.
 }
 
 
 AstNode* Parser::ParseForStatement(String* label_name) {
   TRACE_PARSER("ParseForStatement");
-  intptr_t for_pos = token_index_;
+  const intptr_t for_pos = token_index_;
   ConsumeToken();
   ExpectToken(Token::kLPAREN);
   SourceLabel* label = SourceLabel::New(for_pos, label_name, SourceLabel::kFor);
   if (IsForInStatement()) {
     return ParseForInStatement(for_pos, label);
   }
   OpenBlock();
   // The label is added to the implicit scope that also contains
   // the loop variable declarations.
   current_block_->scope->AddLabel(label);
   AstNode* initializer = NULL;
-  intptr_t init_pos = token_index_;
+  const intptr_t init_pos = token_index_;
   LocalScope* init_scope = current_block_->scope;
   if (CurrentToken() != Token::kSEMICOLON) {
     if (IsVariableDeclaration()) {
       initializer = ParseVariableDeclarationList();
     } else {
       initializer = ParseExpr(kAllowConst);
     }
   }
   ExpectSemicolon();
   AstNode* condition = NULL;
   if (CurrentToken() != Token::kSEMICOLON) {
     condition = ParseExpr(kAllowConst);
   }
   ExpectSemicolon();
   AstNode* increment = NULL;
-  intptr_t incr_pos = token_index_;
+  const intptr_t incr_pos = token_index_;
   LocalScope* incr_scope = current_block_->scope;
   if (CurrentToken() != Token::kRPAREN) {
     increment = ParseExprList();
   }
   ExpectToken(Token::kRPAREN);
   const bool parsing_loop_body =  true;
   SequenceNode* body = ParseNestedStatement(parsing_loop_body, NULL);
 
   // Check whether any of the variables in the initializer part of
   // the for statement are captured by a closure. If so, we insert a
@@ skipping 247 matching lines @@
       String::ZoneHandle(String::NewSymbol(":stacktrace_var"));
   LocalVariable* catch_trace_var =
       current_block_->scope->LocalLookupVariable(catch_trace_var_name);
   if (catch_trace_var == NULL) {
     catch_trace_var = new LocalVariable(token_index_,
                                         catch_trace_var_name,
                                         Type::ZoneHandle(Type::DynamicType()));
     current_block_->scope->AddVariable(catch_trace_var);
   }
 
-  intptr_t try_pos = token_index_;
+  const intptr_t try_pos = token_index_;
   ConsumeToken();  // Consume the 'try'.
 
   SourceLabel* try_label = NULL;
   if (label_name != NULL) {
     try_label = SourceLabel::New(try_pos, label_name, SourceLabel::kStatement);
     OpenBlock();
     current_block_->scope->AddLabel(try_label);
   }
 
   // Now parse the 'try' block.
   OpenBlock();
   Block* current_try_block = current_block_;
   PushTryBlock(current_try_block);
   ExpectToken(Token::kLBRACE);
   ParseStatementSequence();
   ExpectToken(Token::kRBRACE);
   SequenceNode* try_block = CloseBlock();
 
   // Now create a label for the end of catch block processing so that we can
   // jump over the catch block code after executing the try block.
   SourceLabel* end_catch_label =
       SourceLabel::New(token_index_, NULL, SourceLabel::kCatch);
 
   // Now parse the 'catch' blocks if any and merge all of them into
   // an if-then sequence of the different types specified using the 'is'
   // operator.
   bool catch_seen = false;
   bool generic_catch_seen = false;
   SequenceNode* catch_handler_list = NULL;
-  intptr_t handler_pos = token_index_;
+  const intptr_t handler_pos = token_index_;
   OpenBlock();  // Start the catch block sequence.
   current_block_->scope->AddLabel(end_catch_label);
   while (CurrentToken() == Token::kCATCH) {
     catch_seen = true;
-    intptr_t catch_pos = token_index_;
+    const intptr_t catch_pos = token_index_;
     ConsumeToken();  // Consume the 'catch'.
     ExpectToken(Token::kLPAREN);
     CatchParamDesc exception_param;
     CatchParamDesc stack_trace_param;
     ParseCatchParameter(&exception_param);
     if (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
       ParseCatchParameter(&stack_trace_param);
     }
     ExpectToken(Token::kRPAREN);
 
     // If a generic "catch all" statement has already been seen then all
     // subsequent catch statements are dead. We issue an error for now,
     // it might make sense to turn this into a warning.
     if (generic_catch_seen) {
-      ErrorMsg("A generic 'catch all' statement already exists for this "
+      ErrorMsg("a generic 'catch all' statement already exists for this "
                "try block. All subsequent catch statements are dead code");
     }
     OpenBlock();
     AddCatchParamsToScope(exception_param,
                           stack_trace_param,
                           current_block_->scope);
 
     SequenceNode* catch_clause;
 
     // Parse the individual catch handler code and add an unconditional
@@ skipping 55 matching lines @@
     current_block_->statements->Add(catch_clause);
   }
   catch_handler_list = CloseBlock();
   TryBlocks* inner_try_block = PopTryBlock();
 
   // Finally parse the 'finally' block.
   SequenceNode* finally_block = NULL;
   if (CurrentToken() == Token::kFINALLY) {
     current_function_.set_is_optimizable(false);
     ConsumeToken();  // Consume the 'finally'.
-    intptr_t finally_pos = token_index_;
+    const intptr_t finally_pos = token_index_;
     // Add the finally block to the exit points recorded so far.
     intptr_t node_index = 0;
     AstNode* node_to_inline =
         inner_try_block->GetNodeToInlineFinally(node_index);
     while (node_to_inline != NULL) {
       finally_block = ParseFinallyBlock();
       InlinedFinallyNode* node = new InlinedFinallyNode(finally_pos,
                                                         finally_block,
                                                         *context_var);
       AddFinallyBlockToNode(node_to_inline, node);
@@ skipping 42 matching lines @@
     sequence->set_label(try_label);
     try_catch_node = sequence;
   }
   return try_catch_node;
 }
 
 
 AstNode* Parser::ParseJump(String* label_name) {
   ASSERT(CurrentToken() == Token::kBREAK || CurrentToken() == Token::kCONTINUE);
   Token::Kind jump_kind = CurrentToken();
-  intptr_t jump_pos = token_index_;
+  const intptr_t jump_pos = token_index_;
   SourceLabel* target = NULL;
   ConsumeToken();
   if (CurrentToken() == Token::kIDENT) {
     // Explicit label after break/continue.
     const String& target_name = *CurrentLiteral();
     ConsumeToken();
     // Handle pathological cases first.
     if (label_name != NULL && target_name.Equals(*label_name)) {
       if (jump_kind == Token::kCONTINUE) {
         ErrorMsg(jump_pos, "'continue' jump to label '%s' is illegal",
@@ skipping 202 matching lines @@
 
 
 void Parser::Warning(const char* format, ...) {
   if (FLAG_silent_warnings) return;
   va_list args;
   va_start(args, format);
   ReportMsg(script_, token_index_, "Warning", error_msg_, format, args);
   if (FLAG_warning_as_error) {
     Isolate::Current()->long_jump_base()->Jump(1, error_msg_);
     UNREACHABLE();
+  } else {
+    OS::Print(error_msg_);
   }
 }
 
 
 void Parser::Unimplemented(const char* msg) {
   ErrorMsg(token_index_, msg);
 }
 
 
 void Parser::ExpectToken(Token::Kind token_expected) {
@@ skipping 277 matching lines @@
       return new BinaryOpNode(op_pos, Token::kSHL, lhs, rhs);
     case Token::kASSIGN_SHR:
       return new BinaryOpNode(op_pos, Token::kSHR, lhs, rhs);
     case Token::kASSIGN_OR:
       return new BinaryOpNode(op_pos, Token::kBIT_OR, lhs, rhs);
     case Token::kASSIGN_AND:
       return new BinaryOpNode(op_pos, Token::kBIT_AND, lhs, rhs);
     case Token::kASSIGN_XOR:
       return new BinaryOpNode(op_pos, Token::kBIT_XOR, lhs, rhs);
     default:
-      ErrorMsg(op_pos, "Internal error: ExpandAssignableOp '%s' unimplemented",
+      ErrorMsg(op_pos, "internal error: ExpandAssignableOp '%s' unimplemented",
           Token::Name(assignment_op));
       UNIMPLEMENTED();
       return NULL;
   }
 }
 
 
 // Evaluates the value of the compile time constant expression
 // and returns a literal node for the value.
 AstNode* Parser::FoldConstExpr(intptr_t expr_pos, AstNode* expr) {
@@ skipping 27 matching lines @@
   }
   AstNode* right_expr = ParseExpr(require_compiletime_const);
   if (assignment_op != Token::kASSIGN) {
     expr = AsSideEffectFreeNode(expr);
   }
   right_expr =
       ExpandAssignableOp(assignment_pos, assignment_op, expr, right_expr);
   AstNode* assign_expr = expr->MakeAssignmentNode(right_expr);
   if (assign_expr == NULL) {
     ErrorMsg(assignment_pos,
-             "Left hand side of '%s' is not assignable",
+             "left hand side of '%s' is not assignable",
              Token::Str(assignment_op));
   }
   return assign_expr;
 }
 
 
 LiteralNode* Parser::ParseConstExpr() {
   TRACE_PARSER("ParseConstExpr");
   AstNode* expr = ParseExpr(kRequireConst);
   ASSERT(expr->IsLiteralNode());
@@ skipping 23 matching lines @@
   if (IsPrefixOperator(CurrentToken())) {
     Token::Kind unary_op = CurrentToken();
     ConsumeToken();
     expr = ParseUnaryExpr();
     expr = UnaryOpNode::UnaryOpOrLiteral(op_pos, unary_op, expr);
   } else if (IsIncrementOperator(CurrentToken())) {
     Token::Kind incr_op = CurrentToken();
     ConsumeToken();
     expr = ParseUnaryExpr();
     if (!IsAssignableExpr(expr)) {
-      ErrorMsg("Expression is not assignable");
+      ErrorMsg("expression is not assignable");
     }
     // is_prefix.
     AstNode* incr_op_node = expr->MakeIncrOpNode(op_pos, incr_op, true);
     if (incr_op_node == NULL) {
       Unimplemented("incr operation not implemented");
     }
     expr = incr_op_node;
   } else {
     expr = ParsePostfixExpr();
   }
@@ skipping 330 matching lines @@
           Function& func = Function::CheckedHandle(primary->primary().raw());
           String& func_name = String::ZoneHandle(func.name());
           if (func.is_static()) {
             // Parse static function call.
             Class& cls = Class::Handle(func.owner());
             selector = ParseStaticCall(cls, func_name, primary_pos);
           } else {
             // Dynamic function call on implicit "this" parameter.
             if (current_function().is_static()) {
               ErrorMsg(primary_pos,
-                       "Cannot access instance method '%s' "
+                       "cannot access instance method '%s' "
                        "from static function",
                        func_name.ToCString());
             }
             selector = ParseInstanceCall(LoadReceiver(primary_pos), func_name);
           }
         } else if (primary->primary().IsString()) {
           // Primary is an unresolved name.
           String& name = String::CheckedZoneHandle(primary->primary().raw());
           if (current_function().is_static()) {
             ErrorMsg(primary->token_index(),
                      "identifier '%s' is not declared in this scope",
                      name.ToCString());
           } else {
             // Treat as call to unresolved (instance) method.
             AstNode* receiver = LoadReceiver(primary->token_index());
             selector = ParseInstanceCall(receiver, name);
           }
         } else if (primary->primary().IsClass()) {
           ErrorMsg(left->token_index(),
-              "must use 'new' or 'const' to construct new instance");
+                   "must use 'new' or 'const' to construct new instance");
         } else {
           // Internal parser error.
           UNREACHABLE();
         }
       } else {
         // Left is not a primary node; this must be a closure call.
         AstNode* closure = left;
         selector = ParseClosureCall(closure);
       }
     } else {
@@ skipping 60 matching lines @@
         postfix_expr->MakeIncrOpNode(postfix_expr_pos, incr_op, false);
     if (incr_op_node == NULL) {
       Unimplemented("incr op not implemented");
     }
     postfix_expr = incr_op_node;
   }
   return postfix_expr;
 }
 
 
-bool Parser::ResolveTypeFromClass(intptr_t type_pos,
-                                  const Class& cls,
-                                  Type* type) {
+// Try to resolve the given type and its type arguments from the given class.
+// 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::TryResolveTypeFromClass(intptr_t type_pos,
+                                     const Class& cls,
+                                     Type* type) {
   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 check if the type is a type parameter of the given class.
     const TypeParameter& type_parameter = TypeParameter::Handle(
         cls.LookupTypeParameter(unresolved_class_name));
     if (!type_parameter.IsNull()) {
-      CheckTypeParameterReference(type_pos, unresolved_class_name);
       // A type parameter cannot be parameterized, so report an error if type
       // arguments have previously been parsed.
       if (type->arguments() != TypeArguments::null()) {
         ErrorMsg(type_pos, "type parameter '%s' cannot be parameterized",
                  type_parameter.ToCString());
-        return false;
       }
       *type = type_parameter.raw();
-      return true;
+      return;
     }
     const Class& resolved_type_class =
         Class::Handle(LookupClass(unresolved_class_name));
-    if (resolved_type_class.IsNull()) {
-      return false;
+    if (!resolved_type_class.IsNull()) {
+      Object& type_class = Object::Handle(resolved_type_class.raw());
+      ASSERT(type->IsParameterizedType());
+      // Replace unresolved class with resolved type class.
+      ParameterizedType& parameterized_type = ParameterizedType::Handle();
+      parameterized_type ^= type->raw();
+      parameterized_type.set_type_class(type_class);
     }
-    Object& type_class = Object::Handle(resolved_type_class.raw());
-    ASSERT(type->IsParameterizedType());
-    // Replace unresolved class with resolved type class.
-    ParameterizedType& parameterized_type = ParameterizedType::Handle();
-    parameterized_type ^= type->raw();
-    parameterized_type.set_type_class(type_class);
   }
   // Resolve type arguments, if any.
   const TypeArguments& arguments = TypeArguments::Handle(type->arguments());
   if (!arguments.IsNull()) {
-    intptr_t num_arguments = arguments.Length();
+    const intptr_t num_arguments = arguments.Length();
     for (intptr_t i = 0; i < num_arguments; i++) {
       Type& type_argument = Type::Handle(arguments.TypeAt(i));
-      if (!ResolveTypeFromClass(type_pos, cls, &type_argument)) {
-        return false;
-      }
+      TryResolveTypeFromClass(type_pos, cls, &type_argument);
       arguments.SetTypeAt(i, type_argument);
     }
   }
-  return true;
 }
 
 
 // Return class for type name. If the name cannot be resolved (yet), give an
 // error (if type_resolution == kMustResolve) or return the unresolved name.
 RawObject* Parser::LookupTypeClass(const QualIdent& type_name,
                                    TypeResolution type_resolution) {
   ASSERT(type_name.ident != NULL);
   Class& type_class = Class::Handle();
   if (type_name.lib_prefix != NULL) {
@@ skipping 38 matching lines @@
   // Fields are not accessible from a static function, except from a
   // constructor, which is considered as non-static by the compiler.
   if (current_function().is_static()) {
     ErrorMsg(field_pos,
              "cannot access instance field '%s' from a static function",
              field_name.ToCString());
   }
 }
 
 
-void Parser::CheckTypeParameterReference(intptr_t type_parameter_pos,
-                                         const String& type_parameter_name) {
+// If type parameters are currently in scope, return their declaring class,
+// otherwise return null.
+RawClass* Parser::TypeParametersScopeClass() {
   // Type parameters cannot be referred to from a static function, except from
   // a constructor or from a factory.
   // A constructor is considered as non-static by the compiler.
-  if ((is_top_level_ &&
-       (current_member_ != NULL) &&
-       current_member_->has_static &&
-       !current_member_->has_factory) ||
-      (!current_function().IsNull() &&
-       current_function().is_static() &&
-       !current_function().IsInFactoryScope())) {
-    ErrorMsg(type_parameter_pos,
-             "cannot refer to type parameter '%s' from a static function",
-             type_parameter_name.ToCString());
+  if (is_top_level_) {
+    if ((current_member_ != NULL) && current_member_->has_factory) {
+      const Type& factory_result_type = *current_member_->type;
+      ASSERT(!factory_result_type.IsNull());
+      const UnresolvedClass& unresolved_factory_class =
+          UnresolvedClass::Handle(factory_result_type.unresolved_class());
+      // TODO(regis): For now, and until the core lib is fixed, we accept a
+      // factory method with missing list of type parameters and use the
+      // list of the enclosing class.
+      // See bug 5408808.
+      // Therefore, we temporarily return the current class instead of the
+      // factory signature class if the latter one does not declare any type
+      // parameters.
+      const Class& factory_signature_class =
+          Class::Handle(unresolved_factory_class.factory_signature_class());
+      if (factory_signature_class.NumTypeParameters() == 0) {
+        return current_class().raw();
+      } else {
+        return factory_signature_class.raw();
+      }
+    }
+    if ((current_member_ == NULL) || !current_member_->has_static) {
+      return current_class().raw();
+    }
+  } else {
+    if (!current_function().IsNull()) {
+      Function& outer_function = Function::Handle(current_function().raw());
+      while (outer_function.IsLocalFunction()) {
+        outer_function = outer_function.parent_function();
+      }
+      if (outer_function.IsFactory()) {
+        return outer_function.signature_class();
+      }
+      if (!outer_function.is_static()) {
+        return current_class().raw();
+      }
+    }
   }
+  return Class::null();
 }
 
 
 void Parser::RunStaticFieldInitializer(const Field& field) {
   ASSERT(field.is_static());
   const Instance& value = Instance::Handle(field.value());
   if (value.raw() == Object::transition_sentinel()) {
-    ErrorMsg("Circular dependency while initializing static field '%s'",
+    ErrorMsg("circular dependency while initializing static field '%s'",
              String::Handle(field.name()).ToCString());
 
   } else if (value.raw() == Object::sentinel()) {
     // This field has not been referenced yet and thus the value has
     // not been evaluated. Call the static getter method to evaluate
     // the expression and canonicalize the value.
 
     field.set_value(Instance::Handle(Object::transition_sentinel()));
     const String& field_name = String::Handle(field.name());
     const String& getter_name =
         String::Handle(Field::GetterName(field_name));
     const Class& cls = Class::Handle(field.owner());
     GrowableArray<const Object*> arguments;  // no arguments.
     const int kNumArguments = 0;  // no arguments.
     const Array& kNoArgumentNames = Array::Handle();
     const Function& func =
         Function::Handle(Resolver::ResolveStatic(cls,
                                                  getter_name,
                                                  kNumArguments,
                                                  kNoArgumentNames,
                                                  Resolver::kIsQualified));
     ASSERT(!func.IsNull());
     ASSERT(func.kind() == RawFunction::kConstImplicitGetter);
     Instance& const_value = Instance::Handle(
         DartEntry::InvokeStatic(func, arguments, kNoArgumentNames));
     if (const_value.IsUnhandledException()) {
-      ErrorMsg("Exception thrown in Parser::RunStaticFieldInitializer");
+      ErrorMsg("exception thrown in Parser::RunStaticFieldInitializer");
     }
     if (!const_value.IsNull()) {
       const_value ^= const_value.Canonicalize();
     }
     field.set_value(const_value);
   }
 }
 
 
 RawInstance* Parser::EvaluateConstConstructorCall(
@@ skipping 278 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.
 RawType* Parser::ParseType(TypeResolution type_resolution) {
   if (CurrentToken() != Token::kIDENT) {
     ErrorMsg("type name expected");
   }
   QualIdent type_name;
-  intptr_t type_pos = token_index_;
+  const intptr_t type_pos = token_index_;
   ParseQualIdent(&type_name);
-  if (type_name.local_scope_ident) {
-    ErrorMsg(type_pos, "Using '%s' in this context is invalid",
+  if (type_name.is_local_scope_ident) {
+    ErrorMsg(type_pos, "using '%s' in this context is invalid",
              type_name.ident->ToCString());
   }
   Object& type_class = Object::Handle();
   if (type_resolution == kDoNotResolve) {
     String& qualifier = String::Handle();
     if (type_name.qualifier != NULL) {
       qualifier ^= type_name.qualifier->raw();
     }
     type_class = UnresolvedClass::New(type_pos, qualifier, *(type_name.ident));
   } else {
-    TypeParameter& type_parameter = TypeParameter::Handle();
-    // Check if qualifier is a type parameter of the class we are parsing.
-    if (type_name.qualifier != NULL) {
-      type_parameter =
-          current_class().LookupTypeParameter(*type_name.qualifier);
-      if (!type_parameter.IsNull()) {
-        ErrorMsg(type_pos, "Use of '%s' in this context is invalid",
-                 type_name.qualifier->ToCString());
-      }
-    } else {
-      // Check if ident is a type parameter of the class we are parsing.
-      type_parameter = current_class().LookupTypeParameter(*type_name.ident);
-      if (!type_parameter.IsNull()) {
-        CheckTypeParameterReference(type_name.ident_pos, *type_name.ident);
-        if (CurrentToken() == Token::kLT) {
-          // A type parameter cannot be parameterized.
-          ErrorMsg(type_pos, "type parameter '%s' cannot be parameterized",
-                   String::Handle(type_parameter.Name()).ToCString());
+    const Class& scope_class = Class::Handle(TypeParametersScopeClass());
+    if (!scope_class.IsNull()) {
+      TypeParameter& type_parameter = TypeParameter::Handle();
+      // Check if qualifier is a type parameter in scope.
+      if (type_name.qualifier != NULL) {
+        type_parameter = scope_class.LookupTypeParameter(*type_name.qualifier);
+        if (!type_parameter.IsNull()) {
+          ErrorMsg(type_pos, "type Parameter '%s' cannot be used as qualifier",
+                   type_name.qualifier->ToCString());
         }
-        return type_parameter.raw();
+      } else {
+        // Check if ident is a type parameter in scope.
+        type_parameter = scope_class.LookupTypeParameter(*type_name.ident);
+        if (!type_parameter.IsNull()) {
+          if (CurrentToken() == Token::kLT) {
+            // A type parameter cannot be parameterized.
+            ErrorMsg(type_pos, "type parameter '%s' cannot be parameterized",
+                     String::Handle(type_parameter.Name()).ToCString());
+          }
+          return type_parameter.raw();
+        }
       }
     }
     // Try to resolve the type class.
     type_class = LookupTypeClass(type_name, type_resolution);
   }
   TypeArguments& type_arguments =
       TypeArguments::Handle(ParseTypeArguments(type_resolution));
   Type& type = Type::Handle(
       Type::NewParameterizedType(type_class, type_arguments));
   if (type_resolution == kMustResolve) {
     ASSERT(type_class.IsClass());  // Must be resolved.
     String& errmsg = String::Handle();
     type = ClassFinalizer::FinalizeAndCanonicalizeType(type, &errmsg);
     if (!errmsg.IsNull()) {
       ErrorMsg(errmsg.ToCString());
     }
   }
   return type.raw();
 }
 
 
 void Parser::CheckConstructorCallTypeArguments(
     intptr_t pos, Function& constructor, const TypeArguments& type_arguments) {
-  if (!type_arguments.IsNull() &&
-      (type_arguments.Length() !=
-          Class::Handle(constructor.owner()).NumTypeArguments())) {
-    ErrorMsg(pos, "Incorrect number of type arguments, expected %d got %d",
-        Class::Handle(constructor.owner()).NumTypeArguments(),
-        type_arguments.Length());
+  if (!type_arguments.IsNull()) {
+    Class& signature_class = Class::Handle();
+    if (constructor.IsFactory()) {
+      signature_class = constructor.signature_class();
+    } else {
+      signature_class = constructor.owner();
+    }
+    ASSERT(!signature_class.IsNull());
+    ASSERT(signature_class.is_finalized());
+    if (type_arguments.Length() != signature_class.NumTypeArguments()) {
+      ErrorMsg(pos, "incorrect number of type arguments, expected %d got %d",
+               signature_class.NumTypeArguments(),
+               type_arguments.Length());
+    }
   }
 }
 
 
 // Parse "[" [ expr { "," expr } ["," ] "]".
 // Note: if the array literal is empty and the brackets have no whitespace
 // between them, the scanner recognizes the opening and closing bracket
 // as one token of type Token::kINDEX.
 AstNode* Parser::ParseArrayLiteral(intptr_t type_pos,
                                    bool is_const,
                                    const TypeArguments& type_arguments) {
   ASSERT(CurrentToken() == Token::kLBRACK || CurrentToken() == Token::kINDEX);
-  intptr_t literal_pos = token_index_;
+  const intptr_t literal_pos = token_index_;
   bool is_empty_literal = CurrentToken() == Token::kINDEX;
   ConsumeToken();
 
   // If no type arguments are provided, leave them as null, which is equivalent
   // to using Array<Dynamic>. See issue 4966724.
   if (!type_arguments.IsNull()) {
     // For now, only check the number of type arguments. See issue 4975876.
     if (type_arguments.Length() != 1) {
       ASSERT(type_pos >= 0);
       ErrorMsg(type_pos, "wrong number of type arguments for Array literal");
@@ skipping 88 matching lines @@
   pairs->AddElement(key);
   pairs->AddElement(value);
 }
 
 
 AstNode* Parser::ParseMapLiteral(intptr_t type_pos,
                                  bool is_const,
                                  const TypeArguments& type_arguments) {
   TRACE_PARSER("ParseMapLiteral");
   ASSERT(CurrentToken() == Token::kLBRACE);
-  intptr_t literal_pos = token_index_;
+  const intptr_t literal_pos = token_index_;
   ConsumeToken();
 
   String& map_class_name = String::Handle(
       String::NewSymbol(is_const ? kImmutableMapName : kMutableMapName));
   const Class& map_class = Class::Handle(LookupImplClass(map_class_name));
   ASSERT(!map_class.IsNull());
 
   TypeArguments& map_type_arguments =
       TypeArguments::ZoneHandle(type_arguments.raw());
   // If no type arguments are provided, leave them as null, which is equivalent
@@ skipping 91 matching lines @@
   }
 }
 
 
 AstNode* Parser::ParseCompoundLiteral() {
   bool is_const = false;
   if (CurrentToken() == Token::kCONST) {
     is_const = true;
     ConsumeToken();
   }
-  intptr_t type_pos = token_index_;
+  const intptr_t type_pos = token_index_;
   TypeArguments& type_arguments =
       TypeArguments::ZoneHandle(ParseTypeArguments(kMustResolve));
   AstNode* primary = NULL;
   if ((CurrentToken() == Token::kLBRACK) ||
       (CurrentToken() == Token::kINDEX)) {
     primary = ParseArrayLiteral(type_pos, is_const, type_arguments);
   } else if (CurrentToken() == Token::kLBRACE) {
     primary = ParseMapLiteral(type_pos, is_const, type_arguments);
   } else {
-    ErrorMsg("Unexpected token %s", Token::Str(CurrentToken()));
+    ErrorMsg("unexpected token %s", Token::Str(CurrentToken()));
   }
   return primary;
 }
 
 
 static const String& BuildConstructorName(const String& type_class_name,
                                           const String* named_constructor) {
   // By convention, the static function implementing a named constructor 'C'
   // for class 'A' is labeled 'A.C', and the static function implementing the
   // unnamed constructor for class 'A' is labeled 'A.'.
@@ skipping 22 matching lines @@
   // constructor. For that reason, we cannot unconditionally call
   // ParseType(kMustResolve) after we see an identifier, because the named
   // constructor would be misinterpreted as a qualified type name.
   // TODO(regis): Revisit once we correctly support qualified identifiers.
   // For now, we inline a customized version of ParseType(kMustResolve).
   Type& type = Type::Handle();
   Class& type_class = Class::ZoneHandle();
   String& type_class_name = String::Handle();
   TypeArguments& type_arguments = TypeArguments::ZoneHandle();
   String* named_constructor = NULL;
-  intptr_t  type_pos = token_index_;
+  const intptr_t  type_pos = token_index_;
   QualIdent type_name;
   ParseQualIdent(&type_name);
-  if (type_name.local_scope_ident) {
-    ErrorMsg(type_pos, "Using '%s' in this context is invalid",
+  if (type_name.is_local_scope_ident) {
+    ErrorMsg(type_pos, "using '%s' in this context is invalid",
              type_name.ident->ToCString());
   }
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();
     named_constructor = ExpectIdentifier("identifier expected after '.'");
   }
-  TypeParameter& type_parameter = TypeParameter::Handle();
-  if (type_name.lib_prefix != NULL) {
-    // TODO(regis): Ascertain that this check for shadowing is valid
-    // See bug (490270).
-    // Check if qualifier is a type parameter of the class we are parsing.
-    type_parameter ^= current_class().LookupTypeParameter(*type_name.qualifier);
+  const Class& scope_class = Class::Handle(TypeParametersScopeClass());
+  if (!scope_class.IsNull()) {
+    TypeParameter& type_parameter = TypeParameter::Handle();
+    if (type_name.lib_prefix != NULL) {
+      // Check if qualifier is a type parameter in scope.
+      type_parameter ^= scope_class.LookupTypeParameter(*type_name.qualifier);
+      if (!type_parameter.IsNull()) {
+        ErrorMsg(type_pos, "type parameter '%s' cannot be used as qualifier",
+                 String::Handle(type_parameter.Name()).ToCString());
+      }
+    }
+    // Check if ident is a type parameter in scope.
+    type_parameter = scope_class.LookupTypeParameter(*type_name.ident);
     if (!type_parameter.IsNull()) {
-      CheckTypeParameterReference(type_pos, *type_name.qualifier);
       ErrorMsg(type_pos, "type parameter '%s' cannot be instantiated",
                String::Handle(type_parameter.Name()).ToCString());
     }
   }
-  // Check if ident is a type parameter of the class we are parsing.
-  type_parameter = current_class().LookupTypeParameter(*type_name.ident);
-  if (!type_parameter.IsNull()) {
-    CheckTypeParameterReference(type_name.ident_pos, *type_name.ident);
-    ErrorMsg(type_pos, "type parameter '%s' cannot be instantiated",
-             String::Handle(type_parameter.Name()).ToCString());
-  }
   type_class ^= LookupTypeClass(type_name, kMustResolve);
   type_class_name = type_class.Name();
   // Type arguments are not allowed after the optional constructor name.
   if (named_constructor == NULL) {
     type_arguments = ParseTypeArguments(kMustResolve);
     type = Type::NewParameterizedType(type_class, type_arguments);
     String& errmsg = String::Handle();
     type = ClassFinalizer::FinalizeAndCanonicalizeType(type, &errmsg);
     if (!errmsg.IsNull()) {
       ErrorMsg(errmsg.ToCString());
@@ skipping 31 matching lines @@
       ErrorMsg(new_pos, "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' "
                "for interface '%s'",
                external_constructor_name.ToCString(),
                type_class_name.ToCString());
     }
-
-    // TODO(srdjan): Evaluate if the mapping should occur during code
-    // generation or here in the parser.
-    const Type& factory_type = Type::Handle(type_class.factory_type());
-    if (factory_type.IsNull()) {
+    if (!type_class.HasFactoryClass()) {
       ErrorMsg("cannot allocate interface '%s' without factory class",
                type_class_name.ToCString());
     }
-    if (!factory_type.HasResolvedTypeClass()) {
+    if (!type_class.HasResolvedFactoryClass()) {
       // This error can occur only with bootstrap classes.
       const UnresolvedClass& unresolved =
-          UnresolvedClass::Handle(factory_type.unresolved_class());
+          UnresolvedClass::Handle(type_class.UnresolvedFactoryClass());
       const String& missing_class_name = String::Handle(unresolved.ident());
-      ErrorMsg("Unresolved factory class '%s'", missing_class_name.ToCString());
+      ErrorMsg("unresolved factory class '%s'", missing_class_name.ToCString());
     }
-
     // Only change the class of the constructor to the factory class if the
     // factory class implements the interface 'type'.
-    Class& factory_type_class = Class::Handle(factory_type.type_class());
-    // TODO(regis): Verify in the guide/spec that a factory class must have
-    // identical type parameters as the interface.
-    // TODO(regis): Do we check that in the parser?
-    // Assuming that it has been checked, it is sufficient to test if the
-    // raw factory type implements the raw interface type.
-    if (factory_type_class.IsSubtypeOf(TypeArguments::Handle(),
-                                       type_class,
-                                       TypeArguments::Handle())) {
-      type_class_name = factory_type_class.Name();
+    const Class& factory_class = Class::Handle(type_class.FactoryClass());
+    if (factory_class.IsSubtypeOf(TypeArguments::Handle(),
+                                  type_class,
+                                  TypeArguments::Handle())) {
+      // Class finalization verifies that the factory class has identical type
+      // parameters as the interface.
+      type_class_name = factory_class.Name();
     }
     // Always change the result type of the constructor to the factory type.
-    type_class = factory_type_class.raw();
+    type_class = factory_class.raw();
     ASSERT(!type_class.is_interface());
   }
 
   // Make sure that an appropriate constructor exists.
   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));
@@ skipping 48 matching lines @@
 
 // A string literal consists of the concatenation of the next n tokens
 // that satisfy the EBNF grammar:
 // literal = kSTRING {{ interpol }+ kSTRING }
 // interpol = kINTERPOL_VAR | (kINTERPOL_START expression kINTERPOL_END)
 // In other words, the scanner breaks down interpolated strings so that
 // a string literal always begins and ends with a kSTRING token, and
 // there are never two kSTRING tokens next to each other.
 AstNode* Parser::ParseStringLiteral() {
   AstNode* primary = NULL;
-  intptr_t literal_start = token_index_;
+  const intptr_t literal_start = token_index_;
   if ((CurrentToken() == Token::kSTRING) &&
       (LookaheadToken(1) != Token::kINTERPOL_VAR) &&
       (LookaheadToken(1) != Token::kINTERPOL_START)) {
     // Common case: no interpolation.
     primary = new LiteralNode(literal_start, *CurrentLiteral());
     ConsumeToken();
     return primary;
   }
   // String interpolation needed.
   ArrayNode* values = new ArrayNode(token_index_, TypeArguments::ZoneHandle());
@@ skipping 38 matching lines @@
   AstNode* primary = NULL;
   if (IsFunctionLiteral()) {
     // The name of a literal function is visible from inside the function, but
     // must not collide with names in the scope declaring the literal.
     OpenBlock();
     primary = ParseFunctionStatement(true);
     CloseBlock();
   } else if (CurrentToken() == Token::kIDENT) {
     QualIdent qual_ident;
     ParseQualIdent(&qual_ident);
-    if (qual_ident.local_scope_ident) {
+    if (qual_ident.is_local_scope_ident) {
       ResolveIdentInLocalScope(qual_ident.ident_pos,
                                *qual_ident.ident,
                                &primary);
     } else {
       if (qual_ident.qualifier == NULL) {
         // This is an unqualified identifier so resolve the identifier
         // locally in the main app library and all libraries imported by it.
         primary = ResolveIdentInLibraryScope(library_,
                                              qual_ident,
                                              kResolveIncludingImports);
@@ skipping 80 matching lines @@
       const String& ident = *ExpectIdentifier("identifier expected");
       if (CurrentToken() == Token::kLPAREN) {
         primary = ParseSuperCall(ident);
       } else {
         primary = ParseSuperFieldAccess(ident);
       }
     } else if ((CurrentToken() == Token::kLBRACK) ||
         Token::CanBeOverloaded(CurrentToken())) {
       primary = ParseSuperOperator();
     } else {
-      ErrorMsg("Illegal super call");
+      ErrorMsg("illegal super call");
     }
   } else {
     UnexpectedToken();
   }
   return primary;
 }
 
 
 // Evaluate expression in expr and return the value. The expression must
 // be a compile time constant.
@@ skipping 247 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart