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 2624 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 3246 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 1250 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");

[hausner, 2013/07/08 19:51:15]

By moving the compiler error message here, you unfortunately have to make the
message quite vague. I liked the old "left hand side .... not assignable" a bit
better.

[regis, 2013/07/08 23:04:15]

True. Note that many compile time errors are actually gone.

+    }
     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;

[hausner, 2013/07/08 19:51:15]

It seems to me that in this expression:

o.f = expr;

your expr_ident is o. If the left hand side turns out not to be assignable, the
the noSuchMethodError that is thrown reports that there is no "o" instead of
"f".

[regis, 2013/07/08 23:04:15]

The name expr_ident is only used for LiteralNode, LoadLocalNode, and
LoadStaticFieldNode. See CreateAssignmentNode.

Do you have an example of wrong output?

[hausner, 2013/07/08 23:38:07]

No, I did not run your code. I just don't understand where and how the case I
mentioned is handled now.

On 2013/07/08 23:04:15, regis wrote:

[regis, 2013/07/09 00:13:54]

It all depends on the nature of o and f in your case. There are many cases I did
not touch (e.g. no instance field f in an instance o).

   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)) {

[hausner, 2013/07/08 19:51:15]

It looks like you eliminated all uses of this function so it should be removed.
It does handle cases that don't seem to be handled in CreateAssignmentNode,
though, eg. setter super calls.

[regis, 2013/07/08 23:04:15]

Thanks. Removed.
Shouldn't some setter super call test fail if I removed too much?

[hausner, 2013/07/08 23:38:07]

I don't know whether we have a test for this. I would think so.

On 2013/07/08 23:04:15, regis wrote:

-      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