Fix the types used in bit fields.

vm/object.cc

 // 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.
 
 #include "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
@@ skipping 1416 matching lines @@
 void Class::set_signature_function(const Function& value) const {
   ASSERT(value.IsClosureFunction() || value.IsSignatureFunction());
   StorePointer(&raw_ptr()->signature_function_, value.raw());
 }
 
 
 void Class::set_class_state(RawClass::ClassState state) const {
   ASSERT((state == RawClass::kAllocated) ||
          (state == RawClass::kPreFinalized) ||
          (state == RawClass::kFinalized));
-  uword bits = raw_ptr()->state_bits_;
-  raw_ptr()->state_bits_ = StateBits::update(state, bits);
+  raw_ptr()->state_bits_ = static_cast<uint8_t>(
+      StateBits::update(state, raw_ptr()->state_bits_));
 }
 
 
 void Class::set_state_bits(uint8_t bits) const {
   raw_ptr()->state_bits_ = bits;
 }
 
 
 void Class::set_library(const Library& value) const {
   StorePointer(&raw_ptr()->library_, value.raw());
@@ skipping 437 matching lines @@
 }
 
 
 void Class::set_token_pos(intptr_t token_pos) const {
   ASSERT(token_pos >= 0);
   raw_ptr()->token_pos_ = token_pos;
 }
 
 
 void Class::set_is_interface() const {
-  uword bits = raw_ptr()->state_bits_;
-  raw_ptr()->state_bits_ = InterfaceBit::update(true, bits);
+  raw_ptr()->state_bits_ = static_cast<uint8_t>(
+      InterfaceBit::update(true, raw_ptr()->state_bits_));
 }
 
 void Class::set_is_abstract() const {
-  uword bits = raw_ptr()->state_bits_;
-  raw_ptr()->state_bits_ = AbstractBit::update(true, bits);
+  raw_ptr()->state_bits_ = static_cast<uint8_t>(
+      AbstractBit::update(true, raw_ptr()->state_bits_));
 }
 
 
 void Class::set_is_const() const {
-  uword bits = raw_ptr()->state_bits_;
-  raw_ptr()->state_bits_ = ConstBit::update(true, bits);
+  raw_ptr()->state_bits_ = static_cast<uint8_t>(
+      ConstBit::update(true, raw_ptr()->state_bits_));
 }
 
 
 void Class::set_is_finalized() const {
   ASSERT(!is_finalized());
-  uword bits = raw_ptr()->state_bits_;
-  raw_ptr()->state_bits_ = StateBits::update(RawClass::kFinalized, bits);
+  raw_ptr()->state_bits_ = static_cast<uint8_t>(
+      StateBits::update(RawClass::kFinalized, raw_ptr()->state_bits_));
 }
 
 
 void Class::set_is_prefinalized() const {
   ASSERT(!is_finalized());
-  uword bits = raw_ptr()->state_bits_;
-  raw_ptr()->state_bits_ = StateBits::update(RawClass::kPreFinalized, bits);
+  raw_ptr()->state_bits_ = static_cast<uint8_t>(
+      StateBits::update(RawClass::kPreFinalized, raw_ptr()->state_bits_));
 }
 
 
 void Class::set_interfaces(const Array& value) const {
   // Verification and resolving of interfaces occurs in finalizer.
   ASSERT(!value.IsNull());
   StorePointer(&raw_ptr()->interfaces_, value.raw());
 }
 
 
@@ skipping 2070 matching lines @@
   parameter_names.SetAt(index, value);
 }
 
 
 void Function::set_parameter_names(const Array& value) const {
   StorePointer(&raw_ptr()->parameter_names_, value.raw());
 }
 
 
 void Function::set_kind(RawFunction::Kind value) const {
-  uword bits = raw_ptr()->kind_tag_;
-  raw_ptr()->kind_tag_ = KindBits::update(value, bits);
+  set_kind_tag(KindBits::update(value, raw_ptr()->kind_tag_));
 }
 
 
 void Function::set_is_static(bool value) const {
-  uword bits = raw_ptr()->kind_tag_;
-  raw_ptr()->kind_tag_ = StaticBit::update(value, bits);
+  set_kind_tag(StaticBit::update(value, raw_ptr()->kind_tag_));
 }
 
 
 void Function::set_is_const(bool value) const {
-  uword bits = raw_ptr()->kind_tag_;
-  raw_ptr()->kind_tag_ = ConstBit::update(value, bits);
+  set_kind_tag(ConstBit::update(value, raw_ptr()->kind_tag_));
 }
 
 
 void Function::set_is_external(bool value) const {
-  uword bits = raw_ptr()->kind_tag_;
-  raw_ptr()->kind_tag_ = ExternalBit::update(value, bits);
+  set_kind_tag(ExternalBit::update(value, raw_ptr()->kind_tag_));
 }
 
 
 void Function::set_token_pos(intptr_t value) const {
   ASSERT(value >= 0);
   raw_ptr()->token_pos_ = value;
 }
 
 
 void Function::set_kind_tag(intptr_t value) const {
-  raw_ptr()->kind_tag_ = value;
+  raw_ptr()->kind_tag_ = static_cast<uint16_t>(value);
 }
 
 
 void Function::set_num_fixed_parameters(intptr_t value) const {
   ASSERT(value >= 0);
   ASSERT(Utils::IsInt(16, value));
   raw_ptr()->num_fixed_parameters_ = static_cast<int16_t>(value);
 }
 
 
@@ skipping 14 matching lines @@
 
 
 bool Function::is_optimizable() const {
   return OptimizableBit::decode(raw_ptr()->kind_tag_) &&
          (script() != Script::null()) &&
          !is_native();
 }
 
 
 void Function::set_is_optimizable(bool value) const {
-  uword bits = raw_ptr()->kind_tag_;
-  raw_ptr()->kind_tag_ = OptimizableBit::update(value, bits);
+  set_kind_tag(OptimizableBit::update(value, raw_ptr()->kind_tag_));
 }
 
 
 void Function::set_has_finally(bool value) const {
-  uword bits = raw_ptr()->kind_tag_;
-  raw_ptr()->kind_tag_ = HasFinallyBit::update(value, bits);
+  set_kind_tag(HasFinallyBit::update(value, raw_ptr()->kind_tag_));
 }
 
 
 void Function::set_is_native(bool value) const {
-  uword bits = raw_ptr()->kind_tag_;
-  raw_ptr()->kind_tag_ = NativeBit::update(value, bits);
+  set_kind_tag(NativeBit::update(value, raw_ptr()->kind_tag_));
 }
 
 
 void Function::set_is_abstract(bool value) const {
-  uword bits = raw_ptr()->kind_tag_;
-  raw_ptr()->kind_tag_ = AbstractBit::update(value, bits);
+  set_kind_tag(AbstractBit::update(value, raw_ptr()->kind_tag_));
 }
 
 
 intptr_t Function::NumParameters() const {
   return num_fixed_parameters() + NumOptionalParameters();
 }
 
 
 intptr_t Function::NumImplicitParameters() const {
   if (kind() == RawFunction::kConstructor) {
@@ skipping 7726 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart