diff --git a/hphp/runtime/base/array-init.h b/hphp/runtime/base/array-init.h
index 9a14d4ec4..967aa0298 100644
--- a/hphp/runtime/base/array-init.h
+++ b/hphp/runtime/base/array-init.h
@@ -21,66 +21,9 @@
 #include "hphp/runtime/base/hphp-array.h"
 
 namespace HPHP {
-///////////////////////////////////////////////////////////////////////////////
-// macros for creating vectors or maps
 
-#define CREATE_VECTOR1(e)                                               \
-  PackedArrayInit(1).add(e).toArray()
-#define CREATE_VECTOR2(e1, e2)                                          \
-  PackedArrayInit(2).add(e1).add(e2).toArray()
-#define CREATE_VECTOR3(e1, e2, e3)                                      \
-  PackedArrayInit(3).add(e1).add(e2).add(e3).toArray()
-#define CREATE_VECTOR4(e1, e2, e3, e4)                                  \
-  PackedArrayInit(4).add(e1).add(e2).add(e3).add(e4).toArray()
-#define CREATE_VECTOR5(e1, e2, e3, e4, e5)                              \
-  PackedArrayInit(5).add(e1).add(e2).add(e3).add(e4).add(e5).toArray()
-#define CREATE_VECTOR6(e1, e2, e3, e4, e5, e6)                          \
-  PackedArrayInit(6).add(e1).add(e2).add(e3).add(e4).add(e5).add(e6).toArray()
+//////////////////////////////////////////////////////////////////////
 
-inline String initkey(const char* s) { return String(s); }
-inline int64_t initkey(int k) { return k; }
-inline int64_t initkey(int64_t k) { return k; }
-inline CStrRef initkey(CStrRef k) { return k; }
-
-#define CREATE_MAP1(n, e) Array(ArrayInit(1).set(initkey(n), e).create())
-#define CREATE_MAP2(n1, e1, n2, e2)\
-  Array(ArrayInit(2).set(initkey(n1), e1)\
-                    .set(initkey(n2), e2).create())
-#define CREATE_MAP3(n1, e1, n2, e2, n3, e3)\
-  Array(ArrayInit(3).set(initkey(n1), e1)\
-                    .set(initkey(n2), e2)\
-                    .set(initkey(n3), e3).create())
-#define CREATE_MAP4(n1, e1, n2, e2, n3, e3, n4, e4)\
-  Array(ArrayInit(4).set(initkey(n1), e1)\
-                    .set(initkey(n2), e2)\
-                    .set(initkey(n3), e3)\
-                    .set(initkey(n4), e4).create())
-#define CREATE_MAP5(n1, e1, n2, e2, n3, e3, n4, e4, n5, e5)\
-  Array(ArrayInit(5).set(initkey(n1), e1)\
-                    .set(initkey(n2), e2)\
-                    .set(initkey(n3), e3)\
-                    .set(initkey(n4), e4)\
-                    .set(initkey(n5), e5).create())
-#define CREATE_MAP6(n1, e1, n2, e2, n3, e3, n4, e4, n5, e5, n6, e6)\
-  Array(ArrayInit(6).set(initkey(n1), e1)\
-                    .set(initkey(n2), e2)\
-                    .set(initkey(n3), e3)\
-                    .set(initkey(n4), e4)\
-                    .set(initkey(n5), e5)\
-                    .set(initkey(n6), e6).create())
-
-///////////////////////////////////////////////////////////////////////////////
-// ArrayInit
-
-/**
- * When an Array is created, ArrayInit completely skips the use of
- * ArrayElement, (the set methods mimic the constructors of ArrayElement).
- * The setRef method handles the case where the value needs to be a reference.
- *
- * For arrays that need to have C++ references/pointers to their elements for
- * an extended period of time, set keepRef to true, so that there will not
- * be reference-breaking escalation.
- */
 class ArrayInit {
 public:
   enum MapInit { mapInit };
@@ -300,6 +243,8 @@ private:
   ArrayData* m_data;
 };
 
+//////////////////////////////////////////////////////////////////////
+
 /*
  * Initializer for a vector-shaped array.
  */
@@ -358,7 +303,69 @@ private:
   HphpArray* m_vec;
 };
 
-///////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////
+
+namespace make_array_detail {
+
+  inline void packed_impl(PackedArrayInit&) {}
+
+  template<class Val, class... Vals>
+  void packed_impl(PackedArrayInit& init, Val&& val, Vals&&... vals) {
+    init.add(std::forward<Val>(val));
+    packed_impl(init, std::forward<Vals>(vals)...);
+  }
+
+  inline String init_key(const char* s) { return String(s); }
+  inline int64_t init_key(int k) { return k; }
+  inline int64_t init_key(int64_t k) { return k; }
+  inline CStrRef init_key(CStrRef k) { return k; }
+
+  inline void map_impl(ArrayInit&) {}
+
+  template<class Key, class Val, class... KVPairs>
+  void map_impl(ArrayInit& init, Key&& key, Val&& val, KVPairs&&... kvpairs) {
+    init.set(init_key(std::forward<Key>(key)), std::forward<Val>(val));
+    map_impl(init, std::forward<KVPairs>(kvpairs)...);
+  }
+
 }
 
-#endif /* incl_HPHP_ARRAY_INIT_H_ */
+/*
+ * Helper for creating packed arrays (vector-like).
+ *
+ * Usage:
+ *
+ *   auto newArray = make_packed_array(1, 2, 3, 4);
+ *
+ */
+template<class... Vals>
+Array make_packed_array(Vals&&... vals) {
+  PackedArrayInit init(sizeof...(vals));
+  make_array_detail::packed_impl(init, std::forward<Vals>(vals)...);
+  return init.toArray();
+}
+
+/*
+ * Helper for creating map-like arrays (kMixedKind).  Takes pairs of
+ * arguments for the keys and values.
+ *
+ * Usage:
+ *
+ *   auto newArray = make_map_array(keyOne, valueOne,
+ *                                  otherKey, otherValue);
+ *
+ */
+template<class... KVPairs>
+Array make_map_array(KVPairs&&... kvpairs) {
+  static_assert(
+    sizeof...(kvpairs) % 2 == 0, "make_map_array needs key value pairs");
+  ArrayInit init(sizeof...(kvpairs) / 2);
+  make_array_detail::map_impl(init, std::forward<KVPairs>(kvpairs)...);
+  return init.toArray();
+}
+
+//////////////////////////////////////////////////////////////////////
+
+}
+
+#endif
diff --git a/hphp/runtime/base/builtin-functions.cpp b/hphp/runtime/base/builtin-functions.cpp
index 4bc19b331..64b85257d 100644
--- a/hphp/runtime/base/builtin-functions.cpp
+++ b/hphp/runtime/base/builtin-functions.cpp
@@ -1094,7 +1094,7 @@ AutoloadHandler::Result AutoloadHandler::loadFromMap(CStrRef name,
     //  - true means the map was updated. try again
     //  - false means we should stop applying autoloaders (only affects classes)
     //  - anything else means keep going
-    Variant action = vm_call_user_func(func, CREATE_VECTOR2(kind, name));
+    Variant action = vm_call_user_func(func, make_packed_array(kind, name));
     auto const actionCell = action.asCell();
     if (actionCell->m_type == KindOfBoolean) {
       if (actionCell->m_data.num) continue;
@@ -1199,7 +1199,7 @@ bool AutoloadHandler::addHandler(CVarRef handler, bool prepend) {
     m_handlers.add(name, handler, true);
   } else {
     // This adds the handler at the beginning
-    m_handlers = CREATE_MAP1(name, handler) + m_handlers;
+    m_handlers = make_map_array(name, handler) + m_handlers;
   }
   return true;
 }
diff --git a/hphp/runtime/base/bzip2-file.cpp b/hphp/runtime/base/bzip2-file.cpp
index 298ba7b61..ab3616709 100644
--- a/hphp/runtime/base/bzip2-file.cpp
+++ b/hphp/runtime/base/bzip2-file.cpp
@@ -74,7 +74,7 @@ Variant BZ2File::error() {
   int errnum;
   const char * errstr;
   errstr = BZ2_bzerror(m_bzFile, &errnum);
-  return CREATE_MAP2(s_errno, errnum, s_errstr, String(errstr));
+  return make_map_array(s_errno, errnum, s_errstr, String(errstr));
 }
 
 bool BZ2File::flush() {
diff --git a/hphp/runtime/base/execution-context.cpp b/hphp/runtime/base/execution-context.cpp
index 0ef80d595..601fd7002 100644
--- a/hphp/runtime/base/execution-context.cpp
+++ b/hphp/runtime/base/execution-context.cpp
@@ -286,7 +286,7 @@ bool BaseExecutionContext::obFlush() {
         try {
           Variant tout =
             vm_call_user_func(last->handler,
-                                   CREATE_VECTOR2(last->oss.detach(), flag));
+                                   make_packed_array(last->oss.detach(), flag));
           prev->oss.append(tout.toString());
           last->oss.clear();
         } catch (...) {
@@ -300,7 +300,7 @@ bool BaseExecutionContext::obFlush() {
       try {
         Variant tout =
           vm_call_user_func(last->handler,
-                                 CREATE_VECTOR2(last->oss.detach(), flag));
+                                 make_packed_array(last->oss.detach(), flag));
         String sout = tout.toString();
         writeStdout(sout.data(), sout.size());
         last->oss.clear();
@@ -420,7 +420,7 @@ void BaseExecutionContext::resetCurrentBuffer() {
 void BaseExecutionContext::registerShutdownFunction(CVarRef function,
                                                     Array arguments,
                                                     ShutdownType type) {
-  Array callback = CREATE_MAP2(s_name, function, s_args, arguments);
+  Array callback = make_map_array(s_name, function, s_args, arguments);
   Variant &funcs = m_shutdowns.lvalAt(type);
   funcs.append(callback);
 }
@@ -670,7 +670,7 @@ bool BaseExecutionContext::callUserErrorHandler(const Exception &e, int errnum,
       ErrorStateHelper esh(this, ErrorState::ExecutingUserHandler);
       if (!same(vm_call_user_func
                 (m_userErrorHandlers.back().first,
-                 CREATE_VECTOR6(errnum, String(e.getMessage()), errfile,
+                 make_packed_array(errnum, String(e.getMessage()), errfile,
                                 errline, "", backtrace)),
                 false)) {
         return true;
@@ -730,7 +730,7 @@ bool BaseExecutionContext::onUnhandledException(Object e) {
     if (!m_userExceptionHandlers.empty()) {
       if (!same(vm_call_user_func
                 (m_userExceptionHandlers.back(),
-                 CREATE_VECTOR1(e)),
+                 make_packed_array(e)),
                 false)) {
         return true;
       }
diff --git a/hphp/runtime/base/intercept.cpp b/hphp/runtime/base/intercept.cpp
index 9143008c2..4e7b1c8f7 100644
--- a/hphp/runtime/base/intercept.cpp
+++ b/hphp/runtime/base/intercept.cpp
@@ -98,7 +98,7 @@ bool register_intercept(CStrRef name, CVarRef callback, CVarRef data) {
 
   EventHook::EnableIntercept();
 
-  Array handler = CREATE_VECTOR2(callback, data);
+  Array handler = make_packed_array(callback, data);
 
   if (name.empty()) {
     s_intercept_data->m_global_handler = handler;
diff --git a/hphp/runtime/base/program-functions.cpp b/hphp/runtime/base/program-functions.cpp
index aec4bf223..2b9ab1217 100644
--- a/hphp/runtime/base/program-functions.cpp
+++ b/hphp/runtime/base/program-functions.cpp
@@ -336,7 +336,7 @@ static void handle_exception_helper(bool& ret,
         !context->getExitCallback().isNull() &&
         f_is_callable(context->getExitCallback())) {
       Array stack = e.getBackTrace();
-      Array argv = CREATE_VECTOR2(e.ExitCode, stack);
+      Array argv = make_packed_array(e.ExitCode, stack);
       vm_call_user_func(context->getExitCallback(), argv);
     }
   } catch (const PhpFileDoesNotExistException &e) {
diff --git a/hphp/runtime/base/user-file.cpp b/hphp/runtime/base/user-file.cpp
index ed3ed42a9..b6fa452eb 100644
--- a/hphp/runtime/base/user-file.cpp
+++ b/hphp/runtime/base/user-file.cpp
@@ -121,7 +121,7 @@ Variant UserFile::invoke(const Func *func, CStrRef name,
     {
       Variant ret;
       g_vmContext->invokeFunc(ret.asTypedValue(), func,
-                              CREATE_VECTOR2(name, args), m_obj.get());
+                              make_packed_array(name, args), m_obj.get());
       success = true;
       return ret;
     }
@@ -154,7 +154,7 @@ bool UserFile::open(CStrRef filename, CStrRef mode) {
   // bool stream_open($path, $mode, $options, &$opened_path)
   bool success = false;
   Variant opened_path;
-  Variant ret = invoke(m_StreamOpen, s_stream_open, CREATE_VECTOR4(
+  Variant ret = invoke(m_StreamOpen, s_stream_open, make_packed_array(
                        filename, mode, m_options, ref(opened_path)), success);
   if (success && (ret.toBoolean() == true)) {
     return true;
@@ -181,7 +181,7 @@ int64_t UserFile::readImpl(char *buffer, int64_t length) {
   // String stread_read($count)
   bool success = false;
   String str = invoke(m_StreamRead, s_stream_read,
-                      CREATE_VECTOR1(length), success);
+                      make_packed_array(length), success);
   if (!success) {
     raise_warning("%s::stream_read is not implemented",
                   m_cls->name()->data());
@@ -205,7 +205,7 @@ int64_t UserFile::writeImpl(const char *buffer, int64_t length) {
   // stream_write($data)
   bool success = false;
   int64_t didWrite = invoke(m_StreamWrite, s_stream_write,
-                          CREATE_VECTOR1(String(buffer, length, CopyString)),
+                          make_packed_array(String(buffer, length, CopyString)),
                           success).toInt64();
   if (!success) {
     raise_warning("%s::stream_write is not implemented",
@@ -230,7 +230,7 @@ bool UserFile::seek(int64_t offset, int whence /* = SEEK_SET */) {
   // bool stream_seek($offset, $whence)
   bool success = false;
   bool sought  = invoke(m_StreamSeek, s_stream_seek,
-                        CREATE_VECTOR2(offset, whence), success).toBoolean();
+                        make_packed_array(offset, whence), success).toBoolean();
   return success ? sought : false;
 }
 
@@ -285,7 +285,7 @@ bool UserFile::lock(int operation, bool &wouldBlock) {
   // bool stream_lock(int $operation)
   bool success = false;
   Variant ret = invoke(m_StreamLock, s_stream_lock,
-                       CREATE_VECTOR1(op), success);
+                       make_packed_array(op), success);
   if (!success) {
     if (operation) {
       raise_warning("%s::stream_lock is not implemented!",
diff --git a/hphp/runtime/debugger/cmd/cmd_machine.cpp b/hphp/runtime/debugger/cmd/cmd_machine.cpp
index c429ecd0c..3ae01af23 100644
--- a/hphp/runtime/debugger/cmd/cmd_machine.cpp
+++ b/hphp/runtime/debugger/cmd/cmd_machine.cpp
@@ -196,7 +196,7 @@ void CmdMachine::UpdateIntercept(DebuggerClient &client,
                                  const std::string &host, int port) {
   CmdMachine cmd;
   cmd.m_body = "rpc";
-  cmd.m_rpcConfig = CREATE_MAP4
+  cmd.m_rpcConfig = make_map_array
     (s_host, String(host),
      s_port, port ? port : RuntimeOption::DebuggerDefaultRpcPort,
      s_auth, String(RuntimeOption::DebuggerDefaultRpcAuth),
diff --git a/hphp/runtime/ext/asio/asio_session.cpp b/hphp/runtime/ext/asio/asio_session.cpp
index 90143b213..4f883da7d 100644
--- a/hphp/runtime/ext/asio/asio_session.cpp
+++ b/hphp/runtime/ext/asio/asio_session.cpp
@@ -100,7 +100,7 @@ void AsioSession::onContinuationYield(c_ContinuationWaitHandle* cont, c_WaitHand
   try {
     vm_call_user_func(
       m_onContinuationYieldCallback,
-      CREATE_VECTOR2(cont, child));
+      make_packed_array(cont, child));
   } catch (const Object& callback_exception) {
     raise_warning("[asio] Ignoring exception thrown by ContinuationWaitHandle::onYield callback");
   }
@@ -111,7 +111,7 @@ void AsioSession::onContinuationSuccess(c_ContinuationWaitHandle* cont, CVarRef
   try {
     vm_call_user_func(
       m_onContinuationSuccessCallback,
-      CREATE_VECTOR2(cont, result));
+      make_packed_array(cont, result));
   } catch (const Object& callback_exception) {
     raise_warning("[asio] Ignoring exception thrown by ContinuationWaitHandle::onSuccess callback");
   }
@@ -122,7 +122,7 @@ void AsioSession::onContinuationFail(c_ContinuationWaitHandle* cont, CObjRef exc
   try {
     vm_call_user_func(
       m_onContinuationFailCallback,
-      CREATE_VECTOR2(cont, exception));
+      make_packed_array(cont, exception));
   } catch (const Object& callback_exception) {
     raise_warning("[asio] Ignoring exception thrown by ContinuationWaitHandle::onFail callback");
   }
@@ -142,7 +142,7 @@ void AsioSession::onGenArrayCreate(c_GenArrayWaitHandle* wait_handle, CVarRef de
   try {
     vm_call_user_func(
       m_onGenArrayCreateCallback,
-      CREATE_VECTOR2(wait_handle, dependencies));
+      make_packed_array(wait_handle, dependencies));
   } catch (const Object& callback_exception) {
     raise_warning("[asio] Ignoring exception thrown by GenArrayWaitHandle::onCreate callback");
   }
@@ -153,7 +153,7 @@ void AsioSession::onGenMapCreate(c_GenMapWaitHandle* wait_handle, CVarRef depend
   try {
     vm_call_user_func(
       m_onGenMapCreateCallback,
-      CREATE_VECTOR2(wait_handle, dependencies));
+      make_packed_array(wait_handle, dependencies));
   } catch (const Object& callback_exception) {
     raise_warning("[asio] Ignoring exception thrown by GenMapWaitHandle::onCreate callback");
   }
@@ -164,7 +164,7 @@ void AsioSession::onGenVectorCreate(c_GenVectorWaitHandle* wait_handle, CVarRef
   try {
     vm_call_user_func(
       m_onGenVectorCreateCallback,
-      CREATE_VECTOR2(wait_handle, dependencies));
+      make_packed_array(wait_handle, dependencies));
   } catch (const Object& callback_exception) {
     raise_warning("[asio] Ignoring exception thrown by GenVectorWaitHandle::onCreate callback");
   }
@@ -175,7 +175,7 @@ void AsioSession::onSetResultToRefCreate(c_SetResultToRefWaitHandle* wait_handle
   try {
     vm_call_user_func(
       m_onSetResultToRefCreateCallback,
-      CREATE_VECTOR2(wait_handle, child));
+      make_packed_array(wait_handle, child));
   } catch (const Object& callback_exception) {
     raise_warning("[asio] Ignoring exception thrown by SetResultToRefWaitHandle::onCreate callback");
   }
diff --git a/hphp/runtime/ext/ext_apc.cpp b/hphp/runtime/ext/ext_apc.cpp
index 7a4b481f8..b908fa6e2 100644
--- a/hphp/runtime/ext/ext_apc.cpp
+++ b/hphp/runtime/ext/ext_apc.cpp
@@ -298,7 +298,7 @@ Variant f_apc_exists(CVarRef key, int64_t cache_id /* = 0 */) {
 const StaticString s_start_time("start_time");
 
 Variant f_apc_cache_info(int64_t cache_id /* = 0 */, bool limited /* = false */) {
-  return CREATE_MAP1(s_start_time, start_time());
+  return make_map_array(s_start_time, start_time());
 }
 
 Array f_apc_sma_info(bool limited /* = false */) {
diff --git a/hphp/runtime/ext/ext_array.cpp b/hphp/runtime/ext/ext_array.cpp
index a6a137890..71c406be1 100644
--- a/hphp/runtime/ext/ext_array.cpp
+++ b/hphp/runtime/ext/ext_array.cpp
@@ -842,7 +842,7 @@ Variant f_range(CVarRef low, CVarRef high, CVarRef step /* = 1 */) {
 
 static int cmp_func(CVarRef v1, CVarRef v2, const void *data) {
   Variant *callback = (Variant *)data;
-  return vm_call_user_func(*callback, CREATE_VECTOR2(v1, v2)).toInt32();
+  return vm_call_user_func(*callback, make_packed_array(v1, v2)).toInt32();
 }
 
 #define COMMA ,
diff --git a/hphp/runtime/ext/ext_curl.cpp b/hphp/runtime/ext/ext_curl.cpp
index 283610278..a970e5269 100644
--- a/hphp/runtime/ext/ext_curl.cpp
+++ b/hphp/runtime/ext/ext_curl.cpp
@@ -655,7 +655,7 @@ public:
       {
         int data_size = size * nmemb;
         Variant ret = ch->do_callback(
-          t->callback, CREATE_VECTOR3(Resource(ch), t->fp->fd(), data_size));
+          t->callback, make_packed_array(Resource(ch), t->fp->fd(), data_size));
         if (ret.isString()) {
           String sret = ret.toString();
           length = data_size < sret.size() ? data_size : sret.size();
@@ -687,7 +687,7 @@ public:
       {
         Variant ret = ch->do_callback(
           t->callback,
-          CREATE_VECTOR2(Resource(ch), String(data, length, CopyString)));
+          make_packed_array(Resource(ch), String(data, length, CopyString)));
         length = ret.toInt64();
       }
       break;
@@ -717,7 +717,7 @@ public:
       {
         Variant ret = ch->do_callback(
           t->callback,
-          CREATE_VECTOR2(Resource(ch), String(data, length, CopyString)));
+          make_packed_array(Resource(ch), String(data, length, CopyString)));
         length = ret.toInt64();
       }
       break;
diff --git a/hphp/runtime/ext/ext_error.cpp b/hphp/runtime/ext/ext_error.cpp
index f22cfd595..a06ab2170 100644
--- a/hphp/runtime/ext/ext_error.cpp
+++ b/hphp/runtime/ext/ext_error.cpp
@@ -121,7 +121,7 @@ Array f_error_get_last() {
   if (lastError.isNull()) {
     return (ArrayData *)NULL;
   }
-  return CREATE_MAP2(s_message, g_context->getLastError(),
+  return make_map_array(s_message, g_context->getLastError(),
                      s_type, g_context->getLastErrorNumber());
 }
 
diff --git a/hphp/runtime/ext/ext_fb.cpp b/hphp/runtime/ext/ext_fb.cpp
index b2b372b57..02e748be1 100644
--- a/hphp/runtime/ext/ext_fb.cpp
+++ b/hphp/runtime/ext/ext_fb.cpp
@@ -1196,9 +1196,9 @@ Variant f_fb_call_user_func_safe_return(int _argc, CVarRef function,
 
 Array f_fb_call_user_func_array_safe(CVarRef function, CArrRef params) {
   if (f_is_callable(function)) {
-    return CREATE_VECTOR2(true, vm_call_user_func(function, params));
+    return make_packed_array(true, vm_call_user_func(function, params));
   }
-  return CREATE_VECTOR2(false, uninit_null());
+  return make_packed_array(false, uninit_null());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/hphp/runtime/ext/ext_function.cpp b/hphp/runtime/ext/ext_function.cpp
index 5a55b64f7..fc2815341 100644
--- a/hphp/runtime/ext/ext_function.cpp
+++ b/hphp/runtime/ext/ext_function.cpp
@@ -39,7 +39,7 @@ const StaticString
   s_user("user");
 
 Array f_get_defined_functions() {
-  return CREATE_MAP2(s_internal, ClassInfo::GetSystemFunctions(),
+  return make_map_array(s_internal, ClassInfo::GetSystemFunctions(),
                      s_user, ClassInfo::GetUserFunctions());
 }
 
@@ -191,7 +191,7 @@ Variant f_call_user_func_rpc(int _argc, CStrRef host, int port, CStrRef auth,
   url += "/call_user_func_serialized?auth=";
   url += auth.data();
 
-  Array blob = CREATE_MAP2(s_func, function, s_args, _argv);
+  Array blob = make_map_array(s_func, function, s_args, _argv);
   String message = f_serialize(blob);
 
   vector<string> headers;
diff --git a/hphp/runtime/ext/ext_iconv.cpp b/hphp/runtime/ext/ext_iconv.cpp
index a4ce09acb..61543ef41 100644
--- a/hphp/runtime/ext/ext_iconv.cpp
+++ b/hphp/runtime/ext/ext_iconv.cpp
@@ -1685,7 +1685,7 @@ Variant f_iconv_mime_decode_headers(CStrRef encoded_headers,
       if (ret.exists(header)) {
         Variant elem = ret[header];
         if (!elem.is(KindOfArray)) {
-          ret.set(header, CREATE_VECTOR2(elem, value));
+          ret.set(header, make_packed_array(elem, value));
         } else {
           elem.append(value);
           ret.set(header, elem);
diff --git a/hphp/runtime/ext/ext_icu.cpp b/hphp/runtime/ext/ext_icu.cpp
index 8056f66b7..762b244d8 100644
--- a/hphp/runtime/ext/ext_icu.cpp
+++ b/hphp/runtime/ext/ext_icu.cpp
@@ -119,7 +119,7 @@ Variant f_icu_match(CStrRef pattern, CStrRef subject,
           }
 
           start = usubject.countChar32(0, start);
-          matches->append(CREATE_VECTOR2(match, start));
+          matches->append(make_packed_array(match, start));
         } else {
           matches->append(match);
         }
diff --git a/hphp/runtime/ext/ext_ldap.cpp b/hphp/runtime/ext/ext_ldap.cpp
index a32c35cb8..203d177ad 100644
--- a/hphp/runtime/ext/ext_ldap.cpp
+++ b/hphp/runtime/ext/ext_ldap.cpp
@@ -484,7 +484,7 @@ static int _ldap_rebind_proc(LDAP *ldap, const char *url, ber_tag_t req,
 
   /* callback */
   Variant ret = vm_call_user_func
-    (ld->rebindproc, CREATE_VECTOR2(Resource(ld), String(url, CopyString)));
+    (ld->rebindproc, make_packed_array(Resource(ld), String(url, CopyString)));
   return ret.toInt64();
 }
 
diff --git a/hphp/runtime/ext/ext_memcached.cpp b/hphp/runtime/ext/ext_memcached.cpp
index 9c73bab0c..211e7fb96 100644
--- a/hphp/runtime/ext/ext_memcached.cpp
+++ b/hphp/runtime/ext/ext_memcached.cpp
@@ -310,7 +310,7 @@ bool c_Memcached::t_getdelayedbykey(CStrRef server_key, CArrRef keys,
 
   MemcachedResultWrapper result(&m_impl->memcached); Array item;
   while (fetchImpl(result.value, item)) {
-    vm_call_user_func(value_cb, CREATE_VECTOR2(Variant(this), item));
+    vm_call_user_func(value_cb, make_packed_array(Variant(this), item));
   }
 
   if (m_impl->rescode != q_Memcached$$RES_END) return false;
@@ -392,7 +392,7 @@ bool c_Memcached::fetchImpl(memcached_result_st &result, Array &item) {
   String sKey(key, keyLength, CopyString);
   double cas = (double) memcached_result_cas(&result);
 
-  item = CREATE_MAP3(s_key, sKey, s_value, value, s_cas, cas);
+  item = make_map_array(s_key, sKey, s_value, value, s_cas, cas);
   return true;
 }
 
@@ -613,11 +613,11 @@ memcached_return_t doServerListCallback(const memcached_st *ptr,
   const char* hostname = LMCD_SERVER_HOSTNAME(server);
   in_port_t port = LMCD_SERVER_PORT(server);
 #ifdef LMCD_SERVER_QUERY_INCLUDES_WEIGHT
-  returnValue->append(CREATE_MAP3(s_host, String(hostname, CopyString),
+  returnValue->append(make_map_array(s_host, String(hostname, CopyString),
                                   s_port, (int32_t)port,
                                   s_weight, (int32_t)server->weight));
 #else
-  returnValue->append(CREATE_MAP2(s_host, String(hostname, CopyString),
+  returnValue->append(make_map_array(s_host, String(hostname, CopyString),
                                   s_port, (int32_t)port));
 #endif
   return MEMCACHED_SUCCESS;
@@ -649,11 +649,11 @@ Variant c_Memcached::t_getserverbykey(CStrRef server_key) {
   const char* hostname = LMCD_SERVER_HOSTNAME(server);
   in_port_t port = LMCD_SERVER_PORT(server);
 #ifdef LMCD_SERVER_QUERY_INCLUDES_WEIGHT
-  Array returnValue = CREATE_MAP3(s_host, String(hostname, CopyString),
+  Array returnValue = make_map_array(s_host, String(hostname, CopyString),
                                   s_port, (int32_t)port,
                                   s_weight, (int32_t)server->weight);
 #else
-  Array returnValue = CREATE_MAP2(s_host, String(hostname, CopyString),
+  Array returnValue = make_map_array(s_host, String(hostname, CopyString),
                                   s_port, (int32_t)port);
 #endif
   return returnValue;
diff --git a/hphp/runtime/ext/ext_misc.cpp b/hphp/runtime/ext/ext_misc.cpp
index 39f137887..003ff808e 100644
--- a/hphp/runtime/ext/ext_misc.cpp
+++ b/hphp/runtime/ext/ext_misc.cpp
@@ -252,7 +252,7 @@ Variant f_time_nanosleep(int seconds, int nanoseconds) {
     return true;
   }
   if (errno == EINTR) {
-    return CREATE_MAP2(s_seconds, (int64_t)rem.tv_sec,
+    return make_map_array(s_seconds, (int64_t)rem.tv_sec,
                        s_nanoseconds, (int64_t)rem.tv_nsec);
   }
   return false;
@@ -314,7 +314,7 @@ Variant f_unpack(CStrRef format, CStrRef data) {
 Array f_sys_getloadavg() {
   double load[3];
   getloadavg(load, 3);
-  return CREATE_VECTOR3(load[0], load[1], load[2]);
+  return make_packed_array(load[0], load[1], load[2]);
 }
 
 
@@ -329,7 +329,7 @@ Array f_token_get_all(CStrRef source) {
     if (tokid < 256) {
       res.append(String::FromChar((char)tokid));
     } else {
-      Array p = CREATE_VECTOR3(tokid, String(tok.text()), loc.line0);
+      Array p = make_packed_array(tokid, String(tok.text()), loc.line0);
       res.append(p);
     }
   }
diff --git a/hphp/runtime/ext/ext_options.cpp b/hphp/runtime/ext/ext_options.cpp
index bae661f73..495fbca7d 100644
--- a/hphp/runtime/ext/ext_options.cpp
+++ b/hphp/runtime/ext/ext_options.cpp
@@ -605,7 +605,7 @@ Array f_getopt(CStrRef options, CVarRef longopts /* = null_variant */) {
       if (ret.exists(optname_int)) {
         Variant &e = ret.lvalAt(optname_int);
         if (!e.isArray()) {
-          ret.set(optname_int, CREATE_VECTOR2(e, val));
+          ret.set(optname_int, make_packed_array(e, val));
         } else {
           e.append(val);
         }
@@ -618,7 +618,7 @@ Array f_getopt(CStrRef options, CVarRef longopts /* = null_variant */) {
       if (ret.exists(key)) {
         Variant &e = ret.lvalAt(key);
         if (!e.isArray()) {
-          ret.set(key, CREATE_VECTOR2(e, val));
+          ret.set(key, make_packed_array(e, val));
         } else {
           e.append(val);
         }
diff --git a/hphp/runtime/ext/ext_pdo.cpp b/hphp/runtime/ext/ext_pdo.cpp
index 168247e01..4966c579b 100644
--- a/hphp/runtime/ext/ext_pdo.cpp
+++ b/hphp/runtime/ext/ext_pdo.cpp
@@ -3089,15 +3089,15 @@ Variant c_PDOStatement::t_debugdumpparams() {
   params.append(m_stmt->query_string.data());
   f->printf("SQL: [%d] %.*s\n", params);
 
-  f->printf("Params:  %d\n", CREATE_VECTOR1(m_stmt->bound_params.size()));
+  f->printf("Params:  %d\n", make_packed_array(m_stmt->bound_params.size()));
   for (ArrayIter iter(m_stmt->bound_params); iter; ++iter) {
     if (iter.first().isString()) {
       String key = iter.first().toString();
-      params = CREATE_VECTOR3(key.size(), key.size(), key.data());
+      params = make_packed_array(key.size(), key.size(), key.data());
       f->printf("Key: Name: [%d] %.*s\n", params);
     } else {
       f->printf("Key: Position #%ld:\n",
-                CREATE_VECTOR1(iter.first().toInt64()));
+                make_packed_array(iter.first().toInt64()));
     }
 
     PDOBoundParam *param = iter.second().toResource().getTyped<PDOBoundParam>();
diff --git a/hphp/runtime/ext/ext_phar.cpp b/hphp/runtime/ext/ext_phar.cpp
index 22778421d..e8e366e93 100644
--- a/hphp/runtime/ext/ext_phar.cpp
+++ b/hphp/runtime/ext/ext_phar.cpp
@@ -50,7 +50,7 @@ static class PharStreamWrapper : public Stream::Wrapper {
     g_vmContext->invokeFunc(
       ret.asTypedValue(),
       f,
-      CREATE_VECTOR1(filename),
+      make_packed_array(filename),
       nullptr,
       SystemLib::s_PharClass
     );
@@ -94,7 +94,7 @@ static class PharStreamWrapper : public Stream::Wrapper {
     g_vmContext->invokeFunc(
       ret.asTypedValue(),
       f,
-      CREATE_VECTOR1(path),
+      make_packed_array(path),
       nullptr,
       SystemLib::s_PharClass
     );
@@ -113,7 +113,7 @@ static class PharStreamWrapper : public Stream::Wrapper {
     g_vmContext->invokeFunc(
       ret.asTypedValue(),
       f,
-      CREATE_VECTOR1(path),
+      make_packed_array(path),
       nullptr,
       SystemLib::s_PharClass
     );
diff --git a/hphp/runtime/ext/ext_process.cpp b/hphp/runtime/ext/ext_process.cpp
index e4d5205b5..11e0ce9c1 100644
--- a/hphp/runtime/ext/ext_process.cpp
+++ b/hphp/runtime/ext/ext_process.cpp
@@ -320,7 +320,7 @@ bool f_pcntl_signal_dispatch() {
       signaled[i] = 0;
       if (s_signal_handlers->handlers.exists(i)) {
         vm_call_user_func(s_signal_handlers->handlers[i],
-                               CREATE_VECTOR1(i));
+                               make_packed_array(i));
       }
     }
   }
diff --git a/hphp/runtime/ext/ext_session.cpp b/hphp/runtime/ext/ext_session.cpp
index d7636e86f..0a2f01005 100644
--- a/hphp/runtime/ext/ext_session.cpp
+++ b/hphp/runtime/ext/ext_session.cpp
@@ -911,24 +911,24 @@ public:
 
   virtual bool open(const char *save_path, const char *session_name) {
     return vm_call_user_func(
-       CREATE_VECTOR2(Object(PS(ps_session_handler)),
+       make_packed_array(Object(PS(ps_session_handler)),
                       String("open")),
-       CREATE_VECTOR2(String(save_path, CopyString),
+       make_packed_array(String(save_path, CopyString),
                       String(session_name, CopyString))).toBoolean();
   }
 
   virtual bool close() {
     return vm_call_user_func(
-       CREATE_VECTOR2(Object(PS(ps_session_handler)),
+       make_packed_array(Object(PS(ps_session_handler)),
                       String("close")),
        Array::Create()).toBoolean();
   }
 
   virtual bool read(const char *key, String &value) {
     Variant ret = vm_call_user_func(
-       CREATE_VECTOR2(Object(PS(ps_session_handler)),
+       make_packed_array(Object(PS(ps_session_handler)),
                       String("read")),
-       CREATE_VECTOR1(String(key, CopyString)));
+       make_packed_array(String(key, CopyString)));
     if (ret.isString()) {
       value = ret.toString();
       return true;
@@ -938,23 +938,23 @@ public:
 
   virtual bool write(const char *key, CStrRef value) {
     return vm_call_user_func(
-       CREATE_VECTOR2(Object(PS(ps_session_handler)),
+       make_packed_array(Object(PS(ps_session_handler)),
                       String("write")),
-       CREATE_VECTOR2(String(key, CopyString), value)).toBoolean();
+       make_packed_array(String(key, CopyString), value)).toBoolean();
   }
 
   virtual bool destroy(const char *key) {
     return vm_call_user_func(
-       CREATE_VECTOR2(Object(PS(ps_session_handler)),
+       make_packed_array(Object(PS(ps_session_handler)),
                       String("destroy")),
-       CREATE_VECTOR1(String(key, CopyString))).toBoolean();
+       make_packed_array(String(key, CopyString))).toBoolean();
   }
 
   virtual bool gc(int maxlifetime, int *nrdels) {
     return vm_call_user_func(
-       CREATE_VECTOR2(Object(PS(ps_session_handler)),
+       make_packed_array(Object(PS(ps_session_handler)),
                       String("gc")),
-       CREATE_VECTOR1((int64_t)maxlifetime)).toBoolean();
+       make_packed_array((int64_t)maxlifetime)).toBoolean();
   }
 };
 static UserSessionModule s_user_session_module;
diff --git a/hphp/runtime/ext/ext_simplexml.cpp b/hphp/runtime/ext/ext_simplexml.cpp
index efc0c6bcd..f9363227b 100644
--- a/hphp/runtime/ext/ext_simplexml.cpp
+++ b/hphp/runtime/ext/ext_simplexml.cpp
@@ -1146,7 +1146,7 @@ void c_SimpleXMLElementIterator::reset_iterator() {
                                 "", false);
     m_parent = obj.getTyped<c_SimpleXMLElement>();
     Variant children = m_parent->m_children[name];
-    m_parent->m_children = CREATE_MAP1(name, children);
+    m_parent->m_children = make_map_array(name, children);
     // fall through
   }
 
diff --git a/hphp/runtime/ext/ext_soap.cpp b/hphp/runtime/ext/ext_soap.cpp
index 33c1a6f48..7aa0b5ec0 100644
--- a/hphp/runtime/ext/ext_soap.cpp
+++ b/hphp/runtime/ext/ext_soap.cpp
@@ -2189,7 +2189,7 @@ void c_SoapServer::t_handle(CStrRef request /* = null_string */) {
       try {
         if (m_type == SOAP_CLASS || m_type == SOAP_OBJECT) {
           h->retval = vm_call_user_func
-            (CREATE_VECTOR2(soap_obj, fn_name), h->parameters);
+            (make_packed_array(soap_obj, fn_name), h->parameters);
         } else {
           h->retval = vm_call_user_func(fn_name, h->parameters);
         }
@@ -2214,7 +2214,7 @@ void c_SoapServer::t_handle(CStrRef request /* = null_string */) {
     try {
       if (m_type == SOAP_CLASS || m_type == SOAP_OBJECT) {
         retval = vm_call_user_func
-          (CREATE_VECTOR2(soap_obj, fn_name), params);
+          (make_packed_array(soap_obj, fn_name), params);
       } else {
         retval = vm_call_user_func(fn_name, params);
       }
@@ -2487,7 +2487,7 @@ Variant c_SoapClient::t___soapcall(CStrRef name, CArrRef args,
     soap_headers = input_headers;
   } else if (input_headers.isObject() &&
              input_headers.toObject().is<c_SoapHeader>()) {
-    soap_headers = CREATE_VECTOR1(input_headers);
+    soap_headers = make_packed_array(input_headers);
   } else{
     raise_warning("Invalid SOAP header");
     return uninit_null();
@@ -2754,7 +2754,7 @@ Variant c_SoapClient::t___dorequest(CStrRef buf, CStrRef location, CStrRef actio
 Variant c_SoapClient::t___setcookie(CStrRef name,
                                     CStrRef value /* = null_string */) {
   if (!value.isNull()) {
-    m_cookies.set(name, CREATE_VECTOR1(value));
+    m_cookies.set(name, make_packed_array(value));
   } else {
     const Variant* t = o_realProp("_cookies", RealPropUnchecked);
     if (t && t->isInitialized()) {
@@ -2778,7 +2778,7 @@ bool c_SoapClient::t___setsoapheaders(CVarRef headers /* = null_variant */) {
     verify_soap_headers_array(arr);
     m_default_headers = arr;
   } else if (headers.isObject() && headers.toObject().is<c_SoapHeader>()) {
-    m_default_headers = CREATE_VECTOR1(headers);
+    m_default_headers = make_packed_array(headers);
   } else {
     raise_warning("Invalid SOAP header");
   }
diff --git a/hphp/runtime/ext/ext_spl.cpp b/hphp/runtime/ext/ext_spl.cpp
index 04adc1486..6ad9e0845 100644
--- a/hphp/runtime/ext/ext_spl.cpp
+++ b/hphp/runtime/ext/ext_spl.cpp
@@ -316,7 +316,7 @@ namespace {
 class ExtensionList : public RequestEventHandler {
 public:
   virtual void requestInit() {
-    extensions = CREATE_VECTOR2(String(".inc"), String(".php"));
+    extensions = make_packed_array(String(".inc"), String(".php"));
   }
   virtual void requestShutdown() {
     extensions.reset();
diff --git a/hphp/runtime/ext/ext_stream.cpp b/hphp/runtime/ext/ext_stream.cpp
index ff99e7be2..cacc7d28b 100644
--- a/hphp/runtime/ext/ext_stream.cpp
+++ b/hphp/runtime/ext/ext_stream.cpp
@@ -212,7 +212,7 @@ Variant f_stream_get_meta_data(CResRef stream) {
 }
 
 Array f_stream_get_transports() {
-  return CREATE_VECTOR4("tcp", "udp", "unix", "udg");
+  return make_packed_array("tcp", "udp", "unix", "udg");
 }
 
 String f_stream_resolve_include_path(CStrRef filename,
@@ -246,7 +246,7 @@ bool f_stream_set_timeout(CResRef stream, int seconds,
   if (stream.getTyped<Socket>(false, true)) {
     return f_socket_set_option
       (stream, SOL_SOCKET, SO_RCVTIMEO,
-       CREATE_MAP2(s_sec, seconds, s_usec, microseconds));
+       make_map_array(s_sec, seconds, s_usec, microseconds));
   }
   return false;
 }
diff --git a/hphp/runtime/ext/ext_xml.cpp b/hphp/runtime/ext/ext_xml.cpp
index 2745d8265..c1676515b 100644
--- a/hphp/runtime/ext/ext_xml.cpp
+++ b/hphp/runtime/ext/ext_xml.cpp
@@ -496,7 +496,7 @@ void _xml_defaultHandler(void *userData, const XML_Char *s, int len) {
   XmlParser *parser = (XmlParser *)userData;
 
   if (parser && parser->defaultHandler.toBoolean()) {
-    xml_call_handler(parser, parser->defaultHandler, CREATE_VECTOR2(
+    xml_call_handler(parser, parser->defaultHandler, make_packed_array(
         parser, _xml_xmlchar_zval(s, len, parser->target_encoding)));
   }
 }
diff --git a/hphp/runtime/ext/filter/ext_filter.cpp b/hphp/runtime/ext/filter/ext_filter.cpp
index 284c11966..c495fa822 100644
--- a/hphp/runtime/ext/filter/ext_filter.cpp
+++ b/hphp/runtime/ext/filter/ext_filter.cpp
@@ -305,7 +305,7 @@ Variant f_filter_var(CVarRef variable, int64_t filter /* = 516 */,
   Variant ret;
   FAIL_IF(!filter_var(ret, variable, filter, options));
   if (filter_flags & k_FILTER_FORCE_ARRAY && !ret.isArray()) {
-    ret = CREATE_VECTOR1(ret);
+    ret = make_packed_array(ret);
   }
   return ret;
 }
diff --git a/hphp/runtime/ext/filter/logical_filters.cpp b/hphp/runtime/ext/filter/logical_filters.cpp
index 761922280..dc6d481f9 100644
--- a/hphp/runtime/ext/filter/logical_filters.cpp
+++ b/hphp/runtime/ext/filter/logical_filters.cpp
@@ -767,7 +767,7 @@ Variant php_filter_callback(PHP_INPUT_FILTER_PARAM_DECL) {
     raise_warning("First argument is expected to be a valid callback");
     return uninit_null();
   }
-  return vm_call_user_func(option_array, CREATE_VECTOR1(ref(value)));
+  return vm_call_user_func(option_array, make_packed_array(ref(value)));
 }
 
 }
diff --git a/hphp/runtime/ext/mailparse/mime.cpp b/hphp/runtime/ext/mailparse/mime.cpp
index c16f500b5..189b70661 100644
--- a/hphp/runtime/ext/mailparse/mime.cpp
+++ b/hphp/runtime/ext/mailparse/mime.cpp
@@ -988,7 +988,7 @@ int MimePart::extractImpl(int decode, File *src) {
 }
 
 void MimePart::callUserFunc(CStrRef s) {
-  vm_call_user_func(m_extract_context, CREATE_VECTOR1(s));
+  vm_call_user_func(m_extract_context, make_packed_array(s));
 }
 
 void MimePart::outputToStdout(CStrRef s) {
diff --git a/hphp/runtime/ext/soap/encoding.cpp b/hphp/runtime/ext/soap/encoding.cpp
index 95de4aa9b..1210cc8aa 100644
--- a/hphp/runtime/ext/soap/encoding.cpp
+++ b/hphp/runtime/ext/soap/encoding.cpp
@@ -687,7 +687,7 @@ xmlNodePtr to_xml_user(encodeTypePtr type, CVarRef data, int style,
   xmlNodePtr ret = NULL;
   if (type && type->map && !type->map->to_xml.isNull()) {
     Variant return_value = vm_call_user_func(type->map->to_xml,
-                                                  CREATE_VECTOR1(data));
+                                                  make_packed_array(data));
     if (return_value.isString()) {
       String sdoc = return_value.toString();
       xmlDocPtr doc = soap_xmlParseMemory(sdoc.data(), sdoc.size());
@@ -718,7 +718,7 @@ Variant to_zval_user(encodeTypePtr type, xmlNodePtr node) {
     xmlFreeNode(copy);
 
     return_value = vm_call_user_func(type->map->to_zval,
-                                          CREATE_VECTOR1(data));
+                                          make_packed_array(data));
   }
   return return_value;
 }
diff --git a/hphp/runtime/ext/soap/xml.cpp b/hphp/runtime/ext/soap/xml.cpp
index 971c824f5..fbbfbe7f6 100644
--- a/hphp/runtime/ext/soap/xml.cpp
+++ b/hphp/runtime/ext/soap/xml.cpp
@@ -80,7 +80,7 @@ xmlDocPtr soap_xmlParseFile(const char *filename) {
   Variant content = f_apc_fetch(cache_key);
   if (same(content, false)) {
     Variant stream = File::Open(filename, "rb", 0, f_stream_context_create(
-                CREATE_MAP1(s_http, CREATE_MAP1(s_timeout, 1000))));
+                make_map_array(s_http, make_map_array(s_timeout, 1000))));
     if (!same(stream, false)) {
       content = f_stream_get_contents(stream.toResource());
       if (!same(content, false)) {
diff --git a/hphp/runtime/ext/thrift/binary.cpp b/hphp/runtime/ext/thrift/binary.cpp
index 07e5362fc..214902343 100644
--- a/hphp/runtime/ext/thrift/binary.cpp
+++ b/hphp/runtime/ext/thrift/binary.cpp
@@ -72,9 +72,9 @@ Object createObject(CStrRef obj_typename, int nargs = 0,
   }
   Array args;
   if (nargs == 1) {
-    args = CREATE_VECTOR1(arg1);
+    args = make_packed_array(arg1);
   } else if (nargs == 2 ) {
-    args = CREATE_VECTOR2(arg1, arg2);
+    args = make_packed_array(arg1, arg2);
   }
   return create_object(obj_typename, args);
 }
diff --git a/hphp/runtime/ext/thrift/compact.cpp b/hphp/runtime/ext/thrift/compact.cpp
index d7e4eac15..118fc0137 100644
--- a/hphp/runtime/ext/thrift/compact.cpp
+++ b/hphp/runtime/ext/thrift/compact.cpp
@@ -164,7 +164,7 @@ IMPLEMENT_STATIC_REQUEST_LOCAL(CompactRequestData, s_compact_request_data);
 
 static void thrift_error(CStrRef what, TError why) ATTRIBUTE_NORETURN;
 static void thrift_error(CStrRef what, TError why) {
-  throw create_object("TProtocolException", CREATE_VECTOR2(what, why));
+  throw create_object("TProtocolException", make_packed_array(what, why));
 }
 
 class CompactWriter {
diff --git a/hphp/runtime/server/http-protocol.cpp b/hphp/runtime/server/http-protocol.cpp
index eb18c720f..d0e3671c6 100644
--- a/hphp/runtime/server/http-protocol.cpp
+++ b/hphp/runtime/server/http-protocol.cpp
@@ -377,7 +377,7 @@ void HttpProtocol::PrepareSystemVariables(Transport *transport,
     server.set(s_PATH_INFO, r.pathInfo());
   }
 
-  server.set(s_argv, CREATE_VECTOR1(r.queryString()));
+  server.set(s_argv, make_packed_array(r.queryString()));
   server.set(s_argc, 1);
   server.set(s_GATEWAY_INTERFACE, s_CGI_1_1);
   server.set(s_SERVER_ADDR, String(RuntimeOption::ServerPrimaryIP));
diff --git a/hphp/runtime/server/rpc-request-handler.cpp b/hphp/runtime/server/rpc-request-handler.cpp
index 3779852c1..90f800907 100644
--- a/hphp/runtime/server/rpc-request-handler.cpp
+++ b/hphp/runtime/server/rpc-request-handler.cpp
@@ -309,7 +309,8 @@ bool RPCRequestHandler::executePHPFunction(Transport *transport,
         case 1: response = m_context->obDetachContents(); break;
         case 2:
           response =
-            f_json_encode(CREATE_MAP2(s_output, m_context->obDetachContents(),
+            f_json_encode(
+              make_map_array(s_output, m_context->obDetachContents(),
                                       s_return, f_json_encode(funcRet)));
           break;
         case 3: response = f_serialize(funcRet); break;
diff --git a/hphp/runtime/server/server-stats.cpp b/hphp/runtime/server/server-stats.cpp
index 020ab57a3..2a54ca4cb 100644
--- a/hphp/runtime/server/server-stats.cpp
+++ b/hphp/runtime/server/server-stats.cpp
@@ -972,7 +972,7 @@ Array ServerStats::EndNetworkProfile() {
     for (IOStatusMap::const_iterator iter = status.begin();
          iter != status.end(); ++iter) {
       ret.set(String(iter->first),
-              CREATE_MAP2(s_ct, iter->second.count,
+              make_map_array(s_ct, iter->second.count,
                           s_wt, iter->second.wall_time));
     }
     status.clear();
@@ -1224,7 +1224,7 @@ Array ServerStats::getThreadIOStatuses() {
   for (IOStatusMap::const_iterator iter = status.begin();
        iter != status.end(); ++iter) {
     ret.set(String(iter->first),
-            CREATE_MAP2(s_ct, iter->second.count,
+            make_map_array(s_ct, iter->second.count,
                         s_wt, iter->second.wall_time));
   }
   status.clear();
diff --git a/hphp/runtime/vm/bytecode.cpp b/hphp/runtime/vm/bytecode.cpp
index 18c54dd3f..3b425e0c5 100644
--- a/hphp/runtime/vm/bytecode.cpp
+++ b/hphp/runtime/vm/bytecode.cpp
@@ -6358,6 +6358,7 @@ lookupStatic(StringData* name,
   if (val == nullptr) {
     TypedValue tv;
     tvWriteUninit(&tv);
+    // TODO(#2836647): needs to check return value
     map->set(name, tvAsCVarRef(&tv), false);
     val = map->nvGet(name);
     inited = false;
diff --git a/hphp/runtime/vm/event-hook.cpp b/hphp/runtime/vm/event-hook.cpp
index 977497107..bf47f5761 100644
--- a/hphp/runtime/vm/event-hook.cpp
+++ b/hphp/runtime/vm/event-hook.cpp
@@ -149,7 +149,7 @@ bool EventHook::RunInterceptHandler(ActRec* ar) {
     called_on = Variant(const_cast<StringData*>(ar->getClass()->name()));
   }
   Array intArgs =
-    CREATE_VECTOR5(ar->m_func->fullNameRef(),
+    make_packed_array(ar->m_func->fullNameRef(),
                    called_on,
                    get_frame_args_with_ref(ar),
                    h->asCArrRef()[1],
diff --git a/hphp/system/systemlib.cpp b/hphp/system/systemlib.cpp
index 587a562e0..685d55f8f 100644
--- a/hphp/system/systemlib.cpp
+++ b/hphp/system/systemlib.cpp
@@ -69,36 +69,36 @@ ObjectData* SystemLib::AllocPinitSentinel() {
   return inst;
 
 ObjectData* SystemLib::AllocExceptionObject(CVarRef message) {
-  CREATE_AND_CONSTRUCT(Exception, CREATE_VECTOR1(message));
+  CREATE_AND_CONSTRUCT(Exception, make_packed_array(message));
 }
 
 ObjectData* SystemLib::AllocBadMethodCallExceptionObject(CVarRef message) {
-  CREATE_AND_CONSTRUCT(BadMethodCallException, CREATE_VECTOR1(message));
+  CREATE_AND_CONSTRUCT(BadMethodCallException, make_packed_array(message));
 }
 
 ObjectData* SystemLib::AllocInvalidArgumentExceptionObject(CVarRef message) {
-  CREATE_AND_CONSTRUCT(InvalidArgumentException, CREATE_VECTOR1(message));
+  CREATE_AND_CONSTRUCT(InvalidArgumentException, make_packed_array(message));
 }
 
 ObjectData* SystemLib::AllocRuntimeExceptionObject(CVarRef message) {
-  CREATE_AND_CONSTRUCT(RuntimeException, CREATE_VECTOR1(message));
+  CREATE_AND_CONSTRUCT(RuntimeException, make_packed_array(message));
 }
 
 ObjectData* SystemLib::AllocOutOfBoundsExceptionObject(CVarRef message) {
-  CREATE_AND_CONSTRUCT(OutOfBoundsException, CREATE_VECTOR1(message));
+  CREATE_AND_CONSTRUCT(OutOfBoundsException, make_packed_array(message));
 }
 
 ObjectData* SystemLib::AllocInvalidOperationExceptionObject(CVarRef message) {
-  CREATE_AND_CONSTRUCT(InvalidOperationException, CREATE_VECTOR1(message));
+  CREATE_AND_CONSTRUCT(InvalidOperationException, make_packed_array(message));
 }
 
 ObjectData* SystemLib::AllocDOMDocumentObject(CStrRef version,
                                               CStrRef encoding) {
-  CREATE_AND_CONSTRUCT(DOMDocument, CREATE_VECTOR2(version, encoding));
+  CREATE_AND_CONSTRUCT(DOMDocument, make_packed_array(version, encoding));
 }
 
 ObjectData* SystemLib::AllocDOMExceptionObject(CVarRef message, CVarRef code) {
-  CREATE_AND_CONSTRUCT(DOMException, CREATE_VECTOR2(message, code));
+  CREATE_AND_CONSTRUCT(DOMException, make_packed_array(message, code));
 }
 
 ObjectData*
@@ -108,20 +108,20 @@ SystemLib::AllocSoapFaultObject(CVarRef code,
                                 CVarRef detail /* = null_variant */,
                                 CVarRef name /* = null_variant */,
                                 CVarRef header /* = null_variant */) {
-  CREATE_AND_CONSTRUCT(SoapFault, CREATE_VECTOR6(code, message, actor,
+  CREATE_AND_CONSTRUCT(SoapFault, make_packed_array(code, message, actor,
                                                  detail, name, header));
 }
 
 ObjectData* SystemLib::AllocLazyKVZipIterableObject(CVarRef mp) {
-  CREATE_AND_CONSTRUCT(LazyKVZipIterable, CREATE_VECTOR1(mp));
+  CREATE_AND_CONSTRUCT(LazyKVZipIterable, make_packed_array(mp));
 }
 
 ObjectData* SystemLib::AllocLazyIterableViewObject(CVarRef iterable) {
-  CREATE_AND_CONSTRUCT(LazyIterableView, CREATE_VECTOR1(iterable));
+  CREATE_AND_CONSTRUCT(LazyIterableView, make_packed_array(iterable));
 }
 
 ObjectData* SystemLib::AllocLazyKeyedIterableViewObject(CVarRef iterable) {
-  CREATE_AND_CONSTRUCT(LazyKeyedIterableView, CREATE_VECTOR1(iterable));
+  CREATE_AND_CONSTRUCT(LazyKeyedIterableView, make_packed_array(iterable));
 }
 
 #undef CREATE_AND_CONSTRUCT
diff --git a/hphp/test/ext/test_cpp_base.cpp b/hphp/test/ext/test_cpp_base.cpp
index 226bc59a0..694b20be5 100644
--- a/hphp/test/ext/test_cpp_base.cpp
+++ b/hphp/test/ext/test_cpp_base.cpp
@@ -208,7 +208,7 @@ bool TestCppBase::TestArray() {
 
   // iteration
   {
-    Array arr = CREATE_MAP2("n1", "v1", "n2", "v2");
+    Array arr = make_map_array("n1", "v1", "n2", "v2");
     int i = 0;
     for (ArrayIter iter = arr.begin(); iter; ++iter, ++i) {
       if (i == 0) {
@@ -223,7 +223,7 @@ bool TestCppBase::TestArray() {
   }
   /* TODO: fix this
   {
-    Variant arr = CREATE_MAP2("n1", "v1", "n2", "v2");
+    Variant arr = make_map_array("n1", "v1", "n2", "v2");
     arr.escalate();
     for (ArrayIter iter = arr.begin(arr, true); !iter->end(); iter->next()){
       arr.lvalAt(iter->first()).reset();
@@ -260,31 +260,31 @@ bool TestCppBase::TestArray() {
     Array arr;
     arr.set(0, "v1");
     arr.set(1, "v2");
-    VS(arr, CREATE_VECTOR2("v1", "v2"));
+    VS(arr, make_packed_array("v1", "v2"));
   }
   {
     Array arr;
     arr.set(s_n1, "v1");
     arr.set(s_n2, "v2");
-    VS(arr, CREATE_MAP2("n1", "v1", "n2", "v2"));
+    VS(arr, make_map_array("n1", "v1", "n2", "v2"));
   }
   {
     Array arr;
     arr.lvalAt(0) = String("v1");
     arr.lvalAt(1) = String("v2");
-    VS(arr, CREATE_VECTOR2("v1", "v2"));
+    VS(arr, make_packed_array("v1", "v2"));
   }
   {
     Array arr;
     arr.lvalAt(s_n1) = String("v1");
     arr.lvalAt(s_n2) = String("v2");
-    VS(arr, CREATE_MAP2("n1", "v1", "n2", "v2"));
+    VS(arr, make_map_array("n1", "v1", "n2", "v2"));
   }
   {
     Array arr;
     Variant name = "name";
     arr.lvalAt(name) = String("value");
-    VS(arr, CREATE_MAP1("name", "value"));
+    VS(arr, make_map_array("name", "value"));
   }
 
   {
@@ -330,7 +330,7 @@ bool TestCppBase::TestArray() {
     VERIFY(!arr.exists(0));
     VS(arr, Array::Create(1, "v2"));
     arr.append("v3");
-    VS(arr, CREATE_MAP2(1, "v2", 2, "v3"));
+    VS(arr, make_map_array(1, "v2", 2, "v3"));
   }
   {
     static const StaticString s_0("0");
@@ -377,12 +377,12 @@ bool TestCppBase::TestArray() {
     VERIFY(!arr.exists(s_n1));
     VS(arr, Array::Create(s_n2, "v2"));
     arr.append("v3");
-    VS(arr, CREATE_MAP2("n2", "v2", 0, "v3"));
+    VS(arr, make_map_array("n2", "v2", 0, "v3"));
   }
   {
     Array arr;
     arr.lvalAt() = String("test");
-    VS(arr, CREATE_VECTOR1("test"));
+    VS(arr, make_packed_array("test"));
   }
   {
     Array arr;
@@ -430,81 +430,81 @@ bool TestCppBase::TestArray() {
   {
     Array arr = Array::Create(0) + Array::Create(1);
     VS(arr, Array::Create(0));
-    arr += CREATE_VECTOR2(0, 1);
-    VS(arr, CREATE_VECTOR2(0, 1));
+    arr += make_packed_array(0, 1);
+    VS(arr, make_packed_array(0, 1));
 
     arr = Array::Create(0).merge(Array::Create(1));
-    VS(arr, CREATE_VECTOR2(0, 1));
-    arr = arr.merge(CREATE_VECTOR2(0, 1));
-    VS(arr, CREATE_VECTOR4(0, 1, 0, 1));
+    VS(arr, make_packed_array(0, 1));
+    arr = arr.merge(make_packed_array(0, 1));
+    VS(arr, make_packed_array(0, 1, 0, 1));
 
     arr = Array::Create("s0").merge(Array::Create("s1"));
-    VS(arr, CREATE_VECTOR2("s0", "s1"));
+    VS(arr, make_packed_array("s0", "s1"));
 
     arr = Array::Create("n0", "s0") + Array::Create("n1", "s1");
-    VS(arr, CREATE_MAP2("n0", "s0", "n1", "s1"));
-    arr += CREATE_MAP2("n0", "s0", "n1", "s1");
-    VS(arr, CREATE_MAP2("n0", "s0", "n1", "s1"));
+    VS(arr, make_map_array("n0", "s0", "n1", "s1"));
+    arr += make_map_array("n0", "s0", "n1", "s1");
+    VS(arr, make_map_array("n0", "s0", "n1", "s1"));
 
     arr = Array::Create("n0", "s0").merge(Array::Create("n1", "s1"));
-    VS(arr, CREATE_MAP2("n0", "s0", "n1", "s1"));
-    Array arrX = CREATE_MAP2("n0", "s2", "n1", "s3");
+    VS(arr, make_map_array("n0", "s0", "n1", "s1"));
+    Array arrX = make_map_array("n0", "s2", "n1", "s3");
     arr = arr.merge(arrX);
-    VS(arr, CREATE_MAP2("n0", "s2", "n1", "s3"));
+    VS(arr, make_map_array("n0", "s2", "n1", "s3"));
   }
 
   // slice
   {
-    Array arr = CREATE_VECTOR2("test1", "test2");
+    Array arr = make_packed_array("test1", "test2");
     Array sub = arr.slice(1, 1, true);
-    VS(sub, CREATE_MAP1(1, "test2"));
+    VS(sub, make_map_array(1, "test2"));
   }
   {
-    Array arr = CREATE_VECTOR2("test1", "test2");
+    Array arr = make_packed_array("test1", "test2");
     Array sub = arr.slice(1, 1, false);
-    VS(sub, CREATE_VECTOR1("test2"));
+    VS(sub, make_packed_array("test2"));
   }
   {
-    Array arr = CREATE_MAP2("n1", "test1", "n2", "test2");
+    Array arr = make_map_array("n1", "test1", "n2", "test2");
     Array sub = arr.slice(1, 1, true);
-    VS(sub, CREATE_MAP1("n2", "test2"));
+    VS(sub, make_map_array("n2", "test2"));
   }
   {
-    Array arr = CREATE_MAP2("n1", "test1", "n2", "test2");
+    Array arr = make_map_array("n1", "test1", "n2", "test2");
     Array sub = arr.slice(1, 1, false);
-    VS(sub, CREATE_MAP1("n2", "test2"));
+    VS(sub, make_map_array("n2", "test2"));
   }
 
   // escalation
   {
     Array arr;
     arr.lvalAt(0).lvalAt(0) = 1.2;
-    VS(arr, CREATE_VECTOR1(CREATE_VECTOR1(1.2)));
+    VS(arr, make_packed_array(make_packed_array(1.2)));
   }
   {
     Array arr;
     arr.lvalAt(s_name).lvalAt(0) = 1.2;
-    VS(arr, CREATE_MAP1(s_name, CREATE_VECTOR1(1.2)));
+    VS(arr, make_map_array(s_name, make_packed_array(1.2)));
   }
   {
     Array arr = Array::Create();
     arr.lvalAt(0).lvalAt(0) = 1.2;
-    VS(arr, CREATE_VECTOR1(CREATE_VECTOR1(1.2)));
+    VS(arr, make_packed_array(make_packed_array(1.2)));
   }
   {
     Array arr = Array::Create();
     arr.lvalAt(s_name).lvalAt(0) = 1.2;
-    VS(arr, CREATE_MAP1(s_name, CREATE_VECTOR1(1.2)));
+    VS(arr, make_map_array(s_name, make_packed_array(1.2)));
   }
   {
     Array arr = Array::Create("test");
-    arr.lvalAt(0) = CREATE_VECTOR1(1.2);
-    VS(arr, CREATE_VECTOR1(CREATE_VECTOR1(1.2)));
+    arr.lvalAt(0) = make_packed_array(1.2);
+    VS(arr, make_packed_array(make_packed_array(1.2)));
   }
   {
     Array arr = Array::Create("test");
     arr.lvalAt(s_name).lvalAt(0) = 1.2;
-    VS(arr, CREATE_MAP2(0, "test", s_name, CREATE_VECTOR1(1.2)));
+    VS(arr, make_map_array(0, "test", s_name, make_packed_array(1.2)));
   }
   {
     Array arr = Array::Create();
@@ -514,19 +514,19 @@ bool TestCppBase::TestArray() {
   }
 
   {
-    Array arr = CREATE_MAP2(0, "a", 1, "b");
+    Array arr = make_map_array(0, "a", 1, "b");
     VERIFY(arr->isVectorData());
   }
   {
-    Array arr = CREATE_MAP2(1, "a", 0, "b");
+    Array arr = make_map_array(1, "a", 0, "b");
     VERIFY(!arr->isVectorData());
   }
   {
-    Array arr = CREATE_MAP2(1, "a", 2, "b");
+    Array arr = make_map_array(1, "a", 2, "b");
     VERIFY(!arr->isVectorData());
   }
   {
-    Array arr = CREATE_MAP1(1, "a");
+    Array arr = make_map_array(1, "a");
     arr.set(0, "b");
     VERIFY(!arr->isVectorData());
   }
@@ -569,7 +569,7 @@ bool TestCppBase::TestVariant() {
   {
     Variant v;
     v.lvalAt() = String("test");
-    VS(v, CREATE_VECTOR1("test"));
+    VS(v, make_packed_array("test"));
   }
   {
     Variant v;
@@ -617,37 +617,37 @@ bool TestCppBase::TestVariant() {
     v.lvalAt(s_n0) = String("v0");
     v.lvalAt(s_n1) = String("v1");
     v.remove(s_n1);
-    VS(v, CREATE_MAP1(s_n0, "v0"));
+    VS(v, make_map_array(s_n0, "v0"));
     v.append("v2");
-    VS(v, CREATE_MAP2(s_n0, "v0", 0, "v2"));
+    VS(v, make_map_array(s_n0, "v0", 0, "v2"));
   }
   {
     Variant v;
     v.lvalAt(s_n0) = String("v0");
     v.lvalAt(1) = String("v1");
     v.remove(Variant(1.5));
-    VS(v, CREATE_MAP1("n0", "v0"));
+    VS(v, make_map_array("n0", "v0"));
   }
   {
     Variant v;
     v.lvalAt(s_n0) = String("v0");
     v.lvalAt(1) = String("v1");
     v.remove(Variant("1"));
-    VS(v, CREATE_MAP1("n0", "v0"));
+    VS(v, make_map_array("n0", "v0"));
   }
   {
     Variant v;
     v.lvalAt(s_n0) = String("v0");
     v.lvalAt(1) = String("v1");
     v.remove(String("1"));
-    VS(v, CREATE_MAP1("n0", "v0"));
+    VS(v, make_map_array("n0", "v0"));
   }
   {
     Variant v;
     v.lvalAt(s_n0) = String("v0");
     v.lvalAt(empty_string) = String("v1");
     v.remove(Variant());
-    VS(v, CREATE_MAP1("n0", "v0"));
+    VS(v, make_map_array("n0", "v0"));
   }
 
   // references
@@ -678,7 +678,7 @@ bool TestCppBase::TestVariant() {
   }
   {
     Variant v1 = 10;
-    Variant v2 = CREATE_VECTOR1(5);
+    Variant v2 = make_packed_array(5);
     v2.lvalAt() = ref(v1);
     v1 = 20;
     VS(v2[1], 20);
@@ -688,32 +688,32 @@ bool TestCppBase::TestVariant() {
   {
     Variant arr;
     arr.lvalAt(0).lvalAt(0) = 1.2;
-    VS(arr, CREATE_VECTOR1(CREATE_VECTOR1(1.2)));
+    VS(arr, make_packed_array(make_packed_array(1.2)));
   }
   {
     Variant arr;
     arr.lvalAt(s_name).lvalAt(0) = 1.2;
-    VS(arr, CREATE_MAP1(s_name, CREATE_VECTOR1(1.2)));
+    VS(arr, make_map_array(s_name, make_packed_array(1.2)));
   }
   {
     Variant arr = Array::Create();
     arr.lvalAt(0).lvalAt(0) = 1.2;
-    VS(arr, CREATE_VECTOR1(CREATE_VECTOR1(1.2)));
+    VS(arr, make_packed_array(make_packed_array(1.2)));
   }
   {
     Variant arr = Array::Create();
     arr.lvalAt(s_name).lvalAt(0) = 1.2;
-    VS(arr, CREATE_MAP1(s_name, CREATE_VECTOR1(1.2)));
+    VS(arr, make_map_array(s_name, make_packed_array(1.2)));
   }
   {
     Variant arr = Array::Create("test");
-    arr.lvalAt(0) = CREATE_VECTOR1(1.2);
-    VS(arr, CREATE_VECTOR1(CREATE_VECTOR1(1.2)));
+    arr.lvalAt(0) = make_packed_array(1.2);
+    VS(arr, make_packed_array(make_packed_array(1.2)));
   }
   {
     Variant arr = Array::Create("test");
     arr.lvalAt(s_name).lvalAt(0) = 1.2;
-    VS(arr, CREATE_MAP2(0, "test", s_name, CREATE_VECTOR1(1.2)));
+    VS(arr, make_map_array(0, "test", s_name, make_packed_array(1.2)));
   }
 
   return Count(true);
diff --git a/hphp/test/ext/test_ext_curl.cpp b/hphp/test/ext/test_ext_curl.cpp
index 7c5cc339d..5d1933d8c 100644
--- a/hphp/test/ext/test_ext_curl.cpp
+++ b/hphp/test/ext/test_ext_curl.cpp
@@ -165,7 +165,7 @@ bool TestExtCurl::test_curl_setopt_array() {
   Variant c = f_curl_init();
   f_curl_setopt_array
     (c.toResource(),
-     CREATE_MAP2(k_CURLOPT_URL, String(get_request_uri()),
+     make_map_array(k_CURLOPT_URL, String(get_request_uri()),
                  k_CURLOPT_RETURNTRANSFER, true));
   Variant res = f_curl_exec(c.toResource());
   VS(res, "OK");
@@ -343,7 +343,7 @@ bool TestExtCurl::test_evhttp_set_cache() {
   f_evhttp_set_cache("localhost", 4, s_server_port);
   for (int i = 0; i < 10; i++) {
     Variant ret = f_evhttp_get(String(get_request_uri()),
-                               CREATE_VECTOR1("ECHO: foo"));
+                               make_packed_array("ECHO: foo"));
     VS(ret[s_code], 200);
     VS(ret[s_response], "OK");
     VS(ret[s_headers][0], "ECHOED: foo");
@@ -355,7 +355,7 @@ bool TestExtCurl::test_evhttp_set_cache() {
 
 bool TestExtCurl::test_evhttp_get() {
   Variant ret = f_evhttp_get(String(get_request_uri()),
-                             CREATE_VECTOR1("ECHO: foo"));
+                             make_packed_array("ECHO: foo"));
   VS(ret[s_code], 200);
   VS(ret[s_response], "OK");
   VS(ret[s_headers][0], "ECHOED: foo");
@@ -365,7 +365,7 @@ bool TestExtCurl::test_evhttp_get() {
 
 bool TestExtCurl::test_evhttp_post() {
   Variant ret = f_evhttp_post(String(get_request_uri()), "echo",
-                              CREATE_VECTOR1("ECHO: foo"));
+                              make_packed_array("ECHO: foo"));
   VS(ret[s_code], 200);
   VS(ret[s_response], "POST: echo");
   VS(ret[s_headers][0], "ECHOED: foo");
@@ -382,7 +382,7 @@ bool TestExtCurl::test_evhttp_post_gzip() {
   memset(postBody, 'a', sizeof(fullPostBody) - 7);
   fullPostBody[sizeof(fullPostBody) - 1] = '\0';
   Variant ret = f_evhttp_post(String(get_request_uri()), postBody,
-                              CREATE_VECTOR2("ECHO: foo",
+                              make_packed_array("ECHO: foo",
                                              "Accept-Encoding: gzip"));
   VS(ret[s_code], 200);
   VS(ret[s_response], fullPostBody);
@@ -393,7 +393,7 @@ bool TestExtCurl::test_evhttp_post_gzip() {
 
 bool TestExtCurl::test_evhttp_async_get() {
   Variant ret = f_evhttp_async_get(String(get_request_uri()),
-                                   CREATE_VECTOR1("ECHO: foo"));
+                                   make_packed_array("ECHO: foo"));
   ret = f_evhttp_recv(ret.toResource());
   VS(ret[s_code], 200);
   VS(ret[s_response], "OK");
@@ -404,7 +404,7 @@ bool TestExtCurl::test_evhttp_async_get() {
 
 bool TestExtCurl::test_evhttp_async_post() {
   Variant ret = f_evhttp_async_post(String(get_request_uri()), "echo",
-                                    CREATE_VECTOR1("ECHO: foo"));
+                                    make_packed_array("ECHO: foo"));
   ret = f_evhttp_recv(ret.toResource());
   VS(ret[s_code], 200);
   VS(ret[s_response], "POST: echo");
diff --git a/hphp/test/ext/test_ext_memcached.cpp b/hphp/test/ext/test_ext_memcached.cpp
index cadc7fd98..98e6424aa 100644
--- a/hphp/test/ext/test_ext_memcached.cpp
+++ b/hphp/test/ext/test_ext_memcached.cpp
@@ -68,7 +68,7 @@ bool TestExtMemcached::test_Memcached_get_set() {
   CREATE_MEMCACHED();
 
   const char *key = "foo";
-  Array value = CREATE_MAP1("foo", "bar");
+  Array value = make_map_array("foo", "bar");
   memc->t_set(key, value, EXPIRATION);
   VS(memc->t_get(key), value);
 
@@ -107,7 +107,7 @@ bool TestExtMemcached::test_Memcached_types() {
   list.add(s_float_zero, 0.0);
   list.add(s_null, uninit_null());
   list.add(s_array_empty, Array());
-  list.add(s_array, CREATE_VECTOR4(1, 2, 3, "foo"));
+  list.add(s_array, make_packed_array(1, 2, 3, "foo"));
 
   CREATE_MEMCACHED();
   for (ArrayIter iter(list); iter; ++iter) {
diff --git a/hphp/test/ext/test_ext_server.cpp b/hphp/test/ext/test_ext_server.cpp
index 3dbbdf597..bb9db8586 100644
--- a/hphp/test/ext/test_ext_server.cpp
+++ b/hphp/test/ext/test_ext_server.cpp
@@ -87,7 +87,7 @@ bool TestExtServer::test_pagelet_server_task_result() {
     String url = baseurl + String(i);
     String header = baseheader + String(i);
     String post = basepost + String(i);
-    Resource task = f_pagelet_server_task_start(url, CREATE_VECTOR1(header),
+    Resource task = f_pagelet_server_task_start(url, make_packed_array(header),
                                                 post);
     tasks.push_back(task);
   }
diff --git a/hphp/test/ext/test_logger.cpp b/hphp/test/ext/test_logger.cpp
index 5625bba86..daf65b54c 100644
--- a/hphp/test/ext/test_logger.cpp
+++ b/hphp/test/ext/test_logger.cpp
@@ -51,11 +51,11 @@ bool TestLogger::initializeRun() {
   data.set(String("repository"),   getRepoRoot());
   data.set(String("svnRevision"),  getSVNRevision());
   data.set(String("gitRevision"),  getGitRevision());
-  data.set(String("tags"),         CREATE_VECTOR2("hphp", "c++"));
+  data.set(String("tags"),         make_packed_array("hphp", "c++"));
 
   Array dataArr(data.create());
 
-  Array response = postData(CREATE_MAP1("runData", dataArr));
+  Array response = postData(make_map_array("runData", dataArr));
 
   if (!response[s_result].toBoolean()) {
     return false;
@@ -72,8 +72,8 @@ bool TestLogger::finishRun() {
   if (run_id <= 0)
     return false;
 
-  Array data = CREATE_MAP2("runId",   run_id,
-                           "runData", CREATE_MAP1("stillRunning", false));
+  Array data = make_map_array("runId",   run_id,
+                           "runData", make_map_array("stillRunning", false));
 
   Array response = postData(data);
   if (response[s_result].toBoolean()) {
@@ -88,9 +88,9 @@ bool TestLogger::logTest(Array test) {
   if (run_id <= 0)
     return false;
 
-  Array data = CREATE_MAP3("runId",   run_id,
-                           "runData", CREATE_MAP1("stillRunning", true),
-                           "tests",   CREATE_VECTOR1(test));
+  Array data = make_map_array("runId",   run_id,
+                           "runData", make_map_array("stillRunning", true),
+                           "tests",   make_packed_array(test));
 
   Array response = postData(data);
   if (response[s_result].toBoolean()) {
@@ -107,8 +107,8 @@ Array TestLogger::postData(Array arr) {
   HttpClient client;
   StringBuffer response;
 
-  Array data = CREATE_MAP2("method", "recordTestResults",
-                           "args", f_json_encode(CREATE_VECTOR1(arr)));
+  Array data = make_map_array("method", "recordTestResults",
+                           "args", f_json_encode(make_packed_array(arr)));
 
   String str = f_http_build_query(data);
 
diff --git a/hphp/test/ext/test_server.cpp b/hphp/test/ext/test_server.cpp
index 44a08ec57..0c1a34cea 100644
--- a/hphp/test/ext/test_server.cpp
+++ b/hphp/test/ext/test_server.cpp
@@ -94,7 +94,7 @@ bool TestServer::VerifyServerResponse(const char *input, const char **outputs,
       }
       if (header) {
         f_curl_setopt(c.toResource(), k_CURLOPT_HTTPHEADER,
-                      CREATE_VECTOR1(header));
+                      make_packed_array(header));
       }
       if (responseHeader) {
         f_curl_setopt(c.toResource(), k_CURLOPT_HEADER, 1);