Add support for malformed types and postpone some related errors from compile

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 11 matching lines @@
 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, false, "Silence warnings.");
 
 // All references to Dart names are listed here.
 static const char* kAssertionErrorName = "AssertionError";
+static const char* kTypeErrorName = "TypeError";
 static const char* kFallThroughErrorName = "FallThroughError";
 static const char* kStaticResolutionExceptionName = "StaticResolutionException";
 static const char* kThrowNewName = "_throwNew";
 static const char* kListLiteralFactoryClassName = "_ListLiteralFactory";
 static const char* kListLiteralFactoryName = "List.fromLiteral";
 static const char* kMapLiteralFactoryClassName = "_MapLiteralFactory";
 static const char* kMapLiteralFactoryName = "Map.fromLiteral";
 static const char* kImmutableMapName = "ImmutableMap";
 static const char* kImmutableMapConstructorName = "ImmutableMap._create";
 static const char* kStringClassName = "StringBase";
@@ skipping 769 matching lines @@
     // 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::kPERIOD) ||  // Qualified class name of type.
         Token::IsIdentifier(follower) ||  // Parameter name following a type.
         (follower == Token::kTHIS)) {  // Field parameter following a type.
       // The types of formal parameters are never ignored, even in unchecked
       // mode, because they are part of the function type of closurized
       // functions appearing in type tests with typedefs.
       parameter.type = &AbstractType::ZoneHandle(
-          ParseType(is_top_level_ ? kCanResolve : kMustResolve));
+          ParseType(is_top_level_ ? ClassFinalizer::kTryResolve :
+                                    ClassFinalizer::kFinalize));
     } else {
       parameter.type = &Type::ZoneHandle(Type::DynamicType());
     }
   }
   if (!this_seen && (CurrentToken() == Token::kTHIS)) {
     ConsumeToken();
     ExpectToken(Token::kPERIOD);
     this_seen = true;
     parameter.is_field_initializer = true;
   }
@@ skipping 41 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()) {
-        signature_type ^=
-            ClassFinalizer::FinalizeType(signature_class, signature_type);
+        signature_type ^= ClassFinalizer::FinalizeType(
+            signature_class, signature_type, ClassFinalizer::kFinalize);
       }
       // 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 1443 matching lines @@
           (follower == Token::kGET) ||  // Getter following a type.
           (follower == Token::kSET) ||  // Setter following a type.
           (follower == Token::kOPERATOR) ||  // Operator following a type.
           (Token::IsIdentifier(follower))  ||  // 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_);
         // The declared type of fields is never ignored, even in unchecked mode,
         // because getters and setters could be closurized at some time (not
         // supported yet).
-        member.type = &AbstractType::ZoneHandle(ParseType(kCanResolve));
+        member.type = &AbstractType::ZoneHandle(
+            ParseType(ClassFinalizer::kTryResolve));
       }
     }
   }
   Token::Kind operator_token = Token::kILLEGAL;
   // Optionally parse a (possibly named) constructor name or factory.
   if (IsIdentifier() &&
       (CurrentLiteral()->Equals(members->class_name()) || member.has_factory)) {
     if (member.has_factory) {
       // The factory name may be qualified.
       QualIdent factory_name;
@@ skipping 164 matching lines @@
     }
   }
   ASSERT(!cls.IsNull());
   ASSERT(cls.functions() == Array::Empty());
   set_current_class(cls);
   ParseTypeParameters(cls);
   Type& super_type = Type::Handle();
   if (CurrentToken() == Token::kEXTENDS) {
     ConsumeToken();
     const intptr_t type_pos = token_index_;
-    const AbstractType& type = AbstractType::Handle(ParseType(kCanResolve));
+    const AbstractType& type = AbstractType::Handle(
+        ParseType(ClassFinalizer::kTryResolve));
     if (type.IsTypeParameter()) {
       ErrorMsg(type_pos,
                "class '%s' may not extend type parameter '%s'",
                class_name.ToCString(),
                String::Handle(type.Name()).ToCString());
     }
     super_type ^= type.raw();
     if (super_type.IsInterfaceType()) {
       ErrorMsg(type_pos,
                "class '%s' may implement, but cannot extend interface '%s'",
@@ skipping 128 matching lines @@
   set_current_class(alias_owner);
 
   // Parse the result type of the function type.
   AbstractType& result_type = Type::Handle(Type::DynamicType());
   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);
+    result_type = ParseType(ClassFinalizer::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(alias_owner, kCanResolve, &result_type);
+    ResolveTypeFromClass(alias_owner,
+                         ClassFinalizer::kTryResolve,
+                         &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 208 matching lines @@
       if (CurrentToken() != Token::kIDENT) {
         ErrorMsg("type parameter name expected");
       }
       String& type_parameter_name = *CurrentLiteral();
       AbstractType& type_parameter = TypeParameter::ZoneHandle(
           TypeParameter::New(index, type_parameter_name, token_index_));
       ConsumeToken();
       AbstractType& bound = Type::ZoneHandle(Type::DynamicType());
       if (CurrentToken() == Token::kEXTENDS) {
         ConsumeToken();
-        bound = ParseType(kCanResolve);
+        bound = ParseType(ClassFinalizer::kTryResolve);
       }
       type_parameters_array.Add(&type_parameter);
       bounds_array.Add(&bound);
       index++;
     } while (CurrentToken() == Token::kCOMMA);
     Token::Kind token = CurrentToken();
     if ((token == Token::kGT) || (token == Token::kSHR)) {
       ConsumeRightAngleBracket();
     } else {
       ErrorMsg("right angle bracket expected");
     }
     const TypeArguments& type_parameters =
         TypeArguments::Handle(NewTypeArguments(type_parameters_array));
     const TypeArguments& bounds =
         TypeArguments::Handle(NewTypeArguments(bounds_array));
     cls.set_type_parameters(type_parameters);
     cls.set_type_parameter_bounds(bounds);
     // Try to resolve the upper bounds, which will at least resolve the
     // referenced type parameters.
     AbstractType& bound = AbstractType::Handle();
     const intptr_t num_types = bounds.Length();
     for (intptr_t i = 0; i < num_types; i++) {
       bound = bounds.TypeAt(i);
-      ResolveTypeFromClass(cls, kCanResolve, &bound);
+      ResolveTypeFromClass(cls, ClassFinalizer::kTryResolve, &bound);
       bounds.SetTypeAt(i, bound);
     }
   }
 }
 
 
 RawAbstractTypeArguments* Parser::ParseTypeArguments(
-    TypeResolution type_resolution) {
+    Error* malformed_error,
+    ClassFinalizer::FinalizationKind finalization) {
   TRACE_PARSER("ParseTypeArguments");
   if (CurrentToken() == Token::kLT) {
     GrowableArray<AbstractType*> types;
     do {
       ConsumeToken();
-      AbstractType& type = AbstractType::ZoneHandle(ParseType(type_resolution));
+      AbstractType& type = AbstractType::ZoneHandle(ParseType(finalization));
       types.Add(&type);
+      // Only keep the error for the first malformed type argument.
+      if (malformed_error->IsNull() && type.IsMalformed()) {
+        *malformed_error = type.malformed_error();
+      }
     } while (CurrentToken() == Token::kCOMMA);
     Token::Kind token = CurrentToken();
     if ((token == Token::kGT) || (token == Token::kSHR)) {
       ConsumeRightAngleBracket();
     } else {
       ErrorMsg("right angle bracket expected");
     }
-    if (type_resolution != kIgnore) {
+    if (finalization != ClassFinalizer::kIgnore) {
       return NewTypeArguments(types);
     }
   }
   return TypeArguments::null();
 }
 
 
 // Parse and return an array of interface types.
 RawArray* Parser::ParseInterfaceList() {
   TRACE_PARSER("ParseInterfaceList");
   ASSERT((CurrentToken() == Token::kIMPLEMENTS) ||
          (CurrentToken() == Token::kEXTENDS));
   GrowableArray<AbstractType*> interfaces;
   String& interface_name = String::Handle();
   do {
     ConsumeToken();
     intptr_t supertype_pos = token_index_;
-    AbstractType& interface = AbstractType::ZoneHandle(ParseType(kCanResolve));
+    AbstractType& interface = AbstractType::ZoneHandle(
+        ParseType(ClassFinalizer::kTryResolve));
     interface_name = interface.Name();
     for (int i = 0; i < interfaces.length(); i++) {
       String& other_name = String::Handle(interfaces[i]->Name());
       if (interface_name.Equals(other_name)) {
         ErrorMsg(supertype_pos, "Duplicate supertype '%s'",
                  interface_name.ToCString());
       }
     }
     interfaces.Add(&interface);
   } while (CurrentToken() == Token::kCOMMA);
@@ skipping 43 matching lines @@
   cls_interfaces = NewArray<AbstractType>(all_interfaces);
   cls.set_interfaces(cls_interfaces);
 }
 
 
 void Parser::ParseTopLevelVariable(TopLevel* top_level) {
   TRACE_PARSER("ParseTopLevelVariable");
   const bool is_final = (CurrentToken() == Token::kFINAL);
   const bool is_static = true;
   const AbstractType& type = AbstractType::ZoneHandle(ParseFinalVarOrType(
-      FLAG_enable_type_checks ? kCanResolve : kIgnore));
-
+      FLAG_enable_type_checks ? ClassFinalizer::kTryResolve :
+                                ClassFinalizer::kIgnore));
   while (true) {
     const intptr_t name_pos = token_index_;
     String& var_name = *ExpectIdentifier("variable name expected");
 
     if (library_.LookupObject(var_name) != Object::null()) {
       ErrorMsg(name_pos, "'%s' is already defined", var_name.ToCString());
     }
     String& accessor_name = String::Handle(Field::GetterName(var_name));
     if (library_.LookupObject(accessor_name) != Object::null()) {
       ErrorMsg(name_pos, "getter for '%s' is already defined",
@@ skipping 42 matching lines @@
   TRACE_PARSER("ParseTopLevelFunction");
   AbstractType& result_type = Type::Handle(Type::DynamicType());
   const bool is_static = true;
   if (CurrentToken() == Token::kVOID) {
     ConsumeToken();
     result_type = Type::VoidType();
   } else {
     // Parse optional type.
     if ((CurrentToken() == Token::kIDENT) &&
         (LookaheadToken(1) != Token::kLPAREN)) {
-      result_type = ParseType(kCanResolve);
+      result_type = ParseType(ClassFinalizer::kTryResolve);
     }
   }
   const intptr_t name_pos = token_index_;
   const String& func_name = *ExpectIdentifier("function name expected");
 
   if (library_.LookupObject(func_name) != Object::null()) {
     ErrorMsg(name_pos, "'%s' is already defined", func_name.ToCString());
   }
   String& accessor_name = String::Handle(Field::GetterName(func_name));
   if (library_.LookupObject(accessor_name) != Object::null()) {
@@ skipping 46 matching lines @@
   bool is_getter = (CurrentToken() == Token::kGET);
   if (CurrentToken() == Token::kGET ||
       CurrentToken() == Token::kSET) {
     ConsumeToken();
     result_type = Type::DynamicType();
   } else {
     if (CurrentToken() == Token::kVOID) {
       ConsumeToken();
       result_type = Type::VoidType();
     } else {
-      result_type = ParseType(kCanResolve);
+      result_type = ParseType(ClassFinalizer::kTryResolve);
     }
     is_getter = (CurrentToken() == Token::kGET);
     if (CurrentToken() == Token::kGET || CurrentToken() == Token::kSET) {
       ConsumeToken();
     } else {
       UnexpectedToken();
     }
   }
   const intptr_t name_pos = token_index_;
   const String* field_name = ExpectIdentifier("accessor name expected");
@@ skipping 506 matching lines @@
   }
   if (is_final) {
     variable->set_is_final();
   }
   return initialization;
 }
 
 
 // Parses ('var' | 'final' [type] | type).
 // The presence of 'final' must be detected and remembered before the call.
-// If a type is parsed, it is resolved (or not) according to type_resolution.
-RawAbstractType* Parser::ParseFinalVarOrType(TypeResolution type_resolution) {
+// If a type is parsed, it may be resolved and finalized according to the given
+// type finalization mode.
+RawAbstractType* Parser::ParseFinalVarOrType(
+    ClassFinalizer::FinalizationKind finalization) {
   TRACE_PARSER("ParseFinalVarOrType");
   if (CurrentToken() == Token::kVAR) {
     ConsumeToken();
     return Type::DynamicType();
   }
   bool type_is_optional = false;
   if (CurrentToken() == Token::kFINAL) {
     ConsumeToken();
     type_is_optional = true;
   }
   if (CurrentToken() != Token::kIDENT) {
     if (type_is_optional) {
       return Type::DynamicType();
     } else {
       ErrorMsg("type name expected");
     }
   }
   if (type_is_optional) {
     Token::Kind follower = LookaheadToken(1);
     // We have an identifier followed by a 'follower' token.
     // We either parse a type or return now.
     if ((follower != Token::kLT) &&  // Parameterized type.
         (follower != Token::kPERIOD) &&  // Qualified class name of type.
         !Token::IsIdentifier(follower) &&  // Variable name following a type.
         (follower != Token::kTHIS)) {  // Field parameter following a type.
       return Type::DynamicType();
     }
   }
-  return ParseType(type_resolution);
+  return ParseType(finalization);
 }
 
 
 // Returns ast nodes of the variable initialization. Variables without an
 // explicit initializer are initialized to null. If several variables are
 // declared, the individual initializers are collected in a sequence node.
 AstNode* Parser::ParseVariableDeclarationList() {
   TRACE_PARSER("ParseVariableDeclarationList");
   bool is_final = (CurrentToken() == Token::kFINAL);
   const AbstractType& type = AbstractType::ZoneHandle(ParseFinalVarOrType(
-      FLAG_enable_type_checks ? kMustResolve : kIgnore));
+      FLAG_enable_type_checks ? ClassFinalizer::kFinalize :
+                                ClassFinalizer::kIgnore));
   if (!IsIdentifier()) {
     ErrorMsg("identifier expected");
   }
 
   AstNode* initializers = ParseVariableDeclaration(type, is_final);
   ASSERT(initializers != NULL);
   while (CurrentToken() == Token::kCOMMA) {
     ConsumeToken();
     if (!IsIdentifier()) {
       ErrorMsg("identifier expected after comma");
@@ skipping 15 matching lines @@
   AbstractType& result_type = AbstractType::Handle();
   const String* variable_name = NULL;
   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);
+    result_type = ParseType(ClassFinalizer::kFinalize);
   }
   const intptr_t ident_pos = token_index_;
   if (IsIdentifier()) {
     variable_name = CurrentLiteral();
     function_name = variable_name;
     ConsumeToken();
   } else {
     if (!is_literal) {
       ErrorMsg("function name expected");
     }
@@ skipping 80 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()) {
-      signature_type ^=
-          ClassFinalizer::FinalizeType(signature_class, signature_type);
+      signature_type ^= ClassFinalizer::FinalizeType(
+          signature_class, signature_type, ClassFinalizer::kFinalize);
       // 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.
@@ skipping 524 matching lines @@
   bool is_final = (CurrentToken() == Token::kFINAL);
   const String* loop_var_name = NULL;
   LocalVariable* loop_var = NULL;
   intptr_t loop_var_pos = 0;
   if (LookaheadToken(1) == Token::kIN) {
     loop_var_pos = token_index_;
     loop_var_name = ExpectIdentifier("variable name expected");
   } else {
     // The case without a type is handled above, so require a type here.
     const AbstractType& type = AbstractType::ZoneHandle(ParseFinalVarOrType(
-        FLAG_enable_type_checks ? kMustResolve : kIgnore));
+      FLAG_enable_type_checks ? ClassFinalizer::kFinalize :
+                                ClassFinalizer::kIgnore));
     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);
   const intptr_t collection_pos = token_index_;
   AstNode* collection_expr = ParseExpr(kAllowConst);
@@ skipping 238 matching lines @@
 
 
 // Parse the parameter specified in the catch clause.
 void Parser::ParseCatchParameter(CatchParamDesc* catch_param) {
   TRACE_PARSER("ParseCatchParameter");
   ASSERT(catch_param != NULL);
   catch_param->is_final = (CurrentToken() == Token::kFINAL);
   // The type of the catch parameter must always be resolved, even in unchecked
   // mode.
   catch_param->type = &AbstractType::ZoneHandle(
-      ParseFinalVarOrType(kMustResolve));
+      ParseFinalVarOrType(ClassFinalizer::kFinalizeWellFormed));
   catch_param->token_index = token_index_;
   catch_param->var = ExpectIdentifier("identifier expected");
 }
 
 
 // Populate local scope of the catch block with the catch parameters.
 void Parser::AddCatchParamsToScope(const CatchParamDesc& exception_param,
                                    const CatchParamDesc& stack_trace_param,
                                    LocalScope* scope) {
   ASSERT(exception_param.var != NULL);
@@ skipping 511 matching lines @@
                                 new LoadLocalNode(statement_pos, *trace_var));
     }
   } else {
     statement = ParseExpr(kAllowConst);
     ExpectSemicolon();
   }
   return statement;
 }
 
 
-// Static
 RawError* Parser::FormatError(const Script& script,
                               intptr_t token_index,
                               const char* message_header,
                               const char* format,
                               va_list args) {
   const intptr_t kMessageBufferSize = 512;
   char message_buffer[kMessageBufferSize];
   FormatMessage(script, token_index, message_header,
                 message_buffer, kMessageBufferSize,
                 format, args);
   const String& msg = String::Handle(String::New(message_buffer));
   return LanguageError::New(msg);
 }
 
 
-// Static.
 void Parser::FormatMessage(const Script& script,
                            intptr_t token_index,
                            const char* message_header,
                            char* message_buffer,
                            intptr_t message_buffer_size,
                            const char* format, va_list args) {
   intptr_t msg_len = 0;
   if (!script.IsNull()) {
     const String& script_url = String::CheckedHandle(script.url());
     if (token_index >= 0) {
@@ skipping 179 matching lines @@
     SequenceNode* sequence = new SequenceNode(sequence_pos, scope);
     if (node != NULL) {
       sequence->Add(node);
     }
     return sequence;
   }
   return node->AsSequenceNode();
 }
 
 
+AstNode* Parser::ThrowTypeError(intptr_t type_pos, const AbstractType& type) {
+  ASSERT(type.IsMalformed());
+  ArgumentListNode* arguments = new ArgumentListNode(type_pos);
+  // Location argument.
+  arguments->Add(new LiteralNode(
+      type_pos, Integer::ZoneHandle(Integer::New(type_pos))));
+  // Src value argument.
+  arguments->Add(new LiteralNode(type_pos, Instance::ZoneHandle()));
+  // Dst type name argument.
+  arguments->Add(new LiteralNode(type_pos, String::ZoneHandle(
+      String::NewSymbol("malformed type"))));
+  // Dst type name argument.
+  arguments->Add(new LiteralNode(type_pos, String::ZoneHandle(
+    String::NewSymbol(""))));
+  // Malformed type error.
+  const Error& error = Error::Handle(type.malformed_error());
+  arguments->Add(new LiteralNode(type_pos, String::ZoneHandle(
+      String::NewSymbol(error.ToErrorCString()))));
+  return MakeStaticCall(kTypeErrorName, kThrowNewName, arguments);
+}
+
+
 AstNode* Parser::ParseBinaryExpr(int min_preced) {
   TRACE_PARSER("ParseBinaryExpr");
   ASSERT(min_preced >= 4);
   AstNode* left_operand = ParseUnaryExpr();
   int current_preced = Token::Precedence(CurrentToken());
   while (current_preced >= min_preced) {
     while (Token::Precedence(CurrentToken()) == current_preced) {
       Token::Kind op_kind = CurrentToken();
       if (op_kind == Token::kTIGHTADD) {
         op_kind = Token::kADD;
       }
       const intptr_t op_pos = token_index_;
       ConsumeToken();
       AstNode* right_operand = NULL;
       if (op_kind != Token::kIS) {
         right_operand = ParseBinaryExpr(current_preced + 1);
       } else {
         // For 'is' we expect the right operand to be a type.
         if (CurrentToken() == Token::kNOT) {
           ConsumeToken();
           op_kind = Token::kISNOT;
         }
         const intptr_t type_pos = token_index_;
         const AbstractType& type =
-            AbstractType::ZoneHandle(ParseType(kMustResolve));
+            AbstractType::ZoneHandle(ParseType(ClassFinalizer::kFinalize));
         if (!type.IsInstantiated() &&
             (current_block_->scope->function_level() > 0)) {
           // Make sure that the instantiator is captured.
           CaptureReceiver();
         }
         right_operand = new TypeNode(type_pos, type);
+        if (type.IsMalformed()) {
+          return ThrowTypeError(type_pos, type);
+        }
       }
       if (Token::IsRelationalOperator(op_kind)
           || Token::IsInstanceofOperator(op_kind)
           || Token::IsEqualityOperator(op_kind)) {
         left_operand = new ComparisonNode(
             op_pos, op_kind, left_operand, right_operand);
         break;  // Equality and relational operators cannot be chained.
       } else {
         StringConcatNode* str_concat = NULL;
         if (op_kind == Token::kADD) {
@@ skipping 761 matching lines @@
     if (incr_op_node == NULL) {
       Unimplemented("incr op not implemented");
     }
     postfix_expr = incr_op_node;
   }
   return postfix_expr;
 }
 
 
 // Resolve the given type and its type arguments from the given scope class
-// according to the given type_resolution.
+// according to the given type finalization mode.
 // 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(const Class& scope_class,
-                                  TypeResolution type_resolution,
+                                  ClassFinalizer::FinalizationKind finalization,
                                   AbstractType* type) {
-  ASSERT((type_resolution == kCanResolve) || (type_resolution == kMustResolve));
+  ASSERT(finalization >= ClassFinalizer::kTryResolve);
   ASSERT(type != NULL);
   if (type->IsResolved()) {
     return;
   }
   // Resolve class.
   if (!type->HasResolvedTypeClass()) {
     const UnresolvedClass& unresolved_class =
         UnresolvedClass::Handle(type->unresolved_class());
     const String& unresolved_class_name =
         String::Handle(unresolved_class.ident());
@@ skipping 17 matching lines @@
         }
       }
       // Global lookup in current library.
       resolved_type_class = library_.LookupClass(unresolved_class_name);
     } else {
       LibraryPrefix& lib_prefix =
           LibraryPrefix::Handle(unresolved_class.library_prefix());
       // Local lookup in library prefix scope.
       resolved_type_class = lib_prefix.LookupLocalClass(unresolved_class_name);
     }
+    // At this point, we can only have a parameterized_type.
+    Type& parameterized_type = Type::Handle();
+    parameterized_type ^= type->raw();
     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->token_index(), "type '%s' is not loaded",
-               String::Handle(type->Name()).ToCString());
+    } else if (finalization >= ClassFinalizer::kFinalize) {
+      // The type is malformed.
+      ClassFinalizer::FinalizeMalformedType(
+          current_class(), parameterized_type, finalization,
+          "type '%s' is not loaded",
+          String::Handle(parameterized_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(scope_class,
-                           type_resolution,
-                           &type_argument);
+      ResolveTypeFromClass(scope_class, finalization, &type_argument);
       arguments.SetTypeAt(i, type_argument);
     }
   }
 }
 
 
 LocalVariable* Parser::LookupLocalScope(const String& ident) {
   if (current_block_ == NULL) {
     return NULL;
   }
@@ skipping 415 matching lines @@
   String& map_name = String::Handle(library_.LookupImportMap(ident));
   if (!map_name.IsNull()) {
     return map_name.raw();
   }
   ErrorMsg(ident_pos, "import variable '%s' has not been defined",
            ident.ToCString());
   return String::null();
 }
 
 
-// Parses type = [ident "."] ident ["<" type { "," type } ">"] and resolve it
-// according to the given type_resolution.
-RawAbstractType* Parser::ParseType(TypeResolution type_resolution) {
+// Parses type = [ident "."] ident ["<" type { "," type } ">"], then resolve and
+// finalize it according to the given type finalization mode.
+RawAbstractType* Parser::ParseType(
+    ClassFinalizer::FinalizationKind finalization) {
   TRACE_PARSER("ParseType");
   if (CurrentToken() != Token::kIDENT) {
     ErrorMsg("type name expected");
   }
   QualIdent type_name;
-  if (type_resolution == kIgnore) {
+  if (finalization == ClassFinalizer::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_name.ident_pos, *type_name.ident, NULL)) {
       ErrorMsg(type_name.ident_pos, "using '%s' in this context is invalid",
                type_name.ident->ToCString());
     }
   }
   Object& type_class = Object::Handle();
-  // Leave type_class as null if type_resolution equals kIgnore.
-  if (type_resolution != kIgnore) {
+  // Leave type_class as null if type finalization mode is kIgnore.
+  if (finalization != ClassFinalizer::kIgnore) {
     LibraryPrefix& lib_prefix = LibraryPrefix::Handle();
     if (type_name.lib_prefix != NULL) {
       lib_prefix = type_name.lib_prefix->raw();
     }
     type_class = UnresolvedClass::New(lib_prefix,
                                       *type_name.ident,
                                       type_name.ident_pos);
   }
+  Error& malformed_error = Error::Handle();
   AbstractTypeArguments& type_arguments =
-      AbstractTypeArguments::Handle(ParseTypeArguments(type_resolution));
-  if (type_resolution == kIgnore) {
+      AbstractTypeArguments::Handle(ParseTypeArguments(&malformed_error,
+                                                       finalization));
+  if (finalization == ClassFinalizer::kIgnore) {
     return Type::DynamicType();
   }
   AbstractType& type = AbstractType::Handle(
       Type::New(type_class, type_arguments, type_name.ident_pos));
-  if ((type_resolution == kCanResolve) || (type_resolution == kMustResolve)) {
+  if (!malformed_error.IsNull()) {
+    Type& parameterized_type = Type::Handle();
+    parameterized_type ^= type.raw();
+    parameterized_type.set_type_class(Class::Handle(Object::dynamic_class()));
+    parameterized_type.set_arguments(AbstractTypeArguments::Handle());
+    parameterized_type.set_malformed_error(malformed_error);
+  }
+  if (finalization >= ClassFinalizer::kTryResolve) {
     const Class& scope_class = Class::Handle(TypeParametersScopeClass());
-    ResolveTypeFromClass(scope_class, type_resolution, &type);
-    if (type_resolution == kMustResolve) {
-      type ^= ClassFinalizer::FinalizeType(current_class(), type);
+    ResolveTypeFromClass(scope_class, finalization, &type);
+    if (finalization >= ClassFinalizer::kFinalize) {
+      type ^= ClassFinalizer::FinalizeType(current_class(), type, finalization);
     }
   }
   return type.raw();
 }
 
 
 void Parser::CheckConstructorCallTypeArguments(
     intptr_t pos, Function& constructor,
     const AbstractTypeArguments& type_arguments) {
   if (!type_arguments.IsNull()) {
@@ skipping 340 matching lines @@
 
 
 AstNode* Parser::ParseCompoundLiteral() {
   TRACE_PARSER("ParseCompoundLiteral");
   bool is_const = false;
   if (CurrentToken() == Token::kCONST) {
     is_const = true;
     ConsumeToken();
   }
   const intptr_t type_pos = token_index_;
-  AbstractTypeArguments& type_arguments =
-      AbstractTypeArguments::ZoneHandle(ParseTypeArguments(kMustResolve));
+  Error& malformed_error = Error::Handle();
+  AbstractTypeArguments& type_arguments = AbstractTypeArguments::ZoneHandle(
+      ParseTypeArguments(&malformed_error,
+                         ClassFinalizer::kFinalizeWellFormed));
   AstNode* primary = NULL;
   if ((CurrentToken() == Token::kLBRACK) ||
       (CurrentToken() == Token::kINDEX)) {
     primary = ParseListLiteral(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()));
   }
   return primary;
@@ skipping 20 matching lines @@
   TRACE_PARSER("ParseNewOperator");
   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");
   }
   intptr_t type_pos = token_index_;
 
-  const AbstractType& type = AbstractType::Handle(ParseType(kMustResolve));
+  const AbstractType& type = AbstractType::Handle(
+      ParseType(ClassFinalizer::kFinalizeWellFormed));
   if (type.IsTypeParameter()) {
     ErrorMsg(type_pos,
              "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());
 
@@ skipping 125 matching lines @@
           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, type.token_index()));
-    temp_type ^= ClassFinalizer::FinalizeType(current_class(), temp_type);
+    temp_type ^= ClassFinalizer::FinalizeType(
+        current_class(), temp_type, ClassFinalizer::kFinalize);
     // 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 554 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart