Consolidate a few fields in RawFunction using bitfields.

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 1337 matching lines @@
 
   RawCode* closure_allocation_stub() const {
     return raw_ptr()->closure_allocation_stub_;
   }
   void set_closure_allocation_stub(const Code& value) const;
 
   // Return the closure function implicitly created for this function.
   // If none exists yet, create one and remember it.
   RawFunction* ImplicitClosureFunction() const;
 
-  RawFunction::Kind kind() const { return raw_ptr()->kind_; }
+  RawFunction::Kind kind() const { return raw()->GetKind(); }
 
-  bool is_static() const { return raw_ptr()->is_static_; }
-  bool is_const() const { return raw_ptr()->is_const_; }
+  bool is_static() const { return raw()->IsStatic(); }
+  bool is_const() const { return raw()->IsConst(); }
   bool IsConstructor() const {
     return (kind() == RawFunction::kConstructor) && !is_static();
   }
   bool IsFactory() const {
     return (kind() == RawFunction::kConstructor) && is_static();
   }
-  bool IsAbstract() const {
-    return kind() == RawFunction::kAbstract;
-  }
   bool IsDynamicFunction() const {
-    if (is_static()) {
+    if (is_static() || is_abstract()) {

[turnidge, 2012/07/18 04:57:15]

What do you think of this?  I'm preserving the current behavior, but not sure if
it is useful.  I could drop the is_abstract() test here...

       return false;
     }
     switch (kind()) {
       case RawFunction::kFunction:
       case RawFunction::kGetterFunction:
       case RawFunction::kSetterFunction:
       case RawFunction::kImplicitGetter:
       case RawFunction::kImplicitSetter:
         return true;
       case RawFunction::kClosureFunction:
       case RawFunction::kConstructor:
       case RawFunction::kConstImplicitGetter:
-      case RawFunction::kAbstract:
         return false;
       default:
         UNREACHABLE();
         return false;
     }
   }
   bool IsStaticFunction() const {
     if (!is_static()) {
       return false;
     }
@@ skipping 48 matching lines @@
     raw_ptr()->usage_counter_ = value;
   }
 
   intptr_t deoptimization_counter() const {
     return raw_ptr()->deoptimization_counter_;
   }
   void set_deoptimization_counter(intptr_t value) const {
     raw_ptr()->deoptimization_counter_ = value;
   }
 
-  bool is_optimizable() const {
-    return raw_ptr()->is_optimizable_;
-  }
+  bool is_optimizable() const { return raw()->IsOptimizable(); }
   void set_is_optimizable(bool value) const;
 
-  bool is_native() const { return raw_ptr()->is_native_; }
+  bool is_native() const { return raw()->IsNative(); }
   void set_is_native(bool value) const;
 
+  bool is_abstract() const { return raw()->IsAbstract(); }
+  void set_is_abstract(bool value) const;
+
   bool HasOptimizedCode() const;
 
   intptr_t NumberOfParameters() const;
   intptr_t NumberOfImplicitParameters() const;
 
   // Returns true if the argument counts are valid for calling this function.
   // Otherwise, it returns false and the reason (if error_message is not NULL).
   bool AreValidArgumentCounts(int num_arguments,
                               int num_named_arguments,
                               String* error_message) const;
@@ skipping 78 matching lines @@
 
 
   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,
                           intptr_t token_pos);
 
   // Allocates a new Function object representing a closure function, as well as
   // a new associated Class object representing the signature class of the
   // function.
   // The function and the class share the same given name.
   static RawFunction* NewClosureFunction(const String& name,
                                          const Function& parent,
                                          intptr_t token_pos);
 
@@ skipping 3598 matching lines @@
     if (this->CharAt(i) != str.CharAt(begin_index + i)) {
       return false;
     }
   }
   return true;
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_