Implemented class literals in the VM.

runtime/vm/parser.cc

Index: runtime/vm/parser.cc
===================================================================
--- runtime/vm/parser.cc	(revision 16515)
+++ runtime/vm/parser.cc	(working copy)
@@ -6890,6 +6890,11 @@
 // Ensure that the expression temp is allocated for nodes that may need it.
 AstNode* Parser::CreateAssignmentNode(AstNode* original, AstNode* rhs) {
   AstNode* result = original->MakeAssignmentNode(rhs);
+  if ((result == NULL) && original->IsTypeNode()) {
+    const String& type_name = String::ZoneHandle(
+        original->AsTypeNode()->type().ClassName());
+    result = ThrowNoSuchMethodError(original->token_pos(), type_name);
+  }

[regis, 2012/12/27 22:51:24]

Why is this code here and not in TypeNode's MakeAssignmentNode?
Also, can you add a comment explaining why this code is necessary? Without it, I
guess that the parser would report a compile time error? Is that not acceptable
by the spec?

[Tom Ball, 2012/12/27 23:16:31]

I was following existing code here for a test of original->IsStaticGetterNode(),
which was removed a few days ago.  That code was apparently in the parser rather
than ast, because there's no equivalent ThrowNoSuchMethodError function in
AstNode, nor the MakeStaticCall function it depends upon.  I can copy all that
code into TypeNode if necessary, but since there are several
ThrowNoSUchMethodError calls in the parser it seems this is the right place
(IMO).
This is one of several places where the VM catches errors at compile time, which
are spec'd to be caught at runtime.  I double-checked with Gilad before adding
this check.

   if ((result != NULL) &&
       (result->IsStoreIndexedNode() ||
        result->IsInstanceSetterNode() ||
@@ -7482,13 +7487,14 @@
         if (primary->primary().IsFunction()) {
           // Treat as implicit closure.
           left = LoadClosure(primary);
-        } else if (left->AsPrimaryNode()->primary().IsClass()) {
-          Class& cls = Class::CheckedHandle(
-              left->AsPrimaryNode()->primary().raw());
-          String& cls_name = String::Handle(cls.Name());
-          ErrorMsg(left->token_pos(),
-                   "illegal use of class name '%s'",
-                   cls_name.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);
+          left = new TypeNode(primary->token_pos(), type);
         } else if (primary->IsSuper()) {
           // Return "super" to handle unary super operator calls,
           // or to report illegal use of "super" otherwise.