Clear the handle returned by HashTable::Release in ~HashTable.

runtime/vm/hash_table.h

 // Copyright (c) 2014, 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_HASH_TABLE_H_
 #define VM_HASH_TABLE_H_
 
 // Temporarily used when sorting the indices in EnumIndexHashTable.
 // TODO(koda): Remove these dependencies before using in production.
 #include <map>
@@ skipping 26 matching lines @@
 //  - UnorderedHashSet
 //  - EnumIndexHashSet
 //  - LinkedListHashSet
 // Each of these can be finally specialized with KeyTraits to support any set of
 // lookup key types (e.g., look up a char* in a set of String objects), and
 // any equality and hash code computation.
 //
 // The classes all wrap an Array handle, and metods like HashSet::Insert can
 // trigger growth into a new RawArray, updating the handle. Debug mode asserts
 // that 'Release' was called once to access the final array before destruction.
+// NOTE: The handle returned by 'Release' is cleared by ~HashTable.
 //
 // Example use:
 //  typedef UnorderedHashMap<FooTraits> FooMap;
 //  ...
 //  FooMap cache(get_foo_cache());
 //  cache.UpdateOrInsert(name0, obj0);
 //  cache.UpdateOrInsert(name1, obj1);
 //  ...
 //  set_foo_cache(cache.Release());
 //
@@ skipping 26 matching lines @@
 template<typename KeyTraits, intptr_t kPayloadSize, intptr_t kMetaDataSize>
 class HashTable : public ValueObject {
  public:
   typedef KeyTraits Traits;
   // Uses 'isolate' for handle allocation. 'Release' must be called at the end
   // to obtain the final table after potential growth/shrinkage.
   HashTable(Isolate* isolate, RawArray* data)
       : isolate_(isolate),
         key_handle_(Object::Handle(isolate_)),
         smi_handle_(Smi::Handle(isolate_)),
-        data_(&Array::Handle(isolate_, data)) {}
+        data_(&Array::Handle(isolate_, data)),
+        released_data_(NULL) {}
   // Like above, except uses current isolate.
   explicit HashTable(RawArray* data)
       : isolate_(Isolate::Current()),
         key_handle_(Object::Handle(isolate_)),
         smi_handle_(Smi::Handle(isolate_)),
-        data_(&Array::Handle(isolate_, data)) {}
+        data_(&Array::Handle(isolate_, data)),
+        released_data_(NULL) {}
 
+  // Returns the final table. The handle is cleared when this HashTable is
+  // destroyed.
   Array& Release() {
     ASSERT(data_ != NULL);
-    Array* result = data_;
+    ASSERT(released_data_ == NULL);
     // Ensure that no methods are called after 'Release'.
+    released_data_ = data_;
     data_ = NULL;
-    return *result;
+    return *released_data_;
   }
 
   ~HashTable() {
-    // Ensure that 'Release' was called.
+    // In DEBUG mode, calling 'Release' is mandatory.
     ASSERT(data_ == NULL);
+    if (released_data_ != NULL) {
+      *released_data_ = Array::null();
+    }
   }
 
   // Returns a backing storage size such that 'num_occupied' distinct keys can
   // be inserted into the table.
   static intptr_t ArrayLengthForNumOccupied(intptr_t num_occupied) {
     // The current invariant requires at least one unoccupied entry.
     // TODO(koda): Adjust if moving to quadratic probing.
     intptr_t num_entries = num_occupied + 1;
     return kFirstKeyIndex + (kEntrySize * num_entries);
   }
@@ skipping 176 matching lines @@
 
   void AdjustSmiValueAt(intptr_t index, intptr_t delta) const {
     SetSmiValueAt(index, (GetSmiValueAt(index) + delta));
   }
 
   Isolate* isolate() const { return isolate_; }
 
   Isolate* isolate_;
   Object& key_handle_;
   Smi& smi_handle_;
-  // This is a pointer rather than a reference, to enable Release nulling it,
-  // preventing post-Release modification.
+  // Exactly one of these is non-NULL, depending on whether Release was called.
   Array* data_;
+  Array* released_data_;
 
   friend class HashTables;
 };
 
 
 // Table with unspecified iteration order. No payload overhead or metadata.
 template<typename KeyTraits, intptr_t kUserPayloadSize>
 class UnorderedHashTable : public HashTable<KeyTraits, kUserPayloadSize, 0> {
  public:
   typedef HashTable<KeyTraits, kUserPayloadSize, 0> BaseTable;
@@ skipping 361 matching lines @@
 class EnumIndexHashSet : public HashSet<EnumIndexHashTable<KeyTraits, 0> > {
  public:
   typedef HashSet<EnumIndexHashTable<KeyTraits, 0> > BaseSet;
   explicit EnumIndexHashSet(RawArray* data) : BaseSet(data) {}
   EnumIndexHashSet(Isolate* isolate, RawArray* data) : BaseSet(isolate, data) {}
 };
 
 }  // namespace dart
 
 #endif  // VM_HASH_TABLE_H_