diff --git a/hphp/runtime/base/type_array.cpp b/hphp/runtime/base/type_array.cpp
index ebd371abe..2c50d7cb8 100644
--- a/hphp/runtime/base/type_array.cpp
+++ b/hphp/runtime/base/type_array.cpp
@@ -538,7 +538,7 @@ Variant &Array::lvalAt(CVarRef key, ACCESSPARAMS_IMPL) {
 
 template<typename T>
 inline ALWAYS_INLINE
-CVarRef Array::setImpl(const T &key, CVarRef v) {
+void Array::setImpl(const T &key, CVarRef v) {
   if (!m_px) {
     ArrayData *data = ArrayData::Create(key, v);
     ArrayBase::operator=(data);
@@ -546,12 +546,11 @@ CVarRef Array::setImpl(const T &key, CVarRef v) {
     ArrayData *escalated = m_px->set(key, v, (m_px->getCount() > 1));
     if (escalated != m_px) ArrayBase::operator=(escalated);
   }
-  return v;
 }
 
 template<typename T>
 inline ALWAYS_INLINE
-CVarRef Array::setRefImpl(const T &key, CVarRef v) {
+void Array::setRefImpl(const T &key, CVarRef v) {
   if (!m_px) {
     ArrayData *data = ArrayData::CreateRef(key, v);
     ArrayBase::operator=(data);
@@ -560,12 +559,11 @@ CVarRef Array::setRefImpl(const T &key, CVarRef v) {
     ArrayData *escalated = m_px->setRef(key, v, (m_px->getCount() > 1));
     if (escalated != m_px) ArrayBase::operator=(escalated);
   }
-  return v;
 }
 
 template<typename T>
 inline ALWAYS_INLINE
-CVarRef Array::addImpl(const T &key, CVarRef v) {
+void Array::addImpl(const T &key, CVarRef v) {
   if (!m_px) {
     ArrayData *data = ArrayData::Create(key, v);
     ArrayBase::operator=(data);
@@ -573,70 +571,54 @@ CVarRef Array::addImpl(const T &key, CVarRef v) {
     ArrayData *escalated = m_px->add(key, v, (m_px->getCount() > 1));
     if (escalated != m_px) ArrayBase::operator=(escalated);
   }
-  return v;
 }
 
-CVarRef Array::set(int64_t   key, CVarRef v) {
-  return setImpl(key, v);
+void Array::set(int64_t key, CVarRef v) {
+  setImpl(key, v);
 }
 
-CVarRef Array::set(CStrRef key, CVarRef v, bool isKey /* = false */) {
+void Array::set(CStrRef key, CVarRef v, bool isKey /* = false */) {
   if (isKey) return setImpl(key, v);
-  return setImpl(key.toKey(), v);
+  setImpl(key.toKey(), v);
 }
 
-CVarRef Array::set(CVarRef key, CVarRef v, bool isKey /* = false */) {
-  if (key.getRawType() == KindOfInt64) {
-    return setImpl(key.getNumData(), v);
-  }
+void Array::set(CVarRef key, CVarRef v, bool isKey /* = false */) {
+  if (key.getRawType() == KindOfInt64) return setImpl(key.getNumData(), v);
   if (isKey) return setImpl(key, v);
   VarNR k(key.toKey());
-  if (!k.isNull()) {
-    return setImpl(k, v);
-  }
-  return Variant::lvalBlackHole();
+  if (!k.isNull()) setImpl(k, v);
 }
 
-CVarRef Array::setRef(int64_t   key, CVarRef v) {
-  return setRefImpl(key, v);
+void Array::setRef(int64_t key, CVarRef v) {
+  setRefImpl(key, v);
 }
 
-CVarRef Array::setRef(CStrRef key, CVarRef v, bool isKey /* = false */) {
+void Array::setRef(CStrRef key, CVarRef v, bool isKey /* = false */) {
   if (isKey) return setRefImpl(key, v);
-  return setRefImpl(key.toKey(), v);
+  setRefImpl(key.toKey(), v);
 }
 
-CVarRef Array::setRef(CVarRef key, CVarRef v, bool isKey /* = false */) {
-  if (key.getRawType() == KindOfInt64) {
-    return setRefImpl(key.getNumData(), v);
-  }
+void Array::setRef(CVarRef key, CVarRef v, bool isKey /* = false */) {
+  if (key.getRawType() == KindOfInt64) return setRefImpl(key.getNumData(), v);
   if (isKey) return setRefImpl(key, v);
   VarNR k(key.toKey());
-  if (!k.isNull()) {
-    return setRefImpl<Variant>(k, v);
-  }
-  return Variant::lvalBlackHole();
+  if (!k.isNull()) setRefImpl<Variant>(k, v);
 }
 
-CVarRef Array::add(int64_t   key, CVarRef v) {
-  return addImpl(key, v);
+void Array::add(int64_t key, CVarRef v) {
+  addImpl(key, v);
 }
 
-CVarRef Array::add(CStrRef key, CVarRef v, bool isKey /* = false */) {
+void Array::add(CStrRef key, CVarRef v, bool isKey /* = false */) {
   if (isKey) return addImpl(key, v);
-  return addImpl(key.toKey(), v);
+  addImpl(key.toKey(), v);
 }
 
-CVarRef Array::add(CVarRef key, CVarRef v, bool isKey /* = false */) {
-  if (key.getRawType() == KindOfInt64) {
-    return addImpl(key.getNumData(), v);
-  }
+void Array::add(CVarRef key, CVarRef v, bool isKey /* = false */) {
+  if (key.getRawType() == KindOfInt64) return addImpl(key.getNumData(), v);
   if (isKey) return addImpl(key, v);
   VarNR k(key.toKey());
-  if (!k.isNull()) {
-    return addImpl(k, v);
-  }
-  return Variant::lvalBlackHole();
+  if (!k.isNull()) addImpl(k, v);
 }
 
 Variant &Array::addLval(CStrRef key, bool isKey /* = false */) {
diff --git a/hphp/runtime/base/type_array.h b/hphp/runtime/base/type_array.h
index 4b080bdb9..cec27e3dc 100644
--- a/hphp/runtime/base/type_array.h
+++ b/hphp/runtime/base/type_array.h
@@ -320,59 +320,45 @@ class Array : protected SmartPtr<ArrayData> {
 
   // defined in type_variant.h
   template<typename T>
-  CVarRef setImpl(const T &key, CVarRef v);
+  void setImpl(const T &key, CVarRef v);
   template<typename T>
-  CVarRef setRefImpl(const T &key, CVarRef v);
+  void setRefImpl(const T &key, CVarRef v);
 
-  CVarRef set(int     key, CVarRef v) {
-    return set((int64_t)key, v);
-  }
-  CVarRef set(int64_t   key, CVarRef v);
-  CVarRef set(double  key, CVarRef v) {
-    return set(ToKey(key), v);
-  }
+  void set(int key, CVarRef v) { set(int64_t(key), v); }
+  void set(int64_t key, CVarRef v);
+  void set(double  key, CVarRef v) = delete;
 
-  CVarRef set(CStrRef key, CVarRef v, bool isKey = false);
-  CVarRef set(CVarRef key, CVarRef v, bool isKey = false);
+  void set(CStrRef key, CVarRef v, bool isKey = false);
+  void set(CVarRef key, CVarRef v, bool isKey = false);
 
-  CVarRef set(char    key, RefResult v) { return setRef(key,variant(v)); }
-  CVarRef set(short   key, RefResult v) { return setRef(key,variant(v)); }
-  CVarRef set(int     key, RefResult v) { return setRef(key,variant(v)); }
-  CVarRef set(int64_t   key, RefResult v) { return setRef(key,variant(v)); }
-  CVarRef set(double  key, RefResult v) { return setRef(key,variant(v)); }
+  void set(char    key, RefResult v) { setRef(key,variant(v)); }
+  void set(short   key, RefResult v) { setRef(key,variant(v)); }
+  void set(int     key, RefResult v) { setRef(key,variant(v)); }
+  void set(int64_t key, RefResult v) { setRef(key,variant(v)); }
+  void set(double  key, RefResult v) = delete;
 
-  CVarRef set(CStrRef key, RefResult v, bool isKey = false) {
+  void set(CStrRef key, RefResult v, bool isKey = false) {
     return setRef(key,variant(v), isKey);
   }
-  CVarRef set(CVarRef key, RefResult v, bool isKey = false) {
+  void set(CVarRef key, RefResult v, bool isKey = false) {
     return setRef(key,variant(v), isKey);
   }
 
-  CVarRef setRef(int     key, CVarRef v) {
-    return setRef((int64_t)key, v);
-  }
-  CVarRef setRef(int64_t   key, CVarRef v);
-  CVarRef setRef(double  key, CVarRef v) {
-    return setRef(ToKey(key), v);
-  }
-
-  CVarRef setRef(CStrRef key, CVarRef v, bool isKey = false);
-  CVarRef setRef(CVarRef key, CVarRef v, bool isKey = false);
+  void setRef(int     key, CVarRef v) { setRef(int64_t(key), v); }
+  void setRef(int64_t key, CVarRef v);
+  void setRef(double  key, CVarRef v) = delete;
+  void setRef(CStrRef key, CVarRef v, bool isKey = false);
+  void setRef(CVarRef key, CVarRef v, bool isKey = false);
 
   // defined in type_variant.h
   template<typename T>
-  CVarRef addImpl(const T &key, CVarRef v);
+  void addImpl(const T &key, CVarRef v);
 
-  CVarRef add(int     key, CVarRef v) {
-    return add((int64_t)key, v);
-  }
-  CVarRef add(int64_t   key, CVarRef v);
-  CVarRef add(double  key, CVarRef v) {
-    return add(ToKey(key), v);
-  }
-
-  CVarRef add(CStrRef key, CVarRef v, bool isKey = false);
-  CVarRef add(CVarRef key, CVarRef v, bool isKey = false);
+  void add(int     key, CVarRef v) { add(int64_t(key), v); }
+  void add(int64_t key, CVarRef v);
+  void add(double  key, CVarRef v) = delete;
+  void add(CStrRef key, CVarRef v, bool isKey = false);
+  void add(CVarRef key, CVarRef v, bool isKey = false);
 
   // defined in type_variant.h
   template<typename T>