Reland transformation of async functions.

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 1647 matching lines @@
   void SetRedirectionType(const Type& type) const;
   RawString* RedirectionIdentifier() const;
   void SetRedirectionIdentifier(const String& identifier) const;
   RawFunction* RedirectionTarget() const;
   void SetRedirectionTarget(const Function& target) const;
 
   RawFunction::Kind kind() const {
     return KindBits::decode(raw_ptr()->kind_tag_);
   }
 
+  RawFunction::AsyncModifier modifier() const {
+    return ModifierBits::decode(raw_ptr()->kind_tag_);
+  }
+
   static const char* KindToCString(RawFunction::Kind kind);
 
   bool is_static() const { return StaticBit::decode(raw_ptr()->kind_tag_); }
   bool is_const() const { return ConstBit::decode(raw_ptr()->kind_tag_); }
   bool is_external() const { return ExternalBit::decode(raw_ptr()->kind_tag_); }
   bool IsConstructor() const {
     return (kind() == RawFunction::kConstructor) && !is_static();
   }
   bool IsImplicitConstructor() const;
   bool IsFactory() const {
@@ skipping 126 matching lines @@
       value = kMaxInstructionCount;
     }
     raw_ptr()->optimized_call_site_count_ = static_cast<uint16_t>(value);
   }
 
   bool IsOptimizable() const;
   bool IsNativeAutoSetupScope() const;
   void SetIsOptimizable(bool value) const;
   void SetIsNativeAutoSetupScope(bool value) const;
 
+  bool is_async_closure() const {
+    return AsyncClosureBit::decode(raw_ptr()->kind_tag_);
+  }
+  void set_is_async_closure(bool value) const;
+
   bool is_native() const { return NativeBit::decode(raw_ptr()->kind_tag_); }
   void set_is_native(bool value) const;
 
   bool is_abstract() const { return AbstractBit::decode(raw_ptr()->kind_tag_); }
   void set_is_abstract(bool value) const;
 
   bool IsInlineable() const;
   void set_is_inlinable(bool value) const;
 
   bool is_visible() const {
@@ skipping 130 matching lines @@
   // Returns true if this function represents a local function.
   bool IsLocalFunction() const {
     return parent_function() != Function::null();
   }
 
   // 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;
+  }
+
   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 34 matching lines @@
   void RestoreICDataMap(
       ZoneGrowableArray<const ICData*>* deopt_id_to_ic_data) const;
 
   RawArray* ic_data_array() const;
   void ClearICData() const;
 
   static const int kCtorPhaseInit = 1 << 0;
   static const int kCtorPhaseBody = 1 << 1;
   static const int kCtorPhaseAll = (kCtorPhaseInit | kCtorPhaseBody);
 
+  void set_modifier(RawFunction::AsyncModifier value) const;
+
  private:
   void set_ic_data_array(const Array& value) const;
 
   enum KindTagBits {
     kKindTagPos = 0,
     kKindTagSize = 4,
     kStaticBit = kKindTagPos + kKindTagSize,  // = 4
     kConstBit = 5,
     kAbstractBit = 6,
     kVisibleBit = 7,
     kOptimizableBit = 8,
     kInlinableBit = 9,
     kIntrinsicBit = 10,
     kRecognizedBit = 11,
     kNativeBit = 12,
     kRedirectingBit = 13,
     kExternalBit = 14,
     kAllowsHoistingCheckClassBit = 15,
+    kModifierPos = 16,
+    kAsyncClosureBit = 18,
   };
   class KindBits :
     public BitField<RawFunction::Kind, kKindTagPos, kKindTagSize> {};  // NOLINT
   class StaticBit : public BitField<bool, kStaticBit, 1> {};
   class ConstBit : public BitField<bool, kConstBit, 1> {};
   class AbstractBit : public BitField<bool, kAbstractBit, 1> {};
   class VisibleBit : public BitField<bool, kVisibleBit, 1> {};
   class OptimizableBit : public BitField<bool, kOptimizableBit, 1> {};
   class InlinableBit : public BitField<bool, kInlinableBit, 1> {};
   class IntrinsicBit : public BitField<bool, kIntrinsicBit, 1> {};
   class RecognizedBit : public BitField<bool, kRecognizedBit, 1> {};
   class NativeBit : public BitField<bool, kNativeBit, 1> {};
   class ExternalBit : public BitField<bool, kExternalBit, 1> {};
   class RedirectingBit : public BitField<bool, kRedirectingBit, 1> {};
   class AllowsHoistingCheckClassBit :
       public BitField<bool, kAllowsHoistingCheckClassBit, 1> {};  // NOLINT
+  class ModifierBits :
+      public BitField<RawFunction::AsyncModifier, kModifierPos, 2> {};  // NOLINT

[Ivan Posva, 2014/07/29 23:56:14]

There is still a mismatch between the number of bits and the number of states
you need to encode here. Please fix. Iff we need to add more states then we can
add bits.

+  class AsyncClosureBit : public BitField<bool, kAsyncClosureBit, 1> {};
 
   void set_name(const String& value) const;
   void set_kind(RawFunction::Kind value) const;
   void set_is_static(bool value) const;
   void set_is_const(bool value) const;
   void set_is_external(bool value) const;
   void set_parent_function(const Function& value) const;
   void set_owner(const Object& value) const;
   RawFunction* implicit_closure_function() const;
   void set_implicit_closure_function(const Function& value) const;
@@ skipping 5221 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_