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

runtime/vm/object.cc

 // Copyright (c) 2011, 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/object.h"
 
 #include "vm/assembler.h"
 #include "vm/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 860 matching lines @@
   }
   return sup_type.type_class();
 }
 
 
 void Class::set_super_type(const Type& value) const {
   StorePointer(&raw_ptr()->super_type_, value.raw());
 }
 
 
+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 {
   ASSERT(!type_name.IsNull());
   const Array& type_params = Array::Handle(type_parameters());
   if (!type_params.IsNull()) {
     intptr_t num_type_params = type_params.Length();
@@ skipping 673 matching lines @@
 void UnresolvedClass::set_ident(const String& ident) const {
   StorePointer(&raw_ptr()->ident_, ident.raw());
 }
 
 
 void UnresolvedClass::set_qualifier(const String& qualifier) const {
   StorePointer(&raw_ptr()->qualifier_, qualifier.raw());
 }
 
 
+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();
     name = qualifier();
     String& str = String::Handle();
     str = String::New(".");
     name = String::Concat(name, str);
     str = ident();
     name = String::Concat(name, str);
     return name.raw();
@@ skipping 363 matching lines @@
 }
 
 
 void ParameterizedType::set_is_being_finalized() const {
   ASSERT(!IsFinalized() && !IsBeingFinalized());
   set_type_state(RawParameterizedType::kBeingFinalized);
 }
 
 
 bool ParameterizedType::IsResolved() const {
+  if (IsFinalized()) {
+    return true;
+  }
   if (!HasResolvedTypeClass()) {
     return false;
   }
   const TypeArguments& args = TypeArguments::Handle(arguments());
   return args.IsNull() || args.IsResolved();
 }
 
 
 bool ParameterizedType::HasResolvedTypeClass() const {
   const Object& type_class = Object::Handle(raw_ptr()->type_class_);
@@ skipping 5022 matching lines @@
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart