Add DISALLOW_COPY_AND_ASSIGN to subclasses of ValueObject and make ValueObject copyable.

runtime/vm/intermediate_language.h

 // Copyright (c) 2013, 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_INTERMEDIATE_LANGUAGE_H_
 #define VM_INTERMEDIATE_LANGUAGE_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/growable_array.h"
@@ skipping 100 matching lines @@
 //      is guaranteed to be sub type of this type.
 //
 // Values of CompileType form a lattice with a None type as a bottom and a
 // nullable Dynamic type as a top element. Method Union provides a join
 // operation for the lattice.
 class CompileType : public ValueObject {
  public:
   static const bool kNullable = true;
   static const bool kNonNullable = false;
 
-  CompileType(const CompileType& other)
-      : ValueObject(),
-        is_nullable_(other.is_nullable_),
-        cid_(other.cid_),
-        type_(other.type_) { }
-
-  CompileType& operator=(const CompileType& other) {
-    is_nullable_ = other.is_nullable_;
-    cid_ = other.cid_;
-    type_ =  other.type_;
-    return *this;
-  }
-
   // Return type such that concrete value's type in runtime is guaranteed to
   // be subtype of it.
   const AbstractType* ToAbstractType();
 
   // Return class id such that it is either kDynamicCid or in runtime
   // value is guaranteed to have an equal class id.
   intptr_t ToCid();
 
   // Return class id such that it is either kDynamicCid or in runtime
   // value is guaranteed to be either null or have an equal class id.
@@ skipping 872 matching lines @@
   bool Done() const { return current_ == NULL; }
 
   // Removes 'current_' from graph and sets 'current_' to previous instruction.
   void RemoveCurrentFromGraph();
 
   Instruction* Current() const { return current_; }
 
  private:
   BlockEntryInstr* block_entry_;
   Instruction* current_;
+
+  DISALLOW_COPY_AND_ASSIGN(ForwardInstructionIterator);
 };
 
 
 class BackwardInstructionIterator : public ValueObject {
  public:
   explicit BackwardInstructionIterator(BlockEntryInstr* block_entry)
       : block_entry_(block_entry), current_(block_entry->last_instruction()) {
     ASSERT(block_entry_->previous() == NULL);
   }
 
   void Advance() {
     ASSERT(!Done());
     current_ = current_->previous();
   }
 
   bool Done() const { return current_ == block_entry_; }
 
   Instruction* Current() const { return current_; }
 
  private:
   BlockEntryInstr* block_entry_;
   Instruction* current_;
+
+  DISALLOW_COPY_AND_ASSIGN(BackwardInstructionIterator);
 };
 
 
 class GraphEntryInstr : public BlockEntryInstr {
  public:
   GraphEntryInstr(const ParsedFunction& parsed_function,
                   TargetEntryInstr* normal_entry);
 
   DECLARE_INSTRUCTION(GraphEntry)
 
@@ skipping 107 matching lines @@
     return (phis_ == NULL) || (index_ >= phis_->length());
   }
 
   PhiInstr* Current() const {
     return (*phis_)[index_];
   }
 
  private:
   ZoneGrowableArray<PhiInstr*>* phis_;
   intptr_t index_;
+
+  DISALLOW_COPY_AND_ASSIGN(PhiIterator);
 };
 
 
 class TargetEntryInstr : public BlockEntryInstr {
  public:
   TargetEntryInstr(intptr_t block_id, intptr_t try_index)
       : BlockEntryInstr(block_id, try_index),
         predecessor_(NULL),
         catch_try_index_(CatchClauseNode::kInvalidTryIndex),
         catch_handler_types_(Array::ZoneHandle()) { }
@@ skipping 613 matching lines @@
   LocationSummary* locs_;
 };
 
 
 class RangeBoundary : public ValueObject {
  public:
   enum Kind { kUnknown, kSymbol, kConstant };
 
   RangeBoundary() : kind_(kUnknown), value_(0), offset_(0) { }
 
-  RangeBoundary(const RangeBoundary& other)
-      : ValueObject(),
-        kind_(other.kind_),
-        value_(other.value_),
-        offset_(other.offset_) { }
-
-  RangeBoundary& operator=(const RangeBoundary& other) {
-    kind_ = other.kind_;
-    value_ = other.value_;
-    offset_ = other.offset_;
-    return *this;
-  }
-
   static RangeBoundary FromConstant(intptr_t val) {
     return RangeBoundary(kConstant, val, 0);
   }
 
   static RangeBoundary FromDefinition(Definition* defn, intptr_t offs = 0);
 
   static RangeBoundary MinSmi() {
     return FromConstant(Smi::kMinValue);
   }
 
@@ skipping 2494 matching lines @@
 #undef DECLARE_INSTRUCTION
 
 class Environment : public ZoneAllocated {
  public:
   // Iterate the non-NULL values in the innermost level of an environment.
   class ShallowIterator : public ValueObject {
    public:
     explicit ShallowIterator(Environment* environment)
         : environment_(environment), index_(0) { }
 
-    ShallowIterator(const ShallowIterator& other)
-        : ValueObject(),
-          environment_(other.environment_),
-          index_(other.index_) { }
-
-    ShallowIterator& operator=(const ShallowIterator& other) {
-      environment_ = other.environment_;
-      index_ = other.index_;
-      return *this;
-    }
-
     Environment* environment() const { return environment_; }
 
     void Advance() {
       ASSERT(!Done());
       ++index_;
     }
 
     bool Done() const {
       return (environment_ == NULL) || (index_ >= environment_->Length());
     }
@@ skipping 62 matching lines @@
     }
 
    private:
     void SkipDone() {
       while (!Done() && iterator_.Done()) {
         iterator_ = ShallowIterator(iterator_.environment()->outer());
       }
     }
 
     ShallowIterator iterator_;
+
+    DISALLOW_COPY_AND_ASSIGN(DeepIterator);
   };
 
   // Construct an environment by constructing uses from an array of definitions.
   static Environment* From(const GrowableArray<Definition*>& definitions,
                            intptr_t fixed_parameter_count,
                            const Function& function);
 
   void set_locations(Location* locations) {
     ASSERT(locations_ == NULL);
     locations_ = locations;
@@ skipping 106 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_