Support type parameters and classes as expression in the vm.

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 "lib/invocation_mirror.h"
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
@@ skipping 2625 matching lines @@
     if (is_top_level_ ||
         !ResolveIdentInLocalScope(qual_ident->ident_pos,
                                   *(qual_ident->ident),
                                   NULL)) {
       LibraryPrefix& lib_prefix = LibraryPrefix::ZoneHandle();
       lib_prefix = current_class().LookupLibraryPrefix(*(qual_ident->ident));
       if (!lib_prefix.IsNull()) {
         // We have a library prefix qualified identifier, unless the prefix is
         // shadowed by a type parameter in scope.
         if (current_class().IsNull() ||
-            (current_class().LookupTypeParameter(*(qual_ident->ident),
-                                                 TokenPos()) ==
+            (current_class().LookupTypeParameter(*(qual_ident->ident)) ==
              TypeParameter::null())) {
           ConsumeToken();  // Consume the kPERIOD token.
           qual_ident->lib_prefix = &lib_prefix;
           qual_ident->ident_pos = TokenPos();
           qual_ident->ident =
               ExpectIdentifier("identifier expected after '.'");
         }
       }
     }
   }
@@ skipping 3248 matching lines @@
   AstNode* loop_var_assignment = NULL;
   if (loop_var != NULL) {
     // The for loop declares a new variable. Add it to the loop body scope.
     current_block_->scope->AddVariable(loop_var);
     loop_var_assignment =
         new StoreLocalNode(loop_var_pos, loop_var, iterator_current);
   } else {
     AstNode* loop_var_primary =
         ResolveIdent(loop_var_pos, *loop_var_name, false);
     ASSERT(!loop_var_primary->IsPrimaryNode());
-    loop_var_assignment =
-        CreateAssignmentNode(loop_var_primary, iterator_current);
-    if (loop_var_assignment == NULL) {
-      ErrorMsg(loop_var_pos, "variable or field '%s' is not assignable",
-               loop_var_name->ToCString());
-    }
+    loop_var_assignment = CreateAssignmentNode(
+        loop_var_primary, iterator_current, loop_var_name, loop_var_pos);
+    ASSERT(loop_var_assignment != NULL);
   }
   current_block_->statements->Add(loop_var_assignment);
 
   // Now parse the for-in loop statement or block.
   if (CurrentToken() == Token::kLBRACE) {
     ConsumeToken();
     ParseStatementSequence();
     ExpectToken(Token::kRBRACE);
   } else {
     AstNode* statement = ParseStatement();
@@ skipping 1071 matching lines @@
         left_operand = OptimizeBinaryOpNode(
             op_pos, op_kind, left_operand, right_operand);
       }
     }
     current_preced--;
   }
   return left_operand;
 }
 
 
-bool Parser::IsAssignableExpr(AstNode* expr) {
-  return (expr->IsLoadLocalNode()
-          && (!expr->AsLoadLocalNode()->local().is_final()))
-      || expr->IsLoadStaticFieldNode()
-      || expr->IsStaticGetterNode()
-      || expr->IsInstanceGetterNode()
-      || expr->IsLoadIndexedNode()
-      || (expr->IsPrimaryNode() && !expr->AsPrimaryNode()->IsSuper());
-}
-
-
 AstNode* Parser::ParseExprList() {
   TRACE_PARSER("ParseExprList");
   AstNode* expressions = ParseExpr(kAllowConst, kConsumeCascades);
   if (CurrentToken() == Token::kCOMMA) {
     // Collect comma-separated expressions in a non scope owning sequence node.
     SequenceNode* list = new SequenceNode(TokenPos(), NULL);
     list->Add(expressions);
     while (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
       AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
@@ skipping 148 matching lines @@
     }
     *expr = new InstanceGetterNode(token_pos,
                                    receiver,
                                    getter->field_name());
     return result;
   }
   return result;
 }
 
 
-// Ensure that the expression temp is allocated for nodes that may need it.
-AstNode* Parser::CreateAssignmentNode(AstNode* original, AstNode* rhs) {
+AstNode* Parser::CreateAssignmentNode(AstNode* original,
+                                      AstNode* rhs,
+                                      const String* left_ident,
+                                      intptr_t left_pos) {
   AstNode* result = original->MakeAssignmentNode(rhs);
-  if ((result == NULL) && original->IsTypeNode()) {
-    const String& type_name = String::ZoneHandle(
-        original->AsTypeNode()->type().ClassName());
-    // TODO(tball): determine whether NoSuchMethod should be called instead.
+  if (result == NULL) {
+    String& name = String::ZoneHandle();
+    if (original->IsTypeNode()) {
+      name = Symbols::New(original->Name());
+    } else if ((left_ident != NULL) &&
+               (original->IsLiteralNode() ||
+                original->IsLoadLocalNode() ||
+                original->IsLoadStaticFieldNode())) {
+      name = left_ident->raw();
+    }
+    if (name.IsNull()) {
+      ErrorMsg(left_pos, "expression is not assignable");
+    }
     result = ThrowNoSuchMethodError(original->token_pos(),
                                     current_class(),
-                                    type_name,
+                                    name,
                                     InvocationMirror::kStatic,
                                     InvocationMirror::kSetter);
-  }
-  if ((result != NULL) &&
-      (result->IsStoreIndexedNode() ||
-       result->IsInstanceSetterNode() ||
-       result->IsStaticSetterNode() ||
-       result->IsStoreStaticFieldNode() ||
-       result->IsStoreLocalNode())) {
+  } else if (result->IsStoreIndexedNode() ||
+             result->IsInstanceSetterNode() ||
+             result->IsStaticSetterNode() ||
+             result->IsStoreStaticFieldNode() ||
+             result->IsStoreLocalNode()) {
+    // Ensure that the expression temp is allocated for nodes that may need it.
     EnsureExpressionTemp();
   }
   return result;
 }
 
 
 AstNode* Parser::ParseCascades(AstNode* expr) {
   intptr_t cascade_pos = TokenPos();
   LetNode* cascade = new LetNode(cascade_pos);
   LocalVariable* cascade_receiver_var = cascade->AddInitializer(expr);
   while (CurrentToken() == Token::kCASCADE) {
     cascade_pos = TokenPos();
     LoadLocalNode* load_cascade_receiver =
         new LoadLocalNode(cascade_pos, cascade_receiver_var);
     if (Token::IsIdentifier(LookaheadToken(1))) {
       // Replace .. with . for ParseSelectors().
       token_kind_ = Token::kPERIOD;
     } else if (LookaheadToken(1) == Token::kLBRACK) {
       ConsumeToken();
     } else {
       ErrorMsg("identifier or [ expected after ..");
     }
+    String* expr_ident =
+        Token::IsIdentifier(CurrentToken()) ? CurrentLiteral() : NULL;
+    const intptr_t expr_pos = TokenPos();
     expr = ParseSelectors(load_cascade_receiver, true);
 
     // Assignments after a cascade are part of the cascade. The
     // assigned expression must not contain cascades.
     if (Token::IsAssignmentOperator(CurrentToken())) {
       Token::Kind assignment_op = CurrentToken();
       const intptr_t assignment_pos = TokenPos();
       ConsumeToken();
       AstNode* right_expr = ParseExpr(kAllowConst, kNoCascades);
       if (assignment_op != Token::kASSIGN) {
         // Compound assignment: store inputs with side effects into
         // temporary locals.
         LetNode* let_expr = PrepareCompoundAssignmentNodes(&expr);
         right_expr =
             ExpandAssignableOp(assignment_pos, assignment_op, expr, right_expr);
-        AstNode* assign_expr = CreateAssignmentNode(expr, right_expr);
-        if (assign_expr == NULL) {
-          ErrorMsg(assignment_pos,
-                   "left hand side of '%s' is not assignable",
-                   Token::Str(assignment_op));
-        }
+        AstNode* assign_expr = CreateAssignmentNode(
+            expr, right_expr, expr_ident, expr_pos);
+        ASSERT(assign_expr != NULL);
         let_expr->AddNode(assign_expr);
         expr = let_expr;
       } else {
         right_expr =
             ExpandAssignableOp(assignment_pos, assignment_op, expr, right_expr);
-        AstNode* assign_expr = CreateAssignmentNode(expr, right_expr);
-        if (assign_expr == NULL) {
-          ErrorMsg(assignment_pos,
-                   "left hand side of '%s' is not assignable",
-                   Token::Str(assignment_op));
-        }
+        AstNode* assign_expr = CreateAssignmentNode(
+            expr, right_expr, expr_ident, expr_pos);
+        ASSERT(assign_expr != NULL);
         expr = assign_expr;
       }
     }
     cascade->AddNode(expr);
   }
   // The result is an expression with the (side effects of the) cascade
   // sequence followed by the (value of the) receiver temp variable load.
   cascade->AddNode(new LoadLocalNode(cascade_pos, cascade_receiver_var));
   return cascade;
 }
 
 
 AstNode* Parser::ParseExpr(bool require_compiletime_const,
                            bool consume_cascades) {
   TRACE_PARSER("ParseExpr");
+  String* expr_ident =
+      Token::IsIdentifier(CurrentToken()) ? CurrentLiteral() : NULL;
   const intptr_t expr_pos = TokenPos();
 
   if (CurrentToken() == Token::kTHROW) {
     ConsumeToken();
     ASSERT(CurrentToken() != Token::kSEMICOLON);
     AstNode* expr = ParseExpr(require_compiletime_const, consume_cascades);
     return new ThrowNode(expr_pos, expr, NULL);
   }
   AstNode* expr = ParseConditionalExpr();
   if (!Token::IsAssignmentOperator(CurrentToken())) {
     if ((CurrentToken() == Token::kCASCADE) && consume_cascades) {
       return ParseCascades(expr);
     }
     if (require_compiletime_const) {
       expr = FoldConstExpr(expr_pos, expr);
     }
     return expr;
   }
   // Assignment expressions.
-  Token::Kind assignment_op = CurrentToken();
+  const Token::Kind assignment_op = CurrentToken();
   const intptr_t assignment_pos = TokenPos();
   ConsumeToken();
   const intptr_t right_expr_pos = TokenPos();
   if (require_compiletime_const && (assignment_op != Token::kASSIGN)) {
     ErrorMsg(right_expr_pos, "expression must be a compile-time constant");
   }
   AstNode* right_expr = ParseExpr(require_compiletime_const, consume_cascades);
   if (assignment_op != Token::kASSIGN) {
     // Compound assignment: store inputs with side effects into temp. locals.
     LetNode* let_expr = PrepareCompoundAssignmentNodes(&expr);
     AstNode* assigned_value =
         ExpandAssignableOp(assignment_pos, assignment_op, expr, right_expr);
-    AstNode* assign_expr = CreateAssignmentNode(expr, assigned_value);
-    if (assign_expr == NULL) {
-      ErrorMsg(assignment_pos,
-               "left hand side of '%s' is not assignable",
-               Token::Str(assignment_op));
-    }
+    AstNode* assign_expr = CreateAssignmentNode(
+        expr, assigned_value, expr_ident, expr_pos);
+    ASSERT(assign_expr != NULL);
     let_expr->AddNode(assign_expr);
     return let_expr;
   } else {
     AstNode* assigned_value =
         ExpandAssignableOp(assignment_pos, assignment_op, expr, right_expr);
-    AstNode* assign_expr = CreateAssignmentNode(expr, assigned_value);
-    if (assign_expr == NULL) {
-      ErrorMsg(assignment_pos,
-               "left hand side of '%s' is not assignable",
-               Token::Str(assignment_op));
-    }
+    AstNode* assign_expr = CreateAssignmentNode(
+        expr, assigned_value, expr_ident, expr_pos);
+    ASSERT(assign_expr != NULL);
     return assign_expr;
   }
 }
 
 
 LiteralNode* Parser::ParseConstExpr() {
   TRACE_PARSER("ParseConstExpr");
   AstNode* expr = ParseExpr(kRequireConst, kNoCascades);
   ASSERT(expr->IsLiteralNode());
   return expr->AsLiteralNode();
@@ skipping 28 matching lines @@
     ConsumeToken();
     expr = ParseUnaryExpr();
     if (expr->IsPrimaryNode() && (expr->AsPrimaryNode()->IsSuper())) {
       expr = BuildUnarySuperOperator(unary_op, expr->AsPrimaryNode());
     } else {
       expr = UnaryOpNode::UnaryOpOrLiteral(op_pos, unary_op, expr);
     }
   } else if (IsIncrementOperator(CurrentToken())) {
     Token::Kind incr_op = CurrentToken();
     ConsumeToken();
+    String* expr_ident =
+        Token::IsIdentifier(CurrentToken()) ? CurrentLiteral() : NULL;
+    const intptr_t expr_pos = TokenPos();
     expr = ParseUnaryExpr();
-    if (!IsAssignableExpr(expr)) {
-      ErrorMsg("expression is not assignable");
-    }
     // Is prefix.
     LetNode* let_expr = PrepareCompoundAssignmentNodes(&expr);
     Token::Kind binary_op =
         (incr_op == Token::kINCR) ? Token::kADD : Token::kSUB;
     BinaryOpNode* add = new BinaryOpNode(
         op_pos,
         binary_op,
         expr,
         new LiteralNode(op_pos, Smi::ZoneHandle(Smi::New(1))));
-    AstNode* store = CreateAssignmentNode(expr, add);
+    AstNode* store = CreateAssignmentNode(expr, add, expr_ident, expr_pos);
     ASSERT(store != NULL);
     let_expr->AddNode(store);
     expr = let_expr;
   } else {
     expr = ParsePostfixExpr();
   }
   return expr;
 }
 
 
@@ skipping 319 matching lines @@
 
 AstNode* Parser::ParseSelectors(AstNode* primary, bool is_cascade) {
   AstNode* left = primary;
   while (true) {
     AstNode* selector = NULL;
     if (CurrentToken() == Token::kPERIOD) {
       ConsumeToken();
       if (left->IsPrimaryNode()) {
         if (left->AsPrimaryNode()->primary().IsFunction()) {
           left = LoadClosure(left->AsPrimaryNode());
+        } else if (left->AsPrimaryNode()->primary().IsTypeParameter()) {
+          if (current_block_->scope->function_level() > 0) {
+            // Make sure that the instantiator is captured.
+            CaptureInstantiator();
+          }
+          TypeParameter& type_parameter = TypeParameter::ZoneHandle();
+          type_parameter ^= ClassFinalizer::FinalizeType(
+              current_class(),
+              TypeParameter::Cast(left->AsPrimaryNode()->primary()),
+              ClassFinalizer::kFinalize);
+          ASSERT(!type_parameter.IsMalformed());
+          left = new TypeNode(primary->token_pos(), type_parameter);
         } else {
           // Super field access handled in ParseSuperFieldAccess(),
           // super calls handled in ParseSuperCall().
           ASSERT(!left->AsPrimaryNode()->IsSuper());
           left = LoadFieldIfUnresolved(left);
         }
       }
       const intptr_t ident_pos = TokenPos();
       String* ident = ExpectIdentifier("identifier expected");
       if (CurrentToken() == Token::kLPAREN) {
@@ skipping 36 matching lines @@
       const bool saved_mode = SetAllowFunctionLiterals(true);
       AstNode* index = ParseExpr(kAllowConst, kConsumeCascades);
       SetAllowFunctionLiterals(saved_mode);
       ExpectToken(Token::kRBRACK);
       AstNode* array = left;
       if (left->IsPrimaryNode()) {
         PrimaryNode* primary = left->AsPrimaryNode();
         if (primary->primary().IsFunction()) {
           array = LoadClosure(primary);
         } else if (primary->primary().IsClass()) {
-          ErrorMsg(bracket_pos, "cannot apply index operator to class");
+          const Class& type_class = Class::Cast(primary->primary());
+          Type& type = Type::ZoneHandle(
+              Type::New(type_class, TypeArguments::Handle(),
+                        primary->token_pos(), Heap::kOld));
+          type ^= ClassFinalizer::FinalizeType(
+              current_class(), type, ClassFinalizer::kCanonicalize);
+          ASSERT(!type.IsMalformed());
+          array = new TypeNode(primary->token_pos(), type);
+        } else if (primary->primary().IsTypeParameter()) {
+          if (current_block_->scope->function_level() > 0) {
+            // Make sure that the instantiator is captured.
+            CaptureInstantiator();
+          }
+          TypeParameter& type_parameter = TypeParameter::ZoneHandle();
+          type_parameter ^= ClassFinalizer::FinalizeType(
+              current_class(),
+              TypeParameter::Cast(primary->primary()),
+              ClassFinalizer::kFinalize);
+          ASSERT(!type_parameter.IsMalformed());
+          array = new TypeNode(primary->token_pos(), type_parameter);
         } else {
           UNREACHABLE();  // Internal parser error.
         }
       }
       selector =  new LoadIndexedNode(bracket_pos,
                                       array,
                                       index,
                                       Class::ZoneHandle());
     } else if (CurrentToken() == Token::kLPAREN) {
       if (left->IsPrimaryNode()) {
@@ skipping 26 matching lines @@
             selector = ThrowNoSuchMethodError(primary->token_pos(),
                                               current_class(),
                                               name,
                                               InvocationMirror::kStatic,
                                               InvocationMirror::kMethod);
           } else {
             // Treat as call to unresolved (instance) method.
             AstNode* receiver = LoadReceiver(primary->token_pos());
             selector = ParseInstanceCall(receiver, name);
           }
+        } else if (primary->primary().IsTypeParameter()) {
+          const String& name = String::ZoneHandle(
+              Symbols::New(primary->Name()));
+          selector = ThrowNoSuchMethodError(primary->token_pos(),
+                                            current_class(),
+                                            name,
+                                            InvocationMirror::kStatic,
+                                            InvocationMirror::kMethod);
         } else if (primary->primary().IsClass()) {
-          ErrorMsg(left->token_pos(),
-                   "must use 'new' or 'const' to construct new instance");
+          const Class& type_class = Class::Cast(primary->primary());
+          Type& type = Type::ZoneHandle(
+              Type::New(type_class, TypeArguments::Handle(),
+                        primary->token_pos(), Heap::kOld));
+          type ^= ClassFinalizer::FinalizeType(
+              current_class(), type, ClassFinalizer::kCanonicalize);
+          ASSERT(!type.IsMalformed());
+          selector = new TypeNode(primary->token_pos(), type);
         } else {
           UNREACHABLE();  // Internal parser error.
         }
       } else {
         // Left is not a primary node; this must be a closure call.
         AstNode* closure = left;
         selector = ParseClosureCall(closure);
       }
     } else {
       // No (more) selectors to parse.
       left = LoadFieldIfUnresolved(left);
       if (left->IsPrimaryNode()) {
         PrimaryNode* primary = left->AsPrimaryNode();
         if (primary->primary().IsFunction()) {
           // Treat as implicit closure.
           left = LoadClosure(primary);
         } else if (primary->primary().IsClass()) {
           const Class& type_class = Class::Cast(primary->primary());
           Type& type = Type::ZoneHandle(
               Type::New(type_class, TypeArguments::Handle(),
                         primary->token_pos(), Heap::kOld));
           type ^= ClassFinalizer::FinalizeType(
               current_class(), type, ClassFinalizer::kCanonicalize);
+          ASSERT(!type.IsMalformed());
           left = new TypeNode(primary->token_pos(), type);
+        } else if (primary->primary().IsTypeParameter()) {
+          if (current_block_->scope->function_level() > 0) {
+            // Make sure that the instantiator is captured.
+            CaptureInstantiator();
+          }
+          TypeParameter& type_parameter = TypeParameter::ZoneHandle();
+          type_parameter ^= ClassFinalizer::FinalizeType(
+              current_class(),
+              TypeParameter::Cast(primary->primary()),
+              ClassFinalizer::kFinalize);
+          ASSERT(!type_parameter.IsMalformed());
+          left = new TypeNode(primary->token_pos(), type_parameter);
         } else if (primary->IsSuper()) {
           // Return "super" to handle unary super operator calls,
           // or to report illegal use of "super" otherwise.
           left = primary;
         } else {
           UNREACHABLE();  // Internal parser error.
         }
       }
       // Done parsing selectors.
       return left;
     }
     ASSERT(selector != NULL);
     left = selector;
   }
 }
 
 
 AstNode* Parser::ParsePostfixExpr() {
   TRACE_PARSER("ParsePostfixExpr");
-  const intptr_t postfix_expr_pos = TokenPos();
-  AstNode* postfix_expr = ParsePrimary();
-  postfix_expr = ParseSelectors(postfix_expr, false);
+  String* expr_ident =
+      Token::IsIdentifier(CurrentToken()) ? CurrentLiteral() : NULL;
+  const intptr_t expr_pos = TokenPos();
+  AstNode* expr = ParsePrimary();
+  expr = ParseSelectors(expr, false);
   if (IsIncrementOperator(CurrentToken())) {
     TRACE_PARSER("IncrementOperator");
     Token::Kind incr_op = CurrentToken();
-    if (!IsAssignableExpr(postfix_expr)) {
-      ErrorMsg("expression is not assignable");
-    }
     ConsumeToken();
     // Not prefix.
-    LetNode* let_expr = PrepareCompoundAssignmentNodes(&postfix_expr);
-    LocalVariable* temp = let_expr->AddInitializer(postfix_expr);
+    LetNode* let_expr = PrepareCompoundAssignmentNodes(&expr);
+    LocalVariable* temp = let_expr->AddInitializer(expr);
     Token::Kind binary_op =
         (incr_op == Token::kINCR) ? Token::kADD : Token::kSUB;
     BinaryOpNode* add = new BinaryOpNode(
-        postfix_expr_pos,
+        expr_pos,
         binary_op,
-        new LoadLocalNode(postfix_expr_pos, temp),
-        new LiteralNode(postfix_expr_pos, Smi::ZoneHandle(Smi::New(1))));
-    AstNode* store = CreateAssignmentNode(postfix_expr, add);
+        new LoadLocalNode(expr_pos, temp),
+        new LiteralNode(expr_pos, Smi::ZoneHandle(Smi::New(1))));
+    AstNode* store = CreateAssignmentNode(expr, add, expr_ident, expr_pos);
     ASSERT(store != NULL);
     // The result is a pair of the (side effects of the) store followed by
     // the (value of the) initial value temp variable load.
     let_expr->AddNode(store);
-    let_expr->AddNode(new LoadLocalNode(postfix_expr_pos, temp));
+    let_expr->AddNode(new LoadLocalNode(expr_pos, temp));
     return let_expr;
   }
-  return postfix_expr;
+  return expr;
 }
 
 
 // Resolve the given type and its type arguments from the given scope class
 // 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,
                                   ClassFinalizer::FinalizationKind finalization,
                                   AbstractType* type) {
   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());
     Class& resolved_type_class = Class::Handle();
     if (unresolved_class.library_prefix() == LibraryPrefix::null()) {
       if (!scope_class.IsNull()) {
         // First check if the type is a type parameter of the given scope class.
         const TypeParameter& type_parameter = TypeParameter::Handle(
-            scope_class.LookupTypeParameter(unresolved_class_name,
-                                            type->token_pos()));
+            scope_class.LookupTypeParameter(unresolved_class_name));
         if (!type_parameter.IsNull()) {
           // A type parameter is considered to be a malformed type when
           // referenced by a static member.
           if (ParsingStaticMember()) {
             ASSERT(scope_class.raw() == current_class().raw());
             *type = ClassFinalizer::NewFinalizedMalformedType(
                 Error::Handle(),  // No previous error.
                 scope_class,
                 type->token_pos(),
                 finalization,
@@ skipping 684 matching lines @@
   } else {
     // TODO(hausner): Should this be an error? It is not meaningful to
     // reference a library prefix defined in an imported library.
     ASSERT(obj.IsLibraryPrefix());
   }
   // Lexically unresolved primary identifiers are referenced by their name.
   return new PrimaryNode(ident_pos, ident);
 }
 
 
-// Resolve identifier, issue an error message if the name refers to
-// a class/interface or a type parameter. Issue an error message if
+// Resolve identifier. Issue an error message if
 // the ident refers to a method and allow_closure_names is false.
 // If the name cannot be resolved, turn it into an instance field access
 // if we're compiling an instance method, or issue an error message
 // if we're compiling a static method.
 AstNode* Parser::ResolveIdent(intptr_t ident_pos,
                               const String& ident,
                               bool allow_closure_names) {
   TRACE_PARSER("ResolveIdent");
   // First try to find the variable in the local scope (block scope or
   // class scope).
   AstNode* resolved = NULL;
   ResolveIdentInLocalScope(ident_pos, ident, &resolved);
   if (resolved == NULL) {
-    // Check whether the identifier is a type parameter. Type parameters
-    // can never be used in primary expressions.
+    // Check whether the identifier is a type parameter.
     if (!current_class().IsNull()) {
-      TypeParameter& type_param = TypeParameter::Handle(
-          current_class().LookupTypeParameter(ident, ident_pos));
-      if (!type_param.IsNull()) {
-        String& type_param_name = String::Handle(type_param.name());
-        ErrorMsg(ident_pos, "illegal use of type parameter %s",
-                 type_param_name.ToCString());
+      TypeParameter& type_parameter = TypeParameter::ZoneHandle(
+          current_class().LookupTypeParameter(ident));
+      if (!type_parameter.IsNull()) {
+        if (current_block_->scope->function_level() > 0) {
+          // Make sure that the instantiator is captured.
+          CaptureInstantiator();
+        }
+        type_parameter ^= ClassFinalizer::FinalizeType(
+            current_class(), type_parameter, ClassFinalizer::kFinalize);
+        ASSERT(!type_parameter.IsMalformed());
+        return new TypeNode(ident_pos, type_parameter);
       }
     }
     // Not found in the local scope, and the name is not a type parameter.
     // Try finding the variable in the library scope (current library
     // and all libraries imported by it without a library prefix).
     resolved = ResolveIdentInCurrentLibraryScope(ident_pos, ident);
   }
   if (resolved->IsPrimaryNode()) {
     PrimaryNode* primary = resolved->AsPrimaryNode();
     if (primary->primary().IsString()) {
@@ skipping 12 matching lines @@
         // Treat as call to unresolved instance field.
         resolved = CallGetter(ident_pos, LoadReceiver(ident_pos), ident);
       }
     } else if (primary->primary().IsFunction()) {
       if (allow_closure_names) {
         resolved = LoadClosure(primary);
       } else {
         ErrorMsg(ident_pos, "illegal reference to method '%s'",
                  ident.ToCString());
       }
-    } else {
-      ASSERT(primary->primary().IsClass());
-      ErrorMsg(ident_pos, "illegal reference to class or interface '%s'",
-               ident.ToCString());
+    } else if (primary->primary().IsClass()) {
+      const Class& type_class = Class::Cast(primary->primary());
+      Type& type = Type::ZoneHandle(
+          Type::New(type_class, TypeArguments::Handle(),
+                    primary->token_pos(), Heap::kOld));
+      type ^= ClassFinalizer::FinalizeType(
+          current_class(), type, ClassFinalizer::kCanonicalize);
+      ASSERT(!type.IsMalformed());
+      resolved = new TypeNode(primary->token_pos(), type);
     }
   }
   return resolved;
 }
 
 
 // Parses type = [ident "."] ident ["<" type { "," type } ">"], then resolve and
 // finalize it according to the given type finalization mode.
 RawAbstractType* Parser::ParseType(
     ClassFinalizer::FinalizationKind finalization) {
@@ skipping 832 matching lines @@
     OpenBlock();
     primary = ParseFunctionStatement(true);
     CloseBlock();
   } else if (IsIdentifier()) {
     QualIdent qual_ident;
     ParseQualIdent(&qual_ident);
     if (qual_ident.lib_prefix == NULL) {
       if (!ResolveIdentInLocalScope(qual_ident.ident_pos,
                                     *qual_ident.ident,
                                     &primary)) {
-        // Check whether the identifier is a type parameter. Type parameters
-        // can never be used as part of primary expressions.
+        // Check whether the identifier is a type parameter.
         if (!current_class().IsNull()) {
           TypeParameter& type_param = TypeParameter::ZoneHandle(
-              current_class().LookupTypeParameter(*(qual_ident.ident),
-                                                  TokenPos()));
+              current_class().LookupTypeParameter(*(qual_ident.ident)));
           if (!type_param.IsNull()) {
-            const String& type_param_name = String::Handle(type_param.name());
-            ErrorMsg(qual_ident.ident_pos,
-                     "illegal use of type parameter %s",
-                     type_param_name.ToCString());
+            return new PrimaryNode(qual_ident.ident_pos, type_param);
           }
         }
         // This is a non-local unqualified identifier so resolve the
         // identifier locally in the main app library and all libraries
         // imported by it.
         primary = ResolveIdentInCurrentLibraryScope(qual_ident.ident_pos,
                                                     *qual_ident.ident);
       }
     } else {
       // This is a qualified identifier with a library prefix so resolve
@@ skipping 403 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart