Add support for sync* and yield

runtime/vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 2134 matching lines @@
 
   // Returns true if this function represents a signature function without code.
   bool IsSignatureFunction() const {
     return kind() == RawFunction::kSignatureFunction;
   }
 
   bool IsAsyncFunction() const {
     return modifier() == RawFunction::kAsync;
   }
 
+  bool IsAsyncClosure() const {
+    return is_generated_body() &&
+        Function::Handle(parent_function()).IsAsyncFunction();
+  }
+
+  bool IsGenerator() const {
+    return (modifier() & RawFunction::kGeneratorBit) != 0;
+  }
+
+  bool IsSyncGenerator() const {
+    return modifier() == RawFunction::kSyncGen;
+  }
+
+  bool IsSyncGenClosure() const {
+    return is_generated_body() &&
+        Function::Handle(parent_function()).IsSyncGenerator();
+  }
+
+  bool IsAsyncOrGenerator() const {
+    return modifier() != RawFunction::kNoModifier;
+  }
+
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawFunction));
   }
 
   static RawFunction* New(const String& name,
                           RawFunction::Kind kind,
                           bool is_static,
                           bool is_const,
                           bool is_abstract,
                           bool is_external,
@@ skipping 67 matching lines @@
   V(Reflectable, is_reflectable)                                               \
   V(Debuggable, is_debuggable)                                                 \
   V(Optimizable, is_optimizable)                                               \
   V(Inlinable, is_inlinable)                                                   \
   V(Intrinsic, is_intrinsic)                                                   \
   V(Native, is_native)                                                         \
   V(Redirecting, is_redirecting)                                               \
   V(External, is_external)                                                     \
   V(AllowsHoistingCheckClass, allows_hoisting_check_class)                     \
   V(AllowsBoundsCheckGeneralization, allows_bounds_check_generalization)       \
-  V(AsyncClosure, is_async_closure)                                            \
+  V(GeneratedBody, is_generated_body)                                          \
   V(AlwaysInline, always_inline)                                               \
   V(PolymorphicTarget, is_polymorphic_target)                                  \
 
 #define DEFINE_ACCESSORS(name, accessor_name)                                  \
   void set_##accessor_name(bool value) const {                                 \
     set_kind_tag(name##Bit::update(value, raw_ptr()->kind_tag_));              \
   }                                                                            \
   bool accessor_name() const {                                                 \
     return name##Bit::decode(raw_ptr()->kind_tag_);                            \
   }
 FOR_EACH_FUNCTION_KIND_BIT(DEFINE_ACCESSORS)
 #undef DEFINE_ACCESSORS
 
  private:
   void set_ic_data_array(const Array& value) const;
 
   enum KindTagBits {
     kKindTagPos = 0,
     kKindTagSize = 4,
     kRecognizedTagPos = kKindTagPos + kKindTagSize,
     kRecognizedTagSize = 8,
     kModifierPos = kRecognizedTagPos + kRecognizedTagSize,
+    kModifierSize = 2,
+    kLastModifierBitPos = kModifierPos + (kModifierSize - 1),
     // Single bit sized fields start here.
 #define DECLARE_BIT(name, _) k##name##Bit,
 FOR_EACH_FUNCTION_KIND_BIT(DECLARE_BIT)
 #undef DECLARE_BIT
     kNumTagBits
   };
 
   COMPILE_ASSERT(
       MethodRecognizer::kNumRecognizedMethods < (1 << kRecognizedTagSize));
   COMPILE_ASSERT(
       kNumTagBits <=
       (kBitsPerByte * sizeof(static_cast<RawFunction*>(0)->kind_tag_)));
 
   class KindBits :
     public BitField<RawFunction::Kind, kKindTagPos, kKindTagSize> {};  // NOLINT
+
   class RecognizedBits : public BitField<MethodRecognizer::Kind,
                                          kRecognizedTagPos,
                                          kRecognizedTagSize> {};
   class ModifierBits :
-      public BitField<RawFunction::AsyncModifier, kModifierPos, 1> {};  // NOLINT
+    public BitField<RawFunction::AsyncModifier,
+                   kModifierPos,
+                   kModifierSize> {};  // NOLINT
 
 #define DEFINE_BIT(name, _) \
   class name##Bit : public BitField<bool, k##name##Bit, 1> {};
 FOR_EACH_FUNCTION_KIND_BIT(DEFINE_BIT)
 #undef DEFINE_BIT
 
   void set_name(const String& value) const;
   void set_kind(RawFunction::Kind value) const;
   void set_parent_function(const Function& value) const;
   void set_owner(const Object& value) const;
@@ skipping 5470 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_