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

runtime/vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "vm/assert.h"
 #include "vm/dart.h"
 #include "vm/globals.h"
@@ skipping 433 matching lines @@
     raw_ptr()->type_arguments_instance_field_offset_ = value;
   }
 
   // The super type of this class, Object type if not explicitly specified.
   RawType* super_type() const { return raw_ptr()->super_type_; }
   void set_super_type(const Type& value) const;
 
   // Asserts that the class of the super type has been resolved.
   RawClass* SuperClass() const;
 
-  // The factory type of this interface, null if not specified.
-  RawType* factory_type() const { return raw_ptr()->factory_type_; }
-  void set_factory_type(const Type& value) const;
+  // Return true if this interface has a factory class.
+  bool HasFactoryClass() const;
 
-  // Asserts that the class of the factory type has been resolved.
+  // Return true if the factory class of this interface is resolved.
+  bool HasResolvedFactoryClass() const;
+
+  // Return the resolved factory class of this interface.
   RawClass* FactoryClass() const;
 
+  // Return the unresolved factory class of this interface.
+  RawUnresolvedClass* UnresolvedFactoryClass() const;
+
+  // Set the resolved or unresolved factory class of this interface.
+  void set_factory_class(const Object& value) const;
+
   // Interfaces is an array of Types.
   RawArray* interfaces() const { return raw_ptr()->interfaces_; }
   void set_interfaces(const Array& value) const;
 
   RawArray* functions_cache() const { return raw_ptr()->functions_cache_; }
   void set_functions_cache(const Array& value) const;
 
   static intptr_t functions_cache_offset() {
     return OFFSET_OF(RawClass, functions_cache_);
   }
@@ skipping 166 matching lines @@
 
 
 // Unresolved class is used for storing unresolved names which will be resolved
 // to a class after all classes have been loaded and finalized.
 class UnresolvedClass : public Object {
  public:
   RawString* qualifier() const { return raw_ptr()->qualifier_; }
   RawString* ident() const { return raw_ptr()->ident_; }
   intptr_t token_index() const { return raw_ptr()->token_index_; }
 
+  RawClass* factory_signature_class() const {
+    return raw_ptr()->factory_signature_class_;
+  }
+  void set_factory_signature_class(const Class& value) const;
+
   RawString* Name() const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawUnresolvedClass));
   }
   static RawUnresolvedClass* New(intptr_t token_index,
                                  const String& qualifier,
                                  const String& ident);
 
  private:
@@ skipping 2355 matching lines @@
 }
 
 
 void Context::SetAt(intptr_t index, const Instance& value) const {
   StorePointer(InstanceAddr(index), value.raw());
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_