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

runtime/vm/object.cc

Index: runtime/vm/object.cc
===================================================================
--- runtime/vm/object.cc	(revision 1585)
+++ runtime/vm/object.cc	(working copy)
@@ -878,20 +878,40 @@
 }
 
 
+bool Class::HasFactoryClass() const {
+  const Object& factory_class = Object::Handle(raw_ptr()->factory_class_);
+  return !factory_class.IsNull();
+}
+
+
+bool Class::HasResolvedFactoryClass() const {
+  ASSERT(HasFactoryClass());
+  const Object& factory_class = Object::Handle(raw_ptr()->factory_class_);
+  return factory_class.IsClass();
+}
+
+
 RawClass* Class::FactoryClass() const {
-  const Type& fact_type = Type::Handle(factory_type());
-  if (fact_type.IsNull()) {
-    return Class::null();
-  }
-  return fact_type.type_class();
+  ASSERT(HasResolvedFactoryClass());
+  Class& type_class = Class::Handle();
+  type_class ^= raw_ptr()->factory_class_;
+  return type_class.raw();
 }
 
 
-void Class::set_factory_type(const Type& value) const {
-  StorePointer(&raw_ptr()->factory_type_, value.raw());
+RawUnresolvedClass* Class::UnresolvedFactoryClass() const {
+  ASSERT(!HasResolvedFactoryClass());
+  UnresolvedClass& unresolved_factory_class = UnresolvedClass::Handle();
+  unresolved_factory_class ^= raw_ptr()->factory_class_;
+  return unresolved_factory_class.raw();
 }
 
 
+void Class::set_factory_class(const Object& value) const {
+  StorePointer(&raw_ptr()->factory_class_, value.raw());
+}
+
+
 // Return a TypeParameter if the type_name is a type parameter of this class.
 // Return null otherwise.
 RawTypeParameter* Class::LookupTypeParameter(const String& type_name) const {
@@ -1582,6 +1602,11 @@
 }
 
 
+void UnresolvedClass::set_factory_signature_class(const Class& value) const {
+  StorePointer(&raw_ptr()->factory_signature_class_, value.raw());
+}
+
+
 RawString* UnresolvedClass::Name() const {
   if (qualifier() != String::null()) {
     String& name = String::Handle();
@@ -1965,6 +1990,9 @@
 
 
 bool ParameterizedType::IsResolved() const {
+  if (IsFinalized()) {
+    return true;
+  }
   if (!HasResolvedTypeClass()) {
     return false;
   }