Add support for UTS #46 , along the lines of Zend, to idn_to_ascii.

Removes the output errorCode parameter (that is not currently used anywhere, except in testing code that gets but ignores it). Adds the options, variant and idna_info parameters that are present in the Zend version of idn_to_ascii. Implement the new functionality required by these parameters by using the UTS #46 API, if present.
make test filters consistent
2013-02-19 07:48:43 -08:00 · 2013-02-19 07:02:21 -08:00
@@ -31,21 +31,15 @@ hphp.log
 /hphp/runtime/tmp/run
 /hphp/runtime/tmp/run.sh
 /hphp/runtime/tmp/libtest.so
-/hphp/hphp_build_info.cpp
-/hphp/hphp_repo_schema.h
+/hphp/runtime/vm/repo_schema.h
+/hphp/runtime/base/compiler_id.h
+
+/hphp/hphpi/gen
+/hphp/hphpi/hphpi

 /hphp/hhvm/gen
 /hphp/hhvm/hhvm

-/hphp/runtime/ext/*.ext_hhvm.cpp
-/hphp/runtime/ext/*.ext_hhvm.h
-/hphp/runtime/ext/*/*.ext_hhvm.cpp
-/hphp/runtime/ext/*/*.ext_hhvm.h
-/hphp/runtime/base/builtin_functions.cpp.ext_hhvm.cpp
-/hphp/runtime/base/builtin_functions.cpp.ext_hhvm.h
-/hphp/runtime/ext_hhvm/ext_hhvm_infotabs.cpp
-/hphp/runtime/ext_hhvm/ext_hhvm_infotabs.h
-
 /hphp/tools/shmw/shmw

 /hphp/ffi/java/classes
@@ -58,7 +52,6 @@ hphp.log
 CMakeFiles
 CMakeCache.txt
 cmake_install.cmake
-install_manifest.txt

 /output_gd/

@@ -1,13 +0,0 @@
-language: cpp
-compiler:
-  - gcc
-before_script: 
-  - ./configure_ubuntu_12.04.sh
-# for some tests  
-  - sudo locale-gen de_DE && sudo locale-gen zh_CN.utf8 && sudo locale-gen fr_FR
-  - HPHP_HOME=`pwd` make -j 8
-  
-script: hphp/hhvm/hhvm hphp/test/run quick slow zend
-
-notifications:
-  irc: "chat.freenode.net#hhvm"
@@ -56,20 +56,6 @@ if(ICU_INCLUDE_DIR AND ICU_LIBRARY)
    set(ICU_I18N_FOUND 0)
    set(ICU_I18N_LIBRARIES)
  endif (ICU_I18N_LIBRARY)
-
-  # Look for the ICU data libraries
-  find_library(
-      ICU_DATA_LIBRARY
-    NAMES icudata cygicudata cygicudata32
-    DOC "Libraries to link against for ICU data")
-  mark_as_advanced(ICU_DATA_LIBRARY)
-  if (ICU_DATA_LIBRARY)
-    set(ICU_DATA_FOUND 1)
-    set(ICU_DATA_LIBRARIES ${ICU_DATA_LIBRARY})
-  else (ICU_DATA_LIBRARY)
-    set(ICU_DATA_FOUND 0)
-    set(ICU_DATA_LIBRARIES)
-  endif (ICU_DATA_LIBRARY)
 else(ICU_INCLUDE_DIR AND ICU_LIBRARY)
  set(ICU_FOUND 0)
  set(ICU_I18N_FOUND 0)
@@ -51,14 +51,5 @@ FIND_PACKAGE_HANDLE_STANDARD_ARGS(LibElf DEFAULT_MSG
    LIBELF_LIBRARIES
    LIBELF_INCLUDE_DIRS)

-SET(CMAKE_REQUIRED_LIBRARIES elf)
-INCLUDE(CheckCXXSourceCompiles)
-CHECK_CXX_SOURCE_COMPILES("#include <libelf.h>
-int main() {
-  Elf *e = (Elf*)0;
-  size_t sz;
-  elf_getshdrstrndx(e, &sz);
-  return 0;
-}" ELF_GETSHDRSTRNDX)

-mark_as_advanced(LIBELF_INCLUDE_DIRS LIBELF_LIBRARIES ELF_GETSHDRSTRNDX)
+mark_as_advanced(LIBELF_INCLUDE_DIRS LIBELF_LIBRARIES)
@@ -29,7 +29,7 @@


 #-------------- FIND MYSQL_INCLUDE_DIR ------------------
-FIND_PATH(MYSQL_INCLUDE_DIR mysql.h
+FIND_PATH(MYSQL_INCLUDE_DIR mysql/mysql.h
 		$ENV{MYSQL_INCLUDE_DIR}
 		$ENV{MYSQL_DIR}/include
 		/usr/include/mysql
@@ -1,27 +0,0 @@
-# - Try to find libpthread
-#
-# Once done this will define
-#
-#  LIBPTHREAD_FOUND - system has libpthread
-#  LIBPTHREAD_INCLUDE_DIRS - the libpthread include directory
-#  LIBPTHREAD_LIBRARIES - Link these to use libpthread
-#  LIBPTHREAD_DEFINITIONS - Compiler switches required for using libpthread
-#
-#  Redistribution and use is allowed according to the terms of the New
-#  BSD license.
-#  For details see the accompanying COPYING-CMAKE-SCRIPTS file.
-#
-
-
-if (LIBPTHREAD_LIBRARIES AND LIBPTHREAD_INCLUDE_DIRS)
-  set (LIBPTHREAD_FIND_QUIETLY TRUE)
-endif (LIBPTHREAD_LIBRARIES AND LIBPTHREAD_INCLUDE_DIRS)
-
-find_path (LIBPTHREAD_INCLUDE_DIRS NAMES pthread.h)
-find_library (LIBPTHREAD_LIBRARIES NAMES pthread)
-
-include (FindPackageHandleStandardArgs)
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(LIBPTHREAD DEFAULT_MSG
-    LIBPTHREAD_LIBRARIES LIBPTHREAD_INCLUDE_DIRS)
-
-mark_as_advanced(LIBPTHREAD_INCLUDE_DIRS LIBPTHREAD_LIBRARIES LIBPTHREAD_FOUND)
@@ -18,7 +18,13 @@
 include(CheckFunctionExists)

 # boost checks
-find_package(Boost 1.48.0 COMPONENTS system program_options filesystem regex REQUIRED)
+
+find_package(Boost 1.37.0 COMPONENTS system;program_options;filesystem REQUIRED)
+if (BOOST_VERSION EQUAL 104200)
+	# Boost bug #3942 prevents us using 1.42
+	message(FATAL_ERROR "Boost 1.42 is not compatible with HipHop")
+endif()
+
 include_directories(${Boost_INCLUDE_DIRS})
 link_directories(${Boost_LIBRARY_DIRS})

@@ -138,6 +144,16 @@ include_directories("${HPHP_HOME}/hphp/third_party/lz4")
 include_directories("${HPHP_HOME}/hphp/third_party/double-conversion/src")
 include_directories("${HPHP_HOME}/hphp/third_party/folly")

+FIND_LIBRARY(XHP_LIB xhp)
+FIND_PATH(XHP_INCLUDE_DIR xhp_preprocess.hpp)
+
+if (XHP_LIB AND XHP_INCLUDE_DIR)
+	include_directories(${XHP_INCLUDE_DIR})
+	set(SKIP_BUNDLED_XHP ON)
+else()
+	include_directories("${HPHP_HOME}/hphp/third_party/xhp/xhp")
+endif()
+
 # ICU
 find_package(ICU REQUIRED)
 if (ICU_FOUND)
@@ -177,7 +193,8 @@ if (USE_GOOGLE_HEAP_PROFILER AND GOOGLE_PROFILER_LIB)
 	endif()
 endif()

-if (USE_JEMALLOC AND NOT GOOGLE_TCMALLOC_ENABLED)
+if (USE_JEMALLOC AND NOT GOOGLE_TCMALLOC_ENABLED
+		AND NOT CMAKE_BUILD_TYPE STREQUAL Debug)
 	FIND_LIBRARY(JEMALLOC_LIB jemalloc)
 	if (JEMALLOC_LIB)
 		message(STATUS "Found jemalloc: ${JEMALLOC_LIB}")
@@ -185,7 +202,8 @@ if (USE_JEMALLOC AND NOT GOOGLE_TCMALLOC_ENABLED)
 	endif()
 endif()

-if (USE_TCMALLOC AND NOT JEMALLOC_ENABLED AND NOT GOOGLE_TCMALLOC_ENABLED)
+if (USE_TCMALLOC AND NOT JEMALLOC_ENABLED AND NOT GOOGLE_TCMALLOC_ENABLED
+		AND NOT CMAKE_BUILD_TYPE STREQUAL Debug)
 	FIND_LIBRARY(GOOGLE_TCMALLOC_MIN_LIB tcmalloc_minimal)
 	if (GOOGLE_TCMALLOC_MIN_LIB)
 		message(STATUS "Found minimal tcmalloc: ${GOOGLE_TCMALLOC_MIN_LIB}")
@@ -197,9 +215,6 @@ endif()

 if (JEMALLOC_ENABLED)
 	add_definitions(-DUSE_JEMALLOC=1)
-	if (APPLE)
-		add_definitions(-DJEMALLOC_MANGLE=1 -DJEMALLOC_EXPERIMENTAL=1)
-	endif()
 else()
 	add_definitions(-DNO_JEMALLOC=1)
 endif()
@@ -255,10 +270,6 @@ include_directories(${LDAP_INCLUDE_DIR})
 find_package(Ncurses REQUIRED)
 include_directories(${NCURSES_INCLUDE_PATH})

-# libpthreads
-find_package(PThread REQUIRED)
-include_directories(${LIBPTHREAD_INCLUDE_DIRS})
-
 find_package(Readline REQUIRED)
 include_directories(${READLINE_INCLUDE_DIR})

@@ -270,9 +281,6 @@ include_directories(${LIBDWARF_INCLUDE_DIRS})

 find_package(LibElf REQUIRED)
 include_directories(${LIBELF_INCLUDE_DIRS})
-if (ELF_GETSHDRSTRNDX)
-        add_definitions("-DHAVE_ELF_GETSHDRSTRNDX")
-endif()

 CONTAINS_STRING("${CCLIENT_INCLUDE_PATH}/utf8.h" U8T_DECOMPOSE RECENT_CCLIENT)
 if (NOT RECENT_CCLIENT)
@@ -297,9 +305,12 @@ if (NOT CCLIENT_HAS_SSL)
 	add_definitions(-DSKIP_IMAP_SSL=1)
 endif()

-FIND_LIBRARY(CRYPT_LIB NAMES xcrypt crypt crypto)
 if (LINUX OR FREEBSD)
+	FIND_LIBRARY (CRYPT_LIB NAMES xcrypt crypt)
 	FIND_LIBRARY (RT_LIB rt)
+elseif (APPLE)
+	FIND_LIBRARY (CRYPT_LIB crypto)
+	FIND_LIBRARY (ICONV_LIB iconv)
 endif()

 if (LINUX)
@@ -333,11 +344,6 @@ if (FREEBSD)
 	endif()
 endif()

-if (APPLE)
-	find_library(LIBINTL_LIBRARIES NAMES intl libintl)
-	find_library(KERBEROS_LIB NAMES gssapi_krb5)
-endif()
-
 #find_package(BISON REQUIRED)
 #find_package(FLEX REQUIRED)

@@ -367,7 +373,7 @@ macro(hphp_link target)
 	target_link_libraries(${target} ${LIBUNWIND_LIBRARY})
 	target_link_libraries(${target} ${MYSQL_CLIENT_LIBS})
 	target_link_libraries(${target} ${PCRE_LIBRARY})
-	target_link_libraries(${target} ${ICU_DATA_LIBRARIES} ${ICU_I18N_LIBRARIES} ${ICU_LIBRARIES})
+	target_link_libraries(${target} ${ICU_LIBRARIES} ${ICU_I18N_LIBRARIES})
 	target_link_libraries(${target} ${LIBEVENT_LIB})
 	target_link_libraries(${target} ${CURL_LIBRARIES})
 	target_link_libraries(${target} ${LIBGLOG_LIBRARY})
@@ -398,16 +404,9 @@ if (FREEBSD)
 	target_link_libraries(${target} ${EXECINFO_LIB})
 endif()

-if (APPLE)
-	target_link_libraries(${target} ${LIBINTL_LIBRARIES})
-	target_link_libraries(${target} ${KERBEROS_LIB})
-endif()
-
 	target_link_libraries(${target} ${BFD_LIB})
 	target_link_libraries(${target} ${BINUTIL_LIB})
-if (${LIBPTHREAD_LIBRARIES})
-	target_link_libraries(${target} ${LIBPTHREAD_LIBRARIES})
-endif()
+	target_link_libraries(${target} pthread)
 	target_link_libraries(${target} ${TBB_LIBRARIES})
 	target_link_libraries(${target} ${OPENSSL_LIBRARIES})
 	target_link_libraries(${target} ${ZLIB_LIBRARIES})
@@ -424,9 +423,12 @@ endif()

 	target_link_libraries(${target} ${LIBMEMCACHED_LIBRARY})

-	target_link_libraries(${target} ${CRYPT_LIB})
 	if (LINUX OR FREEBSD)
+		target_link_libraries(${target} ${CRYPT_LIB})
 		target_link_libraries(${target} ${RT_LIB})
+	elseif (APPLE)
+		target_link_libraries(${target} ${CRYPTO_LIB})
+		target_link_libraries(${target} ${ICONV_LIB})
 	endif()

 	target_link_libraries(${target} timelib)
@@ -435,6 +437,12 @@ endif()
 	target_link_libraries(${target} double-conversion)
 	target_link_libraries(${target} folly)

+	if (SKIP_BUNDLED_XHP)
+		target_link_libraries(${target} ${XHP_LIB})
+	else()
+		target_link_libraries(${target} xhp)
+	endif()
+
 	target_link_libraries(${target} afdt)
 	target_link_libraries(${target} mbfl)

@@ -11,13 +11,13 @@ endif()
 if(CMAKE_COMPILER_IS_GNUCC)
 	INCLUDE(CheckCSourceCompiles)
 	CHECK_C_SOURCE_COMPILES("#define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
-#if GCC_VERSION < 40600
-#error Need GCC 4.6.0+
+#if GCC_VERSION < 40400
+#error Need GCC 4.4.0+
 #endif
-int main() { return 0; }" HAVE_GCC_46)
+int main() { return 0; }" HAVE_GCC_44)

-	if(NOT HAVE_GCC_46)
-		message(FATAL_ERROR "Need at least GCC 4.6")
+	if(NOT HAVE_GCC_44)
+		message(FATAL_ERROR "Need at least GCC 4.4")
 	endif()

 endif()
@@ -45,20 +45,11 @@ endif()
 include(HPHPFunctions)
 include(HPHPFindLibs)

-add_definitions(-D_REENTRANT=1 -D_PTHREADS=1 -D__STDC_FORMAT_MACROS)
+add_definitions(-D_GNU_SOURCE -D_REENTRANT=1 -D_PTHREADS=1)
 add_definitions(-DHHVM_LIB_PATH_DEFAULT="${HPHP_HOME}/bin")

-if (LINUX)
-	add_definitions(-D_GNU_SOURCE)
-endif()
-
 if(${CMAKE_BUILD_TYPE} MATCHES "Release")
 	add_definitions(-DRELEASE=1)
-	add_definitions(-DNDEBUG)
-	message("Generating Release build")
-else()
-	add_definitions(-DDEBUG)
-	message("Generating DEBUG build")
 endif()

 if(INFINITE_LOOP_DETECTION)
@@ -109,25 +100,15 @@ if(APPLE OR FREEBSD)
 	add_definitions(-DSKIP_USER_CHANGE=1)
 endif()

-if(APPLE)
-	# We have to be a little more permissive in some cases.
-	add_definitions(-fpermissive)
-
-	# Skip deprecation warnings in OpenSSL. 
-	add_definitions(-DMAC_OS_X_VERSION_MIN_REQUIRED=MAC_OS_X_VERSION_10_6)
-
-	# Just assume we have sched.h
-	add_definitions(-DFOLLY_HAVE_SCHED_H=1)
-
-	# Enable weak linking
-	add_definitions(-DMACOSX_DEPLOYMENT_TARGET=10.6)
-endif()
-
 # enable the OSS options if we have any
 add_definitions(-DHPHP_OSS=1)

-# later versions of binutils don't play well without automake
-add_definitions(-DPACKAGE=hhvm -DPACKAGE_VERSION=Release)
+execute_process(COMMAND git describe --all --long --abbrev=40 --always
+    OUTPUT_VARIABLE _COMPILER_ID OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET)
+
+if (_COMPILER_ID)
+	add_definitions(-DCOMPILER_ID="${_COMPILER_ID}")
+endif()

 IF($ENV{CXX} MATCHES "icpc")
 	set(CMAKE_C_FLAGS "-no-ipo -fp-model precise -wd584 -wd1418 -wd1918 -wd383 -wd869 -wd981 -wd424 -wd1419 -wd444 -wd271 -wd2259 -wd1572 -wd1599 -wd82 -wd177 -wd593 -w")
@@ -1,5 +1,5 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8.5 FATAL_ERROR)
-PROJECT(hphp C CXX ASM)
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6.4 FATAL_ERROR)
+PROJECT(hphp C CXX)

 IF("$ENV{HPHP_HOME}" STREQUAL "")
 	message(FATAL_ERROR "You should set the HPHP_HOME environmental")
@@ -30,5 +30,5 @@ if ("$ENV{USE_HHVM}" STREQUAL "1")
 	message("Building for HHVM")
 endif()
 if ("$ENV{USE_HPHPC}" STREQUAL "1")
-	message(FATAL_ERROR "Building HPHPc is no longer supported")
+	message("Building for HPHPc")
 endif()
@@ -1,33 +1,74 @@
-# HipHop VM for PHP [![Build Status](https://travis-ci.org/facebook/hiphop-php.png?branch=master)](https://travis-ci.org/facebook/hiphop-php)
+# HipHop for PHP

-HipHop VM (HHVM) is a new open-source virtual machine designed for executing programs written in PHP. HHVM uses a just-in-time compilation approach to achieve superior performance while maintaining the flexibility that PHP developers are accustomed to. HipHop VM (and before it HPHPc) has realized > 5x increase in throughput for Facebook compared with Zend PHP 5.2.
+HipHop is a high performance PHP toolchain. Currently supported platforms are Linux and FreeBSD. There is no OS X support.

-HipHop is most commonly run as a standalone server, replacing both Apache and modphp.
+* [Developer Mailing List](http://groups.google.com/group/hiphop-php-dev)
+* [Wiki](http://wiki.github.com/facebook/hiphop-php)
+* [Issue Tracker](http://github.com/facebook/hiphop-php/issues)

-## Installing
+## Required Packages

-You can install a [prebuilt package](https://github.com/facebook/hiphop-php/wiki#installing-pre-built-packages-for-hhvm) or [compile from source](https://github.com/facebook/hiphop-php/wiki#building-hhvm).
+The latest information is available on the [wiki](http://wiki.github.com/facebook/hiphop-php/building-and-installing)

-## Running
+* cmake *2.6 is the minimum version*
+* g++/gcc *4.3 is the minimum version*
+* Boost *1.37 is the minimum version*
+* flex
+* bison
+* re2c
+* libmysql
+* libxml2
+* libmcrypt
+* libicu *4.2 is the minimum version*
+* openssl
+* binutils
+* libcap
+* gd
+* zlib
+* tbb *Intel's Thread Building Blocks*
+* [Oniguruma](http://www.geocities.jp/kosako3/oniguruma/)
+* libpcre
+* libexpat
+* libmemcached
+* google-glog (http://code.google.com/p/google-glog/)

-You can run standalone programs just by passing them to hhvm: `hhvm my_script.php`.
+The following packages have had slight modifications added to them. Patches are provided and should be made against the current source copies.

-HipHop bundles in a webserver. So if you want to run on port 80 in the current directory:
+* [libcurl](http://curl.haxx.se/download.html)
+* src/third_party/libcurl.fb-changes.diff
+* [libevent 1.4](http://www.monkey.org/~provos/libevent/)
+* src/third_party/libevent-1.4.13.fb-changes.diff	OR src/third_party/libevent-1.4.14.fb-changes.diff

-```
-sudo hhvm -m server
-```
+## Installation

-For anything more complicated, you'll want to make a [config.hdf](https://github.com/facebook/hiphop-php/wiki/Runtime-options#server) and run `sudo hhvm -m server -c config.hdf`.
+You may need to point CMake to the location of your custom libcurl and libevent, or to any other libraries which needed to be installed. The *CMAKE_PREFIX_PATH* variable is used to hint to the location.

-## Contributing
+    export CMAKE_PREFIX_PATH=/home/user

-We'd love to have your help in making HipHop better. If you run into problems, please open an [issue](http://github.com/facebook/hiphop-php/issues), or better yet, fork us and send a pull request. Join us on [#hhvm on freenode](http://webchat.freenode.net/?channels=hhvm).
+To build HipHop, use the following:

-If you want to help but don't know where to start, try fixing some of the [Zend tests that don't pass](hphp/test/zend/bad). You can run them with [hphp/test/run](hphp/test/run). When they work, move them to [zend/good](hphp/test/zend/good) and send a pull request.
+Linux:

-Before changes can be accepted a [Contributors Licensing Agreement](http://developers.facebook.com/opensource/cla) ([pdf](https://github.com/facebook/hiphop-php/raw/master/hphp/doc/FB_Individual_CLA.pdf) - print, sign, scan, link) must be signed.
+    cd /home/user/dev
+    git clone git://github.com/facebook/hiphop-php.git
+    cd hiphop-php
+    git submodule init
+    git submodule update
+    export HPHP_HOME=`pwd`
+    export HPHP_LIB=`pwd`/bin
+    cmake .

-## Licence
+If you are using FreeBSD instead use export - setenv

-HipHop VM is licensed under the PHP and Zend licenses except as otherwise noted.
+Once this is done you can generate the build file. This will return you to the shell. Finally, to build, run `make`. If any errors occur, it may be required to remove the CMakeCache.txt directory in the checkout.
+
+    make
+
+## Contributing to HipHop
+HipHop is licensed under the PHP and Zend licenses except as otherwise noted.
+
+Before changes can be accepted a [Contributors Licensing Agreement](http://developers.facebook.com/opensource/cla) must be signed and returned.
+
+## Running HipHop
+
+Please see [the wiki page](http://wiki.github.com/facebook/hiphop-php/running-hiphop)
@@ -1,71 +0,0 @@
-#########################################
-# 
-# Install all the dependancies for HipHop
-#
-#########################################
-
-SCRIPT_NAME='./configure_ubuntu_12.04.sh'
-if [ "$0" != "$SCRIPT_NAME" ]; then
-  echo "Run the script from the hiphop-php directory like:"
-  echo "  $SCRIPT_NAME"
-  exit 1
-fi
-
-export CMAKE_PREFIX_PATH=`/bin/pwd`/..
-export HPHP_HOME=`/bin/pwd`
-
-sudo apt-get install git-core cmake g++ libboost1.48-dev libmysqlclient-dev \
-  libxml2-dev libmcrypt-dev libicu-dev openssl build-essential binutils-dev \
-  libcap-dev libgd2-xpm-dev zlib1g-dev libtbb-dev libonig-dev libpcre3-dev \
-  autoconf libtool libcurl4-openssl-dev libboost-regex1.48-dev libboost-system1.48-dev \
-  libboost-program-options1.48-dev libboost-filesystem1.48-dev wget memcached \
-  libreadline-dev libncurses-dev libmemcached-dev libbz2-dev \
-  libc-client2007e-dev php5-mcrypt php5-imagick libgoogle-perftools-dev \
-  libcloog-ppl0 libelf-dev libdwarf-dev libunwind7-dev subversion
-
-# libevent
-git clone git://github.com/libevent/libevent.git
-cd libevent
-git checkout release-1.4.14b-stable
-cat ../hphp/third_party/libevent-1.4.14.fb-changes.diff | patch -p1
-./autogen.sh
-./configure --prefix=$CMAKE_PREFIX_PATH
-make
-make install
-cd ..
-
-# curl
-git clone git://github.com/bagder/curl.git
-cd curl
-./buildconf
-./configure --prefix=$CMAKE_PREFIX_PATH
-make
-make install
-cd ..
-
-# glog
-svn checkout http://google-glog.googlecode.com/svn/trunk/ google-glog
-cd google-glog
-./configure --prefix=$CMAKE_PREFIX_PATH
-make
-make install
-cd ..
-
-# jemaloc
-wget http://www.canonware.com/download/jemalloc/jemalloc-3.0.0.tar.bz2
-tar xjvf jemalloc-3.0.0.tar.bz2
-cd jemalloc-3.0.0
-./configure --prefix=$CMAKE_PREFIX_PATH
-make
-make install
-cd ..
-
-# cleanup
-rm -rf libevent curl google-glog jemalloc-3.0.0.tar.bz2 jemalloc-3.0.0
-
-# hphp
-cmake .
-
-echo "-------------------------------------------------------------------------"
-echo "Done. Now run:"
-echo "  CMAKE_PREFIX_PATH=\`pwd\`/.. HPHP_HOME=\`pwd\` make"
@@ -17,12 +17,26 @@

 include(HPHPSetup)

-# HHVM Build
-SET(USE_HHVM TRUE)
-SET(ENV{HHVM} 1)
-ADD_DEFINITIONS("-DHHVM -DHHVM_BINARY=1 -DHHVM_PATH=\\\"${HPHP_HOME}/hphp/hhvm/hhvm\\\"")
+if ("$ENV{USE_HHVM}" STREQUAL "1")
+	# HHVM Build
+	SET(USE_HHVM TRUE)
+	SET(ENV{HHVM} 1)
+	ADD_DEFINITIONS("-DHHVM -DHHVM_BINARY=1 -DHHVM_PATH=\\\"${HPHP_HOME}/hphp/hhvm/hhvm\\\"")

-set(RECURSIVE_SOURCE_SUBDIRS runtime/base runtime/debugger runtime/eval runtime/ext runtime/vm util)
+	if ("$ENV{USE_HPHPC}" STREQUAL "1")
+		message(FATAL_ERROR "Both USE_HHVM and USE_HPHPC are set, you may only select one")
+	endif()
+else()
+	# HPHPc Build
+	SET(USE_HHVM FALSE)
+	ADD_DEFINITIONS("-DHHVM_PATH=\"\"")
+
+	if (NOT "$ENV{USE_HPHPC}" STREQUAL "1")
+		message(FATAL_ERROR "You must select which version of HipHop to build by setting either USE_HHVM=1 or USE_HPHPC=1 in your environment")
+	endif()
+endif()
+
+set(RECURSIVE_SOURCE_SUBDIRS runtime/base runtime/eval runtime/ext runtime/vm system/gen system/lib util)
 foreach (dir ${RECURSIVE_SOURCE_SUBDIRS})

 	auto_sources(files "*.cpp" "RECURSE" "${CMAKE_CURRENT_SOURCE_DIR}/${dir}")
@@ -31,28 +45,99 @@ foreach (dir ${RECURSIVE_SOURCE_SUBDIRS})
 	auto_sources(files "*.c" "RECURSE" "${CMAKE_CURRENT_SOURCE_DIR}/${dir}")
 	list(APPEND C_SOURCES ${files})

-	auto_sources(files "*.S" "RECURSE" "${CMAKE_CURRENT_SOURCE_DIR}/${dir}")
-	list(APPEND ASM_SOURCES ${files})
 endforeach(dir ${RECURSIVE_SOURCE_SUBDIRS})

+# Disable hardware counters off of Linux
 if(NOT LINUX)
 	add_definitions(-DNO_HARDWARE_COUNTERS)
-	list(REMOVE_ITEM CXX_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/runtime/vm/debug/elfwriter.cpp)
+	list(REMOVE_ITEM CXX_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/runtime/base/hardware_counter.cpp)
 endif()

-# remove ext_hhvm, and anything in a test folder
+# remove ext_hhvm, util/tests, and runtime/vm/translator/test
 foreach (file ${CXX_SOURCES})
       	if (${file} MATCHES "ext_hhvm")
 		list(REMOVE_ITEM CXX_SOURCES ${file})
 	endif()
-	if (${file} MATCHES "/test/")
+	if (${file} MATCHES "util/test")
+		list(REMOVE_ITEM CXX_SOURCES ${file})
+	endif()
+	if (${file} MATCHES "runtime/vm/translator/test")
+		list(REMOVE_ITEM CXX_SOURCES ${file})
+	endif()
+	if (${file} MATCHES "runtime/vm/translator/hopt/test")
 		list(REMOVE_ITEM CXX_SOURCES ${file})
 	endif()
 endforeach(file ${CXX_SOURCES})

+# remove ext/sep for hhvm
+if (USE_HHVM)
+	foreach (file ${CXX_SOURCES})
+		if (${file} MATCHES "ext/sep")
+			list(REMOVE_ITEM CXX_SOURCES ${file})
+		endif()
+	endforeach(file ${CXX_SOURCES})
+endif(USE_HHVM)
+
+
+if (EXISTS "${hphp_SOURCE_DIR}/HPHP_EXCLUDE_FILES.txt")
+	FILE(READ ${hphp_SOURCE_DIR}/HPHP_EXCLUDE_FILES.txt HPHP_EXCLUDE_FILES)
+	STRING(REGEX REPLACE "[\n\r]" ";" HPHP_EXCLUDE_FILES "${HPHP_EXCLUDE_FILES}")
+else ()
+	SET(HPHP_EXCLUDE_FILES)
+endif ()
+
+foreach (t ${HPHP_EXCLUDE_FILES})
+	string(SUBSTRING ${t} 0 1 T_FIRST_CHAR)
+	if (${T_FIRST_CHAR} STREQUAL "D")
+
+		string(REGEX REPLACE "^[D]" "" SKIP_DIR "${t}")
+		file(TO_CMAKE_PATH "${hphp_SOURCE_DIR}/${SKIP_DIR}" SKIP_DIR)
+		string(LENGTH "${SKIP_DIR}" SKIP_DIR_LENGTH)
+		
+		message(STATUS "Let's remove ${SKIP_DIR}")
+
+		foreach (file ${CXX_SOURCES})
+			string(LENGTH "${file}" FILE_LENGTH)
+			if (${FILE_LENGTH} GREATER ${SKIP_DIR_LENGTH})
+				string(SUBSTRING ${file} 0 ${SKIP_DIR_LENGTH} FILE_PATH)
+				if (${FILE_PATH} STREQUAL ${SKIP_DIR})
+					list(REMOVE_ITEM CXX_SOURCES ${file})
+				endif ()
+			endif ()
+		endforeach(file ${CXX_SOURCES})
+
+	elseif (${T_FIRST_CHAR} STREQUAL "#")
+
+		# doing nothing since this is a comment
+
+	else ()
+		list(FIND CXX_SOURCES "${hphp_SOURCE_DIR}/${t}" FOUND_T)
+		if (FOUND_T GREATER -1)
+			LIST(REMOVE_AT CXX_SOURCES ${FOUND_T})
+		endif()
+	endif ()
+endforeach(t ${HPHP_EXCLUDE_FILES})
+
+#FLEX_TARGET(HphpScanner ${CMAKE_CURRENT_SOURCE_DIR}/runtime/eval/parser/hphp.x ${CMAKE_CURRENT_SOURCE_DIR}/runtime/eval/parser/lex.eval_.cpp COMPILE_FLAGS " -w -i -Peval_")
+#BISON_TARGET(HphpParser ${CMAKE_CURRENT_SOURCE_DIR}/runtime/eval/parser/hphp.y ${CMAKE_CURRENT_SOURCE_DIR}/runtime/eval/parser/hphp.tab.cpp  COMPILE_FLAGS " -v -d -p eval_")
+#ADD_FLEX_BISON_DEPENDENCY(HphpScanner HphpParser)
+
+# required to remove warning when a file is there twice
+#list(REMOVE_ITEM CXX_SOURCES ${FLEX_HphpScanner_OUTPUTS} ${BISON_HphpParser_OUTPUTS})
+#list(APPEND CXX_SOURCES ${FLEX_HphpScanner_OUTPUTS} ${BISON_HphpParser_OUTPUTS})
+
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/bin")
 set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/bin")

+#add_library(sqlite3 STATIC "${CMAKE_CURRENT_SOURCE_DIR}/third_party/libsqlite3/sqlite3.c")
+
+#auto_sources(TIMELIB_SOURCES "*.c" "RECURSE" "${CMAKE_CURRENT_SOURCE_DIR}/third_party/timelib")
+#add_library(timelib STATIC ${TIMELIB_SOURCES})
+
+if (NOT SKIP_BUNDLED_XHP)
+	add_subdirectory(third_party/xhp/xhp)
+endif()
+
 add_subdirectory(third_party/libafdt)
 add_subdirectory(third_party/libmbfl)
 add_subdirectory(third_party/libsqlite3)
@@ -72,30 +157,39 @@ foreach (CXX_FILE ${CXX_SOURCES})
 endforeach()

 add_custom_command(
-  OUTPUT hphp_repo_schema.h hphp_build_info.cpp
-  COMMAND hphp/util/generate_buildinfo.sh
+  OUTPUT runtime/base/compiler_id.h
+  COMMAND hphp/tools/generate_compiler_id.sh
  DEPENDS ${CXX_SOURCES} ${C_SOURCES}
  WORKING_DIRECTORY ${HPHP_HOME}
-  COMMENT "Generating Repo Schema ID and Compiler ID"
+  COMMENT "Generating Compiler ID"
  VERBATIM)

-ADD_LIBRARY(hphp_runtime_static STATIC
-            hphp_repo_schema.h hphp_build_info.cpp
-            ${CXX_SOURCES} ${C_SOURCES} ${ASM_SOURCES})
+add_custom_command(
+  OUTPUT runtime/vm/repo_schema.h
+  COMMAND hphp/tools/generate_repo_schema.sh
+  DEPENDS ${CXX_SOURCES} ${C_SOURCES}
+  WORKING_DIRECTORY ${HPHP_HOME}
+  COMMENT "Generating Repo Schema ID"
+  VERBATIM)
+
+ADD_LIBRARY(hphp_runtime_static STATIC runtime/vm/repo_schema.h runtime/base/compiler_id.h ${CXX_SOURCES} ${C_SOURCES})
+#ADD_LIBRARY(hphp_runtime SHARED ${C_SOURCES} ${CXX_SOURCES})
 SET_TARGET_PROPERTIES(hphp_runtime_static PROPERTIES OUTPUT_NAME "hphp_runtime")
 SET_TARGET_PROPERTIES(hphp_runtime_static PROPERTIES PREFIX "lib")
+#SET_TARGET_PROPERTIES(hphp_runtime PROPERTIES CLEAN_DIRECT_OUTPUT 1)
 SET_TARGET_PROPERTIES(hphp_runtime_static PROPERTIES CLEAN_DIRECT_OUTPUT 1)

 SET(CMAKE_CXX_ARCHIVE_APPEND "<CMAKE_AR> q <TARGET> <LINK_FLAGS> <OBJECTS>")

 hphp_link(hphp_runtime_static)

-add_subdirectory("tools/bootstrap")
-
 add_subdirectory(compiler)
-add_subdirectory(runtime/ext_hhvm)
+
+if (USE_HHVM)
+	add_subdirectory(runtime/ext_hhvm)
+endif()
+
 add_subdirectory(hhvm)
-add_subdirectory(system)

 if (NOT "$ENV{HPHP_NOTEST}" STREQUAL "1")
 	add_subdirectory(test)
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,61 +14,55 @@
   +----------------------------------------------------------------------+
 */

-#include "hphp/compiler/analysis/alias_manager.h"
+#include <compiler/analysis/analysis_result.h>
+#include <compiler/analysis/function_scope.h>
+#include <compiler/expression/expression.h>
+#include <compiler/expression/assignment_expression.h>
+#include <compiler/expression/array_element_expression.h>
+#include <compiler/expression/list_assignment.h>
+#include <compiler/expression/binary_op_expression.h>
+#include <compiler/expression/unary_op_expression.h>
+#include <compiler/expression/qop_expression.h>
+#include <compiler/expression/simple_variable.h>
+#include <compiler/expression/scalar_expression.h>
+#include <compiler/expression/simple_function_call.h>
+#include <compiler/expression/array_element_expression.h>
+#include <compiler/expression/object_property_expression.h>
+#include <compiler/expression/object_method_expression.h>
+#include <compiler/expression/parameter_expression.h>
+#include <compiler/expression/expression_list.h>
+#include <compiler/expression/expression.h>
+#include <compiler/expression/include_expression.h>
+#include <compiler/expression/closure_expression.h>
+#include <compiler/statement/statement.h>
+#include <compiler/statement/statement_list.h>
+#include <compiler/statement/catch_statement.h>
+#include <compiler/statement/method_statement.h>
+#include <compiler/statement/block_statement.h>
+#include <compiler/statement/if_statement.h>
+#include <compiler/statement/if_branch_statement.h>
+#include <compiler/statement/break_statement.h>
+#include <compiler/statement/return_statement.h>
+#include <compiler/statement/loop_statement.h>
+#include <compiler/statement/foreach_statement.h>
+#include <compiler/statement/for_statement.h>
+#include <compiler/statement/while_statement.h>
+#include <compiler/statement/do_statement.h>
+#include <compiler/statement/exp_statement.h>
+#include <compiler/statement/echo_statement.h>
+#include <compiler/statement/try_statement.h>
+#include <compiler/analysis/alias_manager.h>
+#include <compiler/analysis/control_flow.h>
+#include <compiler/analysis/variable_table.h>
+#include <compiler/analysis/data_flow.h>
+#include <compiler/analysis/dictionary.h>
+#include <compiler/analysis/expr_dict.h>
+#include <compiler/analysis/live_dict.h>
+#include <compiler/analysis/ref_dict.h>

-#include "hphp/compiler/analysis/analysis_result.h"
-#include "hphp/compiler/analysis/function_scope.h"
-#include "hphp/compiler/expression/expression.h"
-#include "hphp/compiler/expression/assignment_expression.h"
-#include "hphp/compiler/expression/array_element_expression.h"
-#include "hphp/compiler/expression/list_assignment.h"
-#include "hphp/compiler/expression/binary_op_expression.h"
-#include "hphp/compiler/expression/unary_op_expression.h"
-#include "hphp/compiler/expression/qop_expression.h"
-#include "hphp/compiler/expression/simple_variable.h"
-#include "hphp/compiler/expression/scalar_expression.h"
-#include "hphp/compiler/expression/simple_function_call.h"
-#include "hphp/compiler/expression/array_element_expression.h"
-#include "hphp/compiler/expression/object_property_expression.h"
-#include "hphp/compiler/expression/object_method_expression.h"
-#include "hphp/compiler/expression/parameter_expression.h"
-#include "hphp/compiler/expression/expression_list.h"
-#include "hphp/compiler/expression/expression.h"
-#include "hphp/compiler/expression/include_expression.h"
-#include "hphp/compiler/expression/closure_expression.h"
-#include "hphp/compiler/statement/statement.h"
-#include "hphp/compiler/statement/statement_list.h"
-#include "hphp/compiler/statement/catch_statement.h"
-#include "hphp/compiler/statement/method_statement.h"
-#include "hphp/compiler/statement/block_statement.h"
-#include "hphp/compiler/statement/if_statement.h"
-#include "hphp/compiler/statement/if_branch_statement.h"
-#include "hphp/compiler/statement/switch_statement.h"
-#include "hphp/compiler/statement/break_statement.h"
-#include "hphp/compiler/statement/return_statement.h"
-#include "hphp/compiler/statement/loop_statement.h"
-#include "hphp/compiler/statement/foreach_statement.h"
-#include "hphp/compiler/statement/for_statement.h"
-#include "hphp/compiler/statement/while_statement.h"
-#include "hphp/compiler/statement/do_statement.h"
-#include "hphp/compiler/statement/exp_statement.h"
-#include "hphp/compiler/statement/echo_statement.h"
-#include "hphp/compiler/statement/try_statement.h"
-#include "hphp/compiler/statement/global_statement.h"
-#include "hphp/compiler/statement/static_statement.h"
-#include "hphp/compiler/analysis/control_flow.h"
-#include "hphp/compiler/analysis/variable_table.h"
-#include "hphp/compiler/analysis/data_flow.h"
-#include "hphp/compiler/analysis/dictionary.h"
-#include "hphp/compiler/analysis/expr_dict.h"
-#include "hphp/compiler/analysis/live_dict.h"
-#include "hphp/compiler/analysis/ref_dict.h"
-
-#include "hphp/runtime/base/builtin_functions.h"
-
-#include "hphp/util/parser/hphp.tab.hpp"
-#include "hphp/util/parser/location.h"
-#include "hphp/util/util.h"
+#include <util/parser/hphp.tab.hpp>
+#include <util/parser/location.h>
+#include <util/util.h>

 #define spc(T,p) boost::static_pointer_cast<T>(p)
 #define dpc(T,p) boost::dynamic_pointer_cast<T>(p)
@@ -266,7 +260,7 @@ void AliasManager::beginScope() {
  ExpressionPtr e(new ScalarExpression(BlockScopePtr(), LocationPtr(),
                                       T_STRING, string("begin")));
  m_accessList.add(e);
-  m_stack.push_back(CondStackElem(m_accessList.size()));
+  m_stack.push_back(m_accessList.size());
  m_accessList.beginScope();
  if (BucketMapEntry *tail = m_bucketList) {
    BucketMapEntry *bm = tail;
@@ -538,7 +532,11 @@ int AliasManager::testAccesses(ExpressionPtr e1, ExpressionPtr e2,
          goto def;
        }
        case Expression::KindOfIncludeExpression: {
-          return InterfAccess;
+          IncludeExpressionPtr inc(spc(IncludeExpression, e2));
+          if (!inc->isPrivateScope()) {
+            return InterfAccess;
+          }
+          goto def;
        }
        case Expression::KindOfStaticMemberExpression:
        case Expression::KindOfObjectPropertyExpression:
@@ -604,14 +602,10 @@ void AliasManager::cleanRefs(ExpressionPtr e,
                             ExpressionPtrList::reverse_iterator it,
                             ExpressionPtrList::reverse_iterator &end,
                             int depth) {
-  if (e->is(Expression::KindOfUnaryOpExpression) &&
-      e->getLocalEffects() == Expression::UnknownEffect) {
-    return;
-  }
  if (e->is(Expression::KindOfAssignmentExpression) ||
      e->is(Expression::KindOfBinaryOpExpression) ||
      e->is(Expression::KindOfUnaryOpExpression)) {
-    ExpressionPtr var = e->getStoreVariable();
+    ExpressionPtr var = e->getNthExpr(0);
    if (var->is(Expression::KindOfSimpleVariable) &&
        !(var->getContext() & Expression::RefAssignmentLHS)) {
      SimpleVariablePtr sv(spc(SimpleVariable, var));
@@ -759,7 +753,6 @@ void AliasManager::killLocals() {
        continue;

      case Expression::KindOfUnaryOpExpression:
-        if (e->getLocalEffects() == Expression::UnknownEffect) goto kill_it;
        cleanInterf(spc(UnaryOpExpression, e)->getExpression(),
                    ++it, end, depth);
        continue;
@@ -857,33 +850,17 @@ int AliasManager::checkInterf(ExpressionPtr rv, ExpressionPtr e,
    }

    case Expression::KindOfUnaryOpExpression:
-      if (e->getLocalEffects() == Expression::UnknownEffect) {
-        isLoad = false;
-        return InterfAccess;
-      }
-      // fall through
-    case Expression::KindOfAssignmentExpression:
-    case Expression::KindOfBinaryOpExpression: {
      isLoad = false;
-      ExpressionPtr var = e->getStoreVariable();
-      int access = testAccesses(var, rv, forLval);
-      if (access == SameAccess) {
-        // An assignment to something that might be visible from
-        // another scope, and that might contain an object, could
-        // end up with some other value (due to a destructor running)
-        // than the rhs.
-        if (var->getKindOf() != Expression::KindOfSimpleVariable) {
-          return InterfAccess;
-        }
-        SimpleVariablePtr sv = static_pointer_cast<SimpleVariable>(var);
-        if (sv->couldBeAliased() &&
-            (sv->isNeededValid() ? sv->isNeeded() :
-             !sv->getSymbol() || sv->getSymbol()->isNeeded())) {
-          return InterfAccess;
-        }
-      }
-      return access;
-    }
+      return testAccesses(
+          spc(UnaryOpExpression,e)->getExpression(), rv, forLval);
+    case Expression::KindOfBinaryOpExpression:
+      isLoad = false;
+      return testAccesses(
+          spc(BinaryOpExpression,e)->getExp1(), rv, forLval);
+    case Expression::KindOfAssignmentExpression:
+      isLoad = false;
+      return testAccesses(
+          spc(AssignmentExpression,e)->getVariable(), rv, forLval);

    default:
      not_reached();
@@ -910,13 +887,11 @@ int AliasManager::checkAnyInterf(ExpressionPtr e1, ExpressionPtr e2,
      return DisjointAccess;
    }
    case Expression::KindOfAssignmentExpression:
-    case Expression::KindOfBinaryOpExpression:
+      e1 = spc(AssignmentExpression, e1)->getVariable();
+      break;
    case Expression::KindOfUnaryOpExpression:
-      if (e1->getLocalEffects() == Expression::UnknownEffect) {
-        isLoad = false;
-        return InterfAccess;
-      }
-      e1 = e1->getStoreVariable();
+    case Expression::KindOfBinaryOpExpression:
+      e1 = e1->getNthExpr(0);
      if (!e1 || !e1->hasContext(Expression::OprLValue)) return DisjointAccess;
      break;
    default:
@@ -1094,10 +1069,14 @@ void AliasManager::setCanonPtrForArrayCSE(
    // need to switch on rep
    ExpressionPtr rep0;
    switch (rep->getKindOf()) {
-    case Expression::KindOfAssignmentExpression:
-    case Expression::KindOfBinaryOpExpression:
    case Expression::KindOfUnaryOpExpression:
-      rep0 = rep->getStoreVariable();
+      rep0 = spc(UnaryOpExpression, rep)->getExpression();
+      break;
+    case Expression::KindOfBinaryOpExpression:
+      rep0 = spc(BinaryOpExpression, rep)->getExp1();
+      break;
+    case Expression::KindOfAssignmentExpression:
+      rep0 = spc(AssignmentExpression, rep)->getVariable();
      break;
    case Expression::KindOfListAssignment:
      // TODO: IMPLEMENT
@@ -1177,12 +1156,11 @@ ExpressionPtr AliasManager::canonicalizeNode(
    return ExpressionPtr();
  }

-  ExpressionPtr var;
  switch (e->getKindOf()) {
-    case Expression::KindOfAssignmentExpression: {
+    case Expression::KindOfAssignmentExpression:
    case Expression::KindOfBinaryOpExpression:
-    case Expression::KindOfUnaryOpExpression:
-      ExpressionPtr var = e->getStoreVariable();
+    case Expression::KindOfUnaryOpExpression: {
+      ExpressionPtr var = e->getNthExpr(0);
      if (var && var->getContext() & (Expression::AssignmentLHS|
                                      Expression::OprLValue)) {
        processAccessChain(var);
@@ -1291,7 +1269,6 @@ ExpressionPtr AliasManager::canonicalizeNode(
          }
          case Expression::KindOfUnaryOpExpression: {
            UnaryOpExpressionPtr u = spc(UnaryOpExpression, rep);
-            assert(u->getOp() == T_INC || u->getOp() == T_DEC);
            if (Option::EliminateDeadCode) {
              if (u->getActualType() && u->getActualType()->isInteger()) {
                ExpressionPtr val = u->getExpression()->clone();
@@ -1410,7 +1387,7 @@ ExpressionPtr AliasManager::canonicalizeNode(
                              value = value->replaceValue(
                                canonicalizeRecurNonNull(
                                  value->makeConstant(m_arp, "null")));
-                              a->setValue(value);
+                              a->setNthKid(1, value);
                              a->recomputeEffects();
                              setChanged();
                            } else {
@@ -1421,7 +1398,7 @@ ExpressionPtr AliasManager::canonicalizeNode(
                              a = spc(AssignmentExpression, a->clone());
                              el->addElement(a);
                              el->addElement(a->getValue());
-                              a->setValue(value->makeConstant(m_arp, "null"));
+                              a->setNthKid(1, value->makeConstant(m_arp, "null"));
                              rep->setReplacement(el);
                              m_replaced++;
                            }
@@ -1526,8 +1503,7 @@ ExpressionPtr AliasManager::canonicalizeNode(
            e->is(Expression::KindOfSimpleVariable) &&
            !e->isThis()) {
          Symbol *s = spc(SimpleVariable, e)->getSymbol();
-          if (s && !s->isParameter() && !s->isGeneratorParameter() &&
-              !s->isClosureVar()) {
+          if (s && !s->isParameter() && !s->isClosureVar()) {
            rep = e->makeConstant(m_arp, "null");
            Compiler::Error(Compiler::UseUndeclaredVariable, e);
            if (m_variables->getAttribute(VariableTable::ContainsCompact)) {
@@ -1586,17 +1562,17 @@ ExpressionPtr AliasManager::canonicalizeNode(
              }
              cur = next;
            }
-            if (!m_inCall &&
-                !last->is(Expression::KindOfYieldExpression) &&
+            if ((!m_inCall || (!hhvm && !ae->getValue()->hasEffect())) &&
                ae->isUnused() && m_accessList.isLast(ae) &&
-                !e->hasAnyContext(Expression::AccessContext |
-                                  Expression::ObjectContext |
-                                  Expression::ExistContext |
-                                  Expression::UnsetContext)) {
+                !(hhvm && Option::OutputHHBC &&
+                  e->hasAnyContext(Expression::AccessContext |
+                                   Expression::ObjectContext |
+                                   Expression::ExistContext |
+                                   Expression::UnsetContext))) {
              rep = ae->clone();
              ae->setContext(Expression::DeadStore);
-              ae->setValue(ae->makeConstant(m_arp, "null"));
-              ae->setVariable(ae->makeConstant(m_arp, "null"));
+              ae->setNthKid(1, ae->makeConstant(m_arp, "null"));
+              ae->setNthKid(0, ae->makeConstant(m_arp, "null"));
              e->recomputeEffects();
              m_replaced++;
              return e->replaceValue(canonicalizeRecurNonNull(rep));
@@ -1683,7 +1659,7 @@ ExpressionPtr AliasManager::canonicalizeNode(
                    while (v->getCanonPtr() && v->getCanonPtr() != op0) {
                      v = v->getCanonPtr();
                    }
-                    ok = (v->getCanonPtr() != nullptr);
+                    ok = v->getCanonPtr();
                  }
                  if (ok) {
                    b2->setContext(Expression::DeadStore);
@@ -1731,15 +1707,18 @@ ExpressionPtr AliasManager::canonicalizeNode(
            if (interf == SameAccess) {
              switch (alt->getKindOf()) {
                case Expression::KindOfAssignmentExpression:
+                  alt = spc(AssignmentExpression,alt)->getVariable();
+                  break;
                case Expression::KindOfBinaryOpExpression:
+                  alt = spc(BinaryOpExpression,alt)->getExp1();
+                  break;
                case Expression::KindOfUnaryOpExpression:
-                  alt = alt->getStoreVariable();
+                  alt = spc(UnaryOpExpression,alt)->getExpression();
                  break;
                default:
                  break;
              }
-              always_assert(alt->getKindOf() ==
-                            uop->getExpression()->getKindOf());
+              always_assert(alt->getKindOf() == uop->getExpression()->getKindOf());
              uop->getExpression()->setCanonID(alt->getCanonID());
            } else {
              uop->getExpression()->setCanonID(m_nextID++);
@@ -1748,11 +1727,7 @@ ExpressionPtr AliasManager::canonicalizeNode(
          add(m_accessList, e);
          break;
        default:
-          if (uop->getLocalEffects() == Expression::UnknownEffect) {
-            add(m_accessList, e);
-          } else {
-            getCanonical(e);
-          }
+          getCanonical(e);
          break;
      }
      break;
@@ -1779,8 +1754,6 @@ ExpressionPtr AliasManager::canonicalizeNode(
 }

 void AliasManager::canonicalizeKid(ConstructPtr c, ExpressionPtr kid, int i) {
-  assert(c->getNthKid(i) == kid);
-
  if (kid) {
    StatementPtr sp(dpc(Statement, c));
    if (sp) beginInExpression(sp, kid);
@@ -1800,8 +1773,6 @@ void AliasManager::canonicalizeKid(ConstructPtr c, ExpressionPtr kid, int i) {
 }

 int AliasManager::canonicalizeKid(ConstructPtr c, ConstructPtr kid, int i) {
-  assert(c->getNthKid(i) == kid);
-
  int ret = FallThrough;
  if (kid) {
    ExpressionPtr e = dpc(Expression, kid);
@@ -1835,34 +1806,51 @@ ExpressionPtr AliasManager::canonicalizeRecur(ExpressionPtr e) {
  bool setInCall = true;

  switch (e->getKindOf()) {
-    case Expression::KindOfQOpExpression: {
-      QOpExpressionPtr qe(spc(QOpExpression, e));
-      canonicalizeKid(e, qe->getCondition(), 0);
+    case Expression::KindOfQOpExpression:
+      canonicalizeKid(e, e->getNthExpr(0), 0);
      beginScope();
-      if (ExpressionPtr e1 = qe->getYes()) {
+      if (ExpressionPtr e1 = e->getNthExpr(1)) {
        canonicalizeKid(e, e1, 1);
        resetScope();
      }
-      canonicalizeKid(e, qe->getNo(), 2);
+      canonicalizeKid(e, e->getNthExpr(2), 2);
      endScope();
      return canonicalizeNode(e);
-    }
-    case Expression::KindOfBinaryOpExpression: {
-      BinaryOpExpressionPtr binop(spc(BinaryOpExpression, e));
-      if (binop->isShortCircuitOperator()) {
-        canonicalizeKid(e, binop->getExp1(), 0);
-        beginScope();
-        canonicalizeKid(e, binop->getExp2(), 1);
-        endScope();
-        return canonicalizeNode(e);
+
+    case Expression::KindOfBinaryOpExpression:
+      {
+        BinaryOpExpressionPtr binop(spc(BinaryOpExpression, e));
+        if (binop->isShortCircuitOperator()) {
+          canonicalizeKid(e, e->getNthExpr(0), 0);
+          beginScope();
+          canonicalizeKid(e, e->getNthExpr(1), 1);
+          endScope();
+          return canonicalizeNode(e);
+        }
      }
      break;
-    }
+
    case Expression::KindOfExpressionList:
      delayVars = false;
      break;

    case Expression::KindOfSimpleFunctionCall:
+      if (!hhvm || !Option::OutputHHBC) {
+        SimpleFunctionCallPtr f(spc(SimpleFunctionCall, e));
+        if (!f->getClass()) {
+          if (f->getClassName().empty()) {
+            if (f->getFuncScope() &&
+                !f->getFuncScope()->isVolatile()) {
+              setInCall = false;
+            }
+          } else if (ClassScopePtr cls = f->resolveClass()) {
+            if (!cls->isVolatile()) {
+              setInCall = false;
+            }
+          }
+        }
+      }
+      // fall through
    case Expression::KindOfNewObjectExpression:
    case Expression::KindOfDynamicFunctionCall:
      inCall = setInCall;
@@ -1884,7 +1872,6 @@ ExpressionPtr AliasManager::canonicalizeRecur(ExpressionPtr e) {

  int n = e->getKidCount();
  if (n < 2) delayVars = false;
-  if (e->is(Expression::KindOfAssignmentExpression)) delayVars = false;

  m_inCall += inCall;
  for (int j = delayVars ? 0 : 1; j < 2; j++) {
@@ -1954,42 +1941,42 @@ StatementPtr AliasManager::canonicalizeRecur(StatementPtr s, int &ret) {
    // and fall through
    break;

-  case Statement::KindOfIfStatement: {
-    IfStatementPtr is = spc(IfStatement, s);
-    StatementListPtr iflist = is->getIfBranches();
-    if (iflist) {
-      for (int i = 0, n = iflist->getKidCount(); i < n; i++) {
-        IfBranchStatementPtr ifstmt = spc(IfBranchStatement, (*iflist)[i]);
-        canonicalizeKid(ifstmt, ifstmt->getCondition(), 0);
-        if (!i) beginScope();
-        beginScope();
-        canonicalizeKid(ifstmt, ifstmt->getStmt(), 1);
+  case Statement::KindOfIfStatement:
+    {
+      StatementPtr iflist = spc(Statement, s->getNthKid(0));
+      if (iflist) {
+        for (int i = 0, n = iflist->getKidCount(); i < n; i++) {
+          StatementPtr ifstmt = spc(Statement, iflist->getNthKid(i));
+          ExpressionPtr cond = spc(Expression, ifstmt->getNthKid(0));
+          canonicalizeKid(ifstmt, cond, 0);
+          if (!i) beginScope();
+          beginScope();
+          canonicalizeKid(ifstmt, ifstmt->getNthKid(1), 1);
+          endScope();
+          if (i+1 < n) resetScope();
+        }
        endScope();
-        if (i+1 < n) resetScope();
      }
-      endScope();
+      ret = FallThrough;
+      start = nkid;
    }
-    ret = FallThrough;
-    start = nkid;
    break;
-  }

  case Statement::KindOfIfBranchStatement:
    always_assert(0);
    break;

-  case Statement::KindOfForStatement: {
-    ForStatementPtr fs(spc(ForStatement, s));
-    canonicalizeKid(s, fs->getInitExp(), 0);
+  case Statement::KindOfForStatement:
+    canonicalizeKid(s, spc(Expression,s->getNthKid(0)), 0);
    clear();
-    canonicalizeKid(s, fs->getCondExp(), 1);
-    canonicalizeKid(s, fs->getBody(), 2);
+    canonicalizeKid(s, spc(Expression,s->getNthKid(1)), 1);
+    canonicalizeKid(s, s->getNthKid(2), 2);
    clear();
-    canonicalizeKid(s, fs->getIncExp(), 3);
+    canonicalizeKid(s, spc(Expression,s->getNthKid(3)), 3);
    ret = Converge;
    start = nkid;
    break;
-  }
+
  case Statement::KindOfWhileStatement:
  case Statement::KindOfDoStatement:
  case Statement::KindOfForEachStatement:
@@ -1997,27 +1984,27 @@ StatementPtr AliasManager::canonicalizeRecur(StatementPtr s, int &ret) {
    ret = Converge;
    break;

-  case Statement::KindOfSwitchStatement: {
-    SwitchStatementPtr ss(spc(SwitchStatement, s));
-    canonicalizeKid(s, ss->getExp(), 0);
+  case Statement::KindOfSwitchStatement:
+    canonicalizeKid(s, spc(Expression,s->getNthKid(0)), 0);
    clear();
    start = 1;
    ret = Converge;
    break;
-  }
+
  case Statement::KindOfCaseStatement:
  case Statement::KindOfLabelStatement:
    clear();
    break;

-  case Statement::KindOfReturnStatement: {
-    ReturnStatementPtr rs(spc(ReturnStatement, s));
-    canonicalizeKid(s, rs->getRetExp(), 0);
+  case Statement::KindOfReturnStatement:
+  {
+    canonicalizeKid(s, spc(Expression,s->getNthKid(0)), 0);
    killLocals();
    ret = FallThrough;
    start = nkid;
    break;
  }
+
  case Statement::KindOfBreakStatement:
  case Statement::KindOfContinueStatement:
  case Statement::KindOfGotoStatement:
@@ -2044,9 +2031,6 @@ StatementPtr AliasManager::canonicalizeRecur(StatementPtr s, int &ret) {
    break;
  }

-  case Statement::KindOfTypedefStatement:
-    break;
-
  case Statement::KindOfCatchStatement:
    clear();
    ret = Converge;
@@ -2146,10 +2130,7 @@ int AliasManager::collectAliasInfoRecur(ConstructPtr cs, bool unused) {
      case Statement::KindOfGlobalStatement:
      case Statement::KindOfStaticStatement:
      {
-        ExpressionListPtr vars = (skind == Statement::KindOfGlobalStatement)
-          ? spc(GlobalStatement, s)->getVars()
-          : spc(StaticStatement, s)->getVars();
-
+        ExpressionListPtr vars = dpc(ExpressionList, s->getNthKid(0));
        for (int i = 0, n = vars->getCount(); i < n; i++) {
          ExpressionPtr e = (*vars)[i];
          if (AssignmentExpressionPtr ae = dpc(AssignmentExpression, e)) {
@@ -2205,18 +2186,17 @@ int AliasManager::collectAliasInfoRecur(ConstructPtr cs, bool unused) {
        }
        break;
      case Statement::KindOfForEachStatement: {
-        ForEachStatementPtr fs(static_pointer_cast<ForEachStatement>(s));
-        SimpleVariablePtr name = dpc(SimpleVariable, fs->getNameExp());
+        SimpleVariablePtr name =
+          dpc(SimpleVariable, s->getNthKid(ForEachStatement::NameExpr));
        if (name) {
-          if (Symbol *sym = name->getSymbol()) {
-            sym->setNeeded();
-          }
+          Symbol *sym = name->getSymbol();
+          sym->setNeeded();
        }
-        SimpleVariablePtr value = dpc(SimpleVariable, fs->getValueExp());
+        SimpleVariablePtr value =
+          dpc(SimpleVariable, s->getNthKid(ForEachStatement::ValueExpr));
        if (value) {
-          if (Symbol *sym = value->getSymbol()) {
-            sym->setNeeded();
-          }
+          Symbol *sym = value->getSymbol();
+          sym->setNeeded();
        }
        break;
      }
@@ -2331,7 +2311,9 @@ int AliasManager::collectAliasInfoRecur(ConstructPtr cs, bool unused) {
      case Expression::KindOfIncludeExpression:
      {
        IncludeExpressionPtr inc(spc(IncludeExpression, e));
-        m_variables->setAttribute(VariableTable::ContainsLDynamicVariable);
+        if (!inc->isPrivateScope()) {
+          m_variables->setAttribute(VariableTable::ContainsLDynamicVariable);
+        }
      }
      break;
      case Expression::KindOfArrayElementExpression:
@@ -2427,14 +2409,14 @@ int AliasManager::collectAliasInfoRecur(ConstructPtr cs, bool unused) {
        }
        break;
      }
-      case Expression::KindOfQOpExpression: {
-        QOpExpressionPtr q(spc(QOpExpression, e));
+
+      case Expression::KindOfQOpExpression:
        if (unused) {
-          if (ExpressionPtr t1 = q->getYes()) t1->setUnused(true);
-          q->getNo()->setUnused(true);
+          if (ExpressionPtr t1 = e->getNthExpr(1)) t1->setUnused(true);
+          e->getNthExpr(2)->setUnused(true);
        }
        break;
-      }
+
      default:
        break;
    }
@@ -2529,7 +2511,7 @@ static void markAvailable(ExpressionRawPtr e) {

 class TypeAssertionInserter {
 public:
-  explicit TypeAssertionInserter(AnalysisResultConstPtr ar) :
+  TypeAssertionInserter(AnalysisResultConstPtr ar) :
    m_ar(ar), m_changed(false) {
    BuildAssertionMap();
  }
@@ -2640,10 +2622,6 @@ private:
    if (sv && se) {
      const string &s = se->getLiteralString();
      if (s.empty()) return ExpressionPtr();
-      if (interface_supports_array(s)) {
-        // This could be an array, so don't assert anything
-        return ExpressionPtr();
-      }
      TypePtr o(Type::CreateObjectType(Util::toLower(s)));

      // don't do specific type assertions for unknown classes
@@ -2977,6 +2955,15 @@ private:
        }
      }
      break;
+    case Statement::KindOfBreakStatement:
+      {
+        BreakStatementPtr bs(spc(BreakStatement, stmt));
+        if (bs->getExp()) {
+          ExpressionPtr rep(
+              insertTypeAssertion(assertion, bs->getExp()));
+          replaceExpression(bs, rep, bs->getExp(), 0);
+        }
+      }
    default:
      // this is something like a continue statement,
      // in which case we don't do anything
@@ -2988,9 +2975,8 @@ private:
    if (!e) return ExpressionPtr();
    if (FunctionWalker::SkipRecurse(e)) return ExpressionPtr();

-    ExpressionPtr loopCond;
-    StatementPtr loopBody;
-    std::vector<ExpressionPtr> needed;
+    int loopCondIdx = -1, loopBodyIdx = -1;
+    std::vector<int> needed;
    switch (e->getKindOf()) {
    case Statement::KindOfIfStatement:
      {
@@ -3062,45 +3048,46 @@ private:
        }
      }
      return ExpressionPtr();
-    case Statement::KindOfForStatement: {
-      ForStatementPtr fs(static_pointer_cast<ForStatement>(e));
-      loopCond = fs->getCondExp();
-      loopBody = fs->getBody();
-      needed.push_back(fs->getInitExp());
-      needed.push_back(fs->getIncExp());
+    case Statement::KindOfForStatement:
+      loopCondIdx = ForStatement::CondExpr;
+      loopBodyIdx = ForStatement::BodyStmt;
+      needed.push_back(ForStatement::InitExpr);
+      needed.push_back(ForStatement::IncExpr);
      goto loop_stmt;
-    }
-    case Statement::KindOfWhileStatement: {
-      WhileStatementPtr ws(static_pointer_cast<WhileStatement>(e));
-      loopCond = ws->getCondExp();
-      loopBody = ws->getBody();
+    case Statement::KindOfWhileStatement:
+      loopCondIdx = WhileStatement::CondExpr;
+      loopBodyIdx = WhileStatement::BodyStmt;
      goto loop_stmt;
-    }
-    case Statement::KindOfDoStatement: {
-      DoStatementPtr ds(static_pointer_cast<DoStatement>(e));
-      loopCond = ds->getCondExp();
-      loopBody = ds->getBody();
-    }
+    case Statement::KindOfDoStatement:
+      loopCondIdx = DoStatement::CondExpr;
+      loopBodyIdx = DoStatement::BodyStmt;

 loop_stmt:
      {
-        if (loopCond) {
+        assert(loopCondIdx >= 0);
+        assert(loopBodyIdx >= 0);
+        if (e->getNthKid(loopCondIdx)) {
          bool passStmt;
          bool negate;
-          ExpressionPtr after(createTypeAssertions(loopCond, passStmt, negate));
+          ExpressionPtr after(createTypeAssertions(
+              spc(Expression, e->getNthKid(loopCondIdx)), passStmt, negate));
          if (after && !negate) {
-            insertTypeAssertion(after, loopBody);
+            insertTypeAssertion(
+                after, dpc(Statement, e->getNthKid(loopBodyIdx)));
          }
        }
-        for (auto it = needed.begin(); it != needed.end(); ++it) {
-          ExpressionPtr k(dpc(Expression, *it));
+        for (std::vector<int>::const_iterator it = needed.begin();
+             it != needed.end();
+             ++it) {
+          ExpressionPtr k(dpc(Expression, e->getNthKid(*it)));
          if (k) {
            bool passStmt;
            bool negate;
            createTypeAssertions(k, passStmt, negate);
          }
        }
-        createTypeAssertions(loopBody);
+        ConstructPtr body(e->getNthKid(loopBodyIdx));
+        createTypeAssertions(dpc(Statement, body));
      }
      return ExpressionPtr();
    case Statement::KindOfStatementList:
@@ -3337,7 +3324,7 @@ public:
        b->setBit(DataFlow::PRefIn, it->second);
        b->setBit(DataFlow::PInitIn, it->second);
      }
-      updateParamInfo(m->getParams(), Option::HardTypeHints);
+      updateParamInfo(m->getParams(), hhvm && Option::HardTypeHints);
      updateParamInfo(m->getFunctionScope()->getClosureVars(), false);
    }
  }
@@ -3351,9 +3338,6 @@ public:
      std::map<std::string,int>::iterator it =
        m_gidMap.find("v:" + p->getName());
      if (it != m_gidMap.end() && it->second) {
-        // NB: this is unsound if the user error handler swallows a
-        // parameter typehint failure.  It's opt-in via compiler
-        // options, though.
        if (useDefaults && p->hasTypeHint() && !p->defaultValue()) {
          b->setBit(DataFlow::AvailIn, it->second);
        }
@@ -3928,8 +3912,7 @@ void AliasManager::invalidateChainRoots(StatementPtr s) {
      // otherwise we'd have to declare all CSE temps like:
      //   declare_temps;
      //   do { ... } while (cond);
-      DoStatementPtr ds(static_pointer_cast<DoStatement>(s));
-      disableCSE(ds->getBody());
+      disableCSE(s->getNthStmt(DoStatement::BodyStmt));
    }
    // fall through
  default:
@@ -3940,56 +3923,47 @@ void AliasManager::invalidateChainRoots(StatementPtr s) {
  }
 }

-void AliasManager::nullSafeDisableCSE(StatementPtr parent, ExpressionPtr kid) {
+void AliasManager::nullSafeDisableCSE(StatementPtr parent, int kid) {
  assert(parent);
-  if (!kid) return;
-  kid->disableCSE();
+  ConstructPtr c(parent->getNthKid(kid));
+  if (!c) return;
+  ExpressionPtr e(dpc(Expression, c));
+  assert(e);
+  e->disableCSE();
 }

 void AliasManager::disableCSE(StatementPtr s) {
  if (!s) return;
  switch (s->getKindOf()) {
-  case Statement::KindOfIfBranchStatement: {
-    IfBranchStatementPtr is(static_pointer_cast<IfBranchStatement>(s));
-    nullSafeDisableCSE(s, is->getCondition());
+  case Statement::KindOfIfBranchStatement:
+    nullSafeDisableCSE(s, 0);
    break;
-  }
-  case Statement::KindOfSwitchStatement: {
-    SwitchStatementPtr ss(static_pointer_cast<SwitchStatement>(s));
-    nullSafeDisableCSE(s, ss->getExp());
+  case Statement::KindOfSwitchStatement:
+    nullSafeDisableCSE(s, 0);
    break;
-  }
-  case Statement::KindOfForStatement: {
-    ForStatementPtr fs(static_pointer_cast<ForStatement>(s));
-    nullSafeDisableCSE(s, fs->getInitExp());
-    nullSafeDisableCSE(s, fs->getCondExp());
-    nullSafeDisableCSE(s, fs->getIncExp());
+  case Statement::KindOfForStatement:
+    nullSafeDisableCSE(s, ForStatement::InitExpr);
+    nullSafeDisableCSE(s, ForStatement::CondExpr);
+    nullSafeDisableCSE(s, ForStatement::IncExpr);
    break;
-  }
-  case Statement::KindOfForEachStatement: {
-    ForEachStatementPtr fs(static_pointer_cast<ForEachStatement>(s));
-    nullSafeDisableCSE(s, fs->getArrayExp());
-    nullSafeDisableCSE(s, fs->getNameExp());
-    nullSafeDisableCSE(s, fs->getValueExp());
+  case Statement::KindOfForEachStatement:
+    nullSafeDisableCSE(s, ForEachStatement::ArrayExpr);
+    nullSafeDisableCSE(s, ForEachStatement::NameExpr);
+    nullSafeDisableCSE(s, ForEachStatement::ValueExpr);
    break;
-  }
-  case Statement::KindOfWhileStatement: {
-    WhileStatementPtr ws(static_pointer_cast<WhileStatement>(s));
-    nullSafeDisableCSE(s, ws->getCondExp());
+  case Statement::KindOfWhileStatement:
+    nullSafeDisableCSE(s, WhileStatement::CondExpr);
    break;
-  }
-  case Statement::KindOfDoStatement: {
-    DoStatementPtr ds(static_pointer_cast<DoStatement>(s));
-    nullSafeDisableCSE(s, ds->getCondExp());
+  case Statement::KindOfDoStatement:
+    nullSafeDisableCSE(s, DoStatement::CondExpr);
    break;
-  }
  default:
    for (int i = s->getKidCount(); i--; ) {
      ConstructPtr c(s->getNthKid(i));
      if (StatementPtr skid = dpc(Statement, c)) {
        disableCSE(skid);
      } else {
-        nullSafeDisableCSE(s, dpc(Expression, c));
+        nullSafeDisableCSE(s, i);
      }
    }
    break;
@@ -4133,42 +4107,38 @@ void AliasManager::stringOptsRecur(StatementPtr s) {
    }
    break;

-  case Statement::KindOfForStatement: {
-    ForStatementPtr fs = spc(ForStatement, s);
-    stringOptsRecur(fs->getInitExp(), true);
+  case Statement::KindOfForStatement:
+    stringOptsRecur(spc(Expression,s->getNthKid(0)), true);
    pushStringScope(s);
-    stringOptsRecur(fs->getCondExp(), false);
-    stringOptsRecur(fs->getBody());
-    stringOptsRecur(fs->getIncExp(), true);
+    stringOptsRecur(spc(Expression,s->getNthKid(1)), false);
+    stringOptsRecur(spc(Statement, s->getNthKid(2)));
+    stringOptsRecur(spc(Expression,s->getNthKid(3)), true);
    popStringScope(s);
    return;
-  }
-  case Statement::KindOfWhileStatement: {
-    WhileStatementPtr ws = spc(WhileStatement, s);
+
+  case Statement::KindOfWhileStatement:
    pushStringScope(s);
-    stringOptsRecur(ws->getCondExp(), false);
-    stringOptsRecur(ws->getBody());
+    stringOptsRecur(spc(Expression,s->getNthKid(0)), false);
+    stringOptsRecur(spc(Statement, s->getNthKid(1)));
    popStringScope(s);
    return;
-  }
-  case Statement::KindOfDoStatement: {
-    DoStatementPtr ds = spc(DoStatement, s);
+
+  case Statement::KindOfDoStatement:
    pushStringScope(s);
-    stringOptsRecur(ds->getBody());
-    stringOptsRecur(ds->getCondExp(), false);
+    stringOptsRecur(spc(Statement, s->getNthKid(0)));
+    stringOptsRecur(spc(Expression,s->getNthKid(1)), false);
    popStringScope(s);
    return;
-  }
-  case Statement::KindOfForEachStatement: {
-    ForEachStatementPtr fs = spc(ForEachStatement, s);
-    stringOptsRecur(fs->getArrayExp(), false);
-    stringOptsRecur(fs->getNameExp(), false);
-    stringOptsRecur(fs->getValueExp(), false);
+
+  case Statement::KindOfForEachStatement:
+    stringOptsRecur(spc(Expression,s->getNthKid(0)), false);
+    stringOptsRecur(spc(Expression,s->getNthKid(1)), false);
+    stringOptsRecur(spc(Expression,s->getNthKid(2)), false);
    pushStringScope(s);
-    stringOptsRecur(fs->getBody());
+    stringOptsRecur(spc(Statement, s->getNthKid(3)));
    popStringScope(s);
    return;
-  }
+
  case Statement::KindOfExpStatement:
    stringOptsRecur(spc(ExpStatement,s)->getExpression(), true);
    return;
@@ -4176,9 +4146,9 @@ void AliasManager::stringOptsRecur(StatementPtr s) {
  case Statement::KindOfBreakStatement:
    {
      BreakStatementPtr b = spc(BreakStatement, s);
-      int64_t depth = b->getDepth();
+      int64 depth = b->getDepth();
      if (depth != 1) {
-        int64_t s = m_loopInfo.size() - 1;
+        int64 s = m_loopInfo.size() - 1;
        if (s >= 0) {
          if (!depth || depth > s) depth = s;
          while (depth--) {
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,10 +14,10 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_ALIAS_MANAGER_H_
-#define incl_HPHP_ALIAS_MANAGER_H_
+#ifndef __ALIAS_MANAGER_H__
+#define __ALIAS_MANAGER_H__

-#include "hphp/compiler/expression/expression.h"
+#include <compiler/expression/expression.h>

 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////
@@ -88,7 +88,7 @@ class AliasManager {
  enum { SameAccess, SameLValueAccess, InterfAccess,
    DisjointAccess, NotAccess };

-  explicit AliasManager(int opt);
+  AliasManager(int opt);
  ~AliasManager();

  void clear();
@@ -141,7 +141,7 @@ class AliasManager {
  enum { FallThrough, CondBranch, Branch, Converge };
  enum { NoCopyProp = 1, NoDeadStore = 2 };
  struct CondStackElem {
-    explicit CondStackElem(size_t s = 0) : m_size(s), m_exprs() {}
+    CondStackElem(size_t s = 0) : m_size(s), m_exprs() {}
    size_t              m_size;
    ExpressionPtrList   m_exprs;
  };
@@ -154,7 +154,7 @@ class AliasManager {

  class LoopInfo {
  public:
-    explicit LoopInfo(StatementPtr s);
+    LoopInfo(StatementPtr s);

    StatementPtr m_stmt;
    StatementPtrVec m_inner;
@@ -205,7 +205,7 @@ class AliasManager {
  StatementPtr canonicalizeRecur(StatementPtr e, int &ret);

  void invalidateChainRoots(StatementPtr s);
-  void nullSafeDisableCSE(StatementPtr parent, ExpressionPtr kid);
+  void nullSafeDisableCSE(StatementPtr parent, int kid);
  void disableCSE(StatementPtr s);
  void createCFG(MethodStatementPtr m);
  void deleteCFG();
@@ -276,4 +276,4 @@ class AliasManager {

 ///////////////////////////////////////////////////////////////////////////////
 }
-#endif // incl_HPHP_ALIAS_MANAGER_H_
+#endif // __ALIAS_MANAGER_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,22 +14,22 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_ANALYSIS_RESULT_H_
-#define incl_HPHP_ANALYSIS_RESULT_H_
+#ifndef __ANALYSIS_RESULT_H__
+#define __ANALYSIS_RESULT_H__

-#include "hphp/compiler/code_generator.h"
-#include "hphp/compiler/analysis/code_error.h"
-#include "hphp/compiler/option.h"
-#include "hphp/compiler/analysis/block_scope.h"
-#include "hphp/compiler/analysis/symbol_table.h"
-#include "hphp/compiler/analysis/function_container.h"
-#include "hphp/compiler/package.h"
+#include <compiler/code_generator.h>
+#include <compiler/analysis/code_error.h>
+#include <compiler/option.h>
+#include <compiler/analysis/block_scope.h>
+#include <compiler/analysis/symbol_table.h>
+#include <compiler/analysis/function_container.h>
+#include <compiler/package.h>

-#include "hphp/util/string_bag.h"
-#include "hphp/util/thread_local.h"
+#include <util/string_bag.h>
+#include <util/thread_local.h>

 #include <boost/graph/adjacency_list.hpp>
-#include "tbb/concurrent_hash_map.h"
+#include <tbb/concurrent_hash_map.h>

 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////
@@ -91,12 +91,12 @@ public:

  class Locker {
  public:
-    explicit Locker(const AnalysisResult *ar) :
+    Locker(const AnalysisResult *ar) :
        m_ar(const_cast<AnalysisResult*>(ar)),
        m_mutex(m_ar->getMutex()) {
      m_mutex.lock();
    }
-    explicit Locker(AnalysisResultConstPtr ar) :
+    Locker(AnalysisResultConstPtr ar) :
        m_ar(const_cast<AnalysisResult*>(ar.get())),
        m_mutex(m_ar->getMutex()) {
      m_mutex.lock();
@@ -148,8 +148,7 @@ public:
  void addEntryPoint(const std::string &name);
  void addEntryPoints(const std::vector<std::string> &names);

-  void addNSFallbackFunc(ConstructPtr c, FileScopePtr fs);
-
+  void loadBuiltinFunctions();
  void loadBuiltins();
  void analyzeProgram(bool system = false);
  void analyzeIncludes();
@@ -167,6 +166,28 @@ public:
  void inferTypes();
  void postOptimize();

+  /**
+   * Scalar array handling.
+   */
+  int registerScalarArray(bool insideScalarArray, FileScopePtr scope,
+                          ExpressionPtr pairs, int &hash, int &index,
+                          std::string &text);
+  int checkScalarArray(const std::string &text, int &index);
+  int getScalarArrayId(const std::string &text);
+  void outputCPPNamedScalarArrays(const std::string &file);
+
+  std::string getScalarArrayCompressedText();
+  std::string getScalarArrayName(int hash, int index);
+  std::string getScalarVarArrayName(int hash, int index);
+
+  int checkScalarVarInteger(int64 val, int &index);
+  std::string getScalarVarIntegerName(int hash, int index);
+  void outputCPPNamedScalarVarIntegers(const std::string &file);
+
+  int checkScalarVarDouble(double dval, int &index);
+  std::string getScalarVarDoubleName(int hash, int index);
+  void outputCPPNamedScalarVarDoubles(const std::string &file);
+
  /**
   * Force all class variables to be variants, since l-val or reference
   * of dynamic properties are used.
@@ -189,6 +210,30 @@ public:
   * Code generation functions.
   */
  bool outputAllPHP(CodeGenerator::Output output);
+  void outputAllCPP(CodeGenerator::Output output, int clusterCount,
+                    const std::string *compileDir);
+
+  void outputCPPSystemImplementations(CodeGenerator &cg);
+  void getCPPFileRunDecls(CodeGenerator &cg, Type2SymbolSetMap &type2names);
+  void getCPPRedeclaredFunctionDecl(CodeGenerator &cg,
+                                    Type2SymbolSetMap &type2names);
+  void getCPPRedeclaredClassDecl(CodeGenerator &cg,
+                                 Type2SymbolSetMap &type2names);
+  void outputCPPRedeclaredClassImpl(CodeGenerator &cg);
+  void getCPPDynamicConstantDecl(CodeGenerator &cg,
+                                 Type2SymbolSetMap &type2names);
+  void outputCPPDynamicConstantImpl(CodeGenerator &cg);
+  void outputCPPScalarArrayDecl(CodeGenerator &cg);
+  void outputCPPScalarArrayImpl(CodeGenerator &cg);
+  void outputCPPScalarArrayInit(CodeGenerator &cg, int fileCount, int part);
+  void outputCPPScalarArrayId(CodeGenerator &cg, int id, int hash, int index,
+                              bool scalarVariant = false);
+  void getCPPClassStaticInitializerFlags(CodeGenerator &cg,
+                                         Type2SymbolSetMap &type2names);
+  void getCPPClassDeclaredFlags(CodeGenerator &cg,
+                                Type2SymbolSetMap &type2names);
+
+  void outputCPPFiniteDouble(CodeGenerator &cg, double dval);

  /**
   * Parser creates a FileScope upon parsing a new file.
@@ -237,14 +282,12 @@ public:
  ClassScopePtr findClass(const std::string &className) const;
  ClassScopePtr findClass(const std::string &className,
                          FindClassBy by);
-
  /**
   * Find all the redeclared classes by the name, excluding system classes.
   * Note that system classes cannot be redeclared.
   */
  const ClassScopePtrVec &findRedeclaredClasses(
    const std::string &className) const;
-
  /**
   * Find all the classes by the name, including system classes.
   */
@@ -275,36 +318,72 @@ public:
    return m_outputPath;
  }

+  /**
+   * PHP source info functions.
+   */
+  void recordSourceInfo(const std::string &file, int line, LocationPtr loc);
+  void recordClassSource(const std::string &clsname, LocationPtr loc,
+                         const std::string &filename);
+  void recordFunctionSource(const std::string &funcname, LocationPtr loc,
+                            const std::string &filename);
+
  /**
   * Literal string to String precomputation
   */
-  std::string getLiteralStringName(int64_t hash, int index, bool iproxy = false);
-  std::string getLitVarStringName(int64_t hash, int index, bool iproxy = false);
+  std::string getLiteralStringName(int64 hash, int index, bool iproxy = false);
+  std::string getLitVarStringName(int64 hash, int index, bool iproxy = false);
  int getLiteralStringId(const std::string &s, int &index);

  /**
   * Profiling runtime parameter type
   */
  std::string getFuncId(ClassScopePtr cls, FunctionScopePtr func);
+  std::string getParamRTTIEntryKey(ClassScopePtr cls,
+                                   FunctionScopePtr func,
+                                   const std::string &paramName);
+  void addParamRTTIEntry(ClassScopePtr cls,
+                         FunctionScopePtr func,
+                         const std::string &paramName);
+  int getParamRTTIEntryId(ClassScopePtr cls,
+                          FunctionScopePtr func,
+                          const std::string &paramName);
+  void addRTTIFunction(const std::string &id);
+  void cloneRTTIFuncs(const char *RTTIDirectory);
+
  std::vector<const char *> &getFuncTableBucket(FunctionScopePtr func);

+  /**
+   * Generate default implementation for separable extension classes.
+   */
+  void outputCPPSepExtensionImpl(const std::string &filename);
+
+  void outputCPPClusterImpl(CodeGenerator &cg, const FileScopePtrVec &files);
+  void outputCPPFileImpl(CodeGenerator &cg, FileScopePtr fs);
+
+  void addPregeneratedCPP(const std::string &name, std::string &code);
+  const std::string &getPregeneratedCPP(const std::string &name);
+
  std::set<std::string> m_variableTableFunctions;
  std::set<int> m_concatLengths;
  int m_arrayLitstrKeyMaxSize;
  int m_arrayIntegerKeyMaxSize;

-  std::string getHashedName(int64_t hash, int index, const char *prefix,
+  void setSystem() { m_system = true; }
+  bool isSystem() const { return m_system; }
+
+  void setSepExtension() { m_sepExtension = true; }
+  bool isSepExtension() { return m_sepExtension; }
+
+  std::string getHashedName(int64 hash, int index, const char *prefix,
                            bool longName = false);
  void addNamedLiteralVarString(const std::string &s);
  void addNamedScalarVarArray(const std::string &s);
  StringToClassScopePtrVecMap getExtensionClasses();
-  void addInteger(int64_t n);
-
+  void addInteger(int64 n);
 private:
  Package *m_package;
  bool m_parseOnDemand;
  std::vector<std::string> m_parseOnDemandDirs;
-  std::set<std::pair<ConstructPtr, FileScopePtr> > m_nsFallbackFuncs;
  Phase m_phase;
  StringToFileScopePtrMap m_files;
  FileScopePtrVec m_fileScopes;
@@ -320,20 +399,59 @@ private:
  StringToFileScopePtrMap m_constDecs;
  std::set<std::string> m_constRedeclared;

-  // Map names of class aliases to the class names they will alias.
-  // Only in WholeProgram mode.  See markRedeclaringClasses.
-  std::multimap<std::string,std::string> m_classAliases;
-
-  // Names of type aliases.
-  std::set<std::string> m_typeAliasNames;
-
  bool m_classForcedVariants[2];

  StatementPtrVec m_stmts;
  StatementPtr m_stmt;

  std::string m_outputPath;
+
+  std::map<std::string, int> m_scalarArrays;
+  Mutex m_namedScalarArraysMutex;
+  std::map<int, std::vector<std::string> > m_namedScalarArrays;
+  std::set<std::string> m_namedScalarVarArrays;
+  int m_scalarArraysCounter;
+  std::vector<ExpressionPtr> m_scalarArrayIds;
+
+  Mutex m_namedScalarVarIntegersMutex;
+  std::map<int, std::vector<std::string> > m_namedScalarVarIntegers;
+  Mutex m_allIntegersMutex;
+  std::set<int64> m_allIntegers;
+
+  Mutex m_namedScalarVarDoublesMutex;
+  std::map<int, std::vector<std::string> > m_namedScalarVarDoubles;
+
+  std::map<std::string, int> m_paramRTTIs;
+  std::set<std::string> m_rttiFuncs;
+  int m_paramRTTICounter;
+
 public:
+  struct ScalarArrayExp {
+    int id;
+    int len;
+    ExpressionPtr exp;
+  };
+
+  void outputCPPDynamicTables(CodeGenerator::Output output);
+  void outputCPPClassMapFile(CodeGenerator::Output output);
+  void outputCPPSourceInfos();
+  void outputCPPNameMaps();
+  void outputRTTIMetaData(const char *filename);
+  void outputCPPClassMap(CodeGenerator &cg, CodeGenerator::Output);
+  void outputCPPSystem();
+  void outputCPPSepExtensionMake();
+  void outputFFI(std::vector<std::string> &additionalCPPs);
+  void repartitionLargeCPP(const std::vector<std::string> &filenames,
+                           const std::vector<std::string> &additionals);
+
+  void outputCPPUtilDecl(CodeGenerator::Output output);
+  void outputCPPUtilImpl(CodeGenerator::Output output);
+  void outputCPPGlobalDeclarations();
+  void outputCPPMain();
+  void outputCPPScalarArrays(bool system);
+  void outputCPPGlobalVariablesMethods();
+  void outputCPPGlobalState();
+
  AnalysisResultPtr shared_from_this() {
    return boost::static_pointer_cast<AnalysisResult>
      (BlockScope::shared_from_this());
@@ -345,6 +463,12 @@ public:
  }

 private:
+  int m_scalarArraySortedAvgLen;
+  int m_scalarArraySortedIndex;
+  int m_scalarArraySortedSumLen;
+  std::vector<ScalarArrayExp> m_scalarArraySorted;
+  int m_scalarArrayCompressedTextSize;
+  bool m_pregenerating, m_pregenerated;
  BlockScopePtrVec m_ignoredScopes;

  typedef boost::adjacency_list<boost::setS, boost::vecS> Graph;
@@ -354,17 +478,39 @@ private:
  Graph m_depGraph;
  typedef std::map<vertex_descriptor, FileScopePtr> VertexToFileScopePtrMap;
  VertexToFileScopePtrMap m_fileVertMap;
+  void getTrueDeps(FileScopePtr f,
+                   std::map<std::string, FileScopePtr> &trueDeps);
+  void clusterByFileSizes(StringToFileScopePtrVecMap &clusters,
+                          int clusterCount);
+  void renameStaticNames(std::map<int, std::vector<std::string> > &names,
+                         const char *file, const char *prefix);
+
+  typedef std::map<std::string, std::string> StringMap;
+  Mutex m_pregenMapMutex;
+  StringMap m_pregenMap;
+
+  typedef std::map<int, LocationPtr> SourceLocationMap;
+  typedef std::map<std::string, SourceLocationMap> SourceInfo;
+  Mutex m_sourceInfoMutex;
+  SourceInfo m_sourceInfos;
+  SourceInfo m_sourceInfoPregen;
+  std::map<std::string, std::set<std::pair<std::string, int> > > m_clsNameMap;
+  std::map<std::string, std::set<std::pair<std::string, int> > > m_funcNameMap;
+
+  Mutex m_namedStringLiteralsMutex;
+  std::map<int, std::vector<std::string> > m_namedStringLiterals;
+  std::set<std::string> m_namedVarStringLiterals;
+
+  int m_funcTableSize;
+  CodeGenerator::MapIntToStringVec m_funcTable;
+  bool m_system;
+  bool m_sepExtension;

  /**
   * Checks whether the file is in one of the on-demand parsing directories.
   */
  bool inParseOnDemandDirs(const std::string &filename) const;

-  /*
-   * Find the names of all functions and classes in the program; mark
-   * functions with duplicate names as redeclaring, but duplicate
-   * classes aren't yet marked.  See markRedeclaringClasses.
-   */
  void collectFunctionsAndClasses(FileScopePtr fs);

  /**
@@ -373,23 +519,106 @@ private:
   */
  void canonicalizeSymbolOrder();

-  /*
-   * After all the class names have been collected and symbol order is
-   * canonicalized, this passes through and marks duplicate class
-   * names as redeclaring.
-   */
-  void markRedeclaringClasses();
-
  /**
   * Checks circular class derivations that can cause stack overflows for
   * subsequent analysis. Also checks to make sure no two redundant parents.
   */
  void checkClassDerivations();

-  void resolveNSFallbackFuncs();
+  /**
+   * Creates the global function table. Needs to be called before generating
+   * cpp code for each toplevel function.
+   */
+  void createGlobalFuncTable();

+  void outputCPPScalarArrays(CodeGenerator &cg, int fileCount, int part);
+
+  void collectCPPGlobalSymbols(StringPairSetVec &symbols,
+                               CodeGenerator &cg);
+  void outputCPPGlobalStateFileHeader(CodeGenerator &cg);
+  void outputCPPGlobalStateBegin(CodeGenerator &cg, const char *section);
+  void outputCPPGlobalStateEnd(CodeGenerator &cg, const char *section);
+  void outputCPPGlobalStateSection(CodeGenerator &cg,
+                                   const StringPairSet &names,
+                                   const char *section,
+                                   const char *prefix = "g->",
+                                   const char *name_prefix = "");
+
+  void outputCPPClassIncludes(CodeGenerator &cg);
+  void outputCPPExtClassImpl(CodeGenerator &cg);
+  void outputCPPDynamicTablesHeader(CodeGenerator &cg,
+                                    bool includeGlobalVars = true,
+                                    bool includes = true,
+                                    bool noNamespace = false);
+  void outputCPPGlobalImplementations(CodeGenerator &cg);
+
+  void preGenerateCPP(CodeGenerator::Output output,
+                      const FileScopePtrVec &files, int threadCount);
+  void movePregeneratedSourceInfo(const std::string &source,
+                                  const std::string &target, int offset);
  int getFileSize(FileScopePtr fs);

+  void repartitionCPP(const std::string &filename, int64 targetSize,
+                      bool insideHPHP, bool force);
+
+  void outputCPPFFIStubs();
+  void outputHSFFIStubs();
+
+  /**
+   * Outputs Java stubs.
+   *
+   * Each PHP file becomes a Java package, in which the HphpMain class
+   * contains all the toplevel function definitions, and the rest of the
+   * classes are one-to-one corresponding to the php classes declared in
+   * that file.
+   */
+  void outputJavaFFIStubs();
+  /**
+   * Outputs one .h file that declares all the Java native method stubs,
+   * avoiding javah for performance reason.
+   */
+  void outputJavaFFICppDecl();
+  /**
+   * Outputs one .cpp file that implements all the native methods declared
+   * in the Java classes generated by outputJavaFFIStubs().
+   */
+  void outputJavaFFICppImpl();
+
+  void outputSwigFFIStubs();
+
+  void outputHexBuffer(CodeGenerator &cg, const char *name,
+                       const char *buf, int len);
+  void outputCPPNamedLiteralStrings(bool genStatic, const std::string &file);
+  void outputCPPSepExtensionIncludes(CodeGenerator &cg);
+
+  void outputCPPInvokeFileHeader(CodeGenerator &cg);
+  void outputCPPEvalHook(CodeGenerator &cg);
+  void outputCPPDefaultInvokeFile(CodeGenerator &cg, const char *file);
+
+  void outputArrayCreateDecl(CodeGenerator &cg);
+  void outputArrayCreateImpl(CodeGenerator &cg);
+  void outputCPPHashTableInvokeFile(CodeGenerator &cg,
+                                    const std::vector<const char*> &entries,
+                                    bool needEvalHook);
+  void outputCPPDynamicClassTables(CodeGenerator::Output output);
+  void outputCPPDynamicConstantTable(CodeGenerator::Output output);
+  void outputCPPHashTableGetConstant(CodeGenerator &cg, bool system,
+         const std::map<std::string, TypePtr> &constMap,
+         const hphp_string_map<bool> &dyns);
+  void cloneRTTIFuncs(const StringToFunctionScopePtrMap &functions,
+                      const StringToFunctionScopePtrVecMap *redecFunctions);
+  void outputInitLiteralVarStrings(CodeGenerator &cg, int fileIndex,
+         std::vector<int> &litVarStrFileIndices,
+         std::vector<std::pair<int, int> > &litVarStrs);
+
+  void outputInitLiteralVarStrings();
+  void outputStringProxyData(CodeGenerator &cg,
+    int fileIndex, std::vector<std::string> &lStrings,
+    std::vector<std::pair<std::string, int> > &bStrings);
+  void outputVarStringProxyData(CodeGenerator &cg,
+    int fileIndex, std::vector<std::pair<int, int> > &litVarStrs);
+
+
 public:
  static DECLARE_THREAD_LOCAL(BlockScopeRawPtr, s_currentScopeThreadLocal);
  static DECLARE_THREAD_LOCAL(BlockScopeRawPtrFlagsHashMap,
@@ -425,8 +654,8 @@ private:

 class RescheduleException : public Exception {
 public:
-  explicit RescheduleException(BlockScopeRawPtr scope) :
-    Exception(), m_scope(scope) {}
+  RescheduleException(BlockScopeRawPtr scope) :
+    Exception(false), m_scope(scope) {}
  BlockScopeRawPtr &getScope() { return m_scope; }
 #ifdef HPHP_INSTRUMENT_TYPE_INF
  static int s_NumReschedules;
@@ -439,7 +668,7 @@ private:

 class SetCurrentScope {
 public:
-  explicit SetCurrentScope(BlockScopeRawPtr scope) {
+  SetCurrentScope(BlockScopeRawPtr scope) {
    assert(!((*AnalysisResult::s_currentScopeThreadLocal).get()));
    *AnalysisResult::s_currentScopeThreadLocal = scope;
    scope->setInVisitScopes(true);
@@ -525,9 +754,9 @@ private:
    }
  }
 #else
-  explicit BaseTryLock(BlockScopeRawPtr scopeToLock,
-                       bool lockCondition = true,
-                       bool profile = true)
+  BaseTryLock(BlockScopeRawPtr scopeToLock,
+              bool lockCondition = true,
+              bool profile = true)
    : m_profiler(profile),
      m_mutex(scopeToLock->getInferTypesMutex()),
      m_acquired(false) {
@@ -562,8 +791,8 @@ public:
          bool profile = true) :
    BaseTryLock(scopeToLock, fromFunction, fromLine, true, profile) {}
 #else
-  explicit TryLock(BlockScopeRawPtr scopeToLock,
-                   bool profile = true) :
+  TryLock(BlockScopeRawPtr scopeToLock,
+          bool profile = true) :
    BaseTryLock(scopeToLock, true, profile) {}
 #endif /* HPHP_INSTRUMENT_TYPE_INF */
 };
@@ -621,4 +850,4 @@ public:

 ///////////////////////////////////////////////////////////////////////////////
 }
-#endif // incl_HPHP_ANALYSIS_RESULT_H_
+#endif // __ANALYSIS_RESULT_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,8 +14,8 @@
   +----------------------------------------------------------------------+
 */

-#include "hphp/compiler/analysis/ast_walker.h"
-#include "hphp/compiler/statement/statement.h"
+#include <compiler/analysis/ast_walker.h>
+#include <compiler/statement/statement.h>

 using namespace HPHP;

@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,11 +14,11 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_AST_WALKER_H_
-#define incl_HPHP_AST_WALKER_H_
+#ifndef __AST_WALKER_H__
+#define __AST_WALKER_H__

-#include "hphp/compiler/hphp.h"
-#include "hphp/compiler/construct.h"
+#include <compiler/hphp.h>
+#include <compiler/construct.h>

 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////
@@ -26,7 +26,7 @@ namespace HPHP {
 class AstWalkerState {
 public:
  AstWalkerState() : index(0) {}
-  explicit AstWalkerState(ConstructRawPtr c) : cp(c), index(0) {}
+  AstWalkerState(ConstructRawPtr c) : cp(c), index(0) {}

  friend bool operator==(const AstWalkerState &s1,
                         const AstWalkerState &s2) {
@@ -40,7 +40,7 @@ public:
 class AstWalkerStateVec : public std::vector<AstWalkerState> {
  public:
  AstWalkerStateVec() {}
-  explicit AstWalkerStateVec(ConstructRawPtr cp) {
+  AstWalkerStateVec(ConstructRawPtr cp) {
    push_back(AstWalkerState(cp));
  }
 };
@@ -132,4 +132,4 @@ public:

 ///////////////////////////////////////////////////////////////////////////////
 }
-#endif // incl_HPHP_AST_WALKER_H_
+#endif // __AST_WALKER_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -15,8 +15,8 @@
 */

 #include <stdlib.h>
-#include "hphp/compiler/analysis/bit_set_vec.h"
-#include "hphp/compiler/analysis/data_flow.h"
+#include <compiler/analysis/bit_set_vec.h>
+#include <compiler/analysis/data_flow.h>

 using namespace HPHP;

@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -19,7 +19,7 @@

 #include <limits.h>
 #include <stddef.h>
-#include "hphp/util/assertions.h"
+#include "util/assertions.h"

 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,16 +14,16 @@
   +----------------------------------------------------------------------+
 */

-#include "hphp/compiler/expression/expression.h"
+#include <compiler/expression/expression.h>

-#include "hphp/compiler/analysis/block_scope.h"
-#include "hphp/compiler/analysis/analysis_result.h"
-#include "hphp/compiler/statement/statement_list.h"
-#include "hphp/compiler/analysis/variable_table.h"
-#include "hphp/compiler/analysis/constant_table.h"
-#include "hphp/compiler/analysis/class_scope.h"
-#include "hphp/compiler/analysis/function_scope.h"
-#include "hphp/compiler/analysis/file_scope.h"
+#include <compiler/analysis/block_scope.h>
+#include <compiler/analysis/analysis_result.h>
+#include <compiler/statement/statement_list.h>
+#include <compiler/analysis/variable_table.h>
+#include <compiler/analysis/constant_table.h>
+#include <compiler/analysis/class_scope.h>
+#include <compiler/analysis/function_scope.h>
+#include <compiler/analysis/file_scope.h>

 using namespace HPHP;

@@ -89,29 +89,13 @@ AnalysisResultRawPtr BlockScope::getContainingProgram() {
  return AnalysisResultRawPtr((AnalysisResult*)bs);
 }

-FunctionScopeRawPtr BlockScope::getContainingNonClosureFunction() {
-  BlockScope *bs = this;
-  // walk out through all the closures
-  while (bs && bs->is(BlockScope::FunctionScope)) {
-    HPHP::FunctionScope *fs = static_cast<HPHP::FunctionScope*>(bs);
-    if (!fs->isClosure() && !fs->isGeneratorFromClosure()) {
-      return FunctionScopeRawPtr(fs);
-    }
-    bs = bs->m_outerScope.get();
-  }
-  return FunctionScopeRawPtr();
-}
-
 ClassScopeRawPtr BlockScope::getContainingClass() {
-  BlockScope *bs = getContainingNonClosureFunction().get();
-  if (!bs) {
-    bs = this;
-  }
-  if (bs && bs->is(BlockScope::FunctionScope)) {
+  BlockScope *bs = this;
+  if (bs->is(BlockScope::FunctionScope)) {
    bs = bs->m_outerScope.get();
  }
-  if (!bs || !bs->is(BlockScope::ClassScope)) {
-    return ClassScopeRawPtr();
+  if (bs && !bs->is(BlockScope::ClassScope)) {
+    bs = 0;
  }
  return ClassScopeRawPtr((HPHP::ClassScope*)bs);
 }
@@ -241,6 +225,11 @@ void BlockScope::outputPHP(CodeGenerator &cg, AnalysisResultPtr ar) {
  m_variables->outputPHP(cg, ar);
 }

+void BlockScope::outputCPP(CodeGenerator &cg, AnalysisResultPtr ar) {
+  m_constants->outputCPP(cg, ar);
+  m_variables->outputCPP(cg, ar);
+}
+
 int BlockScope::ScopeCompare::cmp(const BlockScopeRawPtr &p1,
                                  const BlockScopeRawPtr &p2) const {
  int d1 = p1->m_kind - p2->m_kind;
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,16 +14,16 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_BLOCK_SCOPE_H_
-#define incl_HPHP_BLOCK_SCOPE_H_
+#ifndef __BLOCK_SCOPE_H__
+#define __BLOCK_SCOPE_H__

-#include "hphp/compiler/hphp.h"
+#include <compiler/hphp.h>

-#include "hphp/util/bits.h"
-#include "hphp/util/lock.h"
-#include "hphp/runtime/base/macros.h"
+#include <util/bits.h>
+#include <util/lock.h>
+#include <runtime/base/macros.h>

-#include "tbb/concurrent_hash_map.h"
+#include <tbb/concurrent_hash_map.h>

 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////
@@ -178,7 +178,6 @@ public:
  VariableTablePtr getVariables() { return m_variables;}
  ConstantTablePtr getConstants() { return m_constants;}
  ClassScopeRawPtr getContainingClass();
-  FunctionScopeRawPtr getContainingNonClosureFunction();
  FunctionScopeRawPtr getContainingFunction() const {
    return FunctionScopeRawPtr(is(FunctionScope) ?
                               (HPHP::FunctionScope*)this : 0);
@@ -219,7 +218,9 @@ public:
  /**
   * Code gen
   */
+  virtual void outputCPPDef(CodeGenerator &cg) {}
  virtual void outputPHP(CodeGenerator &cg, AnalysisResultPtr ar);
+  virtual void outputCPP(CodeGenerator &cg, AnalysisResultPtr ar);

  virtual bool inPseudoMain() const {
    return false;
@@ -366,4 +367,4 @@ public:

 ///////////////////////////////////////////////////////////////////////////////
 }
-#endif // incl_HPHP_BLOCK_SCOPE_H_
+#endif // __BLOCK_SCOPE_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,19 +14,19 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_CLASS_SCOPE_H_
-#define incl_HPHP_CLASS_SCOPE_H_
+#ifndef __CLASS_SCOPE_H__
+#define __CLASS_SCOPE_H__

-#include "hphp/compiler/analysis/block_scope.h"
-#include "hphp/compiler/analysis/function_container.h"
-#include "hphp/compiler/statement/class_statement.h"
-#include "hphp/compiler/statement/method_statement.h"
-#include "hphp/compiler/statement/trait_prec_statement.h"
-#include "hphp/compiler/statement/trait_alias_statement.h"
-#include "hphp/compiler/expression/user_attribute.h"
-#include "hphp/util/json.h"
-#include "hphp/util/case_insensitive.h"
-#include "hphp/compiler/option.h"
+#include <compiler/analysis/block_scope.h>
+#include <compiler/analysis/function_container.h>
+#include <compiler/statement/class_statement.h>
+#include <compiler/statement/method_statement.h>
+#include <compiler/statement/trait_prec_statement.h>
+#include <compiler/statement/trait_alias_statement.h>
+#include <compiler/expression/user_attribute.h>
+#include <util/json.h>
+#include <util/case_insensitive.h>
+#include <compiler/option.h>

 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////
@@ -124,6 +124,7 @@ public:

  void checkDerivation(AnalysisResultPtr ar, hphp_string_iset &seen);
  const std::string &getOriginalParent() const { return m_parent; }
+  std::string getHeaderFilename();

  /**
   * Returns topmost parent class that has the method.
@@ -211,7 +212,7 @@ public:
                      bool forInvoke = false);

  /**
-   * Whether or not we can directly call ObjectData::o_invoke() when lookup
+   * Whether or not we can directly call c_ObjectData::o_invoke() when lookup
   * in this class fails. If false, we need to call parent::o_invoke(), which
   * may be redeclared or may have private methods that need to check class
   * context.
@@ -291,6 +292,62 @@ public:

  ClassScopePtr getParentScope(AnalysisResultConstPtr ar) const;

+  void addUsedLiteralStringHeader(const std::string &s) {
+    m_usedLiteralStringsHeader.insert(s);
+  }
+
+  void addUsedLitVarStringHeader(const std::string &s) {
+    m_usedLitVarStringsHeader.insert(s);
+  }
+
+  void addUsedScalarVarInteger(int64 i) {
+    m_usedScalarVarIntegers.insert(i);
+  }
+
+  std::set<int64> &getUsedScalarVarIntegers() {
+    return m_usedScalarVarIntegers;
+  }
+
+  void addUsedScalarVarIntegerHeader(int64 i) {
+    m_usedScalarVarIntegersHeader.insert(i);
+  }
+
+  void addUsedScalarVarDouble(double d) {
+    m_usedScalarVarDoubles.insert(d);
+  }
+
+  std::set<double> &getUsedScalarVarDoubles() {
+    return m_usedScalarVarDoubles;
+  }
+
+  void addUsedScalarVarDoubleHeader(double d) {
+    m_usedScalarVarDoublesHeader.insert(d);
+  }
+
+  void addUsedDefaultValueScalarArray(const std::string &s) {
+    m_usedDefaultValueScalarArrays.insert(s);
+  }
+
+  void addUsedDefaultValueScalarVarArray(const std::string &s) {
+    m_usedDefaultValueScalarVarArrays.insert(s);
+  }
+
+  void addUsedConstHeader(const std::string &s) {
+    m_usedConstsHeader.insert(s);
+  }
+
+  void addUsedClassConstHeader(ClassScopeRawPtr cls, const std::string &s) {
+    m_usedClassConstsHeader.insert(CodeGenerator::UsedClassConst(cls, s));
+  }
+
+  void addUsedClassHeader(ClassScopeRawPtr s) {
+    m_usedClassesHeader.insert(s);
+  }
+
+  void addUsedClassFullHeader(ClassScopeRawPtr s) {
+    m_usedClassesFullHeader.insert(s);
+  }
+
  void addUsedTrait(const std::string &s) {
    if (!usesTrait(s)) {
      m_usedTraitNames.push_back(s);
@@ -318,12 +375,42 @@ public:

  void importUsedTraits(AnalysisResultPtr ar);

+  /**
+   * Output class meta info for g_class_map.
+   */
+  void outputCPPClassMap(CodeGenerator &cg, AnalysisResultPtr ar);
+
  /**
   * Serialize the iface, not everything.
   */
  void serialize(JSON::CodeError::OutputStream &out) const;
  void serialize(JSON::DocTarget::OutputStream &out) const;

+  static void outputCPPHashTableClasses
+    (CodeGenerator &cg, const StringToClassScopePtrVecMap &classScopes,
+     const std::vector<const char*> &classes);
+  static void outputCPPClassVarInitImpl(
+    CodeGenerator &cg, const StringToClassScopePtrVecMap &classScopes,
+    const std::vector<const char *> &classes);
+
+  void outputCPPDynamicClassDecl(CodeGenerator &cg);
+  void outputCPPDynamicClassImpl(CodeGenerator &cg, AnalysisResultPtr ar);
+  static void outputCPPDynamicClassCreateDecl(CodeGenerator &cg);
+  static void outputCPPDynamicClassCreateImpl
+  (CodeGenerator &cg, const StringToClassScopePtrVecMap &classScopes,
+   const std::vector<const char*> &classes);
+  static void outputCPPGetCallInfoStaticMethodImpl
+  (CodeGenerator &cg, const StringToClassScopePtrVecMap &classScopes,
+   const std::vector<const char*> &classes);
+  static void outputCPPGetStaticPropertyImpl
+  (CodeGenerator &cg, const StringToClassScopePtrVecMap &classScopes,
+   const std::vector<const char*> &classes);
+  static void outputCPPGetClassConstantImpl
+  (CodeGenerator &cg, const StringToClassScopePtrVecMap &classScopes);
+  static void outputCPPGetClassPropTableImpl
+  (CodeGenerator &cg, AnalysisResultPtr ar,
+   const StringToClassScopePtrVecMap &classScopes,
+   bool extension = false);
  bool isInterface() const { return m_kindOf == KindOfInterface; }
  bool isFinal() const { return m_kindOf == KindOfFinalClass ||
                                m_kindOf == KindOfTrait; }
@@ -332,6 +419,32 @@ public:
  bool isTrait() const { return m_kindOf == KindOfTrait; }
  bool hasProperty(const std::string &name) const;
  bool hasConst(const std::string &name) const;
+  void outputCPPDef(CodeGenerator &cg);
+  void outputCPPHeader(AnalysisResultPtr ar,
+                       CodeGenerator::Output output);
+  void outputCPPForwardHeader(CodeGenerator &cg,AnalysisResultPtr ar);
+  void outputCPPJumpTableDecl(CodeGenerator &cg, AnalysisResultPtr ar);
+
+  void outputMethodWrappers(CodeGenerator &cg, AnalysisResultPtr ar);
+
+  /**
+   * This prints out all the support methods (invoke, create, destructor,
+   * etc.)
+   * This is here instead of ClassStatement because I want to be able to call
+   * these for extension classes that don't have a statement.
+   */
+  void outputCPPSupportMethodsImpl(CodeGenerator &cg, AnalysisResultPtr ar);
+
+  std::string getClassPropTableId(AnalysisResultPtr ar);
+
+  /**
+   * These output wrappers for class methods so that class definitions don't
+   * have to be used in generating global jump tables.
+   */
+  void outputCPPGlobalTableWrappersDecl(CodeGenerator &cg,
+                                        AnalysisResultPtr ar);
+  void outputCPPGlobalTableWrappersImpl(CodeGenerator &cg,
+                                        AnalysisResultPtr ar);

  static bool NeedStaticArray(ClassScopePtr cls, FunctionScopePtr func);
  void inheritedMagicMethods(ClassScopePtr super);
@@ -348,12 +461,40 @@ public:
    m_parent = "";
  }

+  void outputCPPStaticMethodWrappers(CodeGenerator &cg, AnalysisResultPtr ar,
+                                     std::set<std::string> &done,
+                                     const char *cls);
  /**
   * Override function container
   */
  bool addFunction(AnalysisResultConstPtr ar,
                   FunctionScopePtr funcScope);

+  void outputVolatileCheckBegin(CodeGenerator &cg,
+                                AnalysisResultPtr ar,
+                                BlockScopePtr bs,
+                                const std::string &name);
+  void outputVolatileCheckEnd(CodeGenerator &cg);
+  static void OutputVolatileCheckBegin(CodeGenerator &cg,
+                                       AnalysisResultPtr ar,
+                                       BlockScopePtr bs,
+                                       const std::string &origName);
+  static void OutputVolatileCheckEnd(CodeGenerator &cg);
+  static void OutputVolatileCheck(CodeGenerator &cg, AnalysisResultPtr ar,
+                                  BlockScopePtr bs,
+                                  const std::string &origName, bool noThrow);
+
+
+  /**
+   * Whether or not the specified jump table is empty.
+   */
+  bool hasAllJumpTables() const {
+    return m_emptyJumpTables.empty();
+  }
+  bool hasJumpTable(JumpTableName name) const {
+    return m_emptyJumpTables.find(name) == m_emptyJumpTables.end();
+  }
+
  void setNeedsCppCtor(bool needsCppCtor) {
    m_needsCppCtor = needsCppCtor;
  }
@@ -370,9 +511,33 @@ public:
    return m_needsInit;
  }

+  bool needsEnableDestructor(AnalysisResultConstPtr ar) const;
  bool canSkipCreateMethod(AnalysisResultConstPtr ar) const;
  bool checkHasPropTable(AnalysisResultConstPtr ar);

+  struct IndexedSym {
+    IndexedSym(int i, int p, const Symbol *s) :
+        origIndex(i), privIndex(p), sym(s) {}
+
+    int                 origIndex;
+    int                 privIndex;
+    const Symbol        *sym;
+  };
+
+  struct ClassPropTableInfo {
+    ClassScopeRawPtr            cls;
+    std::vector<int>            actualIndex[3];
+    std::vector<int>            privateIndex[3];
+    std::map<int, std::vector<IndexedSym> > syms[3];
+  };
+
+  typedef std::map<std::string, ClassPropTableInfo>
+    ClassPropTableMap;
+
+protected:
+  void findJumpTableMethods(CodeGenerator &cg, AnalysisResultPtr ar,
+                            std::vector<const char *> &funcs);
+  bool hasJumpTableMethods(CodeGenerator &cg, AnalysisResultPtr ar);
 private:
  // need to maintain declaration order for ClassInfo map
  FunctionScopePtrVec m_functionsVec;
@@ -381,6 +546,19 @@ private:
  mutable std::vector<std::string> m_bases;
  UserAttributeMap m_userAttributes;

+  std::set<JumpTableName> m_emptyJumpTables;
+  std::set<std::string> m_usedLiteralStringsHeader;
+  std::set<std::string> m_usedLitVarStringsHeader;
+  std::set<int64> m_usedScalarVarIntegers;
+  std::set<int64> m_usedScalarVarIntegersHeader;
+  std::set<double> m_usedScalarVarDoubles;
+  std::set<double> m_usedScalarVarDoublesHeader;
+  std::set<std::string> m_usedDefaultValueScalarArrays;
+  std::set<std::string> m_usedDefaultValueScalarVarArrays;
+  std::set<std::string> m_usedConstsHeader;
+  CodeGenerator::UsedClassConstSet m_usedClassConstsHeader;
+  CodeGenerator::ClassScopeSet m_usedClassesHeader;
+  CodeGenerator::ClassScopeSet m_usedClassesFullHeader;
  std::vector<std::string> m_usedTraitNames;
  // m_traitAliases is used to support ReflectionClass::getTraitAliases
  std::vector<std::pair<std::string, std::string> > m_traitAliases;
@@ -432,12 +610,10 @@ private:
  // for classes with more than 31 bases, bit 31 is set iff
  // bases 32 through n are all known.
  unsigned m_knownBases;
+  mutable unsigned m_needsEnableDestructor:2;

  void addImportTraitMethod(const TraitMethod &traitMethod,
                            const std::string &methName);
-  void informClosuresAboutScopeClone(ConstructPtr root,
-                                     FunctionScopePtr outerScope,
-                                     AnalysisResultPtr ar);

  void setImportTraitMethodModifiers(const std::string &methName,
                                     ClassScopePtr traitCls,
@@ -483,8 +659,25 @@ private:
  void renameCreateContinuationCalls(AnalysisResultPtr ar, ConstructPtr c,
                                     ImportedMethodMap &importedMethods);

+  std::string getBaseHeaderFilename();
+
+  void outputCPPMethodInvokeBareObjectSupport(
+    CodeGenerator &cg, AnalysisResultPtr ar,
+    FunctionScopePtr func, bool fewArgs);
+
+  void outputCPPMethodInvokeTable
+    (CodeGenerator &cg, AnalysisResultPtr ar,
+     const std::vector <const char*> &keys,
+     const StringToFunctionScopePtrMap &funcScopes, bool fewArgs,
+     bool staticOnly);
+  void outputCPPMethodInvokeTableSupport(CodeGenerator &cg,
+      AnalysisResultPtr ar, const std::vector<const char*> &keys,
+      const StringToFunctionScopePtrMap &funcScopes, bool fewArgs);
+  hphp_const_char_imap<int> m_implemented;
+
+  ClassScopePtr getNextParentWithProp(AnalysisResultPtr ar);
 };

 ///////////////////////////////////////////////////////////////////////////////
 }
-#endif // incl_HPHP_CLASS_SCOPE_H_
+#endif // __CLASS_SCOPE_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,13 +14,13 @@
   +----------------------------------------------------------------------+
 */

-#include "hphp/compiler/analysis/code_error.h"
-#include "hphp/compiler/analysis/file_scope.h"
-#include "hphp/compiler/parser/parser.h"
-#include "hphp/compiler/construct.h"
-#include "hphp/compiler/option.h"
-#include "hphp/util/exception.h"
-#include "hphp/util/lock.h"
+#include <compiler/analysis/code_error.h>
+#include <compiler/analysis/file_scope.h>
+#include <compiler/parser/parser.h>
+#include <compiler/construct.h>
+#include <compiler/option.h>
+#include <util/exception.h>
+#include <util/lock.h>

 using namespace HPHP::JSON;

@@ -79,7 +79,7 @@ std::vector<const char *> &CodeErrors::getErrorTexts() {
  if (ErrorTexts.empty()) {
    ErrorTexts.resize(ErrorCount);
 #define CODE_ERROR_ENTRY(x) ErrorTexts[x] = #x;
-#include "hphp/compiler/analysis/core_code_error.inc"
+#include "compiler/analysis/core_code_error.inc"
 #undef CODE_ERROR_ENTRY
  }
  return ErrorTexts;
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,11 +14,11 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_COMPILER_ERROR_H_
-#define incl_HPHP_COMPILER_ERROR_H_
+#ifndef __COMPILER_ERROR_H__
+#define __COMPILER_ERROR_H__

-#include "hphp/compiler/analysis/type.h"
-#include "hphp/util/json.h"
+#include <compiler/analysis/type.h>
+#include <util/json.h>

 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////
@@ -31,7 +31,7 @@ namespace Compiler {

 enum ErrorType {
 #define CODE_ERROR_ENTRY(x) x,
-#include "hphp/compiler/analysis/core_code_error.inc"
+#include "compiler/analysis/core_code_error.inc"
 #undef CODE_ERROR_ENTRY
  ErrorCount,
  NoError
@@ -79,4 +79,4 @@ bool HasError(); // any error
 ///////////////////////////////////////////////////////////////////////////////
 }}

-#endif // incl_HPHP_COMPILER_ERROR_H_
+#endif // __COMPILER_ERROR_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,18 +14,18 @@
   +----------------------------------------------------------------------+
 */

-#include "hphp/compiler/analysis/constant_table.h"
-#include "hphp/compiler/analysis/analysis_result.h"
-#include "hphp/compiler/analysis/code_error.h"
-#include "hphp/compiler/analysis/type.h"
-#include "hphp/compiler/code_generator.h"
-#include "hphp/compiler/expression/expression.h"
-#include "hphp/compiler/expression/scalar_expression.h"
-#include "hphp/compiler/option.h"
-#include "hphp/util/util.h"
-#include "hphp/util/hash.h"
-#include "hphp/compiler/analysis/class_scope.h"
-#include "hphp/runtime/base/complex_types.h"
+#include <compiler/analysis/constant_table.h>
+#include <compiler/analysis/analysis_result.h>
+#include <compiler/analysis/code_error.h>
+#include <compiler/analysis/type.h>
+#include <compiler/code_generator.h>
+#include <compiler/expression/expression.h>
+#include <compiler/expression/scalar_expression.h>
+#include <compiler/option.h>
+#include <util/util.h>
+#include <util/hash.h>
+#include <compiler/analysis/class_scope.h>
+#include <runtime/base/complex_types.h>

 using namespace HPHP;

@@ -251,3 +251,185 @@ void ConstantTable::outputPHP(CodeGenerator &cg, AnalysisResultPtr ar) {
    }
  }
 }
+
+void ConstantTable::getCPPDynamicDecl(CodeGenerator &cg,
+                                      AnalysisResultPtr ar,
+                                      Type2SymbolSetMap &type2names) {
+  const char *prefix = Option::ConstantPrefix;
+  string classId;
+  const char *fmt = "";
+  ClassScopePtr scope = getClassScope();
+  if (scope) {
+    prefix = Option::ClassConstantPrefix;
+    classId = scope->getId();
+    fmt = Option::IdPrefix.c_str();
+  }
+
+  bool system = cg.getOutput() == CodeGenerator::SystemCPP;
+
+  SymbolSet &symbols = type2names["Variant"];
+  BOOST_FOREACH(Symbol *sym, m_symbolVec) {
+    if (sym->declarationSet() && sym->isDynamic() &&
+        system == sym->isSystem()) {
+      string tmp = string(prefix) + classId + fmt +
+        CodeGenerator::FormatLabel(sym->getName());
+      if (Type::IsMappedToVariant(sym->getFinalType())) {
+        symbols.insert(tmp);
+      } else {
+        type2names[sym->getFinalType()->getCPPDecl(ar, BlockScopeRawPtr())].
+          insert(tmp);
+      }
+    }
+  }
+}
+
+void ConstantTable::outputCPPDynamicImpl(CodeGenerator &cg,
+                                         AnalysisResultPtr ar) {
+  BOOST_FOREACH(Symbol *sym, m_symbolVec) {
+    if (sym->declarationSet() && sym->isDynamic()) {
+      cg_printf("%s%s = \"%s\";\n", Option::ConstantPrefix,
+                CodeGenerator::FormatLabel(sym->getName()).c_str(),
+                CodeGenerator::EscapeLabel(sym->getName()).c_str());
+    }
+  }
+}
+
+void ConstantTable::collectCPPGlobalSymbols(StringPairSet &symbols,
+                                            CodeGenerator &cg,
+                                            AnalysisResultPtr ar) {
+  BOOST_FOREACH(Symbol *sym, m_symbolVec) {
+    if (sym->declarationSet() && sym->isDynamic()) {
+      string varname = Option::ConstantPrefix +
+                       CodeGenerator::FormatLabel(sym->getName());
+      symbols.insert(StringPair(varname, varname));
+    }
+  }
+}
+
+void ConstantTable::outputCPP(CodeGenerator &cg, AnalysisResultPtr ar,
+                              bool newline /* = true */) const {
+  bool printed = false;
+  BOOST_FOREACH(Symbol *sym, m_symbolVec) {
+    if (outputCPP(cg, ar, sym)) printed = true;
+  }
+  if (newline && printed) {
+    cg_printf("\n");
+  }
+}
+
+bool ConstantTable::outputCPP(CodeGenerator &cg, AnalysisResultPtr ar,
+                              const Symbol *sym) const {
+  bool decl = true;
+  if (cg.getContext() == CodeGenerator::CppConstantsDecl) {
+    decl = false;
+  }
+
+  if (!const_cast<Symbol*>(sym)->checkDefined() ||
+      sym->isDynamic()) {
+    return false;
+  }
+  if (sym->isSystem() && cg.getOutput() != CodeGenerator::SystemCPP) {
+    return false;
+  }
+  const string &name = sym->getName();
+  ConstructPtr value = sym->getValue();
+
+  cg_printf(decl ? "extern const " : "const ");
+  TypePtr type = sym->getFinalType();
+  bool isString = type->is(Type::KindOfString);
+  if (isString) {
+    cg_printf("StaticString");
+  } else {
+    type->outputCPPDecl(cg, ar, getBlockScope());
+  }
+  ClassScope *cls = dynamic_cast<ClassScope*>(&m_blockScope);
+  if (decl) {
+    if (!cls) {
+      cg_printf(" %s%s", Option::ConstantPrefix,
+                CodeGenerator::FormatLabel(name).c_str());
+    } else {
+      cg_printf(" %s%s%s%s", Option::ClassConstantPrefix,
+                cls->getId().c_str(),
+                Option::IdPrefix.c_str(),
+                CodeGenerator::FormatLabel(name).c_str());
+    }
+  } else {
+    if (!cls) {
+      cg_printf(" %s%s", Option::ConstantPrefix,
+                CodeGenerator::FormatLabel(name).c_str());
+    } else {
+      cg_printf(" %s%s%s%s", Option::ClassConstantPrefix,
+                cls->getId().c_str(),
+                Option::IdPrefix.c_str(),
+                CodeGenerator::FormatLabel(name).c_str());
+    }
+    cg_printf(isString ? "(" : " = ");
+    if (value) {
+      ExpressionPtr exp = dynamic_pointer_cast<Expression>(value);
+      if (isString && exp->isScalar()) {
+        ScalarExpressionPtr scalarExp =
+          dynamic_pointer_cast<ScalarExpression>(exp);
+        if (scalarExp) {
+          cg_printf("LITSTR_INIT(%s)",
+                    scalarExp->getCPPLiteralString().c_str());
+        } else {
+          Variant v;
+          exp->getScalarValue(v);
+          cg_printf("LITSTR_INIT(\"%s\")",
+                    CodeGenerator::EscapeLabel(v.toString().data()).c_str());
+        }
+      } else {
+        exp->outputCPP(cg, ar);
+      }
+    } else {
+      cg_printf("\"%s\"", CodeGenerator::EscapeLabel(name).c_str());
+    }
+    if (isString) {
+      cg_printf(")");
+    }
+  }
+  cg_printf(";\n");
+  return true;
+}
+
+bool ConstantTable::outputSingleConstant(CodeGenerator &cg,
+                                         AnalysisResultPtr ar,
+                                         const std::string &name) const {
+  const Symbol *sym = getSymbol(name);
+  return sym && outputCPP(cg, ar, sym);
+}
+
+void ConstantTable::outputCPPConstantSymbol(CodeGenerator &cg,
+                                            AnalysisResultPtr ar,
+                                            Symbol *sym) {
+  ClassScopeRawPtr cls = getClassScope();
+  if (sym->valueSet() &&
+      (cls || (!sym->isDynamic()  &&
+               !ar->isConstantRedeclared(sym->getName())))) {
+    ExpressionPtr value = dynamic_pointer_cast<Expression>(sym->getValue());
+    Variant v;
+    if (value && value->getScalarValue(v)) {
+      int len;
+      string output = getEscapedText(v, len);
+      cg_printf("\"%s\", (const char *)%d, \"%s\",\n",
+                CodeGenerator::EscapeLabel(sym->getName()).c_str(),
+                len, output.c_str());
+    } else if (cls) {
+      cg_printf("\"%s\", (const char *)&%s%s, NULL,\n",
+                CodeGenerator::EscapeLabel(sym->getName()).c_str(),
+                Option::ClassStaticsCallbackPrefix, cls->getId().c_str());
+    } else {
+      cg_printf("\"%s\", (const char *)0, NULL,\n",
+                CodeGenerator::EscapeLabel(sym->getName()).c_str());
+    }
+  }
+}
+
+void ConstantTable::outputCPPClassMap(CodeGenerator &cg,
+                                      AnalysisResultPtr ar,
+                                      bool last /* = true */) {
+  for (unsigned int i = 0; i < m_symbolVec.size(); i++) {
+    outputCPPConstantSymbol(cg, ar, m_symbolVec[i]);
+  }
+  if (last) cg_printf("NULL,\n");
+}
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,11 +14,11 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_CONSTANT_TABLE_H_
-#define incl_HPHP_CONSTANT_TABLE_H_
+#ifndef __CONSTANT_TABLE_H__
+#define __CONSTANT_TABLE_H__

-#include "hphp/compiler/analysis/symbol_table.h"
-#include "hphp/compiler/analysis/block_scope.h"
+#include <compiler/analysis/symbol_table.h>
+#include <compiler/analysis/block_scope.h>

 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////
@@ -37,7 +37,7 @@ DECLARE_BOOST_TYPES(ClassScope);
 */
 class ConstantTable : public SymbolTable {
 public:
-  explicit ConstantTable(BlockScope &blockScope);
+  ConstantTable(BlockScope &blockScope);

  /**
   * Whether defining something to be non-scalar value or redeclared, or
@@ -81,6 +81,22 @@ public:
   * Generate all constant declarations for this symbol table.
   */
  void outputPHP(CodeGenerator &cg, AnalysisResultPtr ar);
+  void outputCPP(CodeGenerator &cg, AnalysisResultPtr ar,
+                 bool newline = true) const;
+  void getCPPDynamicDecl(CodeGenerator &cg, AnalysisResultPtr ar,
+                         Type2SymbolSetMap &type2names);
+  void outputCPPDynamicImpl(CodeGenerator &cg, AnalysisResultPtr ar);
+  bool outputSingleConstant(CodeGenerator &cg, AnalysisResultPtr ar,
+                            const std::string &name) const;
+
+  void collectCPPGlobalSymbols(StringPairSet &symbols, CodeGenerator &cg,
+                               AnalysisResultPtr ar);
+
+  /**
+   * Generate all class constants in class info map.
+   */
+  void outputCPPClassMap(CodeGenerator &cg, AnalysisResultPtr ar,
+                         bool last = true);

  bool isRecursivelyDeclared(AnalysisResultConstPtr ar,
                             const std::string &name) const;
@@ -99,8 +115,12 @@ private:
  ClassScopeRawPtr findBase(AnalysisResultConstPtr ar,
                            const std::string &name,
                            const std::vector<std::string> &bases) const;
+  bool outputCPP(CodeGenerator &cg, AnalysisResultPtr ar,
+                 const Symbol *sym) const;
+  void outputCPPConstantSymbol(CodeGenerator &cg, AnalysisResultPtr ar,
+                               Symbol *sym);
 };

 ///////////////////////////////////////////////////////////////////////////////
 }
-#endif // incl_HPHP_CONSTANT_TABLE_H_
+#endif // __CONSTANT_TABLE_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -13,32 +13,32 @@
   | license@php.net so we can mail you a copy immediately.               |
   +----------------------------------------------------------------------+
 */
-#include "hphp/compiler/analysis/control_flow.h"
+
+#include "compiler/analysis/ast_walker.h"
+#include "compiler/analysis/control_flow.h"
+#include "compiler/analysis/data_flow.h"
+#include "compiler/expression/expression.h"
+#include "compiler/expression/binary_op_expression.h"
+#include "compiler/expression/unary_op_expression.h"
+#include "compiler/expression/qop_expression.h"
+#include "compiler/statement/statement.h"
+#include "compiler/statement/method_statement.h"
+#include "compiler/statement/statement_list.h"
+#include "compiler/statement/if_branch_statement.h"
+#include "compiler/statement/for_statement.h"
+#include "compiler/statement/while_statement.h"
+#include "compiler/statement/do_statement.h"
+#include "compiler/statement/foreach_statement.h"
+#include "compiler/statement/switch_statement.h"
+#include "compiler/statement/break_statement.h"
+#include "compiler/statement/try_statement.h"
+#include "compiler/statement/finally_statement.h"
+#include "compiler/statement/label_statement.h"
+#include "compiler/statement/goto_statement.h"
+#include "compiler/statement/case_statement.h"

 #include <boost/graph/depth_first_search.hpp>

-#include "hphp/compiler/analysis/ast_walker.h"
-#include "hphp/compiler/analysis/data_flow.h"
-#include "hphp/compiler/expression/expression.h"
-#include "hphp/compiler/expression/binary_op_expression.h"
-#include "hphp/compiler/expression/unary_op_expression.h"
-#include "hphp/compiler/expression/qop_expression.h"
-#include "hphp/compiler/statement/statement.h"
-#include "hphp/compiler/statement/method_statement.h"
-#include "hphp/compiler/statement/statement_list.h"
-#include "hphp/compiler/statement/if_branch_statement.h"
-#include "hphp/compiler/statement/for_statement.h"
-#include "hphp/compiler/statement/while_statement.h"
-#include "hphp/compiler/statement/do_statement.h"
-#include "hphp/compiler/statement/foreach_statement.h"
-#include "hphp/compiler/statement/switch_statement.h"
-#include "hphp/compiler/statement/break_statement.h"
-#include "hphp/compiler/statement/try_statement.h"
-#include "hphp/compiler/statement/finally_statement.h"
-#include "hphp/compiler/statement/label_statement.h"
-#include "hphp/compiler/statement/goto_statement.h"
-#include "hphp/compiler/statement/case_statement.h"
-
 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////

@@ -182,7 +182,7 @@ public:

 class dfs_dump : public boost::default_dfs_visitor {
 public:
-  explicit dfs_dump(AnalysisResultConstPtr ar) : m_ar(ar) {}
+  dfs_dump(AnalysisResultConstPtr ar) : m_ar(ar) {}

  void discover_vertex(ControlFlowGraph::vertex_descriptor u,
                       const ControlFlowGraph &g) {
@@ -329,10 +329,9 @@ int ControlFlowBuilder::before(ConstructRawPtr cp) {
          }

          case Statement::KindOfForStatement: {
-            ForStatementPtr fs(static_pointer_cast<ForStatement>(s));
-            ConstructRawPtr body(fs->getBody());
-            ConstructRawPtr cond(fs->getCondExp());
-            ConstructRawPtr incr(fs->getIncExp());
+            ConstructRawPtr cond(s->getNthKid(ForStatement::CondExpr));
+            ConstructRawPtr body(s->getNthKid(ForStatement::BodyStmt));
+            ConstructRawPtr incr(s->getNthKid(ForStatement::IncExpr));
            if (cond) addEdge(cond, AfterConstruct, s, AfterConstruct);
            ConstructRawPtr end = incr ? incr : body ? body : cond;
            ConstructRawPtr start = cond ? cond : body ? body : incr;
@@ -342,9 +341,8 @@ int ControlFlowBuilder::before(ConstructRawPtr cp) {
          }

          case Statement::KindOfWhileStatement: {
-            WhileStatementPtr ws(static_pointer_cast<WhileStatement>(s));
-            ConstructRawPtr body(ws->getBody());
-            ConstructRawPtr cond(ws->getCondExp());
+            ConstructRawPtr cond(s->getNthKid(WhileStatement::CondExpr));
+            ConstructRawPtr body(s->getNthKid(WhileStatement::BodyStmt));
            addEdge(cond, AfterConstruct, s, AfterConstruct);
            addEdge(body ? body : cond, AfterConstruct, cond, BeforeConstruct);
            noFallThrough(s);
@@ -352,16 +350,15 @@ int ControlFlowBuilder::before(ConstructRawPtr cp) {
          }

          case Statement::KindOfDoStatement: {
-            DoStatementPtr ds(static_pointer_cast<DoStatement>(s));
-            addEdge(ds->getCondExp(), AfterConstruct, s, BeforeConstruct);
+            ConstructRawPtr cond(s->getNthKid(DoStatement::CondExpr));
+            addEdge(cond, AfterConstruct, s, BeforeConstruct);
            break;
          }

          case Statement::KindOfForEachStatement: {
-            ForEachStatementPtr fs(static_pointer_cast<ForEachStatement>(s));
-            ConstructRawPtr body(fs->getBody());
-            ConstructRawPtr name(fs->getNameExp());
-            ConstructRawPtr value(fs->getValueExp());
+            ConstructRawPtr body(s->getNthKid(ForEachStatement::BodyStmt));
+            ConstructRawPtr name(s->getNthKid(ForEachStatement::NameExpr));
+            ConstructRawPtr value(s->getNthKid(ForEachStatement::ValueExpr));
            ConstructRawPtr begin = name ? name : value;
            ConstructRawPtr end = body ? body : value;
            addEdge(end, AfterConstruct, begin, BeforeConstruct);
@@ -453,31 +450,23 @@ int ControlFlowBuilder::before(ConstructRawPtr cp) {
                  } else {
                    ConstructRawPtr kid;
                    switch (l->getKindOf()) {
-                      case Statement::KindOfForEachStatement: {
-                        ForEachStatementPtr fs(static_pointer_cast<ForEachStatement>(l));
-                        kid = fs->getNameExp();
+                      case Statement::KindOfForEachStatement:
+                        kid = l->getNthKid(ForEachStatement::NameExpr);
                        if (!kid) {
-                          kid = fs->getValueExp();
+                          kid = l->getNthKid(ForEachStatement::ValueExpr);
                        }
                        break;
-                      }
-                      case Statement::KindOfForStatement: {
-                        ForStatementPtr fs(static_pointer_cast<ForStatement>(l));
-                        kid = fs->getIncExp();
-                        if (!kid) kid = fs->getCondExp();
-                        if (!kid) kid = fs->getBody();
+                      case Statement::KindOfForStatement:
+                        kid = l->getNthKid(ForStatement::IncExpr);
+                        if (!kid) kid = l->getNthKid(ForStatement::CondExpr);
+                        if (!kid) kid = l->getNthKid(ForStatement::BodyStmt);
                        break;
-                      }
-                      case Statement::KindOfWhileStatement: {
-                        WhileStatementPtr ws(static_pointer_cast<WhileStatement>(l));
-                        kid = ws->getCondExp();
+                      case Statement::KindOfWhileStatement:
+                        kid = l->getNthKid(WhileStatement::CondExpr);
                        break;
-                      }
-                      case Statement::KindOfDoStatement: {
-                        DoStatementPtr ds(static_pointer_cast<DoStatement>(l));
-                        kid = ds->getCondExp();
+                      case Statement::KindOfDoStatement:
+                        kid = l->getNthKid(DoStatement::CondExpr);
                        break;
-                      }
                      default:
                        always_assert(0);
                    }
@@ -498,7 +487,6 @@ int ControlFlowBuilder::before(ConstructRawPtr cp) {
          }

          case Statement::KindOfEchoStatement:
-          case Statement::KindOfTypedefStatement:
            break;

          default:
@@ -507,36 +495,36 @@ int ControlFlowBuilder::before(ConstructRawPtr cp) {
      } else {
        ExpressionPtr e(dynamic_pointer_cast<Expression>(cp));
        switch (e->getKindOf()) {
-          case Expression::KindOfBinaryOpExpression: {
-            BinaryOpExpressionPtr b(static_pointer_cast<BinaryOpExpression>(e));
-            if (b->isShortCircuitOperator()) {
-              ConstructPtr trueBranch, falseBranch;
-              ConstructLocation tLoc, fLoc;
-              getTrueFalseBranches(0, trueBranch, tLoc, falseBranch, fLoc);
-              assert(trueBranch);
-              assert(falseBranch);
-              if (b->isLogicalOrOperator()) {
-                addEdge(b->getExp1(), AfterConstruct, trueBranch, tLoc);
-              } else {
-                addEdge(b->getExp1(), AfterConstruct, falseBranch, fLoc);
+          case Expression::KindOfBinaryOpExpression:
+            {
+              BinaryOpExpressionPtr b(
+                  static_pointer_cast<BinaryOpExpression>(e));
+              if (b->isShortCircuitOperator()) {
+                ConstructPtr trueBranch, falseBranch;
+                ConstructLocation tLoc, fLoc;
+                getTrueFalseBranches(0, trueBranch, tLoc, falseBranch, fLoc);
+                assert(trueBranch);
+                assert(falseBranch);
+                if (b->isLogicalOrOperator()) {
+                  addEdge(e->getNthExpr(0), AfterConstruct, trueBranch, tLoc);
+                } else {
+                  addEdge(e->getNthExpr(0), AfterConstruct, falseBranch, fLoc);
+                }
              }
            }
            break;
-          }
-          case Expression::KindOfQOpExpression: {
-            QOpExpressionPtr q(static_pointer_cast<QOpExpression>(e));
-            if (ExpressionPtr e1 = q->getYes()) {
-              addEdge(q->getCondition(), AfterConstruct,
-                      q->getNo(), BeforeConstruct);
+          case Expression::KindOfQOpExpression:
+            if (ExpressionPtr e1 = e->getNthExpr(1)) {
+              addEdge(e->getNthExpr(0), AfterConstruct,
+                      e->getNthExpr(2), BeforeConstruct);
              addEdge(e1, AfterConstruct,
-                      q->getNo(), AfterConstruct);
+                      e->getNthExpr(2), AfterConstruct);
              noFallThrough(e1);
            } else {
-              addEdge(q->getCondition(), AfterConstruct,
-                      q->getNo(), AfterConstruct);
+              addEdge(e->getNthExpr(0), AfterConstruct,
+                      e->getNthExpr(2), AfterConstruct);
            }
            break;
-          }
          default:
            break;
        }
@@ -598,36 +586,32 @@ void ControlFlowBuilder::getTrueFalseBranches(

  ConstructPtr c(top(level));
  if (StatementPtr s = dynamic_pointer_cast<Statement>(c)) {
-    StatementPtr kidBody;
+    int kidBodyIdx = -1;
    switch (s->getKindOf()) {
-    case Statement::KindOfForStatement: {
+    case Statement::KindOfForStatement:
      // examine which context we're in
-      ForStatementPtr fs(static_pointer_cast<ForStatement>(s));
-      ConstructPtr kid(top(level - 1));
-      if (kid == fs->getInitExp()) {
-        ; // just do the default case
-      } else if (kid == fs->getCondExp()) {
-        kidBody = fs->getBody();
-        goto loop_stmt;
-      } else if (kid == fs->getIncExp()) {
-        ; // just do the default case
-      } else {
-        assert(false);
+      {
+        ConstructPtr kid(top(level - 1));
+        if (kid == s->getNthKid(ForStatement::InitExpr)) {
+          ; // just do the default case
+        } else if (kid == s->getNthKid(ForStatement::CondExpr)) {
+          kidBodyIdx = ForStatement::BodyStmt;
+          goto loop_stmt;
+        } else if (kid == s->getNthKid(ForStatement::IncExpr)) {
+          ; // just do the default case
+        } else {
+          assert(false);
+        }
      }
      break;
-    }
-    case Statement::KindOfWhileStatement: {
-      WhileStatementPtr ws(static_pointer_cast<WhileStatement>(s));
-      kidBody = ws->getBody();
+    case Statement::KindOfWhileStatement:
+      kidBodyIdx = WhileStatement::BodyStmt;
      goto loop_stmt;
-    }
-    case Statement::KindOfDoStatement: {
-      DoStatementPtr ds(static_pointer_cast<DoStatement>(s));
-      kidBody = ds->getBody();
-    }
+    case Statement::KindOfDoStatement:
+      kidBodyIdx = DoStatement::BodyStmt;
    loop_stmt:
      if (!trueBranch) {
-        trueBranch = kidBody;
+        trueBranch = s->getNthKid(kidBodyIdx);
        tLoc = BeforeConstruct;
      }
      if (!falseBranch) {
@@ -868,7 +852,7 @@ ControlFlowGraph *ControlFlowGraph::buildControlFlow(MethodStatementPtr m) {
  ControlFlowGraph *graph = new ControlFlowGraph;

  graph->m_stmt = m;
-  ControlFlowBuilder cfb(graph, !!m->getOrigGeneratorFunc());
+  ControlFlowBuilder cfb(graph, m->getOrigGeneratorFunc());
  cfb.run(m->getStmts());
  graph->m_nextDfn = 1;
  depth_first_visit(*graph, cfb.head(),
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,17 +14,17 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_CONTROL_FLOW_H_
-#define incl_HPHP_CONTROL_FLOW_H_
+#ifndef __CONTROL_FLOW_H__
+#define __CONTROL_FLOW_H__

 #include <boost/graph/properties.hpp>
 #include <boost/graph/adjacency_iterator.hpp>
 #include <boost/graph/adjacency_list.hpp>

-#include "hphp/compiler/hphp.h"
+#include <compiler/hphp.h>

-#include "hphp/compiler/analysis/ast_walker.h"
-#include "hphp/compiler/analysis/bit_set_vec.h"
+#include <compiler/analysis/ast_walker.h>
+#include <compiler/analysis/bit_set_vec.h>

 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////
@@ -65,8 +65,6 @@ struct graph_traits<HPHP::ControlFlowGraph> {
  typedef int vertices_size_type;
  typedef int edges_size_type;
  typedef std::list<HPHP::ControlEdge*>::size_type degree_size_type;
-
-  static vertex_descriptor null_vertex() { return nullptr; }
 };

 template<>
@@ -311,10 +309,7 @@ inline void put(boost::vertex_color_t c,

 class ControlFlowGraphWalker : public FunctionWalker {
 public:
-  explicit ControlFlowGraphWalker(ControlFlowGraph *g)
-    : m_block(0)
-    , m_graph(*g)
-  {}
+  ControlFlowGraphWalker(ControlFlowGraph *g) : m_block(0), m_graph(*g) {}
  template <class T>
  void walk(T &t) {
    std::pair<ControlFlowGraph::vertex_iterator,
@@ -338,4 +333,4 @@ protected:

 ///////////////////////////////////////////////////////////////////////////////
 }
-#endif // incl_HPHP_CONTROL_FLOW_H_
+#endif // __CONTROL_FLOW_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,12 +14,12 @@
   +----------------------------------------------------------------------+
 */

-#include "hphp/compiler/analysis/data_flow.h"
+#include "compiler/analysis/data_flow.h"

-#include "hphp/compiler/expression/expression.h"
-#include "hphp/compiler/expression/simple_variable.h"
-#include "hphp/compiler/expression/binary_op_expression.h"
-#include "hphp/compiler/expression/list_assignment.h"
+#include "compiler/expression/expression.h"
+#include "compiler/expression/simple_variable.h"
+#include "compiler/expression/binary_op_expression.h"
+#include "compiler/expression/list_assignment.h"

 using namespace HPHP;
 using std::pair;
@@ -350,13 +350,12 @@ void DataFlowWalker::process(ExpressionPtr e, bool doAccessChains) {
    case Expression::KindOfAssignmentExpression:
    case Expression::KindOfBinaryOpExpression:
    case Expression::KindOfUnaryOpExpression: {
-      ExpressionPtr var = e->getStoreVariable();
+      ExpressionPtr var = e->getNthExpr(0);
      if (var && var->getContext() & (Expression::AssignmentLHS|
                                      Expression::OprLValue)) {
        processAccessChain(var);
        processAccess(var);
      }
-      // fall through
    }
    default:
      processAccess(e);
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,11 +14,11 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_DATA_FLOW_H_
-#define incl_HPHP_DATA_FLOW_H_
+#ifndef __DATA_FLOW_H__
+#define __DATA_FLOW_H__

-#include "hphp/compiler/analysis/bit_set_vec.h"
-#include "hphp/compiler/analysis/control_flow.h"
+#include <compiler/analysis/bit_set_vec.h>
+#include <compiler/analysis/control_flow.h>

 namespace HPHP {

@@ -91,7 +91,7 @@ private:

 class DataFlowWalker : public ControlFlowGraphWalker {
 public:
-  explicit DataFlowWalker(ControlFlowGraph *g) : ControlFlowGraphWalker(g) {}
+  DataFlowWalker(ControlFlowGraph *g) : ControlFlowGraphWalker(g) {}

  template<class T>
  void walk(T &t) { ControlFlowGraphWalker::walk(t); }
@@ -107,4 +107,4 @@ public:

 ///////////////////////////////////////////////////////////////////////////////
 }
-#endif // incl_HPHP_DATA_FLOW_H_
+#endif // __DATA_FLOW_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,15 +14,15 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_DEPTH_FIRST_VISITOR_H_
-#define incl_HPHP_DEPTH_FIRST_VISITOR_H_
+#ifndef __DEPTH_FIRST_VISITOR_H__
+#define __DEPTH_FIRST_VISITOR_H__

-#include "hphp/compiler/analysis/analysis_result.h"
-#include "hphp/compiler/analysis/ast_walker.h"
-#include "hphp/compiler/analysis/block_scope.h"
+#include <compiler/analysis/analysis_result.h>
+#include <compiler/analysis/ast_walker.h>
+#include <compiler/analysis/block_scope.h>

-#include "hphp/compiler/expression/expression.h"
-#include "hphp/compiler/statement/statement.h"
+#include <compiler/expression/expression.h>
+#include <compiler/statement/statement.h>

 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////
@@ -230,4 +230,4 @@ private:

 ///////////////////////////////////////////////////////////////////////////////
 }
-#endif // incl_HPHP_DEPTH_FIRST_VISITOR_H_
+#endif // __DEPTH_FIRST_VISITOR_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,12 +14,12 @@
   +----------------------------------------------------------------------+
 */

-#include "hphp/compiler/analysis/alias_manager.h"
-#include "hphp/compiler/analysis/dictionary.h"
-#include "hphp/compiler/expression/expression.h"
-#include "hphp/compiler/statement/statement.h"
-#include "hphp/compiler/statement/method_statement.h"
-#include "hphp/compiler/statement/statement_list.h"
+#include <compiler/analysis/alias_manager.h>
+#include <compiler/analysis/dictionary.h>
+#include <compiler/expression/expression.h>
+#include <compiler/statement/statement.h>
+#include <compiler/statement/method_statement.h>
+#include <compiler/statement/statement_list.h>

 using namespace HPHP;
 using std::vector;
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,11 +14,11 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_DICTIONARY_H_
-#define incl_HPHP_DICTIONARY_H_
+#ifndef __DICTIONARY_H__
+#define __DICTIONARY_H__

-#include "hphp/compiler/hphp.h"
-#include "hphp/compiler/analysis/data_flow.h"
+#include <compiler/hphp.h>
+#include <compiler/analysis/data_flow.h>

 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////
@@ -32,7 +32,7 @@ class Dictionary {
 public:
  typedef std::vector<ExpressionPtr> IdMap;

-  explicit Dictionary(AliasManager &am);
+  Dictionary(AliasManager &am);
  void build(MethodStatementPtr s);
  void build(StatementPtr s);
  void build(ExpressionPtr s);
@@ -78,4 +78,4 @@ private:

 ///////////////////////////////////////////////////////////////////////////////
 }
-#endif // incl_HPHP_DICTIONARY_H_
+#endif // __DICTIONARY_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,19 +14,18 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_COMPILER_EMITTER_H_
-#define incl_HPHP_COMPILER_EMITTER_H_
+#ifndef __COMPILER_EMITTER_H__
+#define __COMPILER_EMITTER_H__

-#include "hphp/compiler/expression/expression.h"
-#include "hphp/compiler/statement/statement.h"
-#include "hphp/compiler/statement/use_trait_statement.h"
-#include "hphp/compiler/statement/trait_prec_statement.h"
-#include "hphp/compiler/statement/trait_alias_statement.h"
-#include "hphp/compiler/statement/typedef_statement.h"
+#include <compiler/expression/expression.h>
+#include <compiler/statement/statement.h>
+#include <compiler/statement/use_trait_statement.h>
+#include <compiler/statement/trait_prec_statement.h>
+#include <compiler/statement/trait_alias_statement.h>

-#include "hphp/runtime/vm/func.h"
-#include "hphp/runtime/vm/unit.h"
-#include "hphp/util/hash.h"
+#include <runtime/vm/func.h>
+#include <runtime/vm/unit.h>
+#include <util/hash.h>

 namespace HPHP {

@@ -41,12 +40,20 @@ DECLARE_BOOST_TYPES(SimpleFunctionCall);
 DECLARE_BOOST_TYPES(SwitchStatement);
 DECLARE_BOOST_TYPES(ForEachStatement);
 class StaticClassName;
-class HhbcExtFuncInfo;
-class HhbcExtClassInfo;

 namespace Compiler {
 ///////////////////////////////////////////////////////////////////////////////

+using VM::Offset;
+using VM::Func;
+using VM::Class;
+using VM::Unit;
+using VM::InvalidAbsoluteOffset;
+using VM::Opcode;
+using VM::Id;
+
+using namespace VM;
+
 // Forward declarations.
 class Label;
 class EmitterVisitor;
@@ -89,12 +96,6 @@ public:
    Id str;
    Label* dest;
  };
-
-  struct IterPair {
-    IterPair(IterKind k, Id i) : kind(k), id(i) {}
-    IterKind kind;
-    Id id;
-  };
 #define O(name, imm, pop, push, flags) \
  void name(imm);
 #define NA
@@ -109,11 +110,10 @@ public:
 #define MA std::vector<uchar>
 #define BLA std::vector<Label*>&
 #define SLA std::vector<StrOff>&
-#define ILA std::vector<IterPair>&
-#define IVA int32_t
-#define HA int32_t
-#define IA int32_t
-#define I64A int64_t
+#define IVA int32
+#define HA int32
+#define IA int32
+#define I64A int64
 #define DA double
 #define SA const StringData*
 #define AA ArrayData*
@@ -129,7 +129,6 @@ public:
 #undef MA
 #undef BLA
 #undef SLA
-#undef ILA
 #undef IVA
 #undef HA
 #undef IA
@@ -201,7 +200,7 @@ private:
      DataType dt;              // META_DATA_TYPE
    }   metaData;
    const StringData* className;
-    int64_t intval; // used for L and I symbolic flavors
+    int64 intval; // used for L and I symbolic flavors

    // If intval is an unnamed local temporary, this offset is the start
    // of the region we are using it (which we will need to have a
@@ -238,7 +237,7 @@ public:
  std::string pretty() const;

  void push(char sym);
-  void setInt(int64_t v);
+  void setInt(int64 v);
  void setString(const StringData* s);
  void setKnownCls(const StringData* s, bool nonNull);
  void setNotRef();
@@ -275,7 +274,7 @@ public:

  ClassBaseType getClsBaseType(int index) const;
  int getLoc(int index) const;
-  int64_t getInt(int index) const;
+  int64 getInt(int index) const;
  Offset getUnnamedLocStart(int index) const;

  void pushFDesc();
@@ -285,7 +284,7 @@ public:
 class Label {
 public:
  Label() : m_off(InvalidAbsoluteOffset) {}
-  explicit Label(Emitter& e) : m_off(InvalidAbsoluteOffset) {
+  Label(Emitter& e) : m_off(InvalidAbsoluteOffset) {
    set(e);
  }
  Offset getAbsoluteOffset() const { return m_off; }
@@ -324,7 +323,7 @@ public:
 class EmitterVisitor {
  friend class UnsetUnnamedLocalThunklet;
 public:
-  explicit EmitterVisitor(UnitEmitter& ue);
+  EmitterVisitor(UnitEmitter& ue);
  ~EmitterVisitor();

  bool visit(ConstructPtr c);
@@ -333,7 +332,7 @@ public:
  void visit(FileScopePtr file);
  void assignLocalVariableIds(FunctionScopePtr fs);
  void fixReturnType(Emitter& e, FunctionCallPtr fn,
-                     Func* builtinFunc = nullptr);
+                     bool isBuiltinCall = false);
  typedef std::vector<int> IndexChain;
  void visitListAssignmentLHS(Emitter& e, ExpressionPtr exp,
                              IndexChain& indexChain,
@@ -348,10 +347,9 @@ public:
  }
  bool evalStackIsUnknown() { return m_evalStackIsUnknown; }
  void popEvalStack(char symFlavor, int arg = -1, int pos = -1);
-  void popSymbolicLocal(Op opcode, int arg = -1, int pos = -1);
+  void popSymbolicLocal(Opcode opcode, int arg = -1, int pos = -1);
  void popEvalStackLMany();
  void popEvalStackMany(int len, char symFlavor);
-  void popEvalStackCVMany(int len);
  void pushEvalStack(char symFlavor);
  void peekEvalStack(char symFlavor, int depthActual);
  void pokeEvalStack(char symFlavor, int depthActual);
@@ -361,10 +359,9 @@ public:
    recordJumpTarget(target, m_evalStack);
  }
  void restoreJumpTargetEvalStack();
-  void recordCall();
  bool isJumpTarget(Offset target);
-  void setPrevOpcode(Op op) { m_prevOpcode = op; }
-  Op getPrevOpcode() const { return m_prevOpcode; }
+  void setPrevOpcode(Opcode op) { m_prevOpcode = op; }
+  Opcode getPrevOpcode() const { return m_prevOpcode; }
  bool currentPositionIsReachable() {
    return (m_ue.bcPos() == m_curFunc->base()
            || isJumpTarget(m_ue.bcPos())
@@ -382,19 +379,20 @@ public:
    EXCEPTION_COMMON_IMPL(IncludeTimeFatalException);
  };

-  void pushIterScope(Id id, IterKind kind) {
-    m_pendingIters.emplace_back(id, kind);
+  enum IterKind {
+    KindOfIter = 0,
+    KindOfMIter = 1
+  };
+
+  void pushIterScope(Id id, bool itRef = false) {
+    IterKind itKind = itRef ? KindOfMIter : KindOfIter;
+    m_pendingIters.push_back(std::pair<Id,IterKind>(id,itKind));
  }
  void popIterScope() { m_pendingIters.pop_back(); }
-
 private:
  typedef std::pair<StringData*, bool> ClosureUseVar;  // (name, byRef)
  typedef std::vector<ClosureUseVar> ClosureUseVarVec;
  typedef std::vector<std::pair<Id,IterKind> > PendingIterVec;
-  typedef std::pair<StringData*, ExpressionPtr> NonScalarPair;
-  typedef std::vector<NonScalarPair> NonScalarVec;
-  typedef std::pair<Id, int> StrCase;
-
  class PostponedMeth {
  public:
    PostponedMeth(MethodStatementPtr m, FuncEmitter* fe, bool top,
@@ -405,7 +403,6 @@ private:
    bool m_top;
    ClosureUseVarVec* m_closureUseVars;
  };
-
  class PostponedCtor {
  public:
    PostponedCtor(InterfaceStatementPtr is, FuncEmitter* fe)
@@ -413,7 +410,8 @@ private:
    InterfaceStatementPtr m_is;
    FuncEmitter* m_fe;
  };
-
+  typedef std::pair<StringData*, ExpressionPtr> NonScalarPair;
+  typedef std::vector<NonScalarPair> NonScalarVec;
  class PostponedNonScalars {
  public:
    PostponedNonScalars(InterfaceStatementPtr is, FuncEmitter* fe,
@@ -426,7 +424,6 @@ private:
    FuncEmitter* m_fe;
    NonScalarVec* m_vec;
  };
-
  class PostponedClosureCtor {
  public:
    PostponedClosureCtor(ClosureUseVarVec& v, ClosureExpressionPtr e,
@@ -436,32 +433,32 @@ private:
    ClosureExpressionPtr m_expr;
    FuncEmitter* m_fe;
  };
-
  class ControlTargets {
  public:
-    ControlTargets(Id itId, bool itRef, Label& brkTarg, Label& cntTarg)
-        : m_itId(itId), m_itRef(itRef), m_brkTarg(brkTarg), m_cntTarg(cntTarg)
-      {}
+    ControlTargets(Id itId, bool itRef, Label& brkTarg, Label& cntTarg,
+                   Label& brkHand, Label& cntHand) :
+        m_itId(itId), m_itRef(itRef), m_brkTarg(brkTarg), m_cntTarg(cntTarg),
+        m_brkHand(brkHand), m_cntHand(cntHand) {}
    Id m_itId;
    bool m_itRef;
    Label& m_brkTarg;  // Jump here for "break;" (after doing IterFree)
    Label& m_cntTarg;  // Jump here for "continue;"
+    Label& m_brkHand;  // Push N and jump here for "break N;"
+    Label& m_cntHand;  // Push N and jump here for "continue N;"
  };
-
  class ControlTargetPusher {
  public:
    ControlTargetPusher(EmitterVisitor* e, Id itId, bool itRef, Label& brkTarg,
-        Label& cntTarg) : m_e(e) {
-      e->m_controlTargets.push_front(ControlTargets(itId, itRef, brkTarg,
-            cntTarg));
+        Label& cntTarg, Label& brkHand, Label& cntHand) : m_e(e) {
+      e->m_contTargets.push_front(ControlTargets(itId, itRef, brkTarg, cntTarg,
+            brkHand, cntHand));
    }
    ~ControlTargetPusher() {
-      m_e->m_controlTargets.pop_front();
+      m_e->m_contTargets.pop_front();
    }
  private:
    EmitterVisitor* m_e;
  };
-
  class ExnHandlerRegion {
  public:
    ExnHandlerRegion(Offset start, Offset end) : m_start(start),
@@ -477,23 +474,15 @@ private:
    std::set<StringData*, string_data_lt> m_names;
    std::vector<std::pair<StringData*, Label*> > m_catchLabels;
  };
-
  class FaultRegion {
  public:
-    FaultRegion(Offset start, Offset end, Id iterId, IterKind kind)
-      : m_start(start)
-      , m_end(end)
-      , m_iterId(iterId)
-      , m_iterKind(kind)
-    {}
-
+    FaultRegion(Offset start, Offset end, Id iterId)
+     : m_start(start), m_end(end), m_iterId(iterId) {}
    Offset m_start;
    Offset m_end;
    Id m_iterId;
-    IterKind m_iterKind;
-    Label m_func; // note: a pointer to this is handed out to the Funclet
+    Label m_func;
  };
-
  class FPIRegion {
    public:
      FPIRegion(Offset start, Offset end, Offset fpOff)
@@ -502,10 +491,10 @@ private:
      Offset m_end;
      Offset m_fpOff;
  };
-
+  typedef std::pair<Id, int> StrCase;
  struct SwitchState : private boost::noncopyable {
    SwitchState() : nonZeroI(-1), defI(-1) {}
-    std::map<int64_t, int> cases; // a map from int (or litstr id) to case index
+    std::map<int64, int> cases; // a map from int (or litstr id) to case index
    std::vector<StrCase> caseOrder; // for string switches, a list of the
                                    // <litstr id, case index> in the order
                                    // they appear in the source
@@ -513,16 +502,12 @@ private:
    int defI;
  };

-private:
-  void emitFatal(Emitter& e, const char* message);
-
-private:
  static const size_t kMinStringSwitchCases = 8;
  UnitEmitter& m_ue;
  FuncEmitter* m_curFunc;
  FileScopePtr m_file;

-  Op m_prevOpcode;
+  Opcode m_prevOpcode;

  std::deque<PostponedMeth> m_postponedMeths;
  std::deque<PostponedCtor> m_postponedCtors;
@@ -531,17 +516,15 @@ private:
  std::deque<PostponedNonScalars> m_postponedCinits;
  std::deque<PostponedClosureCtor> m_postponedClosureCtors;
  PendingIterVec m_pendingIters;
-  hphp_hash_set<std::string> m_generatorEmitted;
-  hphp_hash_set<std::string> m_topMethodEmitted;
+  typedef std::map<const StringData*, Label*, string_data_lt> LabelMap;
+  LabelMap m_methLabels;
  SymbolicStack m_evalStack;
  bool m_evalStackIsUnknown;
  hphp_hash_map<Offset, SymbolicStack> m_jumpTargetEvalStacks;
  int m_actualStackHighWater;
  int m_fdescHighWater;
-  typedef tbb::concurrent_hash_map<const StringData*, int,
-                                   StringDataHashCompare> EmittedClosures;
-  static EmittedClosures s_emittedClosures;
-  std::deque<ControlTargets> m_controlTargets;
+  int m_closureCounter;  // used to uniquify closures' mangled names
+  std::deque<ControlTargets> m_contTargets;
  std::deque<Funclet> m_funclets;
  std::deque<ExnHandlerRegion*> m_exnHandlers;
  std::deque<FaultRegion*> m_faultRegions;
@@ -550,9 +533,11 @@ private:
  std::set<std::string,stdltistr> m_hoistables;
  LocationPtr m_tempLoc;
  std::map<StringData*, Label, string_data_lt> m_gotoLabels;
-  std::vector<Label> m_yieldLabels;
  MetaInfoBuilder m_metaInfo;
 public:
+  Label& topBreakHandler() { return m_contTargets.front().m_brkHand; }
+  Label& topContHandler() { return m_contTargets.front().m_cntHand; }
+
  bool checkIfStackEmpty(const char* forInstruction) const;
  void unexpectedStackSym(char sym, const char* where) const;

@@ -580,8 +565,7 @@ public:
  void emitIsDouble(Emitter& e);
  void emitIsBool(Emitter& e);
  void emitEmpty(Emitter& e);
-  void emitUnset(Emitter& e, ExpressionPtr exp = ExpressionPtr());
-  void emitVisitAndUnset(Emitter& e, ExpressionPtr exp);
+  void emitUnset(Emitter& e);
  void emitSet(Emitter& e);
  void emitSetOp(Emitter& e, int op);
  void emitBind(Emitter& e);
@@ -598,9 +582,8 @@ public:
  template<class Expr> void emitVirtualClassBase(Emitter&, Expr* node);
  void emitResolveClsBase(Emitter& e, int pos);
  void emitClsIfSPropBase(Emitter& e);
-  Id emitVisitAndSetUnnamedL(Emitter& e, ExpressionPtr exp);
-  void emitPushAndFreeUnnamedL(Emitter& e, Id tempLocal, Offset start);
-  void emitContinuationSwitch(Emitter& e, int ncase);
+  Label* getContinuationGotoLabel(StatementPtr s);
+  void emitContinuationSwitch(Emitter& e, SwitchStatementPtr s);
  DataType analyzeSwitch(SwitchStatementPtr s, SwitchState& state);
  void emitIntegerSwitch(Emitter& e, SwitchStatementPtr s,
                         std::vector<Label>& caseLabels, Label& done,
@@ -608,7 +591,6 @@ public:
  void emitStringSwitch(Emitter& e, SwitchStatementPtr s,
                        std::vector<Label>& caseLabels, Label& done,
                        const SwitchState& state);
-  void emitIterBreak(Emitter& e, uint64_t n, Label& targ);

  void markElem(Emitter& e);
  void markNewElem(Emitter& e);
@@ -647,7 +629,8 @@ public:
  };

  bool emitCallUserFunc(Emitter& e, SimpleFunctionCallPtr node);
-  Func* canEmitBuiltinCall(const std::string& name, int numParams);
+  bool canEmitBuiltinCall(FunctionCallPtr fn, const std::string& name,
+                          int numParams);
  void emitFuncCall(Emitter& e, FunctionCallPtr node);
  void emitFuncCallArg(Emitter& e, ExpressionPtr exp, int paramId);
  void emitBuiltinCallArg(Emitter& e, ExpressionPtr exp, int paramId,
@@ -655,29 +638,24 @@ public:
  void emitBuiltinDefaultArg(Emitter& e, Variant& v, DataType t, int paramId);
  PreClass::Hoistable emitClass(Emitter& e, ClassScopePtr cNode,
                                bool topLevel);
-  void emitTypedef(Emitter& e, TypedefStatementPtr);
+  void emitBreakHandler(Emitter& e, Label& brkTarg, Label& cntTarg,
+                        Label& brkHand, Label& cntHand, Id iter = -1,
+                        IterKind itKind = KindOfIter);
  void emitForeach(Emitter& e, ForEachStatementPtr fe);
  void emitRestoreErrorReporting(Emitter& e, Id oldLevelLoc);
  void emitMakeUnitFatal(Emitter& e, const std::string& message);

  void addFunclet(Thunklet* body, Label* entry);
  void emitFunclets(Emitter& e);
-
-  struct FaultIterInfo {
-    Id iterId;
-    IterKind kind;
-  };
-  void newFaultRegion(Offset start, Offset end, Thunklet* t,
-                      FaultIterInfo = FaultIterInfo { -1, KindOfIter });
-
+  void newFaultRegion(Offset start, Offset end, Thunklet* t, Id iter = -1);
  void newFPIRegion(Offset start, Offset end, Offset fpOff);
  void copyOverExnHandlers(FuncEmitter* fe);
  void copyOverFPIRegions(FuncEmitter* fe);
  void saveMaxStackCells(FuncEmitter* fe);
  void finishFunc(Emitter& e, FuncEmitter* fe);
+  StringData* newClosureName();

  void initScalar(TypedValue& tvVal, ExpressionPtr val);
-  bool requiresDeepInit(ExpressionPtr initExpr) const;

  void emitClassTraitPrecRule(PreClassEmitter* pce, TraitPrecStatementPtr rule);
  void emitClassTraitAliasRule(PreClassEmitter* pce,
@@ -700,4 +678,4 @@ extern "C" {
 }
 }

-#endif // incl_HPHP_COMPILER_EMITTER_H_
+#endif // __COMPILER_EMITTER_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,14 +14,14 @@
   +----------------------------------------------------------------------+
 */

-#include "hphp/compiler/analysis/expr_dict.h"
-#include "hphp/compiler/analysis/alias_manager.h"
+#include <compiler/analysis/alias_manager.h>
+#include <compiler/analysis/expr_dict.h>

-#include "hphp/compiler/expression/expression.h"
-#include "hphp/compiler/expression/assignment_expression.h"
+#include <compiler/expression/expression.h>
+#include <compiler/expression/assignment_expression.h>

-#include "hphp/compiler/statement/statement.h"
-#include "hphp/compiler/statement/method_statement.h"
+#include <compiler/statement/statement.h>
+#include <compiler/statement/method_statement.h>

 using namespace HPHP;
 using std::vector;
@@ -59,7 +59,7 @@ void ExprDict::getTypes(ExpressionPtr e, TypePtrIdxPairVec &types) {

 class TypeFunc { public:
  bool operator()(const TypePtrIdxPair& entry) const {
-    return entry.first != nullptr;
+    return entry.first;
  }
 };
 static TypeFunc s_type_func;
@@ -313,7 +313,7 @@ void ExprDict::updateAccess(ExpressionPtr e) {
            BitOps::set_bit(aid, m_altered, true);
          }
          if (!(cls & Expression::Store) ||
-              a != e->getStoreVariable()) {
+              a != e->getNthExpr(0)) {
            a->clearAvailable();
            m_avlAccess[i] = m_avlAccess[--n];
            m_avlAccess.resize(n);
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,10 +14,10 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_EXPR_DICT_H_
-#define incl_HPHP_EXPR_DICT_H_
+#ifndef __EXPR_DICT_H__
+#define __EXPR_DICT_H__

-#include "hphp/compiler/analysis/dictionary.h"
+#include <compiler/analysis/dictionary.h>

 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////
@@ -27,7 +27,7 @@ typedef std::vector<TypePtrIdxPair> TypePtrIdxPairVec;

 class ExprDict : public Dictionary {
 public:
-  explicit ExprDict(AliasManager &am);
+  ExprDict(AliasManager &am);
  /* Building the dictionary */
  void build(MethodStatementPtr m);
  void visit(ExpressionPtr e);
@@ -43,8 +43,8 @@ public:
  TypePtr propagateType(ExpressionPtr e);

  void getTypes(ExpressionPtr e, TypePtrIdxPairVec &types);
-
 private:
+
  /**
   * types is filled with (type assertion, canon id for that type assertion)
   * tuples
@@ -94,4 +94,4 @@ private:

 ///////////////////////////////////////////////////////////////////////////////
 }
-#endif // incl_HPHP_EXPR_DICT_H_
+#endif // __EXPR_DICT_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,27 +14,27 @@
   +----------------------------------------------------------------------+
 */

-#include "hphp/compiler/analysis/file_scope.h"
-#include "hphp/compiler/analysis/code_error.h"
-#include "hphp/compiler/analysis/analysis_result.h"
-#include "hphp/compiler/analysis/class_scope.h"
-#include "hphp/compiler/statement/statement_list.h"
-#include "hphp/compiler/statement/exp_statement.h"
-#include "hphp/compiler/option.h"
-#include "hphp/compiler/analysis/constant_table.h"
-#include "hphp/compiler/analysis/function_scope.h"
+#include <compiler/analysis/file_scope.h>
+#include <compiler/analysis/code_error.h>
+#include <compiler/analysis/analysis_result.h>
+#include <compiler/analysis/class_scope.h>
+#include <compiler/statement/statement_list.h>
+#include <compiler/statement/exp_statement.h>
+#include <compiler/option.h>
+#include <compiler/analysis/constant_table.h>
+#include <compiler/analysis/function_scope.h>
 #include <sys/stat.h>
-#include "hphp/compiler/parser/parser.h"
-#include "hphp/util/logger.h"
-#include "hphp/util/util.h"
-#include "hphp/util/base.h"
-#include "hphp/compiler/expression/expression_list.h"
-#include "hphp/compiler/statement/function_statement.h"
-#include "hphp/compiler/analysis/variable_table.h"
-#include "hphp/compiler/expression/simple_function_call.h"
-#include "hphp/compiler/expression/include_expression.h"
-#include "hphp/compiler/expression/user_attribute.h"
-#include "hphp/runtime/base/complex_types.h"
+#include <compiler/parser/parser.h>
+#include <util/logger.h>
+#include <util/util.h>
+#include <util/base.h>
+#include <compiler/expression/expression_list.h>
+#include <compiler/statement/function_statement.h>
+#include <compiler/analysis/variable_table.h>
+#include <compiler/expression/simple_function_call.h>
+#include <compiler/expression/include_expression.h>
+#include <compiler/expression/user_attribute.h>
+#include <runtime/base/complex_types.h>

 using namespace HPHP;

@@ -98,8 +98,7 @@ void FileScope::cleanupForError(AnalysisResultConstPtr ar,
  ExpressionListPtr args(new ExpressionList(scope, loc));
  args->addElement(Expression::MakeScalarExpression(ar, scope, loc, msg));
  SimpleFunctionCallPtr e(
-    new SimpleFunctionCall(scope, loc, "throw_fatal", false, args,
-      ExpressionPtr()));
+    new SimpleFunctionCall(scope, loc, "throw_fatal", args, ExpressionPtr()));
  e->setThrowFatal();
  ExpStatementPtr exp(new ExpStatement(scope, loc, e));
  StatementListPtr stmts(new StatementList(scope, loc));
@@ -207,6 +206,20 @@ ExpressionPtr FileScope::getEffectiveImpl(AnalysisResultConstPtr ar) const {
  return ExpressionPtr();
 }

+bool FileScope::canUseDummyPseudoMain(AnalysisResultConstPtr ar) const {
+  if (!m_pseudoMain) {
+    return false;
+  }
+  assert(!m_pseudoMain->isVolatile());
+  if (!Option::GenerateDummyPseudoMain ||
+      Option::KeepStatementsWithNoEffect) {
+    return false;
+  }
+  ExpressionPtr exp = getEffectiveImpl(ar);
+  Variant val;
+  return (exp && exp->getScalarValue(val) && val.same(true));
+}
+
 ///////////////////////////////////////////////////////////////////////////////

 void FileScope::declareConstant(AnalysisResultPtr ar, const string &name) {
@@ -225,6 +238,7 @@ void FileScope::addConstant(const string &name, TypePtr type,
 void FileScope::addIncludeDependency(AnalysisResultPtr ar,
                                     const string &file, bool byInlined) {
  ar->addIncludeDependency(shared_from_this(), file);
+  if (byInlined) m_usedIncludesInline.insert(file);
 }
 void FileScope::addClassDependency(AnalysisResultPtr ar,
                                   const string &classname) {
@@ -233,6 +247,7 @@ void FileScope::addClassDependency(AnalysisResultPtr ar,
 void FileScope::addFunctionDependency(AnalysisResultPtr ar,
                                      const string &funcname, bool byInlined) {
  ar->addFunctionDependency(shared_from_this(), funcname);
+  if (byInlined) m_usedFuncsInline.insert(funcname);
 }
 void FileScope::addConstantDependency(AnalysisResultPtr ar,
                                      const string &decname) {
@@ -397,9 +412,8 @@ FunctionScopePtr FileScope::createPseudoMain(AnalysisResultConstPtr ar) {
  StatementListPtr st = m_tree;
  FunctionStatementPtr f
    (new FunctionStatement(BlockScopePtr(), LocationPtr(),
-                           ModifierExpressionPtr(),
                           false, pseudoMainName(),
-                           ExpressionListPtr(), "", st, 0, "",
+                           ExpressionListPtr(), st, 0, "",
                           ExpressionListPtr()));
  f->setFileLevel();
  FunctionScopePtr pseudoMain(
@@ -493,3 +507,455 @@ void FileScope::serialize(JSON::DocTarget::OutputStream &out) const {
  ms.done();
 }

+void FileScope::outputCPPHelper(CodeGenerator &cg, AnalysisResultPtr ar,
+                                bool classes /* = true */) {
+  if (classes) {
+    for (StringToClassScopePtrVecMap::iterator it = m_classes.begin();
+         it != m_classes.end(); ++it) {
+      BOOST_FOREACH(ClassScopePtr cls, it->second) {
+        cls->getStmt()->outputCPP(cg, ar);
+      }
+    }
+  }
+  for (StringToFunctionScopePtrMap::iterator it = m_functions.begin();
+       it != m_functions.end(); ++it) {
+    FunctionScopePtr func = it->second;
+    if (func->isLocalRedeclaring()) {
+      BOOST_FOREACH(func, m_redeclaredFunctions->find(it->first)->second) {
+        func->getStmt()->outputCPP(cg, ar);
+      }
+    } else {
+      func->getStmt()->outputCPP(cg, ar);
+    }
+  }
+}
+
+void FileScope::outputCPPImpl(CodeGenerator &cg, AnalysisResultPtr ar) {
+  assert(cg.getContext() == CodeGenerator::CppImplementation);
+
+  cg.setContext(CodeGenerator::CppConstantsDecl);
+  getConstants()->outputCPP(cg, ar);
+
+  cg.setContext(CodeGenerator::CppImplementation);
+  cg_printf("/* preface starts */\n");
+
+  for (StringToFunctionScopePtrMap::iterator it = m_functions.begin();
+       it != m_functions.end(); ++it) {
+    FunctionScopePtr func = it->second;
+    if (func->isLocalRedeclaring()) {
+      BOOST_FOREACH(func, m_redeclaredFunctions->find(it->first)->second) {
+        func->outputCPPPreface(cg, ar);
+      }
+    } else {
+      func->outputCPPPreface(cg, ar);
+    }
+  }
+  BOOST_FOREACH(FunctionScopeRawPtr closure, m_usedClosures) {
+    closure->outputCPPPreface(cg, ar);
+  }
+
+  for (StringToClassScopePtrVecMap::iterator it = m_classes.begin();
+       it != m_classes.end(); ++it) {
+    BOOST_FOREACH(ClassScopePtr cls, it->second) {
+      const FunctionScopePtrVec &funcs = cls->getFunctionsVec();
+      for (int i = 0, size = funcs.size(); i < size; ++i) {
+        FunctionScopePtr func = funcs[i];
+        func->outputCPPPreface(cg, ar);
+      }
+    }
+  }
+
+  cg_printf("/* preface finishes */\n");
+
+  outputCPPHelper(cg, ar);
+
+  if (Option::GenerateCPPMacros) {
+    bool hasRedec;
+    outputCPPJumpTableSupport(cg, ar, m_redeclaredFunctions, hasRedec);
+    if (Option::EnableEval >= Option::LimitedEval) {
+      outputCPPJumpTableEvalSupport(cg, ar, m_redeclaredFunctions, hasRedec);
+    }
+    outputCPPCallInfoTableSupport(cg, ar, m_redeclaredFunctions, hasRedec);
+    outputCPPHelperClassAllocSupport(cg, ar, m_redeclaredFunctions);
+    for (StringToClassScopePtrVecMap::iterator it = m_classes.begin();
+         it != m_classes.end(); ++it) {
+      BOOST_FOREACH(ClassScopePtr cls, it->second) {
+        if (!cls->isInterface()) {
+          cls->outputCPPDynamicClassImpl(cg, ar);
+        }
+      }
+    }
+  }
+}
+
+void FileScope::outputCPPPseudoMain(CodeGenerator &cg, AnalysisResultPtr ar) {
+  assert(cg.getContext() == CodeGenerator::CppPseudoMain);
+  outputCPPHelper(cg, ar, false);
+}
+
+void FileScope::outputCPPForwardDeclarations(CodeGenerator &cg,
+                                             AnalysisResultPtr ar) {
+  cg.setContext(CodeGenerator::CppForwardDeclaration);
+
+  BOOST_FOREACH(ClassScopeRawPtr cls, m_usedClassesFullHeader) {
+    if (cls->isUserClass()) {
+      cg_printInclude(cls->getHeaderFilename());
+    }
+  }
+
+  bool first = true;
+  BOOST_FOREACH(const string &str, m_usedLiteralStringsHeader) {
+    int index = -1;
+    int stringId = cg.checkLiteralString(str, index, ar, BlockScopePtr());
+    always_assert(index != -1);
+    string lisnam = ar->getLiteralStringName(stringId, index);
+    if (!cg.ensureInNamespace() && first) cg_printf("\n");
+    first = false;
+    if (Option::UseStaticStringProxy) {
+      string proxyNam = ar->getLiteralStringName(stringId, index, true);
+      cg_printf("extern StaticStringProxy %s;\n", proxyNam.c_str());
+      cg_printf("#ifndef %s\n", lisnam.c_str());
+      cg_printf("#define %s (*(StaticString *)(&%s))\n",
+                lisnam.c_str(), proxyNam.c_str());
+      cg_printf("#endif\n");
+    } else {
+      cg_printf("extern StaticString %s;\n", lisnam.c_str());
+    }
+  }
+
+  first = true;
+  BOOST_FOREACH(const int64 &val, m_usedScalarVarIntegersHeader) {
+    int index = -1;
+    int hash = ar->checkScalarVarInteger(val, index);
+    always_assert(index != -1);
+    string name = ar->getScalarVarIntegerName(hash, index);
+    if (!cg.ensureInNamespace() && first) cg_printf("\n");
+    first = false;
+    cg_printf("extern const VarNR &%s;\n", name.c_str());
+  }
+
+  first = true;
+  BOOST_FOREACH(const double &val, m_usedScalarVarDoublesHeader) {
+    int index = -1;
+    int hash = ar->checkScalarVarDouble(val, index);
+    always_assert(index != -1);
+    string name = ar->getScalarVarDoubleName(hash, index);
+    if (!cg.ensureInNamespace() && first) cg_printf("\n");
+    first = false;
+    cg_printf("extern const VarNR &%s;\n", name.c_str());
+  }
+
+  first = true;
+  BOOST_FOREACH(const string &str, m_usedLitVarStringsHeader) {
+    int index = -1;
+    int stringId = cg.checkLiteralString(str, index, ar, BlockScopePtr());
+    always_assert(index != -1);
+    string lisnam = ar->getLitVarStringName(stringId, index);
+    if (!cg.ensureInNamespace() && first) cg_printf("\n");
+    first = false;
+    if (Option::UseStaticStringProxy) {
+      string proxyName = ar->getLitVarStringName(stringId, index, true);
+      cg_printf("extern VariantProxy %s;\n", proxyName.c_str());
+      cg_printf("#ifndef %s\n", lisnam.c_str());
+      cg_printf("#define %s (*(Variant *)&%s)\n",
+                lisnam.c_str(), proxyName.c_str());
+      cg_printf("#endif\n");
+    } else {
+      cg_printf("extern VarNR %s;\n", lisnam.c_str());
+    }
+  }
+
+  first = true;
+  BOOST_FOREACH(const string &str, m_usedDefaultValueScalarArrays) {
+    int index = -1;
+    int hash = ar->checkScalarArray(str, index);
+    always_assert(hash != -1 && index != -1);
+    string name = ar->getScalarArrayName(hash, index);
+    if (!cg.ensureInNamespace() && first) cg_printf("\n");
+    first = false;
+    cg_printf("extern StaticArray %s;\n", name.c_str());
+  }
+
+  first = true;
+  BOOST_FOREACH(const string &str, m_usedDefaultValueScalarVarArrays) {
+    int index = -1;
+    int hash = ar->checkScalarArray(str, index);
+    always_assert(hash != -1 && index != -1);
+    string name = ar->getScalarVarArrayName(hash, index);
+    if (!cg.ensureInNamespace() && first) cg_printf("\n");
+    first = false;
+    cg_printf("extern VarNR %s;\n", name.c_str());
+  }
+
+  first = true;
+  BOOST_FOREACH(const string &str, m_usedConstsHeader) {
+    BlockScopeConstPtr block = ar->findConstantDeclarer(str);
+    always_assert(block);
+    ConstantTableConstPtr constants = block->getConstants();
+    if (!cg.ensureInNamespace() && first) cg_printf("\n");
+    first = false;
+    constants->outputSingleConstant(cg, ar, str);
+  }
+
+
+  first = true;
+  BOOST_FOREACH(const CodeGenerator::UsedClassConst& item,
+                m_usedClassConstsHeader) {
+    ClassScopePtr cls = item.first;
+    if (!cg.ensureInNamespace() && first) cg_printf("\n");
+    first = false;
+    cls->getConstants()->outputSingleConstant(cg, ar, item.second);
+  }
+
+  BOOST_FOREACH(ClassScopeRawPtr usedClass, m_usedClassesHeader) {
+    if (!cg.ensureInNamespace() && first) cg_printf("\n");
+    first = false;
+    usedClass->outputForwardDeclaration(cg);
+  }
+
+  cg.ensureOutOfNamespace();
+}
+
+void FileScope::outputCPPDeclarations(CodeGenerator &cg,
+                                      AnalysisResultPtr ar) {
+  cg.printSection("Declarations");
+  cg.setContext(CodeGenerator::CppDeclaration);
+
+  if (cg.getOutput() == CodeGenerator::MonoCPP) {
+    cg.namespaceBegin();
+    outputCPPHelper(cg, ar);
+    cg.namespaceEnd();
+  } else {
+    std::set<FileScopePtr> done;
+    done.insert(shared_from_this());
+
+    // Class declarations cunningly expressed as includes so I don't
+    // have to worry about inheritance dependencies.
+    for (StringToClassScopePtrVecMap::iterator it = m_classes.begin();
+         it != m_classes.end(); ++it) {
+      BOOST_FOREACH(ClassScopePtr cls, it->second) {
+        cg_printInclude(cls->getHeaderFilename());
+      }
+    }
+
+    BOOST_FOREACH(string name, m_usedFuncsInline) {
+      FunctionScopePtr func = ar->findFunction(name);
+      if (func) {
+        FileScopePtr fs = func->getContainingFile();
+        if (fs && done.find(fs) == done.end()) {
+          done.insert(fs);
+          cg_printInclude(fs->outputFilebase());
+        }
+      }
+    }
+    BOOST_FOREACH(string name, m_usedIncludesInline) {
+      FileScopePtr fs = ar->findFileScope(name);
+      if (fs && done.find(fs) == done.end()) {
+        done.insert(fs);
+        cg_printInclude(fs->outputFilebase());
+      }
+    }
+
+    cg.namespaceBegin();
+    cg.setContext(CodeGenerator::CppForwardDeclaration);
+    cg.printSection("Includes and Functions", false);
+    outputCPPHelper(cg, ar, false); // function forward declarations
+    cg.setContext(CodeGenerator::CppDeclaration);
+    outputCPPHelper(cg, ar, false); // function declarations (only inline)
+
+    cg.printSection("Constants");
+    if (cg.getOutput() != CodeGenerator::MonoCPP) {
+      getConstants()->outputCPP(cg, ar, false);
+    } else {
+      cg_printf("// (omitted in MonoCPP mode)\n");
+    }
+
+    cg.namespaceEnd();
+  }
+}
+
+void FileScope::outputCPPForwardStaticDecl(CodeGenerator &cg,
+                                           AnalysisResultPtr ar) {
+  string header = outputFilebase() + ".fws.h";
+  cg.headerBegin(header);
+  cg.namespaceBegin();
+  cg.printSection("1. Static Strings", false);
+  string str;
+  BOOST_FOREACH(str, m_usedLiteralStrings) {
+    if (m_usedLiteralStringsHeader.find(str) !=
+        m_usedLiteralStringsHeader.end()) {
+      continue;
+    }
+    int index = -1;
+    int stringId = cg.checkLiteralString(str, index, ar, BlockScopePtr());
+    always_assert(index != -1);
+    string lisnam = ar->getLiteralStringName(stringId, index);
+    if (Option::UseStaticStringProxy) {
+      string proxyNam = ar->getLiteralStringName(stringId, index, true);
+      cg_printf("extern StaticStringProxy %s;\n", proxyNam.c_str());
+      cg_printf("#ifndef %s\n", lisnam.c_str());
+      cg_printf("#define %s (*(StaticString *)(&%s))\n",
+                lisnam.c_str(), proxyNam.c_str());
+      cg_printf("#endif\n");
+    } else {
+      cg_printf("extern StaticString %s;\n", lisnam.c_str());
+    }
+  }
+  cg_printf("\n");
+  cg.printSection("2. Static Arrays", false);
+  BOOST_FOREACH(str, m_usedScalarArrays) {
+    if (m_usedDefaultValueScalarArrays.find(str) !=
+        m_usedDefaultValueScalarArrays.end()) {
+      continue;
+    }
+    int index = -1;
+    int hash = ar->checkScalarArray(str, index);
+    always_assert(hash != -1 && index != -1);
+    string name = ar->getScalarArrayName(hash, index);
+    cg_printf("extern StaticArray %s;\n", name.c_str());
+  }
+  if (Option::UseScalarVariant) {
+    cg_printf("\n");
+    cg.printSection("3. Static Variants", false);
+    int64 val;
+    BOOST_FOREACH(val, m_usedScalarVarIntegers) {
+      if (m_usedScalarVarIntegersHeader.find(val) !=
+          m_usedScalarVarIntegersHeader.end()) {
+        continue;
+      }
+      int index = -1;
+      int hash = ar->checkScalarVarInteger(val, index);
+      always_assert(index != -1);
+      string name = ar->getScalarVarIntegerName(hash, index);
+      cg_printf("extern const VarNR &%s;\n", name.c_str());
+    }
+    cg_printf("\n");
+    double dval;
+    BOOST_FOREACH(dval, m_usedScalarVarDoubles) {
+      if (m_usedScalarVarDoublesHeader.find(dval) !=
+          m_usedScalarVarDoublesHeader.end()) {
+        continue;
+      }
+      int index = -1;
+      int hash = ar->checkScalarVarDouble(dval, index);
+      always_assert(index != -1);
+      string name = ar->getScalarVarDoubleName(hash, index);
+      cg_printf("extern const VarNR &%s;\n", name.c_str());
+    }
+    cg_printf("\n");
+    BOOST_FOREACH(str, m_usedLitVarStrings) {
+      if (m_usedLitVarStringsHeader.find(str) !=
+          m_usedLitVarStringsHeader.end()) {
+        continue;
+      }
+      int index = -1;
+      int stringId = cg.checkLiteralString(str, index, ar, BlockScopePtr());
+      always_assert(index != -1);
+      string lisnam = ar->getLitVarStringName(stringId, index);
+      if (Option::UseStaticStringProxy) {
+        string proxyName = ar->getLitVarStringName(stringId, index, true);
+        cg_printf("extern VariantProxy %s;\n", proxyName.c_str());
+        cg_printf("#ifndef %s\n", lisnam.c_str());
+        cg_printf("#define %s (*(Variant *)&%s)\n",
+                  lisnam.c_str(), proxyName.c_str());
+        cg_printf("#endif\n");
+      } else {
+        cg_printf("extern VarNR %s;\n", lisnam.c_str());
+      }
+    }
+    cg_printf("\n");
+    BOOST_FOREACH(str, m_usedScalarVarArrays) {
+      if (m_usedDefaultValueScalarVarArrays.find(str) !=
+          m_usedDefaultValueScalarVarArrays.end()) {
+        continue;
+      }
+      int index = -1;
+      int hash = ar->checkScalarArray(str, index);
+      always_assert(hash != -1 && index != -1);
+      string name = ar->getScalarVarArrayName(hash, index);
+      cg_printf("extern VarNR %s;\n", name.c_str());
+    }
+    cg_printf("\n");
+  }
+  cg.namespaceEnd();
+  cg_printf("\n");
+  cg.headerEnd(header);
+}
+
+void FileScope::outputCPPDeclHeader(CodeGenerator &cg, AnalysisResultPtr ar) {
+  cg.setFileOrClassHeader(true);
+  string header = outputFilebase() + ".h";
+  cg.headerBegin(header);
+  if (Option::GenerateCppLibCode ||
+      cg.getOutput() == CodeGenerator::SystemCPP) {
+    cg.printBasicIncludes();
+  }
+  outputCPPForwardDeclarations(cg, ar);
+  outputCPPDeclarations(cg, ar);
+  cg.headerEnd(header);
+}
+
+void FileScope::outputCPPClassHeaders(AnalysisResultPtr ar,
+                                      CodeGenerator::Output output) {
+  ClassScopePtr cls;
+  for (StringToClassScopePtrVecMap::iterator it = m_classes.begin();
+       it != m_classes.end(); ++it) {
+    BOOST_FOREACH(ClassScopePtr cls, it->second) {
+      cls->outputCPPHeader(ar, output);
+    }
+  }
+}
+
+void FileScope::outputCPPFFI(CodeGenerator &cg,
+                             AnalysisResultPtr ar) {
+  cg.setContext(CodeGenerator::CppFFIDecl);
+  cg.useStream(CodeGenerator::PrimaryStream);
+  outputCPPHelper(cg, ar, true);
+  cg.useStream(CodeGenerator::ImplFile);
+  cg.setContext(CodeGenerator::CppFFIImpl);
+  cg_printInclude(outputFilebase() + ".h");
+  outputCPPHelper(cg, ar, true);
+}
+
+void FileScope::outputHSFFI(CodeGenerator &cg,
+                            AnalysisResultPtr ar) {
+  cg.setContext(CodeGenerator::HsFFI);
+  outputCPPHelper(cg, ar, false);
+}
+
+void FileScope::outputJavaFFI(CodeGenerator &cg, AnalysisResultPtr ar) {
+  // first, generate methods in HphpMain.java
+  for (StringToFunctionScopePtrMap::iterator it = m_functions.begin();
+       it != m_functions.end(); ++it) {
+    FunctionScopePtr func = it->second;
+    if (func->isLocalRedeclaring()) {
+      BOOST_FOREACH(func, m_redeclaredFunctions->find(it->first)->second) {
+        func->getStmt()->outputCPP(cg, ar);
+      }
+    } else {
+      func->getStmt()->outputCPP(cg, ar);
+    }
+  }
+
+  // for each php class or interface, generate a Java file
+  for (StringToClassScopePtrVecMap::iterator it = m_classes.begin();
+       it != m_classes.end(); ++it) {
+    BOOST_FOREACH(ClassScopePtr cls, it->second) {
+      cls->getStmt()->outputCPP(cg, ar);
+    }
+  }
+}
+
+void FileScope::outputJavaFFICPPStub(CodeGenerator &cg,
+                                     AnalysisResultPtr ar) {
+  if (cg.getContext() == CodeGenerator::JavaFFICppImpl) {
+    // java_stubs.h doesn't need the extra include
+    cg_printInclude(outputFilebase() + ".h");
+  }
+  outputCPPHelper(cg, ar, true);
+}
+
+void FileScope::outputSwigFFIStubs(CodeGenerator &cg, AnalysisResultPtr ar) {
+  // currently only support toplevel functions
+  outputCPPHelper(cg, ar, false);
+}
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,18 +14,16 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_FILE_SCOPE_H_
-#define incl_HPHP_FILE_SCOPE_H_
+#ifndef __FILE_SCOPE_H__
+#define __FILE_SCOPE_H__

-#include <map>
-
-#include "hphp/compiler/analysis/block_scope.h"
-#include "hphp/compiler/analysis/function_container.h"
-#include "hphp/compiler/analysis/code_error.h"
-#include "hphp/compiler/code_generator.h"
+#include <compiler/analysis/block_scope.h>
+#include <compiler/analysis/function_container.h>
+#include <compiler/analysis/code_error.h>
+#include <compiler/code_generator.h>
 #include <boost/graph/adjacency_list.hpp>
-#include "hphp/util/json.h"
-#include "hphp/runtime/base/md5.h"
+#include <util/json.h>
+#include <runtime/base/md5.h>

 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////
@@ -50,8 +48,8 @@ public:
    ContainsDynamicVariable   = 0x001,
    ContainsLDynamicVariable  = 0x002,
    VariableArgument          = 0x004,
-    ContainsExtract           = 0x008, // contains call to extract()
-    ContainsCompact           = 0x010, // contains call to compact()
+    ContainsExtract           = 0x008, // need special VariableTable
+    ContainsCompact           = 0x010, // need RVariableTable + exists()
    ContainsReference         = 0x020, // returns ref or has ref parameters
    ReferenceVariableArgument = 0x040, // like sscanf or fscanf
    ContainsUnset             = 0x080, // need special handling
@@ -61,7 +59,7 @@ public:
    MixedVariableArgument     = 0x800, // variable args, may or may not be ref'd
    IsFoldable                = 0x1000,// function can be constant folded
    NeedsActRec               = 0x2000,// builtin function needs ActRec
-    AllowOverride             = 0x4000,// allow override of systemlib or builtin
+    IgnoreRedefinition        = 0x4000,// ignore redefinition of builtin function
  };

  typedef boost::adjacency_list<boost::setS, boost::vecS> Graph;
@@ -102,6 +100,8 @@ public:
   */
  ExpressionPtr getEffectiveImpl(AnalysisResultConstPtr ar) const;

+  bool canUseDummyPseudoMain(AnalysisResultConstPtr ar) const;
+
  /**
   * Parser functions. Parser only deals with a FileScope object, and these
   * are the only functions a parser calls upon analysis results.
@@ -115,6 +115,73 @@ public:
  const StringToFunctionScopePtrVecMap *getRedecFunctions() {
    return m_redeclaredFunctions;
  }
+  void addUsedClosure(FunctionScopeRawPtr closure) {
+    m_usedClosures.insert(closure);
+  }
+  void addUsedLiteralString(std::string s) {
+    m_usedLiteralStrings.insert(s);
+  }
+  void addUsedLitVarString(std::string s) {
+    m_usedLitVarStrings.insert(s);
+  }
+  std::set<std::string> &getUsedLiteralStrings() {
+    return m_usedLiteralStrings;
+  }
+  std::set<std::string> &getUsedLitVarStrings() {
+    return m_usedLitVarStrings;
+  }
+  void addUsedLiteralStringHeader(std::string s) {
+    m_usedLiteralStringsHeader.insert(s);
+  }
+  void addUsedLitVarStringHeader(std::string s) {
+    m_usedLitVarStringsHeader.insert(s);
+  }
+  void addUsedScalarVarInteger(int64 i) {
+    m_usedScalarVarIntegers.insert(i);
+  }
+  std::set<int64> &getUsedScalarVarIntegers() {
+    return m_usedScalarVarIntegers;
+  }
+  void addUsedScalarVarIntegerHeader(int64 i) {
+    m_usedScalarVarIntegersHeader.insert(i);
+  }
+  void addUsedScalarVarDouble(double d) {
+    m_usedScalarVarDoubles.insert(d);
+  }
+  std::set<double> &getUsedScalarVarDoubles() {
+    return m_usedScalarVarDoubles;
+  }
+  void addUsedScalarVarDoubleHeader(double d) {
+    m_usedScalarVarDoublesHeader.insert(d);
+  }
+  void addUsedScalarArray(std::string s) {
+    m_usedScalarArrays.insert(s);
+  }
+  void addUsedScalarVarArray(std::string s) {
+    m_usedScalarVarArrays.insert(s);
+  }
+  void addUsedDefaultValueScalarArray(std::string s) {
+    m_usedDefaultValueScalarArrays.insert(s);
+  }
+  void addUsedDefaultValueScalarVarArray(std::string s) {
+    m_usedDefaultValueScalarVarArrays.insert(s);
+  }
+
+  void addUsedConstHeader(const std::string &s) {
+    m_usedConstsHeader.insert(s);
+  }
+
+  void addUsedClassConstHeader(ClassScopeRawPtr cls, const std::string &s) {
+    m_usedClassConstsHeader.insert(CodeGenerator::UsedClassConst(cls, s));
+  }
+
+  void addUsedClassHeader(ClassScopeRawPtr s) {
+    m_usedClassesHeader.insert(s);
+  }
+
+  void addUsedClassFullHeader(ClassScopeRawPtr s) {
+    m_usedClassesFullHeader.insert(s);
+  }

  /**
   * For separate compilation
@@ -137,22 +204,6 @@ public:
  void addConstantDependency(AnalysisResultPtr ar,
                             const std::string &decname);

-  void addClassAlias(const std::string& target, const std::string& alias) {
-    m_classAliasMap.insert(std::make_pair(target, alias));
-  }
-
-  std::multimap<std::string,std::string> const& getClassAliases() const {
-    return m_classAliasMap;
-  }
-
-  void addTypeAliasName(const std::string& name) {
-    m_typeAliasNames.insert(name);
-  }
-
-  std::set<std::string> const& getTypeAliasNames() const {
-    return m_typeAliasNames;
-  }
-
  /**
   * Called only by World
   */
@@ -193,12 +244,27 @@ public:
  FunctionScopeRawPtr getPseudoMain() const {
    return m_pseudoMain;
  }
+  void outputCPPForwardStaticDecl(CodeGenerator &cg, AnalysisResultPtr ar);
+  void outputCPPDeclHeader(CodeGenerator &cg, AnalysisResultPtr ar);
+  void outputCPPForwardDeclarations(CodeGenerator &cg, AnalysisResultPtr ar);
+  void outputCPPDeclarations(CodeGenerator &cg, AnalysisResultPtr ar);
+  void outputCPPClassHeaders(AnalysisResultPtr ar,
+                             CodeGenerator::Output output);
+  void outputCPPImpl(CodeGenerator &cg, AnalysisResultPtr ar);
+  void outputCPPPseudoMain(CodeGenerator &cg, AnalysisResultPtr ar);
+
+  void outputCPPFFI(CodeGenerator &cg, AnalysisResultPtr ar);
+  void outputHSFFI(CodeGenerator &cg, AnalysisResultPtr ar);
+
+  void outputJavaFFI(CodeGenerator &cg, AnalysisResultPtr ar);
+  void outputJavaFFICPPStub(CodeGenerator &cg, AnalysisResultPtr ar);
+
+  void outputSwigFFIStubs(CodeGenerator &cg, AnalysisResultPtr ar);

  FileScopePtr shared_from_this() {
    return boost::static_pointer_cast<FileScope>
      (BlockScope::shared_from_this());
  }
-
 private:
  int m_size;
  MD5 m_md5;
@@ -216,24 +282,36 @@ private:

  vertex_descriptor m_vertex;

+  std::set<FunctionScopeRawPtr> m_usedClosures;
+  std::set<std::string> m_usedFuncsInline;
+  CodeGenerator::ClassScopeSet m_usedClassesHeader;
+  CodeGenerator::ClassScopeSet m_usedClassesFullHeader;
+  std::set<std::string> m_usedConstsHeader;
+  CodeGenerator::UsedClassConstSet m_usedClassConstsHeader;
+  std::set<std::string> m_usedIncludesInline;
+  std::set<std::string> m_usedLiteralStrings;
+  std::set<std::string> m_usedLitVarStrings;
+  std::set<std::string> m_usedLiteralStringsHeader;
+  std::set<std::string> m_usedLitVarStringsHeader;
+  std::set<int64> m_usedScalarVarIntegers;
+  std::set<int64> m_usedScalarVarIntegersHeader;
+  std::set<double> m_usedScalarVarDoubles;
+  std::set<double> m_usedScalarVarDoublesHeader;
+  std::set<std::string> m_usedScalarArrays;
+  std::set<std::string> m_usedScalarVarArrays;
+  std::set<std::string> m_usedDefaultValueScalarArrays;
+  std::set<std::string> m_usedDefaultValueScalarVarArrays;
  std::string m_pseudoMainName;
  std::set<std::string> m_pseudoMainVariables;
  BlockScopeSet m_providedDefs;
  std::set<std::string> m_redecBases;

-  // Map from class alias names to the class they are aliased to.
-  // This is only needed in WholeProgram mode.
-  std::multimap<std::string,std::string> m_classAliasMap;
-
-  // Set of names that are on the left hand side of type alias
-  // declarations.  We need this to make sure we don't mark classes
-  // with the same name Unique.
-  std::set<std::string> m_typeAliasNames;
-
  FunctionScopePtr createPseudoMain(AnalysisResultConstPtr ar);
  void setFileLevel(StatementListPtr stmt);
+  void outputCPPHelper(CodeGenerator &cg, AnalysisResultPtr ar,
+                       bool classes = true);
 };

 ///////////////////////////////////////////////////////////////////////////////
 }
-#endif // incl_HPHP_FILE_SCOPE_H_
+#endif // __FILE_SCOPE_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,16 +14,16 @@
   +----------------------------------------------------------------------+
 */

-#include "hphp/compiler/analysis/function_container.h"
-#include "hphp/compiler/analysis/analysis_result.h"
-#include "hphp/compiler/analysis/function_scope.h"
-#include "hphp/compiler/analysis/class_scope.h"
-#include "hphp/compiler/analysis/file_scope.h"
-#include "hphp/compiler/analysis/code_error.h"
-#include "hphp/compiler/statement/statement_list.h"
-#include "hphp/compiler/option.h"
-#include "hphp/util/util.h"
-#include "hphp/util/hash.h"
+#include <compiler/analysis/function_container.h>
+#include <compiler/analysis/analysis_result.h>
+#include <compiler/analysis/function_scope.h>
+#include <compiler/analysis/class_scope.h>
+#include <compiler/analysis/file_scope.h>
+#include <compiler/analysis/code_error.h>
+#include <compiler/statement/statement_list.h>
+#include <compiler/option.h>
+#include <util/util.h>
+#include <util/hash.h>

 using namespace HPHP;

@@ -78,3 +78,405 @@ void FunctionContainer::getFunctionsFlattened(
    }
  }
 }
+
+class FunctionIterator {
+public:
+  FunctionIterator(const StringToFunctionScopePtrVecMap &mmap,
+                   bool &hasRedec) : m_mmap(&mmap), m_smap(0),
+                                     m_miter(mmap.begin()),
+                                     m_hasRedec(hasRedec) {
+    setup();
+  }
+  FunctionIterator(const StringToFunctionScopePtrMap &smap,
+                   const StringToFunctionScopePtrVecMap *mmap,
+                   bool &hasRedec) : m_mmap(mmap), m_smap(&smap),
+                                     m_siter(smap.begin()),
+                                     m_hasRedec(hasRedec) {
+    setup();
+  }
+
+  bool ready() const {
+    if (m_smap) {
+      return m_siter != m_smap->end();
+    } else {
+      return m_miter != m_mmap->end();
+    }
+  }
+
+  bool firstInner() const {
+    if (m_smap && !m_siter->second->isLocalRedeclaring()) {
+      return true;
+    }
+    return m_innerIter == m_miter->second.begin();
+  }
+
+  void next() {
+    if (m_smap && !m_siter->second->isLocalRedeclaring()) {
+      ++m_siter;
+      setup();
+      return;
+    }
+
+    ++m_innerIter;
+    if (m_innerIter == m_miter->second.end()) {
+      if (m_smap) {
+        ++m_siter;
+      } else {
+        ++m_miter;
+      }
+      setup();
+    }
+  }
+  const string &name() const {
+    return m_smap ? m_siter->first : m_miter->first;
+  }
+  FunctionScopePtr get() const {
+    return m_smap && !m_siter->second->isLocalRedeclaring() ?
+      m_siter->second : *m_innerIter;
+  }
+
+private:
+  const StringToFunctionScopePtrVecMap *m_mmap;
+  const StringToFunctionScopePtrMap *m_smap;
+  StringToFunctionScopePtrVecMap::const_iterator m_miter;
+  FunctionScopePtrVec::const_iterator m_innerIter;
+  StringToFunctionScopePtrMap::const_iterator m_siter;
+  bool &m_hasRedec;
+  void setup() {
+    if (ready()) {
+      if (m_smap) {
+        if (!m_siter->second->isRedeclaring()) {
+          return;
+        }
+        m_hasRedec = true;
+        if (!m_siter->second->isLocalRedeclaring()) {
+          return;
+        }
+        m_miter = m_mmap->find(m_siter->first);
+      } else {
+        if (m_miter->second.size() != 1) {
+          m_hasRedec = true;
+        }
+      }
+      m_innerIter = m_miter->second.begin();
+    }
+  }
+};
+
+void FunctionContainer::outputCPPJumpTableSupportMethod
+(CodeGenerator &cg, AnalysisResultPtr ar, FunctionScopePtr func,
+ const char *funcPrefix) {
+  string name = func->getId();
+  const char *cname = name.c_str();
+
+  string origName = !func->inPseudoMain() ? func->getOriginalName() :
+                    ("run_init::" + func->getContainingFile()->getName());
+  cg_printf("Variant");
+  if (Option::FunctionSections.find(origName) !=
+      Option::FunctionSections.end()) {
+    string funcSection = Option::FunctionSections[origName];
+    if (!funcSection.empty()) {
+      cg_printf(" __attribute__ ((section (\".text.%s\")))",
+          funcSection.c_str());
+    }
+  }
+  cg_indentBegin(" %s%s(void *extra, int count, "
+                 "INVOKE_FEW_ARGS_IMPL_ARGS) {\n",
+                 Option::InvokeFewArgsPrefix, cname);
+  func->outputCPPDynamicInvoke(cg, ar, funcPrefix, cname, false, true);
+  cg_indentEnd("}\n");
+
+  cg_indentBegin("Variant %s%s(void *extra, CArrRef params) {\n",
+                 Option::InvokePrefix, cname);
+  if (func->getMaxParamCount() <= Option::InvokeFewArgsCount &&
+      !func->isVariableArgument()) {
+    if (Option::InvokeWithSpecificArgs && !func->getMaxParamCount() &&
+        !ar->isSystem() && !ar->isSepExtension()) {
+      // For functions with no parameter, we can combine the i_ wrapper and
+      // the ifa_ wrapper.
+      cg_printf("return ((CallInfo::FuncInvoker0Args)&%s%s)(extra, 0);\n",
+                Option::InvokeFewArgsPrefix, cname);
+    } else {
+      cg_printf("return invoke_func_few_handler(extra, params, &%s%s);\n",
+                Option::InvokeFewArgsPrefix, cname);
+    }
+  } else {
+    FunctionScope::OutputCPPDynamicInvokeCount(cg);
+    func->outputCPPDynamicInvoke(cg, ar, funcPrefix, cname);
+  }
+  cg_indentEnd("}\n");
+}
+
+void
+FunctionContainer::outputCPPHelperClassAllocSupport(
+  CodeGenerator &cg, AnalysisResultPtr ar,
+  const StringToFunctionScopePtrVecMap *redec) {
+  bool hasRedeclared;
+  for (FunctionIterator fit(m_functions, redec, hasRedeclared); fit.ready();
+      fit.next()) {
+    FunctionScopePtr func = fit.get();
+    func->outputCPPHelperClassAlloc(cg, ar);
+  }
+}
+
+void FunctionContainer::outputCPPJumpTableSupport(
+  CodeGenerator &cg, AnalysisResultPtr ar,
+  const StringToFunctionScopePtrVecMap *redec, bool &hasRedeclared,
+  vector<const char *> *funcs /* = NULL */) {
+  bool systemcpp = cg.getOutput() == CodeGenerator::SystemCPP;
+  const char *funcPrefix = Option::FunctionPrefix;
+  if (systemcpp) funcPrefix = Option::BuiltinFunctionPrefix;
+  // output invoke support methods
+  for (FunctionIterator fit(m_functions, redec, hasRedeclared); fit.ready();
+      fit.next()) {
+    FunctionScopePtr func = fit.get();
+    if (func->inPseudoMain() || !(systemcpp || func->isDynamic())) continue;
+    if (funcs && fit.firstInner()) {
+      funcs->push_back(fit.name().c_str());
+    }
+
+    outputCPPJumpTableSupportMethod(cg, ar, func, funcPrefix);
+  }
+}
+
+void FunctionContainer::outputCPPCallInfoTableSupport(
+  CodeGenerator &cg, AnalysisResultPtr ar,
+  const StringToFunctionScopePtrVecMap *redec, bool &hasRedeclared,
+  vector<const char *> *funcs /* = NULL */) {
+  bool systemcpp = cg.getOutput() == CodeGenerator::SystemCPP;
+
+  for (FunctionIterator fit(m_functions, redec, hasRedeclared); fit.ready();
+      fit.next()) {
+    FunctionScopePtr func = fit.get();
+
+    if (func->inPseudoMain() || !(systemcpp || func->isDynamic())) continue;
+    if (funcs && fit.firstInner()) {
+      funcs->push_back(fit.name().c_str());
+    }
+    func->outputCPPCallInfo(cg, ar);
+  }
+}
+void FunctionContainer::outputCPPJumpTableEvalSupport(
+  CodeGenerator &cg, AnalysisResultPtr ar,
+  const StringToFunctionScopePtrVecMap *redec,
+  bool &hasRedeclared) {
+  bool systemcpp = cg.getOutput() == CodeGenerator::SystemCPP;
+  // output invoke support methods
+
+  for (FunctionIterator fit(m_functions, redec, hasRedeclared); fit.ready();
+      fit.next()) {
+    FunctionScopePtr func = fit.get();
+    if (func->inPseudoMain() ||
+        (!systemcpp && (!func->isUserFunction() ||
+                        !(func->isSepExtension() || func->isDynamic())))) {
+      continue;
+    }
+    string sname = func->getId();
+  }
+}
+
+void FunctionContainer::outputGetCallInfoHeader(CodeGenerator &cg,
+                                                const char *suffix,
+                                                bool needGlobals) {
+  cg_indentBegin("bool get_call_info%s(const CallInfo *&ci, void *&extra, "
+      "const char *s, strhash_t hash) {\n", suffix ? suffix : "");
+
+  if (needGlobals) cg.printDeclareGlobals();
+  cg_printf("extra = NULL;\n");
+
+  if (!suffix && (!Option::DynamicInvokeFunctions.empty() ||
+                  Option::EnableEval == Option::FullEval)) {
+    cg_printf("const char *ss = get_renamed_function(s);\n");
+    cg_printf("if (ss != s) { s = ss; hash = -1;};\n");
+  }
+}
+
+void FunctionContainer::outputGetCallInfoTail(CodeGenerator &cg,
+                                              bool system) {
+  if (system) {
+    cg_printf("return false;\n");
+  } else {
+    cg_printf("return get_call_info_builtin(ci, extra, s, hash);\n");
+  }
+  cg_indentEnd("}\n");
+}
+
+void FunctionContainer::outputCPPHashTableGetCallInfo(
+  CodeGenerator &cg, bool system, bool noEval,
+  const StringToFunctionScopePtrMap *functions,
+  const vector<const char *> &funcs) {
+  assert(cg.getCurrentIndentation() == 0);
+  const char text1[] =
+    "\n"
+    "struct hashNodeFunc {\n"
+    "  strhash_t hash;\n"
+    "  bool offset;\n"
+    "  bool end;\n"
+    "  const char *name;\n"
+    "  const void *data;\n"
+    "};\n"
+    "static const hashNodeFunc funcBuckets[] = {\n";
+
+  const char text3[] =
+    "static inline const hashNodeFunc *"
+    "findFunc(const char *name, strhash_t hash) {\n"
+    "  const hashNodeFunc *p = funcMapTable[hash & %d];\n"
+    "  if (UNLIKELY(!p)) return NULL;\n"
+    "  do {\n"
+    "    if (LIKELY(p->hash == hash) && (LIKELY(p->name==name)||"
+    "LIKELY(!strcasecmp(p->name, name)))) return p;\n"
+    "  } while (!p++->end);\n"
+    "  return NULL;\n"
+    "}\n"
+    "\n";
+
+  const char text4[] =
+    "  if (hash < 0) hash = hash_string(s);\n"
+    "  const hashNodeFunc *p = findFunc(s, hash);\n"
+    "  if (LIKELY(p!=0)) {\n"
+    "    if (UNLIKELY(p->offset)) {\n"
+    "      DECLARE_GLOBAL_VARIABLES(g);\n"
+    "      const char *addr = (const char *)g + (int64)p->data;\n"
+    "      ci = *(const CallInfo **)addr;\n"
+    "      return ci != 0;\n"
+    "    } else {\n"
+    "      ci = (const CallInfo *)p->data;\n"
+    "      return true;\n"
+    "    }\n"
+    "  }\n";
+
+  const char text4s[] =
+    "  if (hash < 0) hash = hash_string(s);\n"
+    "  const hashNodeFunc *p = findFunc(s, hash);\n"
+    "  if (LIKELY(p!=0)) {\n"
+    "    ci = (const CallInfo *)p->data;\n"
+    "    return true;\n"
+    "  }\n";
+
+  int numEntries = funcs.size();
+  if (!noEval && numEntries > 0) {
+    JumpTable jt(cg, funcs, true, true, true, true);
+    cg_print(text1);
+
+    vector<int> offsets;
+    int prev = -1;
+    for (int n = 0; jt.ready(); ++n, jt.next()) {
+      int cur = jt.current();
+      if (prev != cur) {
+        while (++prev != cur) {
+          offsets.push_back(-1);
+        }
+        offsets.push_back(n);
+      }
+      const char *name = jt.key();
+
+      StringToFunctionScopePtrMap::const_iterator iterFuncs =
+        functions->find(name);
+      assert(iterFuncs != functions->end());
+      // We have assumptions that function names do not contain ".."
+      // (e.g., call_user_func0 ~ call_user_func6)
+      always_assert(!strstr(name, ".."));
+      FunctionScopePtr func = iterFuncs->second;
+      cg_printf(" {" STRHASH_FMT ",%d,%d,\"%s\",",
+                hash_string_i(name),
+                (int)func->isRedeclaring(), (int)jt.last(),
+                CodeGenerator::EscapeLabel(name).c_str());
+
+      if (func->isRedeclaring()) {
+        always_assert(!system);
+        string lname(CodeGenerator::FormatLabel(name));
+        cg_printf("(const void *)(offsetof(GlobalVariables, GCI(%s)))",
+                  lname.c_str());
+      } else {
+        cg_printf("&%s%s",
+                  Option::CallInfoPrefix, func->getId().c_str());
+      }
+      cg_printf("},\n");
+    }
+    cg_printf("};\n");
+    cg_indentBegin("static const hashNodeFunc *funcMapTable[] = {\n");
+    for (int i = 0, e = jt.size(), s = offsets.size(); i < e; i++) {
+      int o = i < s ? offsets[i] : -1;
+      if (o < 0) {
+        cg_printf("0,");
+      } else {
+        cg_printf("funcBuckets+%d,", o);
+      }
+      if ((i & 7) == 7) cg_printf("\n");
+    }
+    cg_printf("\n");
+    cg_indentEnd("};\n");
+    cg_printf(text3, jt.size() - 1);
+  }
+  outputGetCallInfoHeader(cg, system ? "_builtin" : noEval ? "_no_eval" : 0,
+                          false);
+  cg_indentEnd();
+  if (numEntries > 0) {
+    cg_print(system ? text4s : text4);
+  }
+  cg_indentBegin("  ");
+  outputGetCallInfoTail(cg, system);
+}
+
+void FunctionContainer::outputCPPCodeInfoTable(
+  CodeGenerator &cg, AnalysisResultPtr ar, bool useSwitch,
+  const StringToFunctionScopePtrMap &functions) {
+  bool needGlobals = false;
+  vector<const char *> funcs;
+  bool system = cg.getOutput() == CodeGenerator::SystemCPP;
+  if (system) {
+    outputCPPCallInfoTableSupport(cg, ar, 0, needGlobals, nullptr);
+  }
+  for (StringToFunctionScopePtrMap::const_iterator iter = functions.begin(),
+         end = functions.end(); iter != end; ++iter) {
+    FunctionScopePtr func = iter->second;
+    if (!func->inPseudoMain() &&
+        (system || func->isDynamic() || func->isSepExtension())) {
+      funcs.push_back(iter->first.c_str());
+      if (!system && !func->isRedeclaring() && !func->isSepExtension()) {
+        cg_printf("extern const CallInfo %s%s;\n",
+                  Option::CallInfoPrefix, func->getId().c_str());
+      }
+    }
+  }
+  if (!useSwitch) {
+    outputCPPHashTableGetCallInfo(cg, system, false, &functions, funcs);
+    if (!system) {
+      outputCPPHashTableGetCallInfo(cg, system, true, &functions, funcs);
+    }
+    return;
+  }
+  if (!system) cg_printf("static ");
+  outputGetCallInfoHeader(cg, system ? "_builtin" : "_impl", needGlobals);
+
+  for (JumpTable fit(cg, funcs, true, true, false); fit.ready(); fit.next()) {
+    const char *name = fit.key();
+    StringToFunctionScopePtrMap::const_iterator iterFuncs =
+      functions.find(name);
+    assert(iterFuncs != functions.end());
+    cg_indentBegin("HASH_GUARD(" STRHASH_FMT ", %s) {\n",
+                   hash_string_i(name),
+                   CodeGenerator::EscapeLabel(name).c_str());
+    if (iterFuncs->second->isRedeclaring()) {
+      string lname(CodeGenerator::FormatLabel(name));
+      cg_printf("ci = &g->GCI(%s)->ci;\n", lname.c_str());
+    } else {
+      cg_printf("ci = &%s%s;\n", Option::CallInfoPrefix,
+                iterFuncs->second->getId().c_str());
+    }
+    cg_printf("return true;\n");
+    cg_indentEnd("}\n");
+  }
+  outputGetCallInfoTail(cg, system);
+
+  if (system) return;
+
+  outputGetCallInfoHeader(cg, 0, false);
+  cg_printf("return get_call_info_impl(ci, extra, s, hash);\n");
+  cg_indentEnd("}\n");
+
+  outputGetCallInfoHeader(cg, "_no_eval", false);
+  cg_printf("return get_call_info_impl(ci, extra, s, hash);\n");
+  cg_indentEnd("}\n");
+}
+
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,10 +14,11 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_FUNCTION_CONTAINER_H_
-#define incl_HPHP_FUNCTION_CONTAINER_H_
+#ifndef __FUNCTION_CONTAINER_H__
+#define __FUNCTION_CONTAINER_H__

-#include "hphp/compiler/hphp.h"
+#include <compiler/hphp.h>
+#include <compiler/util/jump_table.h>

 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////
@@ -42,18 +43,51 @@ public:
  void countReturnTypes(std::map<std::string, int> &counts,
                        const StringToFunctionScopePtrVecMap *redec);

+  /**
+   * Code generation functions.
+   */
+  void outputCPPJumpTable(CodeGenerator &cg, AnalysisResultPtr ar,
+                          const StringToFunctionScopePtrVecMap *redec);
  const StringToFunctionScopePtrMap &getFunctions() const {
    return m_functions;
  }
  void getFunctionsFlattened(const StringToFunctionScopePtrVecMap *redec,
                             FunctionScopePtrVec &funcs,
                             bool excludePseudoMains = false) const;
+  void outputCPPCodeInfoTable(
+    CodeGenerator &cg, AnalysisResultPtr ar, bool useSwitch,
+    const StringToFunctionScopePtrMap &functions);

 protected:
  // name => functions. Order of declaration
  StringToFunctionScopePtrMap m_functions;
+  void outputCPPJumpTableSupport(CodeGenerator &cg, AnalysisResultPtr ar,
+                                 const StringToFunctionScopePtrVecMap *redec,
+                                 bool &hasRedeclared,
+                                 std::vector<const char *> *funcs = nullptr);
+  void outputCPPJumpTableEvalSupport(
+    CodeGenerator &cg, AnalysisResultPtr ar,
+    const StringToFunctionScopePtrVecMap *redec, bool &hasRedeclared);
+  void outputCPPCallInfoTableSupport(
+    CodeGenerator &cg, AnalysisResultPtr ar,
+    const StringToFunctionScopePtrVecMap *redec,
+    bool &hasRedeclared, std::vector<const char *> *funcs = nullptr);
+  void outputCPPJumpTableSupportMethod(CodeGenerator &cg, AnalysisResultPtr ar,
+                                       FunctionScopePtr func,
+                                       const char *funcPrefix);
+  void outputCPPHelperClassAllocSupport(
+    CodeGenerator &cg, AnalysisResultPtr ar,
+    const StringToFunctionScopePtrVecMap *redec);
+private:
+  void outputGetCallInfoHeader(CodeGenerator &cg, const char *suffix,
+                               bool needGlobals);
+  void outputGetCallInfoTail(CodeGenerator &cg, bool system);
+  void outputCPPHashTableGetCallInfo(
+    CodeGenerator &cg, bool system, bool noEval,
+    const StringToFunctionScopePtrMap *functions,
+    const std::vector<const char *> &funcs);
 };

 ///////////////////////////////////////////////////////////////////////////////
 }
-#endif // incl_HPHP_FUNCTION_CONTAINER_H_
+#endif // __FUNCTION_CONTAINER_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,15 +14,15 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_FUNCTION_SCOPE_H_
-#define incl_HPHP_FUNCTION_SCOPE_H_
+#ifndef __FUNCTION_SCOPE_H__
+#define __FUNCTION_SCOPE_H__

-#include "hphp/compiler/expression/user_attribute.h"
-#include "hphp/compiler/analysis/block_scope.h"
-#include "hphp/compiler/option.h"
+#include <compiler/expression/user_attribute.h>
+#include <compiler/analysis/block_scope.h>
+#include <compiler/option.h>

-#include "hphp/util/json.h"
-#include "hphp/util/parser/parser.h"
+#include <util/json.h>
+#include <util/parser/parser.h>

 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////
@@ -109,15 +109,18 @@ public:
  bool hasImpl() const;
  void setDirectInvoke() { m_directInvoke = true; }
  bool hasDirectInvoke() const { return m_directInvoke; }
-  bool mayContainThis();
  bool isClosure() const;
  bool isGenerator() const;
  bool isGeneratorFromClosure() const;
-  int allocYieldLabel() { return ++m_yieldLabelCount; }
-  int getYieldLabelCount() const { return m_yieldLabelCount; }
  bool hasGeneratorAsBody() const;
  MethodStatementRawPtr getOrigGenStmt() const;
  FunctionScopeRawPtr getOrigGenFS() const;
+  void setNeedsRefTemp() { m_needsRefTemp = true; }
+  bool needsRefTemp() const { return m_needsRefTemp; }
+  void setNeedsObjTemp() { m_needsObjTemp = true; }
+  bool needsObjTemp() const { return m_needsObjTemp; }
+  void setNeedsCheckMem() { m_needsCheckMem = true; }
+  bool needsCheckMem() const { return m_needsCheckMem; }
  void setClosureGenerator() { m_closureGenerator = true; }
  bool isClosureGenerator() const {
    assert(!m_closureGenerator || isClosure());
@@ -173,13 +176,6 @@ public:
    m_volatile = false;
  }

-  /**
-   * Tell this function about another outer scope that contains it.
-   */
-  void addClonedTraitOuterScope(FunctionScopePtr scope) {
-    m_clonedTraitOuterScope.push_back(scope);
-  }
-
  /**
   * Get/set original name of the function, without case being lowered.
   */
@@ -222,10 +218,10 @@ public:
  void setNeedsActRec();

  /*
-   * If this is a builtin (C++ or PHP) and can be redefined
+   * If this is a builtin and can be redefined
   */
-  bool allowOverride() const;
-  void setAllowOverride();
+  bool ignoreRedefinition() const;
+  void setIgnoreRedefinition();

  /**
   * Whether this function is a runtime helper function
@@ -241,10 +237,16 @@ public:
   * Whether this function contains a usage of $this
   */
  bool containsThis() const { return m_containsThis;}
-  void setContainsThis(bool f = true);
+  void setContainsThis(bool f=true) { m_containsThis = f;}
  bool containsBareThis() const { return m_containsBareThis; }
  bool containsRefThis() const { return m_containsBareThis & 2; }
-  void setContainsBareThis(bool f, bool ref = false);
+  void setContainsBareThis(bool f, bool ref = false) {
+    if (f) {
+      m_containsBareThis |= ref ? 2 : 1;
+    } else {
+      m_containsBareThis = 0;
+    }
+  }
  /**
   * How many parameters a caller should provide.
   */
@@ -267,6 +269,9 @@ public:
  void clearRetExprs();
  void fixRetExprs();

+  bool needsTypeCheckWrapper() const;
+  const char *getPrefix(AnalysisResultPtr ar, ExpressionListPtr params);
+
  void setOptFunction(FunctionOptPtr fn) { m_optFunction = fn; }
  FunctionOptPtr getOptFunction() const { return m_optFunction; }

@@ -347,6 +352,92 @@ public:
   * Override BlockScope::outputPHP() to generate return type.
   */
  virtual void outputPHP(CodeGenerator &cg, AnalysisResultPtr ar);
+
+  /**
+   * Override to preface with call temps.
+   */
+  virtual void outputCPP(CodeGenerator &cg, AnalysisResultPtr ar);
+  /**
+   * Generate parameter declaration.
+   */
+  void outputCPPParamsDecl(CodeGenerator &cg, AnalysisResultPtr ar,
+                           ExpressionListPtr params, bool showDefault);
+  /**
+   * This one is a special version that doesn't require a params expression.
+   * It's for use with extension functions. It only works for the
+   * implementation since it ignores optional arguments.
+   */
+  void outputCPPParamsImpl(CodeGenerator &cg, AnalysisResultPtr ar);
+  /**
+   * If inside this function, we have to make a call to an implementation
+   * function that has the same signature, how does the parameter list
+   * look like?
+   */
+  void outputCPPParamsCall(CodeGenerator &cg, AnalysisResultPtr ar,
+                           bool aggregateParams);
+
+  /**
+   * How does a caller prepare parameters.
+   */
+  static void OutputCPPArguments(ExpressionListPtr params,
+                                 FunctionScopePtr func,
+                                 CodeGenerator &cg, AnalysisResultPtr ar,
+                                 int extraArg, bool variableArgument,
+                                 int extraArgArrayId = -1,
+                                 int extraArgArrayHash = -1,
+                                 int extraArgArrayIndex = -1,
+                                 bool ignoreFuncParamTypes = false);
+
+  /**
+   * Only generate arguments that have effects. This is for keeping those
+   * parameters around when generating a error-raising function call, so to
+   * avoid "unused" variable compiler warnings.
+   */
+  static void OutputCPPEffectiveArguments(ExpressionListPtr params,
+                                          CodeGenerator &cg,
+                                          AnalysisResultPtr ar);
+
+  /**
+   * Generate invoke proxy.
+   */
+  static void OutputCPPDynamicInvokeCount(CodeGenerator &cg);
+  void outputCPPDynamicInvoke(CodeGenerator &cg, AnalysisResultPtr ar,
+                              const char *funcPrefix,
+                              const char *name,
+                              bool voidWrapperOff = false,
+                              bool fewArgs = false,
+                              bool ret = true,
+                              const char *extraArg = nullptr,
+                              bool constructor = false,
+                              const char *instance = nullptr,
+                              const char *class_name = "");
+
+  void outputCPPDef(CodeGenerator &cg);
+
+  /**
+   * ...so ClassStatement can call them for classes that don't have
+   * constructors defined
+   */
+  void outputCPPCreateDecl(CodeGenerator &cg, AnalysisResultPtr ar);
+  void outputCPPCreateImpl(CodeGenerator &cg, AnalysisResultPtr ar);
+
+  /**
+   * output functions
+   */
+  void outputCPPClassMap(CodeGenerator &cg, AnalysisResultPtr ar);
+  void outputMethodWrapper(CodeGenerator &cg, AnalysisResultPtr ar,
+                           const char *clsToConstruct);
+
+  /**
+   * Output CallInfo instance for this function.
+   */
+  void outputCPPCallInfo(CodeGenerator &cg, AnalysisResultPtr ar);
+
+  void outputCPPPreface(CodeGenerator &cg, AnalysisResultPtr ar);
+
+  void outputCPPHelperClassAlloc(CodeGenerator &cg,
+                                 AnalysisResultPtr ar);
+
  /**
   * Serialize the iface, not everything.
   */
@@ -396,11 +487,8 @@ public:

  class FunctionInfo {
  public:
-    explicit FunctionInfo(int rva = -1)
-      : m_maybeStatic(false)
-      , m_maybeRefReturn(false)
-      , m_refVarArg(rva)
-    {}
+    FunctionInfo(int rva = -1) : m_maybeStatic(false), m_maybeRefReturn(false),
+                                 m_refVarArg(rva) { }

    bool isRefParam(int p) const {
      if (m_refVarArg >= 0 && p >= m_refVarArg) return true;
@@ -430,6 +518,14 @@ public:
  };

 private:
+  bool outputCPPArrayCreate(CodeGenerator &cg,
+                            AnalysisResultPtr ar,
+                            int m_maxParam);
+
+  void outputCPPSubClassParam(CodeGenerator &cg,
+                              AnalysisResultPtr ar,
+                              ParameterExpressionPtr param);
+
  void init(AnalysisResultConstPtr ar);

  static StringToFunctionInfoPtrMap s_refParamInfo;
@@ -472,6 +568,9 @@ private:
  unsigned m_inlineSameContext : 1;
  unsigned m_contextSensitive : 1;
  unsigned m_directInvoke : 1;
+  unsigned m_needsRefTemp : 1;
+  unsigned m_needsObjTemp : 1;
+  unsigned m_needsCheckMem : 1;
  unsigned m_closureGenerator : 1;
  unsigned m_noLSB : 1;
  unsigned m_nextLSB : 1;
@@ -483,15 +582,15 @@ private:
  StatementPtr m_stmtCloned; // cloned method body stmt
  int m_inlineIndex;
  FunctionOptPtr m_optFunction;
+  int outputCPPInvokeArgCountCheck(CodeGenerator &cg, AnalysisResultPtr ar,
+                                    bool ret, bool constructor, int maxCount);
  ExpressionPtrVec m_retExprsToFix;
  ExpressionListPtr m_closureVars;
  ExpressionListPtr m_closureValues;
  ReadWriteMutex m_inlineMutex;
  unsigned m_nextID; // used when cloning generators for traits
-  int m_yieldLabelCount; // number of allocated yield labels
-  std::list<FunctionScopeRawPtr> m_clonedTraitOuterScope;
 };

 ///////////////////////////////////////////////////////////////////////////////
 }
-#endif // incl_HPHP_FUNCTION_SCOPE_H_
+#endif // __FUNCTION_SCOPE_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,20 +14,20 @@
   +----------------------------------------------------------------------+
 */

-#include "hphp/compiler/analysis/alias_manager.h"
-#include "hphp/compiler/analysis/function_scope.h"
-#include "hphp/compiler/analysis/live_dict.h"
-#include "hphp/compiler/analysis/variable_table.h"
+#include <compiler/analysis/alias_manager.h>
+#include <compiler/analysis/function_scope.h>
+#include <compiler/analysis/live_dict.h>
+#include <compiler/analysis/variable_table.h>

-#include "hphp/compiler/expression/expression.h"
-#include "hphp/compiler/expression/assignment_expression.h"
-#include "hphp/compiler/expression/simple_variable.h"
+#include <compiler/expression/expression.h>
+#include <compiler/expression/assignment_expression.h>
+#include <compiler/expression/simple_variable.h>

-#include "hphp/compiler/statement/statement.h"
-#include "hphp/compiler/statement/block_statement.h"
-#include "hphp/compiler/statement/exp_statement.h"
-#include "hphp/compiler/statement/method_statement.h"
-#include "hphp/compiler/statement/statement_list.h"
+#include <compiler/statement/statement.h>
+#include <compiler/statement/block_statement.h>
+#include <compiler/statement/exp_statement.h>
+#include <compiler/statement/method_statement.h>
+#include <compiler/statement/statement_list.h>

 using namespace HPHP;
 using std::vector;
@@ -326,10 +326,10 @@ void LiveDict::updateAccess(ExpressionPtr e) {
 }

 struct Colorizer {
-  explicit Colorizer(int w) : toNode(w) {}
+  Colorizer(int w) : toNode(w) {}

  struct NodeInfo {
-    explicit NodeInfo(int index) : originalIndex(index), size(0), color(-1) {}
+    NodeInfo(int index) : originalIndex(index), size(0), color(-1) {}
    int originalIndex;
    int size;
    int color;
@@ -359,7 +359,7 @@ struct Colorizer {

  class NodeCmp {
  public:
-    explicit NodeCmp(const Colorizer *c) : m_c(c) {}
+    NodeCmp(const Colorizer *c) : m_c(c) {}
    bool operator()(int a, int b) {
      const NodeInfo &n1 = m_c->nodes[a];
      const NodeInfo &n2 = m_c->nodes[b];
@@ -461,11 +461,25 @@ bool LiveDict::color(TypePtr type) {
      if (Type::SameType(type, e->getCPPType())) {
        SimpleVariablePtr sv(
            static_pointer_cast<SimpleVariable>(e));
+        bool isGenParam = false;
+        if (sv->getFunctionScope()->isGenerator()) {
+          // do not allow coalescing of symbols which are parameters/use vars
+          // in the generator (sym->isParameter() will be false b/c we are in
+          // the scope of the generator function)
+          FunctionScopeRawPtr origScope(sv->getFunctionScope()->getOrigGenFS());
+          assert(origScope);
+          Symbol *origSym =
+            origScope->getVariables()->getSymbol(sv->getName());
+          if (origSym &&
+              (origSym->isParameter() || origSym->isClosureVar())) {
+            isGenParam = true;
+          }
+        }
        Symbol *sym = sv->getSymbol();
        if (sym &&
            !sym->isGlobal() &&
            !sym->isParameter() &&
-            !sym->isGeneratorParameter() &&
+            !isGenParam &&
            !sym->isClosureVar() &&
            !sym->isStatic() &&
            !e->isThis()) {
@@ -609,8 +623,9 @@ public:
      always_assert(e && e->is(Expression::KindOfSimpleVariable));
      SimpleVariablePtr sv(static_pointer_cast<SimpleVariable>(e));
      Symbol *sym = sv->getSymbol();
+      bool inGen = sv->getFunctionScope()->isGenerator();
      if (!sym || sym->isGlobal() || sym->isStatic() || sym->isParameter() ||
-          sym->isGeneratorParameter() || sym->isClosureVar() || sv->isThis()) {
+          sym->isClosureVar() || sv->isThis() || inGen) {
        continue;
      }

@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,10 +14,10 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_LIVE_DICT_H_
-#define incl_HPHP_LIVE_DICT_H_
+#ifndef __LIVE_DICT_H__
+#define __LIVE_DICT_H__

-#include "hphp/compiler/analysis/dictionary.h"
+#include <compiler/analysis/dictionary.h>

 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////
@@ -26,7 +26,7 @@ namespace HPHP {

 class LiveDict : public Dictionary {
 public:
-  explicit LiveDict(AliasManager &am) : Dictionary(am) {}
+  LiveDict(AliasManager &am) : Dictionary(am) {}
  /* Building the dictionary */
  void build(MethodStatementPtr m);
  void visit(ExpressionPtr e);
@@ -53,4 +53,4 @@ private:

 ///////////////////////////////////////////////////////////////////////////////
 }
-#endif // incl_HPHP_LIVE_DICT_H_
+#endif // __LIVE_DICT_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,16 +14,18 @@
   +----------------------------------------------------------------------+
 */

-#include "hphp/compiler/analysis/peephole.h"
-#include "hphp/compiler/analysis/emitter.h"
-#include "hphp/runtime/vm/preclass-emit.h"
+#include "compiler/analysis/peephole.h"
+#include "compiler/analysis/emitter.h"

 namespace HPHP { namespace Compiler {

+using VM::FuncEmitter;
+using VM::UnitEmitter;
+using VM::Offset;

-static void collapseJmp(Offset* offsetPtr, Op* instr, Op* start) {
+static void collapseJmp(Offset* offsetPtr, Opcode* instr, Opcode* start) {
  if (offsetPtr) {
-    Op* dest = instr + *offsetPtr;
+    Opcode* dest = instr + *offsetPtr;
    while (*dest == OpJmp && dest != instr) {
      dest = start + instrJumpTarget(start, dest - start);
    }
@@ -43,10 +45,10 @@ Peephole::Peephole(UnitEmitter &ue, MetaInfoBuilder& metaInfo)
  buildJumpTargets();

  // Scan the bytecode linearly.
-  Op* start = (Op*)ue.m_bc;
-  Op* prev = start;
-  Op* cur = prev + instrLen(prev);
-  Op* end = start + ue.m_bclen;
+  Opcode* start = ue.m_bc;
+  Opcode* prev = start;
+  Opcode* cur = prev + instrLen(prev);
+  Opcode* end = start + ue.m_bclen;

  /*
   * TODO(1086005): we should try to minimize use of CGetL2/CGetL3.
@@ -162,19 +164,14 @@ void Peephole::buildJumpTargets() {
  }
  // all jump targets are targets
  for (Offset pos = 0; pos < (Offset)m_ue.m_bclen;
-       pos += instrLen((Op*)&m_ue.m_bc[pos])) {
-    Op* instr = (Op*)&m_ue.m_bc[pos];
+       pos += instrLen(&m_ue.m_bc[pos])) {
+    Opcode* instr = &m_ue.m_bc[pos];
    if (isSwitch(*instr)) {
      foreachSwitchTarget(instr, [&](Offset& o) {
        m_jumpTargets.insert(pos + o);
      });
-    } else if (*instr == OpIterBreak) {
-      uint32_t veclen = *(uint32_t *)(instr + 1);
-      assert(veclen > 0);
-      Offset target = *(Offset *)((uint32_t *)(instr + 1) + 2 * veclen + 1);
-      m_jumpTargets.insert(pos + target);
    } else {
-      Offset target = instrJumpTarget((Op*)m_ue.m_bc, pos);
+      Offset target = instrJumpTarget(m_ue.m_bc, pos);
      if (target != InvalidAbsoluteOffset) {
        m_jumpTargets.insert(target);
      }
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -34,8 +34,8 @@
 #ifndef incl_HPHP_COMPILER_ANALYSIS_PEEPHOLE_H_
 #define incl_HPHP_COMPILER_ANALYSIS_PEEPHOLE_H_

-#include "hphp/runtime/vm/unit.h"
-#include "hphp/runtime/vm/func.h"
+#include "runtime/vm/unit.h"
+#include "runtime/vm/func.h"

 namespace HPHP { namespace Compiler {

@@ -43,14 +43,14 @@ class MetaInfoBuilder;

 class Peephole {
 public:
-  Peephole(UnitEmitter& ue, MetaInfoBuilder& metaInfo);
+  Peephole(VM::UnitEmitter& ue, MetaInfoBuilder& metaInfo);

 private:
-  void buildFuncTargets(FuncEmitter* fe);
+  void buildFuncTargets(VM::FuncEmitter* fe);
  void buildJumpTargets();

-  UnitEmitter& m_ue;
-  hphp_hash_set<Offset> m_jumpTargets;
+  VM::UnitEmitter& m_ue;
+  hphp_hash_set<VM::Offset> m_jumpTargets;
 };

 }}
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,22 +14,22 @@
   +----------------------------------------------------------------------+
 */

-#include "hphp/compiler/analysis/alias_manager.h"
-#include "hphp/compiler/analysis/function_scope.h"
-#include "hphp/compiler/analysis/ref_dict.h"
+#include <compiler/analysis/alias_manager.h>
+#include <compiler/analysis/function_scope.h>
+#include <compiler/analysis/ref_dict.h>

-#include "hphp/compiler/expression/expression.h"
-#include "hphp/compiler/expression/assignment_expression.h"
-#include "hphp/compiler/expression/binary_op_expression.h"
-#include "hphp/compiler/expression/simple_variable.h"
+#include <compiler/expression/expression.h>
+#include <compiler/expression/assignment_expression.h>
+#include <compiler/expression/binary_op_expression.h>
+#include <compiler/expression/simple_variable.h>

-#include "hphp/compiler/statement/statement.h"
-#include "hphp/compiler/statement/block_statement.h"
-#include "hphp/compiler/statement/exp_statement.h"
-#include "hphp/compiler/statement/method_statement.h"
-#include "hphp/compiler/statement/statement_list.h"
+#include <compiler/statement/statement.h>
+#include <compiler/statement/block_statement.h>
+#include <compiler/statement/exp_statement.h>
+#include <compiler/statement/method_statement.h>
+#include <compiler/statement/statement_list.h>

-#include "hphp/util/parser/hphp.tab.hpp"
+#include <util/parser/hphp.tab.hpp>

 using namespace HPHP;
 using std::vector;
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,17 +14,17 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_REF_DICT_H_
-#define incl_HPHP_REF_DICT_H_
+#ifndef __REF_DICT_H__
+#define __REF_DICT_H__

-#include "hphp/compiler/analysis/dictionary.h"
+#include <compiler/analysis/dictionary.h>

 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////

 class RefDict : public Dictionary {
 public:
-  explicit RefDict(AliasManager &am) : Dictionary(am), first_pass(true) {}
+  RefDict(AliasManager &am) : Dictionary(am), first_pass(true) {}

  /* Building the dictionary */
  void build(MethodStatementPtr m);
@@ -52,7 +52,7 @@ private:

 class RefDictWalker : public ControlFlowGraphWalker {
 public:
-  explicit RefDictWalker(ControlFlowGraph *g) :
+  RefDictWalker(ControlFlowGraph *g) :
    ControlFlowGraphWalker(g), first_pass(true) {}
  void walk() { ControlFlowGraphWalker::walk(*this); }
  int after(ConstructRawPtr cp);
@@ -63,4 +63,4 @@ private:

 ///////////////////////////////////////////////////////////////////////////////
 }
-#endif // incl_HPHP_REF_DICT_H_
+#endif // __REF_DICT_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,24 +14,23 @@
   +----------------------------------------------------------------------+
 */

-#include "hphp/compiler/analysis/symbol_table.h"
-#include "hphp/compiler/analysis/type.h"
-#include "hphp/compiler/analysis/analysis_result.h"
-#include "hphp/compiler/analysis/class_scope.h"
-#include "hphp/compiler/analysis/file_scope.h"
-#include "hphp/compiler/analysis/function_scope.h"
+#include <compiler/analysis/symbol_table.h>
+#include <compiler/analysis/type.h>
+#include <compiler/analysis/analysis_result.h>
+#include <compiler/analysis/class_scope.h>
+#include <compiler/analysis/file_scope.h>
+#include <compiler/analysis/function_scope.h>

-#include "hphp/compiler/expression/assignment_expression.h"
-#include "hphp/compiler/expression/constant_expression.h"
-#include "hphp/compiler/expression/expression_list.h"
-#include "hphp/compiler/expression/parameter_expression.h"
-#include "hphp/compiler/expression/simple_variable.h"
+#include <compiler/expression/constant_expression.h>
+#include <compiler/expression/expression_list.h>
+#include <compiler/expression/parameter_expression.h>
+#include <compiler/expression/simple_variable.h>

-#include "hphp/runtime/base/class_info.h"
-#include "hphp/runtime/base/complex_types.h"
-#include "hphp/runtime/base/variable_serializer.h"
+#include <runtime/base/class_info.h>
+#include <runtime/base/complex_types.h>
+#include <runtime/base/variable_serializer.h>

-#include "hphp/util/logger.h"
+#include <util/logger.h>

 using namespace HPHP;

@@ -285,9 +284,9 @@ void Symbol::serializeParam(JSON::DocTarget::OutputStream &out) const {
    assert(valueExp);
    const string &init = ExtractInitializer(out.analysisResult(), valueExp);
    if (!init.empty()) out << init;
-    else               out << JSON::Null();
+    else               out << JSON::Null;
  } else {
-    out << JSON::Null();
+    out << JSON::Null;
  }

  ms.done();
@@ -296,18 +295,20 @@ void Symbol::serializeParam(JSON::DocTarget::OutputStream &out) const {
 static inline std::string ExtractDocComment(ExpressionPtr e) {
  if (!e) return "";
  switch (e->getKindOf()) {
-  case Expression::KindOfAssignmentExpression: {
-    AssignmentExpressionPtr ae(static_pointer_cast<AssignmentExpression>(e));
-    return ExtractDocComment(ae->getVariable());
-  }
-  case Expression::KindOfSimpleVariable: {
-    SimpleVariablePtr sv(static_pointer_cast<SimpleVariable>(e));
-    return sv->getDocComment();
-  }
-  case Expression::KindOfConstantExpression: {
-    ConstantExpressionPtr ce(static_pointer_cast<ConstantExpression>(e));
-    return ce->getDocComment();
-  }
+  case Expression::KindOfAssignmentExpression:
+    return ExtractDocComment(e->getNthExpr(0));
+  case Expression::KindOfSimpleVariable:
+    {
+      SimpleVariablePtr sv(
+        static_pointer_cast<SimpleVariable>(e));
+      return sv->getDocComment();
+    }
+  case Expression::KindOfConstantExpression:
+    {
+      ConstantExpressionPtr ce(
+        static_pointer_cast<ConstantExpression>(e));
+      return ce->getDocComment();
+    }
  default: return "";
  }
  return "";
@@ -336,9 +337,9 @@ void Symbol::serializeClassVar(JSON::DocTarget::OutputStream &out) const {
    assert(initExp);
    const string &init = ExtractInitializer(out.analysisResult(), initExp);
    if (!init.empty()) out << init;
-    else               out << JSON::Null();
+    else               out << JSON::Null;
  } else {
-    out << JSON::Null();
+    out << JSON::Null;
  }

  const string &docs = ExtractDocComment(
@@ -595,7 +596,7 @@ void SymbolTable::countTypes(std::map<std::string, int> &counts) {
 }

 string SymbolTable::getEscapedText(Variant v, int &len) {
-  VariableSerializer vs(VariableSerializer::Type::Serialize);
+  VariableSerializer vs(VariableSerializer::Serialize);
  String str = vs.serialize(v, true);
  len = str.length();
  string output = Util::escapeStringForCPP(str.data(), len);
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,13 +14,13 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_SYMBOL_TABLE_H_
-#define incl_HPHP_SYMBOL_TABLE_H_
+#ifndef __SYMBOL_TABLE_H__
+#define __SYMBOL_TABLE_H__

-#include "hphp/compiler/hphp.h"
-#include "hphp/util/json.h"
-#include "hphp/util/util.h"
-#include "hphp/util/lock.h"
+#include <compiler/hphp.h>
+#include <util/json.h>
+#include <util/util.h>
+#include <util/lock.h>

 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////
@@ -115,8 +115,6 @@ public:
  bool isIndirectAltered() const { return m_flags.m_indirectAltered; }
  bool isReferenced() const { return !m_flags.m_notReferenced; }
  bool isHidden() const { return m_flags.m_hidden; }
-  bool isGeneratorParameter() const { return m_flags.m_generatorParameter; }
-  bool isRefGeneratorParameter() const { return m_flags.m_refGeneratorParameter; }
  bool isClosureVar() const { return m_flags.m_closureVar; }
  bool isRefClosureVar() const { return m_flags.m_refClosureVar; }
  bool isPassClosureVar() const { return m_flags.m_passClosureVar; }
@@ -142,8 +140,6 @@ public:
  void setIndirectAltered() { m_flags.m_indirectAltered = true; }
  void setReferenced() { m_flags.m_notReferenced = false; }
  void setHidden() { m_flags.m_hidden = true; }
-  void setGeneratorParameter() { m_flags.m_generatorParameter = true; }
-  void setRefGeneratorParameter() { m_flags.m_refGeneratorParameter = true; }
  void setClosureVar() { m_flags.m_closureVar = true; }
  void setRefClosureVar() { m_flags.m_refClosureVar = true; }
  void setPassClosureVar() { m_flags.m_passClosureVar = true; }
@@ -189,7 +185,7 @@ private:
  std::string  m_name;
  unsigned int m_hash;
  union {
-    uint64_t m_flags_val;
+    unsigned m_flags_val;
    struct {
      /* internal */
      unsigned m_declaration_set : 1;
@@ -223,8 +219,6 @@ private:
      unsigned m_indirectAltered : 1;
      unsigned m_notReferenced : 1;
      unsigned m_hidden : 1;
-      unsigned m_generatorParameter : 1;
-      unsigned m_refGeneratorParameter : 1;
      unsigned m_closureVar : 1;
      unsigned m_refClosureVar : 1;
      unsigned m_passClosureVar : 1;
@@ -233,13 +227,7 @@ private:
      unsigned m_stashedVal : 1;
      unsigned m_reseated : 1;
    } m_flags;
-
-
  };
-  static_assert(
-    sizeof(m_flags_val) == sizeof(m_flags),
-    "m_flags_val must cover all the flags");
-
  ConstructPtr        m_declaration;
  ConstructPtr        m_value;
  TypePtr             m_coerced;
@@ -256,7 +244,7 @@ private:

 class SymParamWrapper : public JSON::DocTarget::ISerializable {
 public:
-  explicit SymParamWrapper(const Symbol* sym) : m_sym(sym) {
+  SymParamWrapper(const Symbol* sym) : m_sym(sym) {
    assert(sym);
  }
  virtual void serialize(JSON::DocTarget::OutputStream &out) const {
@@ -268,7 +256,7 @@ private:

 class SymClassVarWrapper : public JSON::DocTarget::ISerializable {
 public:
-  explicit SymClassVarWrapper(const Symbol* sym) : m_sym(sym) {
+  SymClassVarWrapper(const Symbol* sym) : m_sym(sym) {
    assert(sym);
  }
  virtual void serialize(JSON::DocTarget::OutputStream &out) const {
@@ -394,4 +382,4 @@ private:
 ///////////////////////////////////////////////////////////////////////////////
 }

-#endif // incl_HPHP_SYMBOL_TABLE_H_
+#endif // __SYMBOL_TABLE_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,13 +14,12 @@
   +----------------------------------------------------------------------+
 */

-#include "hphp/compiler/analysis/type.h"
-#include "hphp/compiler/code_generator.h"
-#include "hphp/compiler/analysis/analysis_result.h"
-#include "hphp/compiler/analysis/class_scope.h"
-#include "hphp/compiler/analysis/file_scope.h"
-#include "hphp/compiler/expression/expression.h"
-#include "hphp/runtime/base/builtin_functions.h"
+#include <compiler/analysis/type.h>
+#include <compiler/code_generator.h>
+#include <compiler/analysis/analysis_result.h>
+#include <compiler/analysis/class_scope.h>
+#include <compiler/analysis/file_scope.h>
+#include <compiler/expression/expression.h>
 #include <boost/format.hpp>

 using namespace HPHP;
@@ -50,53 +49,38 @@ TypePtr Type::Any         (new Type(Type::KindOfAny         ));
 TypePtr Type::Some        (new Type(Type::KindOfSome        ));

 Type::TypePtrMap Type::s_TypeHintTypes;
-Type::TypePtrMap Type::s_HHTypeHintTypes;

 void Type::InitTypeHintMap() {
  assert(s_TypeHintTypes.empty());
-  assert(s_HHTypeHintTypes.empty());
-
  s_TypeHintTypes["array"] = Type::Array;
-
-  s_HHTypeHintTypes["array"] = Type::Array;
-  s_HHTypeHintTypes["bool"]    = Type::Boolean;
-  s_HHTypeHintTypes["boolean"] = Type::Boolean;
-  s_HHTypeHintTypes["int"]     = Type::Int64;
-  s_HHTypeHintTypes["integer"] = Type::Int64;
-  s_HHTypeHintTypes["real"]    = Type::Double;
-  s_HHTypeHintTypes["double"]  = Type::Double;
-  s_HHTypeHintTypes["float"]   = Type::Double;
-  s_HHTypeHintTypes["string"]  = Type::String;
+  if (Option::EnableHipHopSyntax) {
+    s_TypeHintTypes["bool"]    = Type::Boolean;
+    s_TypeHintTypes["boolean"] = Type::Boolean;
+    s_TypeHintTypes["int"]     = Type::Int64;
+    s_TypeHintTypes["integer"] = Type::Int64;
+    s_TypeHintTypes["real"]    = Type::Double;
+    s_TypeHintTypes["double"]  = Type::Double;
+    s_TypeHintTypes["float"]   = Type::Double;
+    s_TypeHintTypes["string"]  = Type::String;
+  }
 }

-const Type::TypePtrMap &Type::GetTypeHintTypes(bool hhType) {
-  return hhType ? s_HHTypeHintTypes : s_TypeHintTypes;
+const Type::TypePtrMap &Type::GetTypeHintTypes() {
+  return s_TypeHintTypes;
 }

 void Type::ResetTypeHintTypes() {
  s_TypeHintTypes.clear();
-  s_HHTypeHintTypes.clear();
 }

-TypePtr Type::CreateObjectType(const std::string &clsname) {
-  // For interfaces that support arrays we're pessimistic and
-  // we treat it as a Variant
-  if (interface_supports_array(clsname)) {
-    return Type::Variant;
-  }
-  return TypePtr(new Type(KindOfObject, clsname));
+TypePtr Type::CreateObjectType(const std::string &classname) {
+  return TypePtr(new Type(KindOfObject, classname));
 }

-TypePtr Type::GetType(KindOf kindOf, const std::string &clsname /* = "" */) {
+TypePtr Type::GetType(KindOf kindOf,
+                      const std::string &clsname /* = "" */) {
  assert(kindOf);
-  if (!clsname.empty()) {
-    // For interfaces that support arrays we're pessimistic and
-    // we treat it as a Variant
-    if (interface_supports_array(clsname)) {
-      return Type::Variant;
-    }
-    return TypePtr(new Type(kindOf, clsname));
-  }
+  if (!clsname.empty()) return TypePtr(new Type(kindOf, clsname));

  switch (kindOf) {
  case KindOfBoolean:     return Type::Boolean;
@@ -605,6 +589,37 @@ ClassScopePtr Type::getClass(AnalysisResultConstPtr ar,
  return cls;
 }

+string Type::getCPPDecl(AnalysisResultConstPtr ar,
+                        BlockScopeRawPtr scope,
+                        CodeGenerator *cg /* = 0 */) {
+  switch (m_kindOf) {
+    case KindOfBoolean:     return "bool";
+    case KindOfInt32:       return "int";
+    case KindOfInt64:       return "int64";
+    case KindOfDouble:      return "double";
+    case KindOfString:      return "String";
+    case KindOfArray:       return "Array";
+    case KindOfObject:{
+      ClassScopePtr cls(getClass(ar, scope));
+      if (!cls) return "Object";
+      if (cg && cg->isFileOrClassHeader() && scope) {
+        if (scope->getContainingClass()) {
+          scope->getContainingClass()->addUsedClassHeader(cls);
+        } else if (scope->getContainingFile()) {
+          scope->getContainingFile()->addUsedClassHeader(cls);
+        }
+      }
+      return Option::SmartPtrPrefix + cls->getId();
+    }
+    case KindOfNumeric:     return "Numeric";
+    case KindOfPrimitive:   return "Primitive";
+    case KindOfPlusOperand: return "PlusOperand";
+    case KindOfSequence:    return "Sequence";
+    default:
+      return "Variant";
+  }
+}
+
 DataType Type::getDataType() const {
  switch (m_kindOf) {
    case KindOfBoolean:     return HPHP::KindOfBoolean;
@@ -631,6 +646,66 @@ DataType Type::getHhvmDataType() const {
  }
 }

+void Type::outputCPPDecl(CodeGenerator &cg, AnalysisResultConstPtr ar,
+                         BlockScopeRawPtr scope) {
+  cg_print(getCPPDecl(ar, scope, &cg).c_str());
+}
+
+void Type::outputCPPFastObjectCast(CodeGenerator &cg,
+    AnalysisResultConstPtr ar,
+    BlockScopeRawPtr scope,
+    bool isConst) {
+  assert(isSpecificObject());
+  ClassScopePtr cls(getClass(ar, scope));
+  assert(cls);
+  const string &cppClsName = cls->getId();
+  cg_printf("(%s%s%s&)",
+            isConst ? "const " : "",
+            Option::SmartPtrPrefix,
+            cppClsName.c_str());
+}
+
+void Type::outputCPPCast(CodeGenerator &cg, AnalysisResultConstPtr ar,
+                         BlockScopeRawPtr scope) {
+  switch (m_kindOf) {
+    case KindOfBoolean:     cg_printf("toBoolean");   break;
+    case KindOfInt32:       cg_printf("toInt32");     break;
+    case KindOfInt64:       cg_printf("toInt64");     break;
+    case KindOfDouble:      cg_printf("toDouble");    break;
+    case KindOfString:      cg_printf("toString");    break;
+    case KindOfArray:       cg_printf("toArray");     break;
+    case KindOfNumeric:     cg_printf("Numeric");     break;
+    case KindOfPrimitive:   cg_printf("Primitive");   break;
+    case KindOfPlusOperand: cg_printf("PlusOperand"); break;
+    case KindOfSequence:    cg_printf("Sequence");    break;
+    case KindOfObject: {
+      ClassScopePtr cls(getClass(ar, scope));
+      if (!cls) {
+        cg_printf("toObject");
+      } else {
+        cg_printf("%s%s", Option::SmartPtrPrefix, cls->getId().c_str());
+      }
+      break;
+    }
+    default:
+      cg_printf("Variant");
+      break;
+  }
+}
+
+const char *Type::getCPPInitializer() {
+  switch (m_kindOf) {
+  case KindOfBoolean:     return "false";
+  case KindOfInt32:
+  case KindOfInt64:       return "0";
+  case KindOfNumeric:
+  case KindOfPrimitive:
+  case KindOfPlusOperand: return "0";
+  case KindOfDouble:      return "0.0";
+  default:                return nullptr;
+  }
+}
+
 std::string Type::getPHPName() {
  switch (m_kindOf) {
  case KindOfArray:       return "array";
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,13 +14,13 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_TYPE_H_
-#define incl_HPHP_TYPE_H_
+#ifndef __TYPE_H__
+#define __TYPE_H__

-#include "hphp/compiler/hphp.h"
-#include "hphp/util/json.h"
-#include "hphp/util/case_insensitive.h"
-#include "hphp/runtime/base/types.h"
+#include <compiler/hphp.h>
+#include <util/json.h>
+#include <util/case_insensitive.h>
+#include <runtime/base/types.h>


 class TestCodeRun;
@@ -102,7 +102,7 @@ public:
  static TypePtr Some;

  typedef hphp_string_imap<TypePtr> TypePtrMap;
-  static const TypePtrMap &GetTypeHintTypes(bool hhType);
+  static const TypePtrMap &GetTypeHintTypes();

  /**
   * Uncertain types: types that are ambiguous yet.
@@ -201,7 +201,7 @@ public:
  /**
   * KindOf testing.
   */
-  explicit Type(KindOf kindOf);
+  Type(KindOf kindOf);
  bool is(KindOf kindOf) const { return m_kindOf == kindOf;}
  bool isExactType() const { return IsExactType(m_kindOf); }
  bool mustBe(KindOf kindOf) const { return !(m_kindOf & ~kindOf); }
@@ -225,9 +225,35 @@ public:
  ClassScopePtr getClass(AnalysisResultConstPtr ar,
                         BlockScopeRawPtr scope) const;

+  /**
+   * Generate type specifier in C++.
+   */
+  std::string getCPPDecl(AnalysisResultConstPtr ar,
+                         BlockScopeRawPtr scope,
+                         CodeGenerator *cg = 0);
  DataType getDataType() const;
  DataType getHhvmDataType() const;

+  void outputCPPDecl(CodeGenerator &cg, AnalysisResultConstPtr ar,
+                     BlockScopeRawPtr scope);
+
+  /**
+   * Generate type conversion in C++.
+   */
+
+  void outputCPPFastObjectCast(CodeGenerator &cg,
+      AnalysisResultConstPtr ar,
+      BlockScopeRawPtr scope,
+      bool isConst);
+
+  void outputCPPCast(CodeGenerator &cg, AnalysisResultConstPtr ar,
+                     BlockScopeRawPtr scope);
+
+  /**
+   * Generate variable initialization code.
+   */
+  const char *getCPPInitializer();
+
  /**
   * Type hint names in PHP.
   */
@@ -267,7 +293,6 @@ private:
  static void ResetTypeHintTypes();

  static TypePtrMap s_TypeHintTypes;
-  static TypePtrMap s_HHTypeHintTypes;

  const KindOf m_kindOf;
  const std::string m_name;
@@ -275,4 +300,4 @@ private:

 ///////////////////////////////////////////////////////////////////////////////
 }
-#endif // incl_HPHP_TYPE_H_
+#endif // __TYPE_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,12 +14,12 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_VARIABLE_TABLE_H_
-#define incl_HPHP_VARIABLE_TABLE_H_
+#ifndef __VARIABLE_TABLE_H__
+#define __VARIABLE_TABLE_H__

-#include "hphp/compiler/analysis/symbol_table.h"
-#include "hphp/compiler/statement/statement.h"
-#include "hphp/compiler/analysis/class_scope.h"
+#include <compiler/analysis/symbol_table.h>
+#include <compiler/statement/statement.h>
+#include <compiler/analysis/class_scope.h>

 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////
@@ -100,7 +100,7 @@ public:
  }

 public:
-  explicit VariableTable(BlockScope &blockScope);
+  VariableTable(BlockScope &blockScope);

  /**
   * Get/set attributes.
@@ -137,6 +137,15 @@ public:

  virtual bool isInherited(const std::string &name) const;

+  const char *getVariablePrefix(const std::string &name) const;
+  const char *getVariablePrefix(const Symbol *sym) const;
+  std::string getVariableName(AnalysisResultConstPtr ar,
+                              const std::string &name) const;
+  std::string getVariableName(AnalysisResultConstPtr ar,
+                              const Symbol *sym) const;
+  std::string getGlobalVariableName(AnalysisResultConstPtr ar,
+                                    const std::string &name) const;
+
  void getLocalVariableNames(std::vector<std::string> &syms) const;

  /**
@@ -280,6 +289,33 @@ public:
   * Generate all variable declarations for this symbol table.
   */
  void outputPHP(CodeGenerator &cg, AnalysisResultPtr ar);
+  void outputCPP(CodeGenerator &cg, AnalysisResultPtr ar);
+  bool outputCPPPropertyDecl(CodeGenerator &cg, AnalysisResultPtr ar,
+      bool dynamicObject = false);
+  void outputCPPClassMap(CodeGenerator &cg, AnalysisResultPtr ar);
+  void outputCPPStaticVariables(CodeGenerator &cg, AnalysisResultPtr ar);
+  void outputCPPStaticLocals(CodeGenerator &cg, AnalysisResultPtr ar,
+                             bool forInitList);
+
+  void outputCPPGlobalVariablesDtorIncludes(CodeGenerator &cg,
+                                            AnalysisResultPtr ar);
+  void outputCPPGlobalVariablesDtor(CodeGenerator &cg);
+  void outputCPPGVHashTableGetImpl(CodeGenerator &cg, AnalysisResultPtr ar);
+  void outputCPPGlobalVariablesGetImpl(CodeGenerator &cg,
+                                       AnalysisResultPtr ar);
+  void outputCPPGVHashTableExists(CodeGenerator &cg, AnalysisResultPtr ar);
+  void outputCPPGlobalVariablesExists(CodeGenerator &cg,
+                                      AnalysisResultPtr ar);
+  void outputCPPGVHashTableGetIndex(CodeGenerator &cg,
+                                    AnalysisResultPtr ar);
+  void outputCPPGlobalVariablesGetIndex(CodeGenerator &cg,
+                                        AnalysisResultPtr ar);
+  void outputCPPGlobalVariablesMethods(CodeGenerator &cg,
+                                       AnalysisResultPtr ar);
+
+  void collectCPPGlobalSymbols(StringPairSetVec &symbols, CodeGenerator &cg,
+                               AnalysisResultPtr ar);
+
  /**
   * Whether or not the specified jump table is empty.
   */
@@ -347,10 +383,26 @@ private:
                          TypePtr type, bool coerce);
  virtual void dumpStats(std::map<std::string, int> &typeCounts);

+  void outputCPPGlobalVariablesHeader(CodeGenerator &cg,
+                                      AnalysisResultPtr ar);
+  void outputCPPGlobalVariablesImpl(CodeGenerator &cg, AnalysisResultPtr ar);
+  void outputCPPImpl(CodeGenerator &cg, AnalysisResultPtr ar);
+  void outputCPPVariableTable(CodeGenerator &cg, AnalysisResultPtr ar,
+                              const char *paramPrefix);
+  bool outputCPPJumpTable(CodeGenerator &cg, AnalysisResultPtr ar,
+                          const char *prefix, bool defineHash,
+                          bool variantOnly, StaticSelection staticVar,
+                          JumpTableType type = JumpReturn,
+                          PrivateSelection privateVar = NonPrivate,
+                          bool *declaredGlobals = nullptr);
+  bool outputCPPPrivateSelector(CodeGenerator &cg, AnalysisResultPtr ar,
+                                const char *op, const char *args);
+  void outputCPPVariableInit(CodeGenerator &cg, AnalysisResultPtr ar,
+                             bool inPseudoMain, const std::string &name);
  void checkSystemGVOrder(SymbolSet &variants, unsigned int max);
 };

 ///////////////////////////////////////////////////////////////////////////////
 }

-#endif // incl_HPHP_VARIABLE_TABLE_H_
+#endif // __VARIABLE_TABLE_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,27 +14,24 @@
   +----------------------------------------------------------------------+
 */

-#include "hphp/compiler/builtin_symbols.h"
-#include "hphp/compiler/analysis/analysis_result.h"
-#include "hphp/compiler/statement/statement_list.h"
-#include "hphp/compiler/analysis/type.h"
-#include "hphp/compiler/analysis/function_scope.h"
-#include "hphp/compiler/analysis/class_scope.h"
-#include "hphp/compiler/expression/modifier_expression.h"
-#include "hphp/compiler/expression/simple_function_call.h"
-#include "hphp/compiler/option.h"
-#include "hphp/compiler/parser/parser.h"
-#include "hphp/compiler/analysis/file_scope.h"
-#include "hphp/compiler/analysis/variable_table.h"
-#include "hphp/compiler/analysis/constant_table.h"
-#include "hphp/util/parser/hphp.tab.hpp"
-#include "hphp/runtime/base/class_info.h"
-#include "hphp/runtime/base/program_functions.h"
-#include "hphp/runtime/base/array/array_iterator.h"
-#include "hphp/runtime/base/execution_context.h"
-#include "hphp/runtime/base/thread_init_fini.h"
-#include "hphp/util/logger.h"
-#include "hphp/util/util.h"
+#include <compiler/builtin_symbols.h>
+#include <compiler/analysis/analysis_result.h>
+#include <compiler/statement/statement_list.h>
+#include <compiler/analysis/type.h>
+#include <compiler/analysis/function_scope.h>
+#include <compiler/analysis/class_scope.h>
+#include <compiler/expression/modifier_expression.h>
+#include <compiler/option.h>
+#include <compiler/parser/parser.h>
+#include <compiler/analysis/file_scope.h>
+#include <compiler/analysis/variable_table.h>
+#include <compiler/analysis/constant_table.h>
+#include <util/parser/hphp.tab.hpp>
+#include <runtime/base/class_info.h>
+#include <runtime/base/program_functions.h>
+#include <runtime/base/array/array_iterator.h>
+#include <util/logger.h>
+#include <util/util.h>
 #include <dlfcn.h>

 using namespace HPHP;
@@ -49,8 +46,38 @@ using namespace HPHP;
 ///////////////////////////////////////////////////////////////////////////////

 bool BuiltinSymbols::Loaded = false;
+bool BuiltinSymbols::NoSuperGlobals = false;
 StringBag BuiltinSymbols::s_strings;

+namespace HPHP {
+#define EXT_TYPE 4
+#include <system/ext.inc>
+#undef EXT_TYPE
+}
+
+const char *BuiltinSymbols::ExtensionFunctions[] = {
+#define S(n) (const char *)n
+#define T(t) (const char *)Type::KindOf ## t
+#define EXT_TYPE 0
+#include <system/ext.inc>
+  nullptr,
+};
+#undef EXT_TYPE
+
+const char *BuiltinSymbols::ExtensionConsts[] = {
+#define EXT_TYPE 1
+#include <system/ext.inc>
+  nullptr,
+};
+#undef EXT_TYPE
+
+const char *BuiltinSymbols::ExtensionClasses[] = {
+#define EXT_TYPE 2
+#include <system/ext.inc>
+  nullptr,
+};
+#undef EXT_TYPE
+
 StringToFunctionScopePtrMap BuiltinSymbols::s_functions;

 const char *const BuiltinSymbols::GlobalNames[] = {
@@ -73,7 +100,6 @@ const char *BuiltinSymbols::SystemClasses[] = {
  "exception",
  "arrayaccess",
  "iterator",
-  "collections",
  "reflection",
  "splobjectstorage",
  "directory",
@@ -90,7 +116,6 @@ StringToClassScopePtrMap BuiltinSymbols::s_classes;
 VariableTablePtr BuiltinSymbols::s_variables;
 ConstantTablePtr BuiltinSymbols::s_constants;
 StringToTypePtrMap BuiltinSymbols::s_superGlobals;
-AnalysisResultPtr BuiltinSymbols::s_systemAr;
 void *BuiltinSymbols::s_handle_main = nullptr;

 ///////////////////////////////////////////////////////////////////////////////
@@ -100,303 +125,380 @@ int BuiltinSymbols::NumGlobalNames() {
    sizeof(BuiltinSymbols::GlobalNames[0]);
 }

-static TypePtr typePtrFromDataType(DataType dt, TypePtr unknown) {
-  switch (dt) {
-    case KindOfNull:    return Type::Null;
-    case KindOfBoolean: return Type::Boolean;
-    case KindOfInt64:   return Type::Int64;
-    case KindOfDouble:  return Type::Double;
-    case KindOfString:  return Type::String;
-    case KindOfArray:   return Type::Array;
-    case KindOfObject:  return Type::Object;
-    case KindOfUnknown:
-    default:
-      return unknown;
+void BuiltinSymbols::ParseExtFunctions(AnalysisResultPtr ar, const char **p,
+                                       bool sep) {
+  while (*p) {
+    FunctionScopePtr f = ParseExtFunction(ar, p);
+    if (sep) {
+      f->setSepExtension();
+    }
+    assert(!s_functions[f->getName()]);
+    s_functions[f->getName()] = f;
  }
 }

-FunctionScopePtr BuiltinSymbols::ImportFunctionScopePtr(AnalysisResultPtr ar,
-                 ClassInfo *cls, ClassInfo::MethodInfo *method) {
-  int attrs = method->attribute;
-  bool isMethod = cls != ClassInfo::GetSystem();
-  FunctionScopePtr f(new FunctionScope(isMethod,
-                                       method->name.data(),
-                                       attrs & ClassInfo::IsReference));
-
-  int reqCount = 0, totalCount = 0;
-  for(auto it = method->parameters.begin();
-      it != method->parameters.end(); ++it) {
-    const ClassInfo::ParameterInfo *pinfo = *it;
-    if (!pinfo->value || !pinfo->value[0]) {
-      ++reqCount;
+void BuiltinSymbols::ParseExtConsts(AnalysisResultPtr ar, const char **p,
+                                    bool sep) {
+  while (*p) {
+    const char *name = *p++;
+    TypePtr type = ParseType(p);
+    s_constants->add(name, type, ExpressionPtr(), ar, ConstructPtr());
+    if (sep) {
+      s_constants->setSepExtension(name);
    }
-    ++totalCount;
-  }
-  f->setParamCounts(ar, reqCount, totalCount);
-
-  int idx = 0;
-  for(auto it = method->parameters.begin();
-      it != method->parameters.end(); ++it, ++idx) {
-    const ClassInfo::ParameterInfo *pinfo = *it;
-    f->setParamName(idx, pinfo->name);
-    if (pinfo->attribute & ClassInfo::IsReference) {
-      f->setRefParam(idx);
-    }
-    f->setParamType(ar, idx, typePtrFromDataType(pinfo->argType, Type::Any));
-    if (pinfo->valueLen) {
-      f->setParamDefault(idx, pinfo->value, pinfo->valueLen,
-                         std::string(pinfo->valueText, pinfo->valueTextLen));
-    }
-  }
-
-  if (method->returnType != KindOfNull) {
-    f->setReturnType(ar, typePtrFromDataType(method->returnType,
-                                             Type::Variant));
-  }
-
-  f->setClassInfoAttribute(attrs);
-  if (attrs & ClassInfo::HasDocComment) {
-    f->setDocComment(method->docComment);
-  }
-
-  if (!isMethod && (attrs & ClassInfo::HasOptFunction)) {
-    // Legacy optimization functions
-    if (method->name.same("fb_call_user_func_safe") ||
-        method->name.same("fb_call_user_func_safe_return") ||
-        method->name.same("fb_call_user_func_array_safe")) {
-      f->setOptFunction(hphp_opt_fb_call_user_func);
-    } else if (method->name.same("is_callable")) {
-      f->setOptFunction(hphp_opt_is_callable);
-    } else if (method->name.same("call_user_func_array")) {
-      f->setOptFunction(hphp_opt_call_user_func);
-    }
-  }
-
-  if (isMethod) {
-    if (attrs & ClassInfo::IsProtected) {
-      f->addModifier(T_PROTECTED);
-    } else if (attrs & ClassInfo::IsPrivate) {
-      f->addModifier(T_PRIVATE);
-    }
-    if (attrs & ClassInfo::IsStatic) {
-      f->addModifier(T_STATIC);
-    }
-  }
-
-  // This block of code is not needed, if BlockScope directly takes flags.
-  if (attrs & ClassInfo::MixedVariableArguments) {
-    f->setVariableArgument(-1);
-  } else if (attrs & ClassInfo::RefVariableArguments) {
-    f->setVariableArgument(1);
-  } else if (attrs & ClassInfo::VariableArguments) {
-    f->setVariableArgument(0);
-  }
-  if (attrs & ClassInfo::NoEffect) {
-    f->setNoEffect();
-  }
-  if (attrs & ClassInfo::FunctionIsFoldable) {
-    f->setIsFoldable();
-  }
-  if (attrs & ClassInfo::ContextSensitive) {
-    f->setContextSensitive(true);
-  }
-  if (attrs & ClassInfo::NeedsActRec) {
-    f->setNeedsActRec();
-  }
-  if ((attrs & ClassInfo::AllowOverride) && !isMethod) {
-    f->setAllowOverride();
-  }
-
-  FunctionScope::RecordFunctionInfo(f->getName(), f);
-  return f;
-}
-
-void BuiltinSymbols::ImportExtFunctions(AnalysisResultPtr ar,
-                                        StringToFunctionScopePtrMap &map,
-                                        ClassInfo *cls) {
-  const ClassInfo::MethodVec &methods = cls->getMethodsVec();
-  for (auto it = methods.begin(); it != methods.end(); ++it) {
-    FunctionScopePtr f = ImportFunctionScopePtr(ar, cls, *it);
-    assert(!map[f->getName()]);
-    map[f->getName()] = f;
  }
 }

-void BuiltinSymbols::ImportExtFunctions(AnalysisResultPtr ar,
-                                        FunctionScopePtrVec &vec,
-                                        ClassInfo *cls) {
-  const ClassInfo::MethodVec &methods = cls->getMethodsVec();
-  for (auto it = methods.begin(); it != methods.end(); ++it) {
-    FunctionScopePtr f = ImportFunctionScopePtr(ar, cls, *it);
-    vec.push_back(f);
+TypePtr BuiltinSymbols::ParseType(const char **&p) {
+  const char *clsname = nullptr;
+  Type::KindOf ktype = (Type::KindOf)(long)(*p++);
+  if (ktype == CLASS_TYPE) {
+    clsname = *p++;
  }
+  TypePtr type;
+  if (clsname) {
+    type = Type::CreateObjectType(clsname);
+  } else if (ktype != Type::KindOfVoid) {
+    type = Type::GetType(ktype);
+  }
+  return type;
 }

-void BuiltinSymbols::ImportExtProperties(AnalysisResultPtr ar,
-                                         VariableTablePtr dest,
-                                         ClassInfo *cls) {
-  ClassInfo::PropertyVec src = cls->getPropertiesVec();
-  for (auto it = src.begin(); it != src.end(); ++it) {
-    ClassInfo::PropertyInfo *pinfo = *it;
-    int attrs = pinfo->attribute;
-    ModifierExpressionPtr modifiers(
-      new ModifierExpression(BlockScopePtr(), LocationPtr()));
-    if (attrs & ClassInfo::IsPrivate) {
-      modifiers->add(T_PRIVATE);
-    } else if (attrs & ClassInfo::IsProtected) {
-      modifiers->add(T_PROTECTED);
+void BuiltinSymbols::ParseExtClasses(AnalysisResultPtr ar, const char **p,
+                                     bool sep) {
+  while (*p) {
+    // Parse name
+    const char *cname = *p++;
+    // Parse parent
+    const char *cparent = *p++;
+    if (!cparent) cparent = "";
+    // Parse list of interfaces
+    vector<string> ifaces;
+    while (*p) ifaces.push_back(*p++);
+    p++;
+    // Parse methods
+    FunctionScopePtrVec methods;
+    while (*p) {
+      FunctionScopePtr fs = ParseExtFunction(ar, p, true);
+      if (sep) {
+        fs->setSepExtension();
+      }
+      int flags = (int)(int64)(*p++);
+      if (flags & ClassInfo::IsAbstract) {
+        fs->addModifier(T_ABSTRACT);
+      }
+      int vismod = 0;
+      if (flags & ClassInfo::IsProtected) {
+        vismod = T_PROTECTED;
+      } else if (flags & ClassInfo::IsPrivate) {
+        vismod = T_PRIVATE;
+      }
+      fs->addModifier(vismod);
+      if (flags & ClassInfo::IsStatic) {
+        fs->addModifier(T_STATIC);
+      }
+      methods.push_back(fs);
    }
-    if (attrs & ClassInfo::IsStatic) {
-      modifiers->add(T_STATIC);
+    if (cparent && *cparent && (ifaces.empty() || ifaces[0] != cparent)) {
+      ifaces.insert(ifaces.begin(), cparent);
+    }
+    ClassScopePtr cl(new ClassScope(ar, cname, cparent, ifaces, methods));
+    for (uint i = 0; i < methods.size(); ++i) {
+      methods[i]->setOuterScope(cl);
+    }
+    p++;
+    // Parse properties
+    while (*p) {
+      int flags = (int)(int64)(*p++);
+      ModifierExpressionPtr modifiers(
+        new ModifierExpression(BlockScopePtr(), LocationPtr()));
+      if (flags & ClassInfo::IsProtected) {
+        modifiers->add(T_PROTECTED);
+      } else if (flags & ClassInfo::IsPrivate) {
+        modifiers->add(T_PRIVATE);
+      }
+      if (flags & ClassInfo::IsStatic) {
+        modifiers->add(T_STATIC);
+      }
+      const char *name = *p++;
+      TypePtr type = ParseType(p);
+      cl->getVariables()->add(name, type, false, ar, ExpressionPtr(), modifiers);
+    }
+    p++;
+    // Parse consts
+    while (*p) {
+      const char *name = *p++;
+      TypePtr type = ParseType(p);
+      cl->getConstants()->add(name, type, ExpressionPtr(), ar, ConstructPtr());
+    }
+    p++;
+
+    int flags = (int)(int64)(*p++);
+    cl->setClassInfoAttribute(flags);
+    if (flags & ClassInfo::HasDocComment) {
+      cl->setDocComment(*p++);
    }

-    dest->add(pinfo->name.data(),
-              typePtrFromDataType(pinfo->type, Type::Variant),
-              false, ar, ExpressionPtr(), modifiers);
-  }
-}
-
-void BuiltinSymbols::ImportExtConstants(AnalysisResultPtr ar,
-                                        ConstantTablePtr dest,
-                                        ClassInfo *cls) {
-  ClassInfo::ConstantVec src = cls->getConstantsVec();
-  for (auto it = src.begin(); it != src.end(); ++it) {
-    // We make an assumption that if the constant is a callback type
-    // (e.g. STDIN, STDOUT, STDERR) then it will return an Object.
-    // And that if it's deferred (SID, PHP_SAPI) it'll be a String.
-    ClassInfo::ConstantInfo *cinfo = *it;
-    dest->add(cinfo->name.data(),
-              cinfo->isDeferred() ?
-              (cinfo->isCallback() ? Type::Object : Type::String) :
-              typePtrFromDataType(cinfo->getValue().getType(), Type::Variant),
-              ExpressionPtr(), ar, ConstructPtr());
-  }
-}
-
-ClassScopePtr BuiltinSymbols::ImportClassScopePtr(AnalysisResultPtr ar,
-                                                  ClassInfo *cls) {
-  FunctionScopePtrVec methods;
-  ImportExtFunctions(ar, methods, cls);
-
-  ClassInfo::InterfaceVec ifaces = cls->getInterfacesVec();
-  String parent = cls->getParentClass();
-  std::vector<std::string> stdIfaces;
-  if (!parent.empty() && (ifaces.empty() || ifaces[0] != parent)) {
-    stdIfaces.push_back(parent.data());
-  }
-  for (auto it = ifaces.begin(); it != ifaces.end(); ++it) {
-    stdIfaces.push_back(it->data());
-  }
-
-  ClassScopePtr cl(new ClassScope(ar, cls->getName().data(), parent.data(),
-                                  stdIfaces, methods));
-  for (uint i = 0; i < methods.size(); ++i) {
-    methods[i]->setOuterScope(cl);
-  }
-
-  ImportExtProperties(ar, cl->getVariables(), cls);
-  ImportExtConstants(ar, cl->getConstants(), cls);
-  int attrs = cls->getAttribute();
-  cl->setClassInfoAttribute(attrs);
-  if (attrs & ClassInfo::HasDocComment) {
-    cl->setDocComment(cls->getDocComment());
-  }
-  cl->setSystem();
-  return cl;
-}
-
-void BuiltinSymbols::ImportExtClasses(AnalysisResultPtr ar) {
-  const ClassInfo::ClassMap &classes = ClassInfo::GetClassesMap();
-  for (auto it = classes.begin(); it != classes.end(); ++it) {
-    ClassScopePtr cl = ImportClassScopePtr(ar, it->second);
-    assert(!s_classes[cl->getName()]);
+    cl->setSystem();
+    if (sep) {
+      cl->setSepExtension();
+    }
    s_classes[cl->getName()] = cl;
  }
 }

-bool BuiltinSymbols::Load(AnalysisResultPtr ar) {
+FunctionScopePtr BuiltinSymbols::ParseExtFunction(AnalysisResultPtr ar,
+    const char** &p, bool method /* = false */) {
+  const char *name = *p++;
+  TypePtr retType = ParseType(p);
+  bool reference = *p++;
+
+  int minParam = -1;
+  int maxParam = 0;
+  const char **arg = p;
+  while (*arg) {
+    /* name */ arg++;
+    ParseType(arg);
+    const char *argDefault = *arg++;
+    /* const char *argDefaultLen = */ arg++;
+    /* const char *argDefaultText = */ arg++;
+    /* bool argReference = */ arg++;
+    if (argDefault && minParam < 0) {
+      minParam = maxParam;
+    }
+    maxParam++;
+  }
+  if (minParam < 0) minParam = maxParam;
+
+  FunctionScopePtr f(new FunctionScope(method, name, reference));
+  f->setParamCounts(ar, minParam, maxParam);
+  if (retType) {
+    f->setReturnType(ar, retType);
+  }
+
+  int index = 0;
+  const char *paramName = nullptr;
+  while ((paramName = *p++ /* argName */)) {
+    TypePtr argType = ParseType(p);
+    const char *argDefault = *p++;
+    const char *argDefaultLen = *p++;
+    const char *argDefaultText = *p++;
+    bool argReference = *p++;
+
+    f->setParamName(index, paramName);
+    if (argReference) f->setRefParam(index);
+    f->setParamType(ar, index, argType);
+    if (argDefault) f->setParamDefault(index, argDefault,
+                                       (int64_t)argDefaultLen,
+                                       argDefaultText);
+
+    index++;
+  }
+
+  int flags = (int)(int64)(*p++);
+  f->setClassInfoAttribute(flags);
+  if (flags & ClassInfo::HasDocComment) {
+    f->setDocComment(*p++);
+  }
+  if (flags & ClassInfo::HasOptFunction) {
+    f->setOptFunction((FunctionOptPtr)(*p++));
+  }
+
+  // This block of code is not needed, if BlockScope directly takes flags.
+  if (flags & ClassInfo::MixedVariableArguments) {
+    f->setVariableArgument(-1);
+  } else if (flags & ClassInfo::RefVariableArguments) {
+    f->setVariableArgument(1);
+  } else if (flags & ClassInfo::VariableArguments) {
+    f->setVariableArgument(0);
+  }
+  if (flags & ClassInfo::NoEffect) {
+    f->setNoEffect();
+  }
+  if (flags & ClassInfo::FunctionIsFoldable) {
+    f->setIsFoldable();
+  }
+  if (flags & ClassInfo::ContextSensitive) {
+    f->setContextSensitive(true);
+  }
+  if (flags & ClassInfo::NeedsActRec) {
+    f->setNeedsActRec();
+  }
+  if ((flags & ClassInfo::IgnoreRedefinition) && !method) {
+    f->setIgnoreRedefinition();
+  }
+  return f;
+}
+
+FunctionScopePtr BuiltinSymbols::ParseHelperFunction(AnalysisResultPtr ar,
+                                                     const char** &p) {
+  FunctionScopePtr f = ParseExtFunction(ar, p);
+  f->setHelperFunction();
+  return f;
+}
+
+bool BuiltinSymbols::LoadSepExtensionSymbols(AnalysisResultPtr ar,
+                                             const std::string &name,
+                                             const std::string &soname) {
+  string mapname = name + "_map";
+
+  const char ***symbols = nullptr;
+
+  // If we linked with .a, the symbol is already in main program.
+  if (s_handle_main == nullptr) {
+    s_handle_main = dlopen(nullptr, RTLD_NOW | RTLD_GLOBAL);
+    if (!s_handle_main) {
+      const char *error = dlerror();
+      Logger::Error("Unable to load main program's symbols: %s",
+                    error ? error : "(unknown)");
+    }
+  }
+  if (s_handle_main) {
+    symbols = (const char ***)dlsym(s_handle_main, mapname.c_str());
+  }
+
+  // Otherwise, look for .so to load it.
+  void *handle = nullptr;
+  if (!symbols) {
+    handle = dlopen(soname.c_str(), RTLD_NOW | RTLD_GLOBAL);
+    if (!handle) {
+      const char *error = dlerror();
+      Logger::Error("Unable to load %s: %s", soname.c_str(),
+                    error ? error : "(unknown)");
+      return false;
+    }
+    symbols = (const char ***)dlsym(handle, mapname.c_str());
+    if (!symbols) {
+      Logger::Error("Unable to find %s in %s", mapname.c_str(),
+                    soname.c_str());
+      dlclose(handle);
+      return false;
+    }
+  }
+
+  ParseExtFunctions(ar, symbols[0], true);
+  ParseExtConsts   (ar, symbols[1], true);
+  ParseExtClasses  (ar, symbols[2], true);
+
+  if (handle) {
+    /*
+      Not closing for now, because it may have set an object allocator,
+      which would then fail next time its used.
+      I think the object allocators should be fixed instead - one per size,
+      rather than one per class, then this issue wouldnt occur
+    */
+    // dlclose(handle);
+  }
+  return true;
+}
+
+void BuiltinSymbols::Parse(AnalysisResultPtr ar,
+                           const std::string& phpBaseName,
+                           const std::string& phpFileName) {
+  const char *baseName = s_strings.add(phpBaseName.c_str());
+  const char *fileName = s_strings.add(phpFileName.c_str());
+  try {
+    Scanner scanner(fileName, Option::ScannerType);
+    Compiler::Parser parser(scanner, baseName, ar);
+    if (!parser.parse()) {
+      Logger::Error("Unable to parse file %s: %s", fileName,
+                    parser.getMessage().c_str());
+      assert(false);
+    }
+  } catch (FileOpenException &e) {
+    Logger::Error("%s", e.getMessage().c_str());
+  }
+}
+
+bool BuiltinSymbols::Load(AnalysisResultPtr ar, bool extOnly /* = false */) {
  if (Loaded) return true;
  Loaded = true;

-  if (g_context.isNull()) init_thread_locals();
-  ClassInfo::Load();
-
-  // load extension functions first, so system/php may call them
-  ImportExtFunctions(ar, s_functions, ClassInfo::GetSystem());
+  // load extension functions first, so system/classes may call them
+  ParseExtFunctions(ar, ExtensionFunctions, false);
  AnalysisResultPtr ar2 = AnalysisResultPtr(new AnalysisResult());
  s_variables = VariableTablePtr(new VariableTable(*ar2.get()));
  s_constants = ConstantTablePtr(new ConstantTable(*ar2.get()));

+  // parse all PHP files under system/classes
+  if (!extOnly) {
+    ar = AnalysisResultPtr(new AnalysisResult());
+    ar->loadBuiltinFunctions();
+    string slib = systemlib_path();
+    if (slib.empty()) {
+      for (const char **cls = SystemClasses; *cls; cls++) {
+        string phpBaseName = "/system/classes/";
+        phpBaseName += *cls;
+        phpBaseName += ".php";
+        Parse(ar, phpBaseName, Option::GetSystemRoot() + phpBaseName);
+      }
+    } else {
+      Parse(ar, slib, slib);
+    }
+    ar->analyzeProgram(true);
+    ar->inferTypes();
+    const StringToFileScopePtrMap &files = ar->getAllFiles();
+    for (StringToFileScopePtrMap::const_iterator iterFile = files.begin();
+         iterFile != files.end(); iterFile++) {
+      const StringToClassScopePtrVecMap &classes =
+        iterFile->second->getClasses();
+      for (StringToClassScopePtrVecMap::const_iterator iter = classes.begin();
+           iter != classes.end(); ++iter) {
+        assert(iter->second.size() == 1);
+        iter->second[0]->setSystem();
+        assert(!s_classes[iter->first]);
+        s_classes[iter->first] = iter->second[0];
+      }
+    }
+  } else {
+    NoSuperGlobals = true;
+  }
+
  // load extension constants, classes and dynamics
-  ImportExtConstants(ar, s_constants, ClassInfo::GetSystem());
-  ImportExtClasses(ar);
-
-  Array constants = ClassInfo::GetSystemConstants();
-  LocationPtr loc(new Location);
-  for (ArrayIter it = constants.begin(); it; ++it) {
-    CVarRef key = it.first();
-    if (!key.isString()) continue;
-    std::string name = key.toCStrRef().data();
-    if (s_constants->getSymbol(name)) continue;
-    if (name == "true" || name == "false" || name == "null") continue;
-    CVarRef value = it.secondRef();
-    if (!value.isInitialized() || value.isObject()) continue;
-    ExpressionPtr e = Expression::MakeScalarExpression(ar2, ar2, loc, value);
-    TypePtr t =
-      value.isNull()    ? Type::Null    :
-      value.isBoolean() ? Type::Boolean :
-      value.isInteger() ? Type::Int64   :
-      value.isDouble()  ? Type::Double  :
-      value.isArray()   ? Type::Array   : Type::Variant;
-
-    s_constants->add(key.toCStrRef().data(), t, e, ar2, e);
-  }
-  s_variables = ar2->getVariables();
-  for (int i = 0, n = NumGlobalNames(); i < n; ++i) {
-    s_variables->add(GlobalNames[i], Type::Variant, false, ar,
-                     ConstructPtr(), ModifierExpressionPtr());
+  ParseExtConsts(ar, ExtensionConsts, false);
+  ParseExtClasses(ar, ExtensionClasses, false);
+  for (unsigned int i = 0; i < Option::SepExtensions.size(); i++) {
+    Option::SepExtensionOptions &options = Option::SepExtensions[i];
+    string soname = options.soname;
+    if (soname.empty()) {
+      soname = string("lib") + options.name + ".so";
+    }
+    if (!options.lib_path.empty()) {
+      soname = options.lib_path + "/" + soname;
+    }
+    if (!LoadSepExtensionSymbols(ar, options.name, soname)) {
+      return false;
+    }
  }

+  if (!extOnly) {
+    Array constants = ClassInfo::GetSystemConstants();
+    LocationPtr loc(new Location);
+    for (ArrayIter it = constants.begin(); it; ++it) {
+      CVarRef key = it.first();
+      if (!key.isString()) continue;
+      std::string name = key.toCStrRef().data();
+      if (s_constants->getSymbol(name)) continue;
+      if (name == "true" || name == "false" || name == "null") continue;
+      CVarRef value = it.secondRef();
+      if (!value.isInitialized() || value.isObject()) continue;
+      ExpressionPtr e = Expression::MakeScalarExpression(ar2, ar2, loc, value);
+      TypePtr t =
+        value.isNull()    ? Type::Null    :
+        value.isBoolean() ? Type::Boolean :
+        value.isInteger() ? Type::Int64   :
+        value.isDouble()  ? Type::Double  :
+        value.isArray()   ? Type::Array   : Type::Variant;
+
+      s_constants->add(key.toCStrRef().data(), t, e, ar2, e);
+    }
+    s_variables = ar2->getVariables();
+    for (int i = 0, n = NumGlobalNames(); i < n; ++i) {
+      s_variables->add(GlobalNames[i], Type::Variant, false, ar,
+                       ConstructPtr(), ModifierExpressionPtr());
+    }
+  }
  s_constants->setDynamic(ar, "SID", true);
-  s_constants->setDynamic(ar, "PHP_SAPI", true);
-
-  // parse all PHP files under system/php
-  s_systemAr = ar = AnalysisResultPtr(new AnalysisResult());
-  ar->loadBuiltins();
-  string slib = get_systemlib();
-
-  Scanner scanner(slib.c_str(), slib.size(),
-                  Option::GetScannerType(), "systemlib.php");
-  Compiler::Parser parser(scanner, "systemlib.php", ar);
-  if (!parser.parse()) {
-    Logger::Error("Unable to parse systemlib.php: %s",
-                  parser.getMessage().c_str());
-    assert(false);
-  }
-
-  ar->analyzeProgram(true);
-  ar->inferTypes();
-  const StringToFileScopePtrMap &files = ar->getAllFiles();
-  for (StringToFileScopePtrMap::const_iterator iterFile = files.begin();
-       iterFile != files.end(); iterFile++) {
-    const StringToClassScopePtrVecMap &classes =
-      iterFile->second->getClasses();
-    for (StringToClassScopePtrVecMap::const_iterator iter = classes.begin();
-         iter != classes.end(); ++iter) {
-      assert(iter->second.size() == 1);
-      iter->second[0]->setSystem();
-      assert(!s_classes[iter->first]);
-      s_classes[iter->first] = iter->second[0];
-    }
-
-    const StringToFunctionScopePtrMap &functions =
-      iterFile->second->getFunctions();
-    for (StringToFunctionScopePtrMap::const_iterator iter = functions.begin();
-         iter != functions.end(); ++iter) {
-      iter->second->setSystem();
-      s_functions[iter->first] = iter->second;
-    }
-  }

  return true;
 }
@@ -410,7 +512,7 @@ AnalysisResultPtr BuiltinSymbols::LoadGlobalSymbols(const char *fileName) {
  fileName = s_strings.add(phpFileName.c_str());

  try {
-    Scanner scanner(fileName, Option::GetScannerType());
+    Scanner scanner(fileName, Option::ScannerType);
    Compiler::Parser parser(scanner, baseName, ar);
    if (!parser.parse()) {
      assert(false);
@@ -428,13 +530,30 @@ AnalysisResultPtr BuiltinSymbols::LoadGlobalSymbols(const char *fileName) {
 void BuiltinSymbols::LoadFunctions(AnalysisResultPtr ar,
                                   StringToFunctionScopePtrMap &functions) {
  assert(Loaded);
-  functions.insert(s_functions.begin(), s_functions.end());
+  for (StringToFunctionScopePtrMap::const_iterator it = s_functions.begin();
+       it != s_functions.end(); ++it) {
+    if (functions.find(it->first) == functions.end()) {
+      functions[it->first] = it->second;
+      FunctionScope::RecordFunctionInfo(it->first, it->second);
+    }
+  }
 }

 void BuiltinSymbols::LoadClasses(AnalysisResultPtr ar,
                                 StringToClassScopePtrMap &classes) {
  assert(Loaded);
  classes.insert(s_classes.begin(), s_classes.end());
+
+  // we are adding these builtin functions, so that user-defined functions
+  // will not overwrite them with their own file and line number information
+  for (StringToClassScopePtrMap::const_iterator iter =
+         s_classes.begin(); iter != s_classes.end(); ++iter) {
+    const StringToFunctionScopePtrMap &funcs = iter->second->getFunctions();
+    for (StringToFunctionScopePtrMap::const_iterator iter =
+           funcs.begin(); iter != funcs.end(); ++iter) {
+      FunctionScope::RecordFunctionInfo(iter->first, iter->second);
+    }
+  }
 }

 void BuiltinSymbols::LoadVariables(AnalysisResultPtr ar,
@@ -477,6 +596,7 @@ void BuiltinSymbols::LoadSuperGlobals() {
 }

 bool BuiltinSymbols::IsSuperGlobal(const std::string &name) {
+  if (NoSuperGlobals) return false;
  return s_superGlobals.find(name) != s_superGlobals.end();
 }

@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,12 +14,11 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_BUILTIN_SYMBOLS_H_
-#define incl_HPHP_BUILTIN_SYMBOLS_H_
+#ifndef __BUILTIN_SYMBOLS_H__
+#define __BUILTIN_SYMBOLS_H__

-#include "hphp/compiler/hphp.h"
-#include "hphp/util/string_bag.h"
-#include "hphp/runtime/base/class_info.h"
+#include <compiler/hphp.h>
+#include <util/string_bag.h>

 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////
@@ -34,8 +33,9 @@ DECLARE_BOOST_TYPES(ConstantTable);
 class BuiltinSymbols {
 public:
  static bool Loaded;
+  static bool NoSuperGlobals; // for SystemCPP bootstraping only

-  static bool Load(AnalysisResultPtr ar);
+  static bool Load(AnalysisResultPtr ar, bool extOnly = false);

  static void LoadFunctions(AnalysisResultPtr ar,
                            StringToFunctionScopePtrMap &functions);
@@ -64,42 +64,44 @@ public:
  static StringToClassScopePtrMap s_classes;
  static VariableTablePtr s_variables;
  static ConstantTablePtr s_constants;
-  static AnalysisResultPtr s_systemAr;

  static const char *const GlobalNames[];
  static int NumGlobalNames();
 private:
  static StringBag s_strings;
+  static const char *ExtensionFunctions[];
+  static const char *ExtensionClasses[];
+  static const char *ExtensionConsts[];
+  static const char *ExtensionDeclaredDynamic[];
  static const char *SystemClasses[];

  static AnalysisResultPtr LoadGlobalSymbols(const char *fileName);
+  static void Parse(AnalysisResultPtr ar,
+                    const std::string& phpBaseName,
+                    const std::string& phpFileName);

  static StringToTypePtrMap s_superGlobals;

  static std::set<std::string> s_declaredDynamic;

  static void *s_handle_main;
+  static bool LoadSepExtensionSymbols(AnalysisResultPtr ar,
+                                      const std::string &name,
+                                      const std::string &soname);

-  static FunctionScopePtr ImportFunctionScopePtr(AnalysisResultPtr ar,
-                                                 ClassInfo *cls,
-                                                 ClassInfo::MethodInfo *method);
-  static void ImportExtFunctions(AnalysisResultPtr ar,
-                                 StringToFunctionScopePtrMap &map,
-                                 ClassInfo *cls);
-  static void ImportExtFunctions(AnalysisResultPtr ar,
-                                 FunctionScopePtrVec &vec,
-                                 ClassInfo *cls);
-  static void ImportExtProperties(AnalysisResultPtr ar,
-                                  VariableTablePtr dest,
-                                  ClassInfo *cls);
-  static void ImportExtConstants(AnalysisResultPtr ar,
-                                 ConstantTablePtr dest,
-                                 ClassInfo *cls);
-  static ClassScopePtr ImportClassScopePtr(AnalysisResultPtr ar,
-                                           ClassInfo *cls);
-  static void ImportExtClasses(AnalysisResultPtr ar);
+  static TypePtr ParseType(const char **&p);
+  static void ParseExtFunctions(AnalysisResultPtr ar, const char **p,
+                                bool sep);
+  static void ParseExtConsts(AnalysisResultPtr ar, const char **p, bool sep);
+  static void ParseExtClasses(AnalysisResultPtr ar, const char **p, bool sep);
+  static void ParseExtDynamics(AnalysisResultPtr ar, const char **p, bool sep);
+
+  static FunctionScopePtr ParseExtFunction(AnalysisResultPtr ar,
+      const char** &p, bool method = false);
+  static FunctionScopePtr ParseHelperFunction(AnalysisResultPtr ar,
+                                              const char** &p);
 };

 ///////////////////////////////////////////////////////////////////////////////
 }
-#endif // incl_HPHP_BUILTIN_SYMBOLS_H_
+#endif // __BUILTIN_SYMBOLS_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -16,15 +16,15 @@

 #include <stdarg.h>

-#include "hphp/compiler/code_generator.h"
-#include "hphp/compiler/statement/statement_list.h"
-#include "hphp/compiler/option.h"
-#include "hphp/compiler/analysis/file_scope.h"
-#include "hphp/compiler/analysis/function_scope.h"
-#include "hphp/compiler/analysis/analysis_result.h"
-#include "hphp/compiler/analysis/variable_table.h"
-#include "hphp/util/util.h"
-#include "hphp/util/hash.h"
+#include <compiler/code_generator.h>
+#include <compiler/statement/statement_list.h>
+#include <compiler/option.h>
+#include <compiler/analysis/file_scope.h>
+#include <compiler/analysis/function_scope.h>
+#include <compiler/analysis/analysis_result.h>
+#include <compiler/analysis/variable_table.h>
+#include <util/util.h>
+#include <util/hash.h>
 #include <boost/format.hpp>
 #include <boost/scoped_array.hpp>

@@ -61,7 +61,8 @@ CodeGenerator::CodeGenerator(std::ostream *primary,
                             Output output /* = PickledPHP */,
                             const std::string *filename /* = NULL */)
    : m_out(nullptr), m_output(output),
-      m_context(NoContext), m_itemIndex(-1) {
+      m_hoistedClasses(0), m_collectHoistedClasses(false),
+      m_context(NoContext), m_insideScalarArray(false), m_itemIndex(-1) {
  for (int i = 0; i < StreamCount; i++) {
    m_streams[i] = nullptr;
    m_indentation[i] = 0;
@@ -139,6 +140,46 @@ void CodeGenerator::indentEnd() {
  m_indentation[m_curStream]--;
 }

+bool CodeGenerator::wrapExpressionBegin() {
+  if (!m_wrappedExpression[m_curStream]) {
+    m_wrappedExpression[m_curStream] = true;
+    m_referenceTempsUsed[m_curStream] = false;
+    m_localId[m_curStream] = 0;
+    setInExpression(true);
+    indentBegin("{\n");
+    return true;
+  }
+  return false;
+}
+
+bool CodeGenerator::wrapExpressionEnd() {
+  if (m_wrappedExpression[m_curStream]) {
+    if (m_referenceTempsUsed[m_curStream]) {
+      printf("%s.unset();\n", m_referenceTemps[m_curStream].c_str());
+    }
+    m_wrappedExpression[m_curStream] = false;
+    indentEnd("}\n");
+    return true;
+  }
+  return false;
+}
+
+void CodeGenerator::genReferenceTemp(ConstructPtr cp) {
+  string &rt = m_referenceTemps[m_curStream];
+  rt = (string)Option::TempPrefix + "_ref";
+  printf("Variant %s;\n", rt.c_str());
+}
+
+const string &CodeGenerator::getReferenceTemp() {
+  static string empty = "";
+  if (m_wrappedExpression[m_curStream] &&
+      !m_referenceTemps[m_curStream].empty()) {
+    m_referenceTempsUsed[m_curStream] = true;
+    return m_referenceTemps[m_curStream];
+  }
+  return empty;
+}
+
 bool CodeGenerator::inComments() const {
  return m_inComments[m_curStream] > 0;
 }
@@ -207,6 +248,20 @@ bool CodeGenerator::ensureOutOfNamespace() {
  return true;
 }

+void CodeGenerator::headerBegin(const std::string &file) {
+  string formatted = getFormattedName(file);
+  printf("\n");
+  printf("#ifndef __GENERATED_%s__\n", formatted.c_str());
+  printf("#define __GENERATED_%s__\n", formatted.c_str());
+  printf("\n");
+}
+
+void CodeGenerator::headerEnd(const std::string &file) {
+  string formatted = getFormattedName(file);
+  printf("\n");
+  printf("#endif // __GENERATED_%s__\n", formatted.c_str());
+}
+
 void CodeGenerator::ifdefBegin(bool ifdef, const char *fmt, ...) {
  printf(ifdef ? "#ifdef " : "#ifndef ");
  va_list ap; va_start(ap, fmt); print(fmt, ap); va_end(ap);
@@ -219,6 +274,59 @@ void CodeGenerator::ifdefEnd(const char *fmt, ...) {
  printf("\n");
 }

+void CodeGenerator::printInclude(const std::string &file) {
+  assert(!file.empty());
+
+  string formatted = file;
+  if (file[0] != '"' && file[0] != '<') {
+    if (file.substr(file.length() - 2) != ".h") {
+      formatted += ".h";
+    }
+    formatted = string("<") + formatted + '>';
+  }
+  printf("%s %s\n", HASH_INCLUDE, formatted.c_str());
+}
+
+void CodeGenerator::printBasicIncludes() {
+  if (Option::GenerateCPPMain) {
+    printInclude("<runtime/base/hphp.h>");
+    printInclude(string(Option::SystemFilePrefix) +
+                 "literal_strings_remap.h");
+    printInclude(string(Option::SystemFilePrefix) +
+                 "scalar_arrays_remap.h");
+    if (Option::UseScalarVariant) {
+      printInclude(string(Option::SystemFilePrefix) +
+                   "scalar_integers_remap.h");
+    }
+    printInclude(string(Option::SystemFilePrefix) + "global_variables.h");
+    if (Option::GenArrayCreate) {
+      printInclude(string(Option::SystemFilePrefix) + "cpputil.h");
+    }
+  } else if (getOutput() == CodeGenerator::SystemCPP) {
+    printInclude("<runtime/base/hphp_system.h>");
+    printInclude(string("system/gen/") + Option::SystemFilePrefix +
+                 "literal_strings_remap.h");
+    printInclude(string("system/gen/") + Option::SystemFilePrefix +
+                 "scalar_arrays_remap.h");
+  }
+}
+
+void CodeGenerator::printDeclareGlobals() {
+  if (getOutput() == SystemCPP) {
+    printf("DECLARE_SYSTEM_GLOBALS(g);\n");
+  } else {
+    printf("DECLARE_GLOBAL_VARIABLES(g);\n");
+  }
+}
+
+void CodeGenerator::printStartOfJumpTable(int tableSize) {
+  if (Util::isPowerOfTwo(tableSize)) {
+    indentBegin("switch (hash & %d) {\n", tableSize-1);
+  } else {
+    indentBegin("switch (hash %% %d) {\n", tableSize);
+  }
+}
+
 void CodeGenerator::printDocComment(const std::string comment) {
  if (comment.empty()) return;
  string escaped;
@@ -234,6 +342,24 @@ void CodeGenerator::printDocComment(const std::string comment) {
  printf("\n");
 }

+void CodeGenerator::printImplStarter() {
+  printf("%s\n", STARTER_MARKER);
+}
+
+void CodeGenerator::printImplSplitter() {
+  printf("%s\n", SPLITTER_MARKER);
+}
+
+const char *CodeGenerator::getGlobals(AnalysisResultPtr ar) {
+  if (m_context == CppParameterDefaultValueDecl ||
+      m_context == CppParameterDefaultValueImpl) {
+    return (m_output == CodeGenerator::SystemCPP) ?
+           "get_system_globals()" : "get_global_variables()";
+  }
+  if (m_output == CodeGenerator::SystemCPP) return "get_system_globals()";
+  return "g";
+}
+
 std::string CodeGenerator::FormatLabel(const std::string &name) {
  string ret;
  ret.reserve(name.size());
@@ -397,6 +523,14 @@ int CodeGenerator::callInfoTop() {
  return m_callInfos.back();
 }

+bool CodeGenerator::getInsideScalarArray() {
+  return m_insideScalarArray;
+}
+
+void CodeGenerator::setInsideScalarArray(bool flag) {
+  m_insideScalarArray = flag;
+}
+
 void CodeGenerator::addLabelId(const char *name, int labelId) {
  if (!strcmp(name, "break")) {
    m_breakLabelIds.insert(labelId);
@@ -418,6 +552,107 @@ bool CodeGenerator::findLabelId(const char *name, int labelId) {
  return false;
 }

+int CodeGenerator::checkLiteralString(const std::string &str, int &index,
+                                      AnalysisResultPtr ar, BlockScopePtr bs,
+                                      bool scalarVariant /* = false */) {
+  always_assert(getContext() != CodeGenerator::CppConstantsDecl &&
+         getContext() != CodeGenerator::CppClassConstantsImpl);
+  int stringId = ar->getLiteralStringId(str, index);
+  if (m_literalScope) {
+    bs = m_literalScope;
+  }
+  if (bs && bs != ar) {
+    FileScopePtr fs = bs->getContainingFile();
+    if (fs) {
+      fs->addUsedLiteralString(str);
+      if (scalarVariant) fs->addUsedLitVarString(str);
+      if (isFileOrClassHeader()) {
+        ClassScopePtr cs = bs->getContainingClass();
+        if (cs) {
+          cs->addUsedLiteralStringHeader(str);
+          if (scalarVariant) cs->addUsedLitVarStringHeader(str);
+        } else {
+          fs->addUsedLiteralStringHeader(str);
+          if (scalarVariant) fs->addUsedLitVarStringHeader(str);
+        }
+      }
+    }
+  }
+
+  return stringId;
+}
+
+string CodeGenerator::printNamedString(const string &str,
+  const string &escaped, AnalysisResultPtr ar, BlockScopeRawPtr bs,
+  bool print) {
+  int index = -1;
+  bool scalarVariant = !print;
+  int stringId = checkLiteralString(str, index, ar, bs, scalarVariant);
+  always_assert(index >= 0);
+  string lisnam = ar->getLiteralStringName(stringId, index);
+  if (print) {
+    printf("NAMSTR(%s, \"%s\")", lisnam.c_str(), escaped.c_str());
+  }
+  return lisnam;
+}
+
+string CodeGenerator::printString(const string &str, AnalysisResultPtr ar,
+                                  BlockScopeRawPtr bs,
+                                  bool stringWrapper /* = true */) {
+  bool isBinary = false;
+  string escaped = EscapeLabel(str, &isBinary);
+  if (bs) {
+    return printNamedString(str, escaped, ar, bs, true);
+  }
+  if (isBinary) {
+    if (stringWrapper) {
+      printf("String(\"%s\", %d, AttachLiteral)",
+             escaped.c_str(), (int)str.length());
+    } else {
+      printf("\"%s\", %d", escaped.c_str(), (int)str.length());
+    }
+  } else {
+    printf("\"%s\"", escaped.c_str());
+  }
+  return "";
+}
+
+string CodeGenerator::printString(const std::string &str, AnalysisResultPtr ar,
+                                  ConstructPtr cs,
+                                  bool stringWrapper /* = true */) {
+  return printString(str, ar, (BlockScopePtr)cs->getScope(), stringWrapper);
+}
+
+void CodeGenerator::beginHoistedClasses() {
+  m_hoistedClasses = new std::set<string,stdltistr>();
+  m_collectHoistedClasses = true;
+}
+
+void CodeGenerator::endHoistedClasses() {
+  delete m_hoistedClasses;
+  m_hoistedClasses = 0;
+}
+
+void CodeGenerator::collectHoistedClasses(bool flag) {
+  m_collectHoistedClasses = flag;
+}
+
+void CodeGenerator::addHoistedClass(const string &cls) {
+  if (m_hoistedClasses && m_collectHoistedClasses) {
+    m_hoistedClasses->insert(cls);
+  }
+}
+
+bool CodeGenerator::checkHoistedClass(const string &cls) {
+  if (m_hoistedClasses) {
+    if (m_hoistedClasses->find(cls) != m_hoistedClasses->end()) {
+      return true;
+    }
+    addHoistedClass(cls);
+  }
+  return false;
+}
+
 int CodeGenerator::ClassScopeCompare::cmp(const ClassScopeRawPtr &p1,
                                          const ClassScopeRawPtr &p2) const {
  int d = p1->getRedeclaringId() - p2->getRedeclaringId();
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,10 +14,10 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_CODE_GENERATOR_H_
-#define incl_HPHP_CODE_GENERATOR_H_
+#ifndef __CODE_GENERATOR_H__
+#define __CODE_GENERATOR_H__

-#include "hphp/compiler/hphp.h"
+#include <compiler/hphp.h>

 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////
@@ -131,8 +131,8 @@ public:

 public:
  CodeGenerator() {} // only for creating a dummy code generator
-  explicit CodeGenerator(std::ostream *primary, Output output = PickledPHP,
-                         const std::string *filename = nullptr);
+  CodeGenerator(std::ostream *primary, Output output = PickledPHP,
+                const std::string *filename = nullptr);

  /**
   * ...if it was passed in from constructor.
@@ -163,6 +163,17 @@ public:
  void indentEnd(const char *fmt, ...) ATTRIBUTE_PRINTF(2,3);
  void indentEnd();
  void printRaw(const char *msg) { print(msg, false);}
+  bool wrapExpressionBegin();
+  bool wrapExpressionEnd();
+  void genReferenceTemp(ConstructPtr scope);
+  void clearRefereceTemp() { m_referenceTemps[m_curStream].clear(); }
+  const std::string &getReferenceTemp();
+  bool hasReferenceTemp() const {
+    return !m_referenceTemps[m_curStream].empty();
+  }
+  void setReferenceTempUsed(bool flag) {
+    m_referenceTempsUsed[m_curStream] = flag;
+  }
  /**
   * Pre-formatted outputs.
   */
@@ -172,9 +183,17 @@ public:
  void namespaceEnd();
  bool ensureInNamespace();
  bool ensureOutOfNamespace();
+  void headerBegin(const std::string &file);
+  void headerEnd(const std::string &file);
  void ifdefBegin(bool ifdef, const char *fmt, ...) ATTRIBUTE_PRINTF(3,4);
  void ifdefEnd(const char *fmt, ...) ATTRIBUTE_PRINTF(2,3);
+  void printInclude(const std::string &file);
+  void printBasicIncludes();
+  void printDeclareGlobals();
+  void printStartOfJumpTable(int tableSize);
  void printDocComment(const std::string comment);
+  void printImplStarter(); // end of includes
+  void printImplSplitter(); // marker to split .cpp into smaller files
  const char *getGlobals(AnalysisResultPtr ar);
  static std::string FormatLabel(const std::string &name);
  static std::string EscapeLabel(const std::string &name, bool *binary = nullptr);
@@ -249,13 +268,31 @@ public:
    m_loopStatement = loop;
  }

+  void setInsideScalarArray(bool flag);
+  bool getInsideScalarArray();
+
  void setFileOrClassHeader(bool value) { m_inFileOrClassHeader = value; }
  bool isFileOrClassHeader() { return m_inFileOrClassHeader; }

+  void beginHoistedClasses();
+  void endHoistedClasses();
+  void collectHoistedClasses(bool flag);
+  void addHoistedClass(const std::string &cls);
+  bool checkHoistedClass(const std::string &cls);
+
+  void setScalarVariant() { m_scalarVariant = true; }
+  bool hasScalarVariant() { return m_scalarVariant; }
+  void clearScalarVariant() { m_scalarVariant = false; }
+
  void setInitListFirstElem() { m_initListFirstElem = true; }
  bool hasInitListFirstElem() { return m_initListFirstElem; }
  void clearInitListFirstElem() { m_initListFirstElem = false; }

+  const StringToClassScopePtrVecMap &getClasses() const { return m_classes; }
+  void addClass(const std::string &name, ClassScopePtr cls) {
+    m_classes[name].push_back(cls);
+  }
+  void clearClasses() { m_classes.clear(); }
  bool insertDeclaredClosure(const FunctionScope *f) {
    return m_declaredClosures.insert(f).second;
  }
@@ -284,6 +321,8 @@ private:
  bool m_inFileOrClassHeader;
  bool m_inNamespace;
  int m_localId[StreamCount];
+  std::set<std::string, stdltistr> *m_hoistedClasses;
+  bool m_collectHoistedClasses;

  static int s_idLambda;
  std::map<std::string, int> m_idCounters;
@@ -293,6 +332,7 @@ private:
  std::set<int> m_contLabelIds;  // continue labels referenced
  std::deque<int> m_callInfos;
  LoopStatementPtr m_loopStatement;
+  bool m_insideScalarArray;
  StringToClassScopePtrVecMap m_classes;
  std::set<const FunctionScope*> m_declaredClosures;
  FileScopeRawPtr m_literalScope;
@@ -308,23 +348,28 @@ private:
  public: void print(const char *msg, bool indent = true);

 private:
-  void print(const char *fmt, va_list ap) ATTRIBUTE_PRINTF(2,0);
+  void print(const char *fmt, va_list ap);
  void printSubstring(const char *start, int length);
  void printIndent();
  std::string getFormattedName(const std::string &file);
 };

-#define cg_printf cg.printf
-#define m_cg_printf m_cg.printf
-#define cg_print cg.print
-#define m_cg_print m_cg.print
-#define cg_indentBegin cg.indentBegin
-#define m_cg_indentBegin m_cg.indentBegin
-#define cg_indentEnd cg.indentEnd
-#define m_cg_indentEnd cg.indentEnd
-#define cg_printInclude cg.printInclude
-#define cg_printString cg.printString
+#define STR(x) #x
+#define XSTR(x) STR(x)
+#define FLANN(stream,func,nl) (Option::FlAnnotate ?                           \
+               stream.printf("/* %s:" XSTR(__LINE__) "*/" nl, __func__):       \
+               void()), stream.func
+#define cg_printf FLANN(cg,printf,"")
+#define m_cg_printf FLANN(m_cg,printf,"")
+#define cg_print FLANN(cg,print,"")
+#define m_cg_print FLANN(m_cg,print,"")
+#define cg_indentBegin FLANN(cg,indentBegin,"")
+#define m_cg_indentBegin FLANN(m_cg,indentBegin,"")
+#define cg_indentEnd FLANN(cg,indentEnd,"")
+#define m_cg_indentEnd FLANN(m_cg,indentEnd,"")
+#define cg_printInclude FLANN(cg,printInclude,"\n")
+#define cg_printString FLANN(cg,printString,"")

 ///////////////////////////////////////////////////////////////////////////////
 }
-#endif // incl_HPHP_CODE_GENERATOR_H_
+#endif // __CODE_GENERATOR_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,45 +14,41 @@
   +----------------------------------------------------------------------+
 */

-#include "hphp/compiler/compiler.h"
-#include "hphp/compiler/package.h"
-#include "hphp/compiler/analysis/analysis_result.h"
-#include "hphp/compiler/analysis/alias_manager.h"
-#include "hphp/compiler/analysis/code_error.h"
-#include "hphp/compiler/analysis/emitter.h"
-#include "hphp/compiler/analysis/type.h"
-#include "hphp/compiler/analysis/symbol_table.h"
-#include "hphp/compiler/option.h"
-#include "hphp/compiler/parser/parser.h"
-#include "hphp/compiler/builtin_symbols.h"
-#include "hphp/util/json.h"
-#include "hphp/util/logger.h"
-#include "hphp/util/db_conn.h"
-#include "hphp/util/exception.h"
-#include "hphp/util/process.h"
-#include "hphp/util/util.h"
-#include "hphp/util/timer.h"
-#include "hphp/util/hdf.h"
-#include "hphp/util/async_func.h"
-#include "hphp/runtime/base/program_functions.h"
-#include "hphp/runtime/base/memory/smart_allocator.h"
-#include "hphp/runtime/base/externals.h"
-#include "hphp/runtime/base/thread_init_fini.h"
-#include "hphp/runtime/vm/repo.h"
-#include "hphp/system/systemlib.h"
-#include "hphp/util/repo_schema.h"
-
-#include "hphp/hhvm/process_init.h"
-
-#include <sys/types.h>
-#include <sys/wait.h>
-#include <dlfcn.h>
-
 #include <boost/program_options/options_description.hpp>
 #include <boost/program_options/positional_options.hpp>
 #include <boost/program_options/variables_map.hpp>
 #include <boost/program_options/parsers.hpp>

+#include <compiler/package.h>
+#include <compiler/analysis/analysis_result.h>
+#include <compiler/analysis/alias_manager.h>
+#include <compiler/analysis/code_error.h>
+#include <compiler/analysis/emitter.h>
+#include <compiler/analysis/type.h>
+#include <util/json.h>
+#include <util/logger.h>
+#include <compiler/analysis/symbol_table.h>
+#include <compiler/option.h>
+#include <compiler/parser/parser.h>
+#include <compiler/builtin_symbols.h>
+#include <util/db_conn.h>
+#include <util/exception.h>
+#include <util/process.h>
+#include <util/util.h>
+#include <util/timer.h>
+#include <util/hdf.h>
+#include <util/async_func.h>
+#include <runtime/base/memory/smart_allocator.h>
+#include <runtime/base/externals.h>
+#include <runtime/base/thread_init_fini.h>
+#include <runtime/base/compiler_id.h>
+#include <runtime/vm/repo.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <dlfcn.h>
+#include <system/lib/systemlib.h>
+#include <compiler/compiler.h>
+
 using namespace boost::program_options;
 using std::cout;

@@ -63,6 +59,7 @@ struct CompilerOptions {
  string target;
  string format;
  string outputDir;
+  string outputFile;
  string syncDir;
  vector<string> config;
  string configDir;
@@ -83,6 +80,8 @@ struct CompilerOptions {
  vector<string> cfiles;
  vector<string> cmodules;
  bool parseOnDemand;
+  vector<string> parseOnDemandDirs; // parse these directories on-demand
+                                    // when parseOnDemand=false
  string program;
  string programArgs;
  string branch;
@@ -91,15 +90,23 @@ struct CompilerOptions {
  bool keepTempDir;
  string dbStats;
  bool noTypeInference;
+  bool noMinInclude;
+  bool noMetaInfo;
  int logLevel;
  bool force;
+  int clusterCount;
  int optimizeLevel;
  string filecache;
+  string rttiDirectory;
+  string javaRoot;
+  bool generateFFI;
  bool dump;
  string docjson;
  bool coredump;
  bool nofork;
+  bool fl_annotate;
  string optimizations;
+  string ppp;
 };

 ///////////////////////////////////////////////////////////////////////////////
@@ -117,8 +124,7 @@ public:

    struct stat sb;
    stat(m_name, &sb);
-    Logger::Info("%" PRId64" MB %s saved",
-                 (int64_t)sb.st_size/(1024*1024), m_name);
+    Logger::Info("%dMB %s saved", (int64)sb.st_size/(1024*1024), m_name);
  }

 private:
@@ -138,9 +144,13 @@ int phpTarget(const CompilerOptions &po, AnalysisResultPtr ar);
 void hhbcTargetInit(const CompilerOptions &po, AnalysisResultPtr ar);
 int hhbcTarget(const CompilerOptions &po, AnalysisResultPtr ar,
               AsyncFileCacheSaver &fcThread);
+int cppTarget(const CompilerOptions &po, AnalysisResultPtr ar,
+              AsyncFileCacheSaver &fcThread, bool allowSys = true);
 int runTargetCheck(const CompilerOptions &po, AnalysisResultPtr ar,
                   AsyncFileCacheSaver &fcThread);
+int buildTarget(const CompilerOptions &po);
 int runTarget(const CompilerOptions &po);
+int generateSepExtCpp(const CompilerOptions &po, AnalysisResultPtr ar);

 ///////////////////////////////////////////////////////////////////////////////

@@ -150,10 +160,6 @@ int compiler_main(int argc, char **argv) {
  try {
    Hdf empty;
    RuntimeOption::Load(empty);
-    initialize_repo();
-
-    // we need to initialize pcre cache table very early
-    pcre_init();

    CompilerOptions po;
 #ifdef FACEBOOK
@@ -180,7 +186,11 @@ int compiler_main(int argc, char **argv) {
      }
    }
    if (ret == 0) {
-      if (po.target == "run") {
+      if (po.target == "cpp") {
+        if (po.format == "exe" || po.format == "lib") {
+          ret = buildTarget(po);
+        }
+      } else if (po.target == "run") {
        ret = runTarget(po);
      }
    }
@@ -192,10 +202,6 @@ int compiler_main(int argc, char **argv) {
    return ret;
  } catch (Exception &e) {
    Logger::Error("Exception: %s\n", e.getMessage().c_str());
-  } catch (const FailedAssertion& fa) {
-    fa.print();
-    StackTraceNoHeap::AddExtraLogging("Assertion failure", fa.summary);
-    abort();
  } catch (std::exception &e) {
    Logger::Error("std::exception: %s\n", e.what());
  } catch (...) {
@@ -218,6 +224,8 @@ int prepareOptions(CompilerOptions &po, int argc, char **argv) {
     "analyze | "
     "php | "
     "hhbc | "
+     "cpp | "
+     "sep-ext-cpp | "
     "filecache | "
     "run (default)")
    ("format,f", value<string>(&po.format),
@@ -226,7 +234,11 @@ int prepareOptions(CompilerOptions &po, int argc, char **argv) {
     "php: trimmed (default) | inlined | pickled | typeinfo |"
     " <any combination of them by any separator>; \n"
     "hhbc: binary (default) | text; \n"
+     "cpp: cluster (default) | file | sys | exe | lib; \n"
     "run: cluster (default) | file")
+    ("cluster-count", value<int>(&po.clusterCount)->default_value(0),
+     "Cluster by file sizes and output roughly these many number of files. "
+     "Use 0 for no clustering.")
    ("input-dir", value<string>(&po.inputDir), "input directory")
    ("program", value<string>(&po.program)->default_value("program"),
     "final program name to use")
@@ -273,6 +285,7 @@ int prepareOptions(CompilerOptions &po, int argc, char **argv) {
    ("branch", value<string>(&po.branch), "SVN branch")
    ("revision", value<int>(&po.revision), "SVN revision")
    ("output-dir,o", value<string>(&po.outputDir), "output directory")
+    ("output-file", value<string>(&po.outputFile), "output file")
    ("sync-dir", value<string>(&po.syncDir),
     "Files will be created in this directory first, then sync with output "
     "directory without overwriting identical files. Great for incremental "
@@ -289,6 +302,13 @@ int prepareOptions(CompilerOptions &po, int argc, char **argv) {
    ("no-type-inference",
     value<bool>(&po.noTypeInference)->default_value(false),
     "turn off type inference for C++ code generation")
+    ("no-min-include",
+     value<bool>(&po.noMinInclude)->default_value(false),
+     "turn off minimium include analysis when target is \"analyze\"")
+    ("no-meta-info",
+     value<bool>(&po.noMetaInfo)->default_value(false),
+     "do not generate class map, function jump table and macros "
+     "when generating code; good for demo purposes")
    ("config,c", value<vector<string> >(&po.config)->composing(),
     "config file name")
    ("config-dir", value<string>(&po.configDir),
@@ -307,6 +327,14 @@ int prepareOptions(CompilerOptions &po, int argc, char **argv) {
    ("file-cache",
     value<string>(&po.filecache),
     "if specified, generate a static file cache with this file name")
+    ("rtti-directory", value<string>(&po.rttiDirectory)->default_value(""),
+     "the directory of rtti profiling data")
+    ("java-root",
+     value<string>(&po.javaRoot)->default_value("php"),
+     "the root package of generated Java FFI classes")
+    ("generate-ffi",
+     value<bool>(&po.generateFFI)->default_value(false),
+     "generate ffi stubs")
    ("dump",
     value<bool>(&po.dump)->default_value(false),
     "dump the program graph")
@@ -320,11 +348,24 @@ int prepareOptions(CompilerOptions &po, int argc, char **argv) {
     value<bool>(&po.nofork)->default_value(false),
     "forking is needed for large compilation to release memory before g++"
     "compilation. turning off forking can help gdb debugging.")
+    ("fl-annotate",
+     value<bool>(&po.fl_annotate)->default_value(false),
+     "Annotate emitted source with compiler file-line info")
    ("opts",
     value<string>(&po.optimizations)->default_value(""),
     "Set optimizations to enable/disable")
+    ("ppp",
+     value<string>(&po.ppp)->default_value(""),
+     "Preprocessed partition configuration. To speed up distcc compilation, "
+     "bin/ppp.php can pre-compute better partition between different .cpp "
+     "files according to preprocessed file sizes, instead of original file "
+     "sizes (default). Run bin/ppp.php to generate an HDF configuration file "
+     "to specify here.")
+#ifdef COMPILER_ID
    ("compiler-id", "display the git hash for the compiler id")
+#endif
    ("repo-schema", "display the repo schema id used by this app")
+    ("taint-status", "check if the compiler was built with taint enabled")
    ;

  positional_options_description p;
@@ -334,7 +375,7 @@ int prepareOptions(CompilerOptions &po, int argc, char **argv) {
    store(command_line_parser(argc, argv).options(desc).positional(p).run(),
          vm);
    notify(vm);
-  } catch (const unknown_option& e) {
+  } catch (unknown_option e) {
    Logger::Error("Error in command line: %s\n\n", e.what());
    cout << desc << "\n";
    return -1;
@@ -361,22 +402,34 @@ int prepareOptions(CompilerOptions &po, int argc, char **argv) {
 #define HPHP_VERSION(v) cout << HPHP_COMPILER_STR #v << "\n";
 #include "../version"

-    cout << "Compiler: " << kCompilerId << "\n";
-    cout << "Repo schema: " << kRepoSchemaId << "\n";
+#ifdef COMPILER_ID
+cout << "Compiler: " << COMPILER_ID << "\n";
+#endif
+    cout << "Repo schema: " << VM::Repo::kSchemaId << "\n";
    return 1;
  }

+#ifdef COMPILER_ID
  if (vm.count("compiler-id")) {
-    cout << kCompilerId << "\n";
+    cout << COMPILER_ID << "\n";
    return 1;
  }
+#endif

  if (vm.count("repo-schema")) {
-    cout << kRepoSchemaId << "\n";
+    cout << VM::Repo::kSchemaId << "\n";
    return 1;
  }

-  if ((po.target == "hhbc" || po.target == "run") &&
+  if (vm.count("taint-status")) {
+#ifdef TAINTED
+    cout << TAINTED << "\n";
+#endif
+    return 1;
+  }
+
+  if (hhvm &&
+      (po.target == "hhbc" || po.target == "run") &&
      po.format.find("exe") == string::npos) {
    if (po.program == "program") {
      po.program = "hhvm.hhbc";
@@ -392,6 +445,14 @@ int prepareOptions(CompilerOptions &po, int argc, char **argv) {
    Logger::LogLevel = Logger::LogInfo;
  }

+  // config and system
+  Option::GenerateCPPMain = true;
+  if (po.noMetaInfo) {
+    Option::GenerateCPPMetaInfo = false;
+    Option::GenerateCPPMacros = false;
+  }
+  Option::FlAnnotate = po.fl_annotate;
+
  Hdf config;
  for (vector<string>::const_iterator it = po.config.begin();
       it != po.config.end(); ++it) {
@@ -443,36 +504,50 @@ int prepareOptions(CompilerOptions &po, int argc, char **argv) {
      (Util::format_pattern(po.excludeStaticPatterns[i], true));
  }

-  if (po.target == "hhbc" || po.target == "run") {
+  if (po.target == "cpp" && po.format == "sys") {
+    BuiltinSymbols::NoSuperGlobals = true; // so to generate super globals
+    Option::AnalyzePerfectVirtuals = false;
+  }
+  Option::SystemGen = (po.target == "cpp" && po.format == "sys") ;
+
+  if (hhvm && (po.target == "hhbc" || po.target == "run")) {
+    Option::OutputHHBC = true;
    Option::AnalyzePerfectVirtuals = false;
  }

  Option::ProgramName = po.program;
+  Option::PreprocessedPartitionConfig = po.ppp;

  if (po.format.empty()) {
-    if (po.target == "php") {
+    if (po.target == "cpp") {
+      po.format = "cluster";
+    } else if (po.target == "php") {
      po.format = "trimmed";
    } else if (po.target == "run") {
-      po.format = "binary";
-    } else if (po.target == "hhbc") {
+      po.format = hhvm ? "binary" : "cluster";
+    } else if (hhvm && po.target == "hhbc") {
      po.format = "binary";
    }
  }

  if (!po.docjson.empty()) {
-    if (po.target != "run" &&
-        po.target != "hhbc" &&
+    if (po.target != "cpp" &&
+        po.target != "run" &&
        po.target != "analyze") {
      Logger::Error(
        "Cannot generate doc JSON file unless target is "
-        "'hhbc', 'run', or 'analyze'");
+        "'cpp', 'run', or 'analyze'");
    } else {
      Option::DocJson = po.docjson;
    }
  }

  if (po.optimizeLevel == -1) {
-    po.optimizeLevel = 1;
+    if (Option::OutputHHBC) {
+      po.optimizeLevel = 1;
+    } else {
+      po.optimizeLevel = 1;
+    }
  }

  // we always do pre/post opt no matter the opt level
@@ -481,7 +556,14 @@ int prepareOptions(CompilerOptions &po, int argc, char **argv) {
  if (po.optimizeLevel == 0) {
    // --optimize-level=0 is equivalent to --opts=none
    po.optimizations = "none";
-    Option::ParseTimeOpts = false;
+    if (Option::OutputHHBC) {
+      Option::ParseTimeOpts = false;
+    }
+  }
+
+  if (po.generateFFI) {
+    Option::GenerateFFI = true;
+    Option::JavaFFIRootPackage = po.javaRoot;
  }

  return 0;
@@ -515,7 +597,6 @@ int process(const CompilerOptions &po) {
    return lintTarget(po);
  }

-  register_process_init();
  init_thread_locals();

  Timer timer(Timer::WallTime);
@@ -525,7 +606,9 @@ int process(const CompilerOptions &po) {
  Package package(po.inputDir.c_str());
  ar = package.getAnalysisResult();

-  hhbcTargetInit(po, ar);
+  if (hhvm && (po.target == "hhbc" || po.target == "run")) {
+    hhbcTargetInit(po, ar);
+  }

  std::string errs;
  if (!AliasManager::parseOptimizations(po.optimizations, errs)) {
@@ -538,18 +621,21 @@ int process(const CompilerOptions &po) {
  BuiltinSymbols::LoadSuperGlobals();
  ClassInfo::Load();

+  if (po.format == "sys") ar->setSystem();
+
  bool isPickledPHP = (po.target == "php" && po.format == "pickled");
  if (!isPickledPHP) {
+    if (!BuiltinSymbols::Load(ar,
+                              (po.target == "cpp" && po.format == "sys")
+                              || (po.target == "hhbc" && !Option::WholeProgram)
+                              )) {
+      return false;
+    }
    if (po.target == "hhbc" && !Option::WholeProgram) {
-      // We're trying to produce the same bytecode as runtime parsing.
-      // There's nothing to do.
+      BuiltinSymbols::NoSuperGlobals = false;
    } else {
-      if (!BuiltinSymbols::Load(ar)) {
-        return false;
-      }
      ar->loadBuiltins();
    }
-    hphp_process_init();
  }

  {
@@ -616,12 +702,17 @@ int process(const CompilerOptions &po) {
    ret = analyzeTarget(po, ar);
  } else if (po.target == "php") {
    ret = phpTarget(po, ar);
-  } else if (po.target == "hhbc") {
+  } else if (hhvm && po.target == "hhbc") {
    ret = hhbcTarget(po, ar, fileCacheThread);
+  } else if (po.target == "cpp") {
+    ret = cppTarget(po, ar, fileCacheThread);
  } else if (po.target == "run") {
    ret = runTargetCheck(po, ar, fileCacheThread);
  } else if (po.target == "filecache") {
    // do nothing
+  } else if (po.target == "sep-ext-cpp") {
+    ar->setSepExtension();
+    ret = generateSepExtCpp(po, ar);
  } else {
    Logger::Error("Unknown target: %s", po.target.c_str());
    return 1;
@@ -649,7 +740,7 @@ int process(const CompilerOptions &po) {
        int runId = package.saveStatsToDB(server, seconds, po.branch,
                                          po.revision);
        package.commitStats(server, runId);
-      } catch (const DatabaseException& e) {
+      } catch (DatabaseException e) {
        Logger::Error("%s", e.what());
      }
    } else {
@@ -674,7 +765,7 @@ int lintTarget(const CompilerOptions &po) {
  for (unsigned int i = 0; i < po.inputs.size(); i++) {
    string filename = po.inputDir + "/" + po.inputs[i];
    try {
-      Scanner scanner(filename.c_str(), Option::GetScannerType());
+      Scanner scanner(filename.c_str(), Option::ScannerType);
      Compiler::Parser parser(scanner, filename.c_str(),
                              AnalysisResultPtr(new AnalysisResult()));
      if (!parser.parse()) {
@@ -805,9 +896,6 @@ void hhbcTargetInit(const CompilerOptions &po, AnalysisResultPtr ar) {
  RuntimeOption::RepoJournal = "memory";
  RuntimeOption::EnableHipHopSyntax = Option::EnableHipHopSyntax;
  RuntimeOption::EvalJitEnableRenameFunction = Option::JitEnableRenameFunction;
-
-  // Turn off commits, because we don't want systemlib to get included
-  RuntimeOption::RepoCommit = false;
 }

 int hhbcTarget(const CompilerOptions &po, AnalysisResultPtr ar,
@@ -839,7 +927,7 @@ int hhbcTarget(const CompilerOptions &po, AnalysisResultPtr ar,
  /* without this, emitClass allows classes with interfaces to be
     hoistable */
  SystemLib::s_inited = true;
-  RuntimeOption::RepoCommit = true;
+
  Option::AutoInline = -1;

  if (po.optimizeLevel > 0) {
@@ -880,10 +968,114 @@ int hhbcTarget(const CompilerOptions &po, AnalysisResultPtr ar,

 ///////////////////////////////////////////////////////////////////////////////

+int cppTarget(const CompilerOptions &po, AnalysisResultPtr ar,
+              AsyncFileCacheSaver &fcThread, bool allowSys /* = true */) {
+  int ret = 0;
+  int clusterCount = po.clusterCount;
+  // format
+  CodeGenerator::Output format = CodeGenerator::InvalidOutput;
+  if (po.format == "file") {
+    clusterCount = 0;
+    format = CodeGenerator::FileCPP;
+  } else if (po.format == "cluster") {
+    format = CodeGenerator::ClusterCPP;
+  } else if (po.format == "sys" && allowSys) {
+    clusterCount = 0;
+    format = CodeGenerator::SystemCPP;
+    ar->setSystem();
+  } else if (po.format == "exe" || po.format == "lib") {
+    format = CodeGenerator::ClusterCPP;
+  }
+
+  if (format == CodeGenerator::InvalidOutput) {
+    Logger::Error("Unknown format for CPP target: %s", po.format.c_str());
+    return 1;
+  }
+
+  if (!Option::RTTIOutputFile.empty()) {
+    if (!po.rttiDirectory.empty()) {
+      Option::UseRTTIProfileData = true;
+      ar->cloneRTTIFuncs(po.rttiDirectory.c_str());
+    } else {
+      Option::GenRTTIProfileData = true;
+    }
+  }
+
+  ret = analyzeTarget(po, ar);
+
+  {
+    Timer timer(Timer::WallTime, "creating CPP files");
+    if (po.syncDir.empty()) {
+      ar->setOutputPath(po.outputDir);
+      ar->outputAllCPP(format, clusterCount, nullptr);
+    } else {
+      ar->setOutputPath(po.syncDir);
+      ar->outputAllCPP(format, clusterCount, &po.outputDir);
+      if (!po.filecache.empty()) {
+        fcThread.waitForEnd();
+      }
+      Util::syncdir(po.outputDir, po.syncDir);
+      boost::filesystem::remove_all(po.syncDir);
+    }
+  }
+
+  return ret;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int generateSepExtCpp(const CompilerOptions &po, AnalysisResultPtr ar) {
+  ar->outputCPPSepExtensionImpl(po.outputFile);
+  return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int buildTarget(const CompilerOptions &po) {
+  const char *HPHP_HOME = getenv("HPHP_HOME");
+  if (!HPHP_HOME || !*HPHP_HOME) {
+    throw Exception("Environment variable HPHP_HOME is not set.");
+  }
+  string cmd = string(HPHP_HOME) + "/hphp/legacy/run.sh";
+  string flags;
+  if (getenv("RELEASE"))      flags += "RELEASE=1 ";
+  if (getenv("SHOW_LINK"))    flags += "SHOW_LINK=1 ";
+  if (getenv("SHOW_COMPILE")) flags += "SHOW_COMPILE=1 ";
+  if (po.format == "lib")     flags += "HPHP_BUILD_LIBRARY=1 ";
+  if (Option::GenerateFFI)    flags += "HPHP_BUILD_FFI=1 ";
+  const char *argv[] = {"", po.outputDir.c_str(),
+                        po.program.c_str(), flags.c_str(), nullptr};
+
+  if (getenv("SHOW_COMPILE")) {
+    Logger::Info ("Compile command: %s %s %s", po.outputDir.c_str(),
+        po.program.c_str(), flags.c_str());
+  }
+  Timer timer(Timer::WallTime, "compiling and linking CPP files");
+  string out, err;
+  bool ret = Process::Exec(cmd.c_str(), argv, nullptr, out, &err);
+  if (getenv("SHOW_COMPILE")) {
+    Logger::Info("%s", out.c_str());
+  } else {
+    Logger::Verbose("%s", out.c_str());
+  }
+  if (!err.empty()) {
+    Logger::Error("%s", err.c_str());
+  }
+  if (!ret) {
+    return 1;
+  }
+
+  return 0;
+}
+
 int runTargetCheck(const CompilerOptions &po, AnalysisResultPtr ar,
                   AsyncFileCacheSaver &fcThread) {
  // generate code
-  if (hhbcTarget(po, ar, fcThread)) {
+  if (po.format == "sep") return 1;
+
+  if (hhvm ?
+      hhbcTarget(po, ar, fcThread) :
+      cppTarget(po, ar, fcThread, false)) {
    return 1;
  }

@@ -897,7 +1089,10 @@ int runTargetCheck(const CompilerOptions &po, AnalysisResultPtr ar,
 }

 int runTarget(const CompilerOptions &po) {
-  int ret = 0;
+  int ret = hhvm ? 0 : buildTarget(po);
+  if (ret) {
+    return ret;
+  }

  // If there are more than one input files, we need one extra arg to run.
  // If it's missing, we will stop right here, with compiled code.
@@ -908,7 +1103,7 @@ int runTarget(const CompilerOptions &po) {

  // run the executable
  string cmd;
-  if (po.format.find("exe") == string::npos) {
+  if (hhvm && po.format.find("exe") == string::npos) {
    char buf[PATH_MAX];
    if (!realpath("/proc/self/exe", buf)) return -1;

@@ -918,9 +1113,8 @@ int runTarget(const CompilerOptions &po) {
  }
  cmd += po.outputDir + '/' + po.program;
  cmd += string(" --file ") +
-    (po.inputs.size() == 1 ? po.inputs[0] : "") +
-    " " + po.programArgs;
-  Logger::Info("running executable: %s", cmd.c_str());
+    (po.inputs.size() == 1 ? po.inputs[0] : "") + po.programArgs;
+  Logger::Info("running executable %s...", cmd.c_str());
  ret = Util::ssystem(cmd.c_str());
  if (ret && ret != -1) ret = 1;

@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,21 +14,21 @@
   +----------------------------------------------------------------------+
 */

-#include "hphp/compiler/construct.h"
-#include "hphp/compiler/parser/parser.h"
-#include "hphp/util/util.h"
+#include <compiler/construct.h>
+#include <compiler/parser/parser.h>
+#include <util/util.h>

-#include "hphp/compiler/analysis/file_scope.h"
-#include "hphp/compiler/analysis/function_scope.h"
-#include "hphp/compiler/analysis/class_scope.h"
-#include "hphp/compiler/analysis/analysis_result.h"
-#include "hphp/compiler/analysis/ast_walker.h"
+#include <compiler/analysis/file_scope.h>
+#include <compiler/analysis/function_scope.h>
+#include <compiler/analysis/class_scope.h>
+#include <compiler/analysis/analysis_result.h>
+#include <compiler/analysis/ast_walker.h>

-#include "hphp/compiler/statement/function_statement.h"
+#include <compiler/statement/function_statement.h>

-#include "hphp/compiler/expression/simple_function_call.h"
-#include "hphp/compiler/expression/simple_variable.h"
-#include "hphp/compiler/expression/closure_expression.h"
+#include <compiler/expression/simple_function_call.h>
+#include <compiler/expression/simple_variable.h>
+#include <compiler/expression/closure_expression.h>
 #include <iomanip>

 using namespace HPHP;
@@ -313,7 +313,7 @@ void Construct::dumpNode(int spc) {
  }

  std::cout << "-> 0x" << std::hex << std::setfill('0')
-            << std::setw(10) << (int64_t)this << std::dec;
+            << std::setw(10) << (int64)this << std::dec;

  std::cout << " " << name << "(" << type << ") ";
  if (id) {
@@ -322,12 +322,12 @@ void Construct::dumpNode(int spc) {
  if (idPtr) {
    std::cout << "idp=0x" <<
      std::hex << std::setfill('0') << std::setw(10) <<
-      (int64_t)idPtr.get() << " ";
+      (int64)idPtr.get() << " ";
  }
  if (idCsePtr) {
    std::cout << "idcsep=0x" <<
      std::hex << std::setfill('0') << std::setw(10) <<
-      (int64_t)idCsePtr.get() << " ";
+      (int64)idCsePtr.get() << " ";
  }

  if (value != "") {
@@ -454,8 +454,7 @@ private:

 void Construct::dump(int spc, AnalysisResultConstPtr ar) {
  ConstructDumper cd(spc, ar);
-  cd.walk(AstWalkerStateVec(ConstructRawPtr(this)),
-    ConstructRawPtr(), ConstructRawPtr());
+  cd.walk(ConstructRawPtr(this), ConstructRawPtr(), ConstructRawPtr());
 }

 void Construct::dump(int spc, AnalysisResultConstPtr ar, bool functionOnly,
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,13 +14,13 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_CONSTRUCT_H_
-#define incl_HPHP_CONSTRUCT_H_
+#ifndef __CONSTRUCT_H__
+#define __CONSTRUCT_H__

-#include "hphp/util/json.h"
-#include "hphp/compiler/code_generator.h"
-#include "hphp/compiler/analysis/code_error.h"
-#include "hphp/compiler/analysis/block_scope.h"
+#include <util/json.h>
+#include <compiler/code_generator.h>
+#include <compiler/analysis/code_error.h>
+#include <compiler/analysis/block_scope.h>

 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////
@@ -178,8 +178,7 @@ public:
    return m_blockScope->getContainingClass();
  }
  void resetScope(BlockScopeRawPtr scope, bool resetOrigScope=false);
-  void parseTimeFatal(Compiler::ErrorType error, const char *fmt, ...)
-    ATTRIBUTE_PRINTF(3,4);
+  void parseTimeFatal(Compiler::ErrorType error, const char *fmt, ...);
  virtual int getLocalEffects() const { return UnknownEffect;}
  int getChildrenEffects() const;
  int getContainedEffects() const;
@@ -247,6 +246,7 @@ public:
   * Called when generating code.
   */
  virtual void outputPHP(CodeGenerator &cg, AnalysisResultPtr ar) = 0;
+  virtual void outputCPP(CodeGenerator &cg, AnalysisResultPtr ar) = 0;

  /**
   * Implements JSON::CodeError::ISerializable.
@@ -315,7 +315,7 @@ public:
  int getLocalEffects() const { return m_localEffects; }
  virtual void effectsCallback() = 0;
 protected:
-  explicit LocalEffectsContainer(Construct::Effect localEffect) :
+  LocalEffectsContainer(Construct::Effect localEffect) :
    m_localEffects(localEffect) {}
  LocalEffectsContainer() :
    m_localEffects(0) {}
@@ -334,4 +334,4 @@ protected:

 ///////////////////////////////////////////////////////////////////////////////
 }
-#endif // incl_HPHP_CONSTRUCT_H_
+#endif // __CONSTRUCT_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,17 +14,17 @@
   +----------------------------------------------------------------------+
 */

-#include "hphp/compiler/expression/array_element_expression.h"
-#include "hphp/compiler/expression/simple_variable.h"
-#include "hphp/compiler/expression/scalar_expression.h"
-#include "hphp/compiler/analysis/variable_table.h"
-#include "hphp/compiler/analysis/code_error.h"
-#include "hphp/compiler/option.h"
-#include "hphp/compiler/expression/static_member_expression.h"
-#include "hphp/compiler/analysis/function_scope.h"
-#include "hphp/util/parser/hphp.tab.hpp"
-#include "hphp/runtime/base/complex_types.h"
-#include "hphp/runtime/base/builtin_functions.h"
+#include <compiler/expression/array_element_expression.h>
+#include <compiler/expression/simple_variable.h>
+#include <compiler/expression/scalar_expression.h>
+#include <compiler/analysis/variable_table.h>
+#include <compiler/analysis/code_error.h>
+#include <compiler/option.h>
+#include <compiler/expression/static_member_expression.h>
+#include <compiler/analysis/function_scope.h>
+#include <util/parser/hphp.tab.hpp>
+#include <runtime/base/complex_types.h>
+#include <runtime/base/builtin_functions.h>

 using namespace HPHP;

@@ -79,7 +79,8 @@ void ArrayElementExpression::setContext(Context context) {
      if (m_variable->is(Expression::KindOfObjectPropertyExpression)) {
        m_variable->clearContext(Expression::NoLValueWrapper);
      }
-      // special case for $GLOBALS[], we do not need lvalue wrapper
+      // special case for $GLOBALS[], see the if (m_global) check in
+      // ArrayElementExpression::outputCPPImpl, we do not need lvalue wrapper
      if (m_variable->is(Expression::KindOfSimpleVariable)) {
        SimpleVariablePtr var =
          dynamic_pointer_cast<SimpleVariable>(m_variable);
@@ -167,6 +168,16 @@ void ArrayElementExpression::analyzeProgram(AnalysisResultPtr ar) {
  m_variable->analyzeProgram(ar);
  if (m_offset) m_offset->analyzeProgram(ar);
  if (ar->getPhase() == AnalysisResult::AnalyzeFinal) {
+    if (!m_global && (m_context & AccessContext) &&
+        !(m_context & (LValue|RefValue|DeepReference|
+                       UnsetContext|RefParameter|InvokeArgument))) {
+      TypePtr type = m_variable->getActualType();
+      if (!type ||
+          (!type->is(Type::KindOfString) && !type->is(Type::KindOfArray))) {
+        FunctionScopePtr scope = getFunctionScope();
+        if (scope && !needsCSE()) scope->setNeedsRefTemp();
+      }
+    }
    if (m_global) {
      if (getContext() & (LValue|RefValue|DeepReference)) {
        setContext(NoLValueWrapper);
@@ -181,6 +192,8 @@ void ArrayElementExpression::analyzeProgram(AnalysisResultPtr ar) {
                          shared_from_this());
        }
      }
+      FunctionScopePtr scope = getFunctionScope();
+      if (scope) scope->setNeedsCheckMem();
    } else {
      TypePtr at(m_variable->getActualType());
      TypePtr et(m_variable->getExpectedType());
@@ -245,14 +258,6 @@ ExpressionPtr ArrayElementExpression::preOptimize(AnalysisResultConstPtr ar) {
          return replaceValue(makeConstant(ar, "null"));
        }
        if (m_offset->isScalar() && m_offset->getScalarValue(o)) {
-          if (v.isString()) {
-            if (!o.isInteger() ||
-                o.toInt64Val() < 0 ||
-                o.toInt64Val() >= v.toCStrRef().size()) {
-              // warnings should be raised...
-              return ExpressionPtr();
-            }
-          }
          try {
            g_context->setThrowAllErrors(true);
            Variant res = v.rvalAt(
@@ -405,3 +410,209 @@ void ArrayElementExpression::outputPHP(CodeGenerator &cg,
    cg_printf("]");
  }
 }
+
+bool ArrayElementExpression::preOutputCPP(CodeGenerator &cg,
+                                          AnalysisResultPtr ar, int state) {
+  return preOutputOffsetLHS(cg, ar, state);
+}
+
+void ArrayElementExpression::outputCPPImpl(CodeGenerator &cg,
+                                           AnalysisResultPtr ar) {
+  if (m_global) {
+    if (!m_globalName.empty()) {
+      VariableTablePtr variables = getScope()->getVariables();
+      string name = variables->getGlobalVariableName(ar, m_globalName);
+      cg_printf("g->%s", name.c_str());
+    } else {
+      cg_printf("((LVariableTable *)g)->get(");
+      m_offset->outputCPP(cg, ar);
+      cg_printf(")");
+    }
+  } else {
+    TypePtr type = m_variable->getType();
+    if (hasContext(UnsetContext)) {
+      cg_printf("unsetLval(");
+      m_variable->outputCPP(cg, ar);
+      cg_printf(", ");
+    } else {
+      if (m_variable->is(Expression::KindOfScalarExpression) ||
+          (type && (type->isInteger() ||
+                    type->is(Type::KindOfDouble) ||
+                    type->is(Type::KindOfObject) ||
+                    type->is(Type::KindOfBoolean)))) {
+        cg_printf(type && type->is(Type::KindOfString) ? "((String)" :
+                  "((Variant)");
+        m_variable->outputCPP(cg, ar);
+        cg_printf(")");
+      } else {
+        m_variable->outputCPP(cg, ar);
+      }
+    }
+    if (m_offset) {
+      bool lvalAt = false;
+      bool rvalAt = false;
+      bool byRef = false;
+      bool arrRef = false;
+      const char *sep = ", AccessFlags::";
+      bool isArrayType = type && type->is(Type::KindOfArray);
+      bool isStringType = type && type->is(Type::KindOfString);
+      bool isRealChainRoot = isChainRoot() && hasCPPCseTemp();
+
+      TypePtr t;
+      bool hasCseStore = isRealChainRoot && GetCseTempInfo(
+          ar,
+          static_pointer_cast<Expression>(shared_from_this()),
+          t);
+
+      if (hasContext(UnsetContext)) {
+        // do nothing
+      } else if (hasContext(InvokeArgument) && cg.callInfoTop() != -1) {
+        assert(!isRealChainRoot); // TODO: handle this case
+        cg_printf(".argvalAt(cit%d->isRef(%d), ", cg.callInfoTop(), m_argNum);
+      } else if (m_context & (LValue|RefValue|DeepReference)) {
+        // if we see an array access element in LValue context, the
+        // type inference pass will never infer its type to be a string
+        assert(!isStringType);
+        if (isRealChainRoot && !isArrayType) {
+          // chain roots for non array types (variants) should call
+          // lvalRef()
+          cg_printf(".lvalRef(");
+        } else {
+          cg_printf(".lvalAt(");
+        }
+        lvalAt = true;
+      } else {
+        byRef =
+          ((m_context & AccessContext) || isRealChainRoot) && !isStringType;
+        arrRef = byRef && isArrayType;
+        cg_printf(".rval%s%s(",
+                  arrRef || !byRef ? "At" : "", byRef ? "Ref" : "");
+        rvalAt = true;
+      }
+      m_offset->outputCPP(cg, ar);
+      if (!isStringType) {
+        if (rvalAt) {
+          if (byRef && !arrRef) {
+            string tmp;
+            if (hasCseStore) {
+              tmp = string(Option::CseTempStoragePrefix) + m_cppCseTemp;
+            } else {
+              tmp = cg.getReferenceTemp();
+            }
+            cg_printf(", %s", tmp.empty() ? "Variant()" : tmp.c_str());
+          }
+          if (!hasContext(ExistContext)) {
+            cg_printf(", AccessFlags::Error"); // raise undefined index error
+            sep = "_";
+          }
+        } else if (lvalAt) {
+          if (hasCseStore && !isArrayType) {
+            cg_printf(", %s%s",
+                Option::CseTempStoragePrefix, m_cppCseTemp.c_str());
+          }
+          if (hasContext(AccessContext)) {
+            // Dont copy the array if the element is an object, or
+            // is referenced.
+            // This is safe in AccessContext (the parent is an ArrayElement,
+            // or an ObjectProperty) because applying [] to an object will
+            // either invoke OffsetGet, or fatal, and modifications to a
+            // referenced element would be reflected in all copies
+            // of the array anyway.
+            cg_printf(", AccessFlags::CheckExist");
+            sep = "_";
+          }
+        }
+        ScalarExpressionPtr sc =
+          dynamic_pointer_cast<ScalarExpression>(m_offset);
+        if (!hasContext(UnsetContext) && sc && sc->isLiteralString()) {
+          String s(sc->getLiteralString());
+          int64 n;
+          if (!s.get()->isStrictlyInteger(n)) {
+            if (lvalAt || rvalAt) {
+              cg_printf("%sKey", sep);
+            } else {
+              cg_printf(", true"); // skip toKey() at run time
+            }
+          }
+        }
+      }
+      cg_printf(")");
+    } else {
+      cg_printf(".lvalAt()");
+    }
+  }
+}
+
+void ArrayElementExpression::outputCPPExistTest(CodeGenerator &cg,
+                                                AnalysisResultPtr ar, int op) {
+  switch (op) {
+  case T_ISSET:  cg_printf("isset("); break;
+  case T_EMPTY:  cg_printf("empty("); break;
+  default: assert(false);
+  }
+
+  if (m_global) {
+    if (!m_globalName.empty()) {
+      VariableTablePtr variables = getScope()->getVariables();
+      string name = variables->getGlobalVariableName(ar, m_globalName);
+      cg_printf("g->%s", name.c_str());
+    } else {
+      cg_printf("((LVariableTable *)g)->get(");
+      m_offset->outputCPP(cg, ar);
+      cg_printf(")");
+    }
+  } else {
+    m_variable->outputCPP(cg, ar);
+    cg_printf(", ");
+    m_offset->outputCPP(cg, ar);
+    ScalarExpressionPtr sc =
+      dynamic_pointer_cast<ScalarExpression>(m_offset);
+    if (sc) {
+      if (sc->isLiteralString()) {
+        String s(sc->getLiteralString());
+        int64 n;
+        if (!s.get()->isStrictlyInteger(n)) {
+          cg_printf(", true"); // skip toKey() at run time
+        }
+      }
+    }
+  }
+  cg_printf(")");
+}
+void ArrayElementExpression::outputCPPUnset(CodeGenerator &cg,
+                                            AnalysisResultPtr ar) {
+  if (isSuperGlobal()) {
+    Expression::outputCPPUnset(cg, ar);
+  } else {
+    TypePtr expected = m_variable->getExpectedType();
+    TypePtr implemented = m_variable->getImplementedType();
+    bool wrap = false;
+    if (TypePtr t = m_variable->getActualType()) {
+      if (t->is(Type::KindOfObject)) {
+        if (!m_variable->getImplementedType() ||
+            !m_variable->getImplementedType()->is(Type::KindOfVariant)) {
+          cg_printf("((Variant)(");
+          wrap = true;
+        }
+        m_variable->setImplementedType(TypePtr());
+        m_variable->setExpectedType(TypePtr());
+      }
+    }
+    m_variable->outputCPP(cg, ar);
+    if (wrap) cg_printf("))");
+    m_variable->setExpectedType(expected);
+    m_variable->setImplementedType(implemented);
+    cg_printf(".weakRemove(");
+    m_offset->outputCPP(cg, ar);
+    ScalarExpressionPtr sc =
+      dynamic_pointer_cast<ScalarExpression>(m_offset);
+    if (sc && sc->isLiteralString()) {
+      String s(sc->getLiteralString());
+      int64 n;
+      if (!s->isStrictlyInteger(n)) {
+        cg_printf(", true");
+      }
+    }
+    cg_printf(")");
+  }
+}
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,10 +14,10 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_ARRAY_ELEMENT_EXPRESSION_H_
-#define incl_HPHP_ARRAY_ELEMENT_EXPRESSION_H_
+#ifndef __ARRAY_ELEMENT_EXPRESSION_H__
+#define __ARRAY_ELEMENT_EXPRESSION_H__

-#include "hphp/compiler/expression/expression.h"
+#include <compiler/expression/expression.h>

 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////
@@ -56,6 +56,11 @@ public:
  bool appendClass(ExpressionPtr cls,
                   AnalysisResultConstPtr ar, FileScopePtr file);

+  virtual void outputCPPExistTest(CodeGenerator &cg, AnalysisResultPtr ar,
+                                  int op);
+  virtual void outputCPPUnset(CodeGenerator &cg, AnalysisResultPtr ar);
+  bool preOutputCPP(CodeGenerator &cg, AnalysisResultPtr ar, int state);
+
  virtual bool canonCompare(ExpressionPtr e) const;

 private:
@@ -70,4 +75,4 @@ private:
 ///////////////////////////////////////////////////////////////////////////////
 }

-#endif // incl_HPHP_ARRAY_ELEMENT_EXPRESSION_H_
+#endif // __ARRAY_ELEMENT_EXPRESSION_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,10 +14,10 @@
   +----------------------------------------------------------------------+
 */

-#include "hphp/compiler/expression/array_pair_expression.h"
-#include "hphp/compiler/expression/scalar_expression.h"
-#include "hphp/compiler/expression/unary_op_expression.h"
-#include "hphp/util/parser/hphp.tab.hpp"
+#include <compiler/expression/array_pair_expression.h>
+#include <compiler/expression/scalar_expression.h>
+#include <compiler/expression/unary_op_expression.h>
+#include <util/parser/hphp.tab.hpp>

 using namespace HPHP;

@@ -126,6 +126,13 @@ bool ArrayPairExpression::canonCompare(ExpressionPtr e) const {
 ///////////////////////////////////////////////////////////////////////////////
 // code generation functions

+void ArrayPairExpression::preOutputStash(CodeGenerator &cg,
+                                         AnalysisResultPtr ar,
+                                         int state) {
+  if (m_name) m_name->preOutputStash(cg, ar, state);
+  m_value->preOutputStash(cg, ar, state);
+}
+
 void ArrayPairExpression::outputPHP(CodeGenerator &cg, AnalysisResultPtr ar) {
  if (m_name) {
    m_name->outputPHP(cg, ar);
@@ -134,3 +141,40 @@ void ArrayPairExpression::outputPHP(CodeGenerator &cg, AnalysisResultPtr ar) {
  if (m_ref) cg_printf("&");
  m_value->outputPHP(cg, ar);
 }
+
+void ArrayPairExpression::outputCPPImpl(CodeGenerator &cg,
+                                        AnalysisResultPtr ar) {
+  bool keyConverted = false;
+  if (m_name) {
+    keyConverted = outputCPPName(cg, ar);
+    cg_printf(", ");
+  }
+  m_value->outputCPP(cg, ar);
+  if (m_name && keyConverted && !m_collection) {
+    cg_printf(", true");
+  }
+}
+
+bool ArrayPairExpression::outputCPPName(CodeGenerator &cg,
+                                        AnalysisResultPtr ar) {
+  assert(m_name);
+  ScalarExpressionPtr sc = dynamic_pointer_cast<ScalarExpression>(m_name);
+  if (sc) {
+    if (sc->isLiteralString()) {
+      string s = sc->getLiteralString();
+      int64 res;
+      if (is_strictly_integer(s.c_str(), s.size(), res)) {
+        cg_printf("%sL", s.c_str());
+      } else {
+        m_name->outputCPP(cg, ar);
+      }
+      return true;
+    }
+    if (sc->isLiteralInteger()) {
+      m_name->outputCPP(cg, ar);
+      return true;
+    }
+  }
+  m_name->outputCPP(cg, ar);
+  return false;
+}
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,10 +14,10 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_ARRAY_PAIR_EXPRESSION_H_
-#define incl_HPHP_ARRAY_PAIR_EXPRESSION_H_
+#ifndef __ARRAY_PAIR_EXPRESSION_H__
+#define __ARRAY_PAIR_EXPRESSION_H__

-#include "hphp/compiler/expression/expression.h"
+#include <compiler/expression/expression.h>

 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////
@@ -40,6 +40,9 @@ public:
  virtual int getLocalEffects() const { return NoEffect; }
  bool isScalarArrayPair() const;

+  void preOutputStash(CodeGenerator &cg, AnalysisResultPtr ar,
+                      int state);
+
  bool isRef() const { return m_ref; }

  bool canonCompare(ExpressionPtr e) const;
@@ -48,9 +51,11 @@ private:
  ExpressionPtr m_value;
  bool m_ref;
  bool m_collection;
+
+  bool outputCPPName(CodeGenerator &cg, AnalysisResultPtr ar);
 };

 ///////////////////////////////////////////////////////////////////////////////
 }

-#endif // incl_HPHP_ARRAY_PAIR_EXPRESSION_H_
+#endif // __ARRAY_PAIR_EXPRESSION_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,26 +14,26 @@
   +----------------------------------------------------------------------+
 */

-#include "hphp/compiler/expression/assignment_expression.h"
-#include "hphp/compiler/expression/array_element_expression.h"
-#include "hphp/compiler/expression/object_property_expression.h"
-#include "hphp/compiler/analysis/code_error.h"
-#include "hphp/compiler/expression/constant_expression.h"
-#include "hphp/compiler/expression/simple_variable.h"
-#include "hphp/compiler/analysis/block_scope.h"
-#include "hphp/compiler/analysis/variable_table.h"
-#include "hphp/compiler/analysis/constant_table.h"
-#include "hphp/compiler/analysis/file_scope.h"
-#include "hphp/compiler/expression/unary_op_expression.h"
-#include "hphp/util/parser/hphp.tab.hpp"
-#include "hphp/compiler/option.h"
-#include "hphp/compiler/analysis/class_scope.h"
-#include "hphp/compiler/analysis/function_scope.h"
-#include "hphp/compiler/expression/scalar_expression.h"
-#include "hphp/compiler/expression/expression_list.h"
-#include "hphp/compiler/expression/simple_function_call.h"
-#include "hphp/runtime/base/complex_types.h"
-#include "hphp/runtime/base/builtin_functions.h"
+#include <compiler/expression/assignment_expression.h>
+#include <compiler/expression/array_element_expression.h>
+#include <compiler/expression/object_property_expression.h>
+#include <compiler/analysis/code_error.h>
+#include <compiler/expression/constant_expression.h>
+#include <compiler/expression/simple_variable.h>
+#include <compiler/analysis/block_scope.h>
+#include <compiler/analysis/variable_table.h>
+#include <compiler/analysis/constant_table.h>
+#include <compiler/analysis/file_scope.h>
+#include <compiler/expression/unary_op_expression.h>
+#include <util/parser/hphp.tab.hpp>
+#include <compiler/option.h>
+#include <compiler/analysis/class_scope.h>
+#include <compiler/analysis/function_scope.h>
+#include <compiler/expression/scalar_expression.h>
+#include <compiler/expression/expression_list.h>
+#include <compiler/expression/simple_function_call.h>
+#include <runtime/base/complex_types.h>
+#include <runtime/base/builtin_functions.h>

 using namespace HPHP;

@@ -42,11 +42,9 @@ using namespace HPHP;

 AssignmentExpression::AssignmentExpression
 (EXPRESSION_CONSTRUCTOR_PARAMETERS,
- ExpressionPtr variable, ExpressionPtr value, bool ref,
- bool rhsFirst /* = false */)
+ ExpressionPtr variable, ExpressionPtr value, bool ref)
  : Expression(EXPRESSION_CONSTRUCTOR_PARAMETER_VALUES(AssignmentExpression)),
-    m_variable(variable), m_value(value), m_ref(ref), m_rhsFirst(rhsFirst) {
-  assert(!m_ref || !m_rhsFirst);
+    m_variable(variable), m_value(value), m_ref(ref) {
  m_variable->setContext(Expression::DeepAssignmentLHS);
  m_variable->setContext(Expression::AssignmentLHS);
  m_variable->setContext(Expression::LValue);
@@ -92,10 +90,6 @@ void AssignmentExpression::onParseRecur(AnalysisResultConstPtr ar,
    // ...as in ClassConstant statement
    // We are handling this one here, not in ClassConstant, purely because
    // we need "value" to store in constant table.
-    if (type->is(Type::KindOfArray)) {
-      parseTimeFatal(Compiler::NoError,
-                     "Arrays are not allowed in class constants");
-    }
    ConstantExpressionPtr exp =
      dynamic_pointer_cast<ConstantExpression>(m_variable);
    scope->getConstants()->add(exp->getName(), type, m_value, ar, m_variable);
@@ -141,7 +135,7 @@ void AssignmentExpression::analyzeProgram(AnalysisResultPtr ar) {
 }

 ConstructPtr AssignmentExpression::getNthKid(int n) const {
-  switch (m_rhsFirst ? 1 - n : n) {
+  switch (n) {
    case 0:
      return m_variable;
    case 1:
@@ -158,7 +152,7 @@ int AssignmentExpression::getKidCount() const {
 }

 void AssignmentExpression::setNthKid(int n, ConstructPtr cp) {
-  switch (m_rhsFirst ? 1 - n : n) {
+  switch (n) {
    case 0:
      m_variable = boost::dynamic_pointer_cast<Expression>(cp);
      break;
@@ -255,14 +249,6 @@ ExpressionPtr AssignmentExpression::preOptimize(AnalysisResultConstPtr ar) {
              g_context->setThrowAllErrors(true);
              if (aoff) {
                if (!aoff->getScalarValue(o)) break;
-                if (v.isString()) {
-                  if (!o.isInteger() ||
-                      o.toInt64Val() < 0 ||
-                      o.toInt64Val() >= v.toCStrRef().size()) {
-                    // warnings should be raised...
-                    break;
-                  }
-                }
                v.set(o, r);
              } else {
                v.append(r);
@@ -315,3 +301,237 @@ void AssignmentExpression::outputPHP(CodeGenerator &cg, AnalysisResultPtr ar) {
  if (m_ref) cg_printf("&");
  m_value->outputPHP(cg, ar);
 }
+
+static void wrapValue(CodeGenerator &cg, AnalysisResultPtr ar,
+                      ExpressionPtr exp, bool ref, bool array, bool varnr) {
+  bool close = false;
+  if (ref) {
+    cg_printf("ref(");
+    close = true;
+  } else if (array && !exp->hasCPPTemp() &&
+             !exp->isTemporary() && !exp->isScalar() &&
+             exp->getActualType() && !exp->getActualType()->isPrimitive() &&
+             exp->getActualType()->getKindOf() != Type::KindOfString) {
+    cg_printf("wrap_variant(");
+    close = true;
+  } else if (varnr && exp->getCPPType()->isExactType()) {
+    bool isScalar = exp->isScalar();
+    if (!isScalar || !Option::UseScalarVariant) {
+      cg_printf("VarNR(");
+      close = true;
+    } else if (isScalar) {
+      assert(!cg.hasScalarVariant());
+      cg.setScalarVariant();
+    }
+  }
+  exp->outputCPP(cg, ar);
+  cg.clearScalarVariant();
+  if (close) cg_printf(")");
+}
+
+void AssignmentExpression::preOutputStash(CodeGenerator &cg,
+                                          AnalysisResultPtr ar, int state) {
+  if (hasCPPTemp()) return;
+  if (m_value->hasCPPTemp() &&
+      (Type::SameType(getType(), m_value->getType()) ||
+       (Type::IsMappedToVariant(getType()) &&
+        Type::IsMappedToVariant(m_value->getType())))) {
+    setUnused(true);
+    outputCPP(cg, ar);
+    cg_printf(";\n");
+    setCPPTemp(m_value->cppTemp());
+    return;
+  }
+  TypePtr at(getActualType());
+  TypePtr et(getExpectedType());
+  TypePtr it(getImplementedType());
+  if (at && !Type::IsMappedToVariant(at) &&
+      !et && it && Type::IsMappedToVariant(it)) {
+    m_value->preOutputStash(cg, ar, state);
+    if (!m_value->hasCPPTemp()) {
+      // preOutputStash did no work, so we need to
+      // explicitly do a stash
+      TypePtr t(m_value->getType());
+      bool constRef = !t->isPrimitive() &&
+        (m_value->isTemporary() || !m_value->isLocalExprAltered());
+      const string &tmp = m_value->genCPPTemp(cg, ar);
+      if (constRef) cg_printf("const ");
+      t->outputCPPDecl(cg, ar, getScope());
+      const char *ref = constRef ? "&" : "";
+      cg_printf(" %s%s((", ref, tmp.c_str());
+      m_value->outputCPP(cg, ar);
+      cg_printf("));\n");
+      m_value->setCPPTemp(tmp);
+    }
+    assert(m_value->hasCPPTemp());
+    setUnused(true);
+    outputCPP(cg, ar);
+    cg_printf(";\n");
+    setCPPTemp(m_value->cppTemp());
+    return;
+  }
+  return Expression::preOutputStash(cg, ar, state);
+}
+
+bool AssignmentExpression::preOutputCPP(CodeGenerator &cg, AnalysisResultPtr ar,
+                                        int state) {
+  if (hasContext(RefValue) && !m_ref) {
+    if (!cg.inExpression()) return true;
+    state |= FixOrder | ForceTemp;
+  }
+  if (m_variable->is(Expression::KindOfArrayElementExpression)) {
+    ExpressionPtr exp = m_value;
+    ExpressionPtr vv(
+      static_pointer_cast<ArrayElementExpression>(m_variable)->getVariable());
+    if ((vv->is(KindOfArrayElementExpression) ||
+         vv->is(KindOfObjectPropertyExpression)) &&
+        (vv->getContainedEffects() && (CreateEffect|AccessorEffect))) {
+      /*
+        We are in a case such as
+          $a->b['c'] = ...;
+          $a['b']['c'] = ...;
+        Where evaluating m_variable may modify $a. Unless we can prove that
+        the rhs is not referring to the same thing as $a, we must generate
+        a temporary for it (note that we could do better with the following
+        checks).
+      */
+      if (!(m_ref && exp->isRefable()) &&
+          !exp->isTemporary() && !exp->isScalar() &&
+          exp->getActualType() && !exp->getActualType()->isPrimitive() &&
+          exp->getActualType()->getKindOf() != Type::KindOfString) {
+        state |= Expression::StashAll;
+      }
+    }
+  }
+
+  return Expression::preOutputCPP(cg, ar, state);
+}
+
+bool AssignmentExpression::SpecialAssignment(CodeGenerator &cg,
+                                             AnalysisResultPtr ar,
+                                             ExpressionPtr lval,
+                                             ExpressionPtr rval,
+                                             const char *rvalStr, bool ref) {
+  if (lval->is(KindOfArrayElementExpression)) {
+    ArrayElementExpressionPtr exp =
+      dynamic_pointer_cast<ArrayElementExpression>(lval);
+    if (!exp->isSuperGlobal() && !exp->isDynamicGlobal()) {
+      exp->getVariable()->outputCPP(cg, ar);
+      if (exp->getOffset()) {
+        cg_printf(".set(");
+        exp->getOffset()->outputCPP(cg, ar);
+        cg_printf(", (");
+      } else {
+        cg_printf(".append((");
+      }
+      if (rval) {
+        wrapValue(cg, ar, rval, ref,
+                  (exp->getVariable()->is(KindOfArrayElementExpression) ||
+                   exp->getVariable()->is(KindOfObjectPropertyExpression)) &&
+                  (exp->getVariable()->getContainedEffects() &&
+                   (CreateEffect|AccessorEffect)), true);
+      } else {
+        cg_printf(ref ? "ref(%s)" : "%s", rvalStr);
+      }
+      cg_printf(")");
+      ExpressionPtr off = exp->getOffset();
+      if (off) {
+        ScalarExpressionPtr sc =
+          dynamic_pointer_cast<ScalarExpression>(off);
+        if (sc) {
+          if (sc->isLiteralString()) {
+            String s(sc->getLiteralString());
+            int64 n;
+            if (!s.get()->isStrictlyInteger(n)) {
+              cg_printf(", true"); // skip toKey() at run time
+            }
+          }
+        }
+      }
+      cg_printf(")");
+      return true;
+    }
+  } else if (lval->is(KindOfObjectPropertyExpression)) {
+    ObjectPropertyExpressionPtr var(
+      dynamic_pointer_cast<ObjectPropertyExpression>(lval));
+    if (!var->isValid()) {
+      bool nonPrivate = var->isNonPrivate(ar);
+      var->outputCPPObject(cg, ar);
+      if (nonPrivate) {
+        cg_printf("o_setPublic(");
+      } else {
+        cg_printf("o_set(");
+      }
+      var->outputCPPProperty(cg, ar);
+      cg_printf(", %s", ref ? "ref(" : "");
+      if (rval) {
+        rval->outputCPP(cg, ar);
+      } else {
+        cg_printf(ref ? "ref(%s)" : "%s", rvalStr);
+      }
+      if (nonPrivate) {
+        cg_printf("%s)", ref ? ")" : "");
+      }
+      else {
+        cg_printf("%s%s)",
+                  ref ? ")" : "",
+                  lval->originalClassName(cg, true).c_str());
+      }
+      return true;
+    }
+  }
+  return false;
+}
+
+void AssignmentExpression::outputCPPImpl(CodeGenerator &cg,
+                                         AnalysisResultPtr ar) {
+  bool ref = (m_ref && m_value->isRefable());
+
+  bool setNull = false;
+
+  if (SpecialAssignment(cg, ar, m_variable, m_value, nullptr, ref)) {
+    return;
+  }
+
+  if (m_value->isLiteralNull()) {
+    if (m_variable->is(Expression::KindOfSimpleVariable)) {
+      setNull = true;
+    } else {
+      TypePtr t = m_variable->getCPPType();
+      if (t && (t->is(Type::KindOfArray) ||
+                t->is(Type::KindOfObject) ||
+                t->is(Type::KindOfString))) {
+        setNull = true;
+      }
+    }
+  }
+
+  bool wrapped = true;
+  if (setNull) {
+    cg_printf("setNull(");
+    m_variable->outputCPP(cg, ar);
+  } else {
+    if (!m_variable->getCPPType()->isExactType() &&
+        !(m_value->hasCPPTemp() ?
+          m_value->getType() : m_value->getCPPType())->isExactType()) {
+      m_variable->outputCPP(cg, ar);
+      cg_printf(".assign%s(", ref ? "Ref" : "Val");
+      wrapped = true;
+      ref = false;
+    } else {
+      if (m_variable->getCPPType()->isExactType()) {
+        ref = false;
+      }
+      if ((wrapped = !isUnused())) {
+        cg_printf("(");
+      }
+      m_variable->outputCPP(cg, ar);
+      cg_printf(" = ");
+    }
+
+    wrapValue(cg, ar, m_value, ref, false, false);
+  }
+  if (wrapped) {
+    cg_printf(")");
+  }
+}
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,10 +14,10 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_ASSIGNMENT_EXPRESSION_H_
-#define incl_HPHP_ASSIGNMENT_EXPRESSION_H_
+#ifndef __ASSIGNMENT_EXPRESSION_H__
+#define __ASSIGNMENT_EXPRESSION_H__

-#include "hphp/compiler/expression/expression.h"
+#include <compiler/expression/expression.h>

 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////
@@ -29,7 +29,7 @@ class AssignmentExpression : public Expression, public IParseHandler {
 public:
  AssignmentExpression(EXPRESSION_CONSTRUCTOR_PARAMETERS,
                       ExpressionPtr variable, ExpressionPtr value,
-                       bool ref, bool rhsFirst = false);
+                       bool ref);

  DECLARE_EXPRESSION_VIRTUAL_FUNCTIONS;
  ExpressionPtr preOptimize(AnalysisResultConstPtr ar);
@@ -45,12 +45,16 @@ public:
  }

  ExpressionPtr getVariable() { return m_variable;}
-  ExpressionPtr getStoreVariable() const { return m_variable; }
  ExpressionPtr getValue() { return m_value;}
-  void setVariable(ExpressionPtr v) { m_variable = v; }
  void setValue(ExpressionPtr v) { m_value = v; }
-  bool isRhsFirst() { return m_rhsFirst; }
  int getLocalEffects() const;
+  bool preOutputCPP(CodeGenerator &cg, AnalysisResultPtr ar, int state);
+  void preOutputStash(CodeGenerator &cg, AnalysisResultPtr ar, int state);
+  static bool SpecialAssignment(CodeGenerator &cg,
+                                AnalysisResultPtr ar,
+                                ExpressionPtr lval,
+                                ExpressionPtr rval,
+                                const char *rvalStr, bool ref);

  // $GLOBALS[<literal-string>] = <scalar>;
  bool isSimpleGlobalAssign(StringData **name, TypedValue *tv) const;
@@ -60,10 +64,9 @@ private:
  ExpressionPtr m_variable;
  ExpressionPtr m_value;
  bool m_ref;
-  bool m_rhsFirst;
 };

 ///////////////////////////////////////////////////////////////////////////////
 }

-#endif // incl_HPHP_ASSIGNMENT_EXPRESSION_H_
+#endif // __ASSIGNMENT_EXPRESSION_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,24 +14,23 @@
   +----------------------------------------------------------------------+
 */

-#include "hphp/compiler/expression/binary_op_expression.h"
-#include "hphp/compiler/expression/array_element_expression.h"
-#include "hphp/compiler/expression/object_property_expression.h"
-#include "hphp/compiler/expression/unary_op_expression.h"
-#include "hphp/util/parser/hphp.tab.hpp"
-#include "hphp/compiler/expression/scalar_expression.h"
-#include "hphp/compiler/expression/constant_expression.h"
-#include "hphp/runtime/base/complex_types.h"
-#include "hphp/runtime/base/type_conversions.h"
-#include "hphp/runtime/base/builtin_functions.h"
-#include "hphp/runtime/base/comparisons.h"
-#include "hphp/runtime/base/zend/zend_string.h"
-#include "hphp/compiler/expression/expression_list.h"
-#include "hphp/compiler/expression/encaps_list_expression.h"
-#include "hphp/compiler/expression/simple_function_call.h"
-#include "hphp/compiler/expression/simple_variable.h"
-#include "hphp/compiler/statement/loop_statement.h"
-#include "hphp/runtime/base/tv_arith.h"
+#include <compiler/expression/binary_op_expression.h>
+#include <compiler/expression/array_element_expression.h>
+#include <compiler/expression/object_property_expression.h>
+#include <compiler/expression/unary_op_expression.h>
+#include <util/parser/hphp.tab.hpp>
+#include <compiler/expression/scalar_expression.h>
+#include <compiler/expression/constant_expression.h>
+#include <runtime/base/complex_types.h>
+#include <runtime/base/type_conversions.h>
+#include <runtime/base/builtin_functions.h>
+#include <runtime/base/comparisons.h>
+#include <runtime/base/zend/zend_string.h>
+#include <compiler/expression/expression_list.h>
+#include <compiler/expression/encaps_list_expression.h>
+#include <compiler/expression/simple_function_call.h>
+#include <compiler/expression/simple_variable.h>
+#include <compiler/statement/loop_statement.h>

 using namespace HPHP;

@@ -72,10 +71,6 @@ BinaryOpExpression::BinaryOpExpression
      cType = Collection::MapType;
    } else if (strcasecmp(s.c_str(), "stablemap") == 0) {
      cType = Collection::StableMapType;
-    } else if (strcasecmp(s.c_str(), "set") == 0) {
-      cType = Collection::SetType;
-    } else if (strcasecmp(s.c_str(), "pair") == 0) {
-      cType = Collection::PairType;
    }
    ExpressionListPtr el = static_pointer_cast<ExpressionList>(m_exp2);
    el->setCollectionType(cType);
@@ -166,19 +161,18 @@ bool BinaryOpExpression::isLogicalOrOperator() const {
 }

 ExpressionPtr BinaryOpExpression::unneededHelper() {
-  bool shortCircuit = isShortCircuitOperator();
-  if (!m_exp2->getContainedEffects() ||
-      (!shortCircuit && !m_exp1->getContainedEffects())) {
+  if (!isShortCircuitOperator() || !m_exp2->getContainedEffects()) {
    return Expression::unneededHelper();
  }

-  if (shortCircuit) {
-    m_exp2 = m_exp2->unneeded();
-    m_exp2->setExpectedType(Type::Boolean);
-  }
+  m_exp2 = m_exp2->unneeded();
+  m_exp2->setExpectedType(Type::Boolean);
  return static_pointer_cast<Expression>(shared_from_this());
 }

+///////////////////////////////////////////////////////////////////////////////
+// parser functions
+
 ///////////////////////////////////////////////////////////////////////////////
 // static analysis functions

@@ -191,7 +185,7 @@ int BinaryOpExpression::getLocalEffects() const {
  case T_DIV_EQUAL:
  case T_MOD_EQUAL: {
    Variant v2;
-    if (!m_exp2->getScalarValue(v2) || equal(v2, 0)) {
+    if (!m_exp2->getScalarValue(v2) || v2.equal(0)) {
      effect = CanThrow;
      m_canThrow = true;
    }
@@ -218,7 +212,7 @@ ExpressionPtr BinaryOpExpression::simplifyLogical(AnalysisResultConstPtr ar) {
  try {
    ExpressionPtr rep = foldConst(ar);
    if (rep) return replaceValue(rep);
-  } catch (const Exception& e) {
+  } catch (Exception e) {
  }
  return ExpressionPtr();
 }
@@ -290,7 +284,7 @@ ExpressionPtr BinaryOpExpression::simplifyArithmetic(
  Variant v2;
  if (m_exp1->getScalarValue(v1)) {
    if (v1.isInteger()) {
-      int64_t ival1 = v1.toInt64();
+      int64 ival1 = v1.toInt64();
      // 1 * $a => $a, 0 + $a => $a
      if ((ival1 == 1 && m_op == '*') || (ival1 == 0 && m_op == '+')) {
        TypePtr actType2 = m_exp2->getActualType();
@@ -323,7 +317,7 @@ ExpressionPtr BinaryOpExpression::simplifyArithmetic(
  }
  if (m_exp2->getScalarValue(v2)) {
    if (v2.isInteger()) {
-      int64_t ival2 = v2.toInt64();
+      int64 ival2 = v2.toInt64();
      // $a * 1 => $a, $a + 0 => $a
      if ((ival2 == 1 && m_op == '*') || (ival2 == 0 && m_op == '+')) {
        TypePtr actType1 = m_exp1->getActualType();
@@ -410,7 +404,7 @@ static ExpressionPtr makeIsNull(AnalysisResultConstPtr ar,

  SimpleFunctionCallPtr call
    (new SimpleFunctionCall(exp->getScope(), loc,
-                            "is_null", false, expList, ExpressionPtr()));
+                            "is_null", expList, ExpressionPtr()));

  call->setValid();
  call->setActualType(Type::Boolean);
@@ -426,21 +420,13 @@ static ExpressionPtr makeIsNull(AnalysisResultConstPtr ar,
  return result;
 }

-// foldConst() is callable from the parse phase as well as the analysis phase.
-// We take advantage of this during the parse phase to reduce very simple
-// expressions down to a single scalar and keep the parse tree smaller,
-// especially in cases of long chains of binary operators. However, we limit
-// the effectivness of this during parse to ensure that we eliminate only
-// very simple scalars that don't require analysis in later phases. For now,
-// that's just simply scalar values.
 ExpressionPtr BinaryOpExpression::foldConst(AnalysisResultConstPtr ar) {
  ExpressionPtr optExp;
  Variant v1;
  Variant v2;

  if (!m_exp2->getScalarValue(v2)) {
-    if ((ar->getPhase() != AnalysisResult::ParseAllFiles) &&
-        m_exp1->isScalar() && m_exp1->getScalarValue(v1)) {
+    if (m_exp1->isScalar() && m_exp1->getScalarValue(v1)) {
      switch (m_op) {
        case T_IS_IDENTICAL:
        case T_IS_NOT_IDENTICAL:
@@ -498,23 +484,17 @@ ExpressionPtr BinaryOpExpression::foldConst(AnalysisResultConstPtr ar) {
  if (m_exp1->isScalar()) {
    if (!m_exp1->getScalarValue(v1)) return ExpressionPtr();
    try {
-      ScalarExpressionPtr scalar1 =
-        dynamic_pointer_cast<ScalarExpression>(m_exp1);
-      ScalarExpressionPtr scalar2 =
-        dynamic_pointer_cast<ScalarExpression>(m_exp2);
-      // Some data, like the values of __CLASS__ and friends, are not available
-      // while we're still in the initial parse phase.
-      if (ar->getPhase() == AnalysisResult::ParseAllFiles) {
-        if ((scalar1 && scalar1->needsTranslation()) ||
-            (scalar2 && scalar2->needsTranslation())) {
-          return ExpressionPtr();
-        }
-      }
-      if (!Option::WholeProgram || !Option::ParseTimeOpts) {
+      if (hhvm &&
+          Option::OutputHHBC &&
+          (!Option::WholeProgram || !Option::ParseTimeOpts)) {
        // In the VM, don't optimize __CLASS__ if within a trait, since
        // __CLASS__ is not resolved yet.
        ClassScopeRawPtr clsScope = getOriginalClass();
        if (clsScope && clsScope->isTrait()) {
+          ScalarExpressionPtr scalar1 =
+            dynamic_pointer_cast<ScalarExpression>(m_exp1);
+          ScalarExpressionPtr scalar2 =
+            dynamic_pointer_cast<ScalarExpression>(m_exp2);
          if ((scalar1 && scalar1->getType() == T_CLASS_C) ||
              (scalar2 && scalar2->getType() == T_CLASS_C)) {
            return ExpressionPtr();
@@ -524,95 +504,68 @@ ExpressionPtr BinaryOpExpression::foldConst(AnalysisResultConstPtr ar) {
      Variant result;
      switch (m_op) {
        case T_LOGICAL_XOR:
-          result = static_cast<bool>(v1.toBoolean() ^ v2.toBoolean());
-          break;
+          result = logical_xor(v1, v2); break;
        case '|':
-          *result.asCell() = cellBitOr(*v1.asCell(), *v2.asCell());
-          break;
+          result = bitwise_or(v1, v2); break;
        case '&':
-          *result.asCell() = cellBitAnd(*v1.asCell(), *v2.asCell());
-          break;
+          result = bitwise_and(v1, v2); break;
        case '^':
-          *result.asCell() = cellBitXor(*v1.asCell(), *v2.asCell());
-          break;
+          result = bitwise_xor(v1, v2); break;
        case '.':
-          result = concat(v1.toString(), v2.toString());
-          break;
+          result = concat(v1, v2); break;
        case T_IS_IDENTICAL:
-          result = same(v1, v2);
-          break;
+          result = same(v1, v2); break;
        case T_IS_NOT_IDENTICAL:
-          result = !same(v1, v2);
-          break;
+          result = !same(v1, v2); break;
        case T_IS_EQUAL:
-          result = equal(v1, v2);
-          break;
+          result = equal(v1, v2); break;
        case T_IS_NOT_EQUAL:
-          result = !equal(v1, v2);
-          break;
+          result = !equal(v1, v2); break;
        case '<':
-          result = less(v1, v2);
-          break;
+          result = less(v1, v2); break;
        case T_IS_SMALLER_OR_EQUAL:
-          result = cellLessOrEqual(*v1.asCell(), *v2.asCell());
-          break;
+          result = not_more(v1, v2); break;
        case '>':
-          result = more(v1, v2);
-          break;
+          result = more(v1, v2); break;
        case T_IS_GREATER_OR_EQUAL:
-          result = cellGreaterOrEqual(*v1.asCell(), *v2.asCell());
-          break;
+          result = not_less(v1, v2); break;
        case '+':
-          *result.asCell() = cellAdd(*v1.asCell(), *v2.asCell());
-          break;
+          result = plus(v1, v2); break;
        case '-':
-          *result.asCell() = cellSub(*v1.asCell(), *v2.asCell());
-          break;
+          result = minus(v1, v2); break;
        case '*':
-          *result.asCell() = cellMul(*v1.asCell(), *v2.asCell());
-          break;
+          result = multiply(v1, v2); break;
        case '/':
          if ((v2.isIntVal() && v2.toInt64() == 0) || v2.toDouble() == 0.0) {
            return ExpressionPtr();
          }
-          *result.asCell() = cellDiv(*v1.asCell(), *v2.asCell());
-          break;
+          result = divide(v1, v2); break;
        case '%':
          if ((v2.isIntVal() && v2.toInt64() == 0) || v2.toDouble() == 0.0) {
            return ExpressionPtr();
          }
-          *result.asCell() = cellMod(*v1.asCell(), *v2.asCell());
-          break;
+          result = modulo(v1, v2); break;
        case T_SL:
-          result = v1.toInt64() << v2.toInt64();
-          break;
+          result = shift_left(v1, v2); break;
        case T_SR:
-          result = v1.toInt64() >> v2.toInt64();
-          break;
+          result = shift_right(v1, v2); break;
        case T_BOOLEAN_OR:
-          result = v1.toBoolean() || v2.toBoolean(); break;
+          result = v1 || v2; break;
        case T_BOOLEAN_AND:
-          result = v1.toBoolean() && v2.toBoolean(); break;
+          result = v1 && v2; break;
        case T_LOGICAL_OR:
-          result = v1.toBoolean() || v2.toBoolean(); break;
+          result = v1 || v2; break;
        case T_LOGICAL_AND:
-          result = v1.toBoolean() && v2.toBoolean(); break;
-        case T_INSTANCEOF: {
-          if (v1.isArray() && v2.isString() &&
-              interface_supports_array(v2.getStringData())) {
-            result = true;
-            break;
-          }
-          result = false;
-          break;
-        }
+          result = v1 && v2; break;
+        case T_INSTANCEOF:
+          result = false; break;
        default:
          return ExpressionPtr();
      }
      return makeScalarExpression(ar, result);
    } catch (...) {
    }
-  } else if (ar->getPhase() != AnalysisResult::ParseAllFiles) {
+  } else {
    switch (m_op) {
      case T_LOGICAL_AND:
      case T_BOOLEAN_AND:
@@ -955,6 +908,284 @@ void BinaryOpExpression::outputPHP(CodeGenerator &cg, AnalysisResultPtr ar) {
  m_exp2->outputPHP(cg, ar);
 }

+static bool castIfNeeded(TypePtr top, TypePtr arg,
+                         CodeGenerator &cg, AnalysisResultPtr ar,
+                         BlockScopeRawPtr scope) {
+  if (top) {
+    if (top->isPrimitive()) {
+      if (!arg || !arg->isPrimitive()) {
+        top->outputCPPCast(cg, ar, scope);
+        cg_printf("(");
+        return true;
+      }
+    } else if (top->is(Type::KindOfArray)) {
+      if (arg && arg->isExactType() && !arg->is(Type::KindOfArray)) {
+        cg_printf("((Variant)");
+        return true;
+      }
+    } else if (top->mustBe(Type::KindOfNumeric)) {
+      if (arg && arg->is(Type::KindOfArray)) {
+        cg_printf("((Variant)");
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+void BinaryOpExpression::preOutputStash(CodeGenerator &cg, AnalysisResultPtr ar,
+                                        int state) {
+  if (hasCPPTemp() || isScalar()) return;
+  if (m_op == '.' && (state & FixOrder)) {
+    if (m_exp1) {
+      if (!m_exp1->getActualType() && m_exp1->hasCPPTemp()) {
+        cg_printf("id(%s);\n", m_exp1->cppTemp().c_str());
+      }
+      m_exp1->preOutputStash(cg, ar, state|StashVars);
+    }
+    if (m_exp2) {
+      if (!m_exp2->getActualType() && m_exp2->hasCPPTemp()) {
+        cg_printf("id(%s);\n", m_exp2->cppTemp().c_str());
+      }
+      m_exp2->preOutputStash(cg, ar, state|StashVars);
+    }
+  } else {
+    Expression::preOutputStash(cg, ar, state);
+  }
+}
+
+static const char *stringBufferPrefix(CodeGenerator &cg, AnalysisResultPtr ar,
+                                      ExpressionPtr var) {
+  if (var->is(Expression::KindOfSimpleVariable)) {
+    if (LoopStatementPtr loop = cg.getLoopStatement()) {
+      SimpleVariablePtr sv = static_pointer_cast<SimpleVariable>(var);
+      if (loop->checkStringBuf(sv->getName())) {
+        return loop->getScope()->getVariables()->
+          getVariablePrefix(sv->getName());
+      }
+    }
+  }
+  return 0;
+}
+
+static std::string stringBufferName(const char *temp, const char *prefix,
+                                    const char *name)
+{
+  return std::string(temp) + "_sbuf_" + prefix + name;
+}
+
+int BinaryOpExpression::getConcatList(ExpressionPtrVec &ev, ExpressionPtr exp,
+                                      bool &hasVoid) {
+  if (!exp->hasCPPTemp()) {
+    if (exp->is(Expression::KindOfUnaryOpExpression)) {
+      UnaryOpExpressionPtr u = static_pointer_cast<UnaryOpExpression>(exp);
+      if (u->getOp() == '(') {
+        return getConcatList(ev, u->getExpression(), hasVoid);
+      }
+    } else if (exp->is(Expression::KindOfBinaryOpExpression)) {
+      BinaryOpExpressionPtr b = static_pointer_cast<BinaryOpExpression>(exp);
+      if (b->getOp() == '.') {
+        if (b->getExp1()->is(Expression::KindOfSimpleVariable) &&
+            b->getExp1()->isLocalExprAltered() &&
+            !b->getExp1()->hasCPPTemp() &&
+            b->getExp2()->hasEffect() &&
+            !b->getExp2()->hasCPPTemp()) {
+          /*
+            In this case, the simple variable must be evaluated
+            after b->getExp2(). But when we output a concat list we
+            explicitly order the expressions from left to right.
+          */
+        } else {
+          return getConcatList(ev, b->getExp1(), hasVoid) +
+            getConcatList(ev, b->getExp2(), hasVoid);
+        }
+      }
+    } else if (exp->is(Expression::KindOfEncapsListExpression)) {
+      EncapsListExpressionPtr e =
+        static_pointer_cast<EncapsListExpression>(exp);
+      if (e->getType() != '`') {
+        ExpressionListPtr el = e->getExpressions();
+        int num = 0;
+        for (int i = 0, s = el->getCount(); i < s; i++) {
+          ExpressionPtr exp = (*el)[i];
+          num += getConcatList(ev, exp, hasVoid);
+        }
+        return num;
+      }
+    }
+  } else if (!exp->getActualType()) {
+    return 0;
+  }
+
+  ev.push_back(exp);
+  bool isVoid = !exp->getActualType();
+  hasVoid |= isVoid;
+  return isVoid ? 0 : 1;
+}
+
+static void outputStringExpr(CodeGenerator &cg, AnalysisResultPtr ar,
+                             ExpressionPtr exp, bool asLitStr) {
+  if (asLitStr && exp->isLiteralString()) {
+    const std::string &s = exp->getLiteralString();
+    std::string enc = string_cplus_escape(s.c_str(), s.size());
+    cg_printf("\"%s\", %d", enc.c_str(), (int)s.size());
+    return;
+  }
+
+  TypePtr et(exp->getExpectedType());
+  exp->setExpectedType(Type::String);
+  exp->outputCPP(cg, ar);
+  exp->setExpectedType(et);
+}
+
+static void outputStringBufExprs(ExpressionPtrVec &ev,
+                                 CodeGenerator &cg, AnalysisResultPtr ar) {
+  for (size_t i = 0; i < ev.size(); i++) {
+    ExpressionPtr exp = ev[i];
+    cg_printf(".addWithTaint(");
+    outputStringExpr(cg, ar, exp, true);
+    cg_printf(")");
+  }
+}
+
+bool BinaryOpExpression::preOutputCPP(CodeGenerator &cg, AnalysisResultPtr ar,
+                                      int state) {
+  if (isOpEqual() && (m_exp1->is(KindOfArrayElementExpression) ||
+                      m_exp1->is(KindOfObjectPropertyExpression))) {
+    return Expression::preOutputCPP(cg, ar, state);
+  }
+
+  bool effect2 = m_exp2->hasEffect();
+  const char *prefix = 0;
+  if (effect2 || m_exp1->hasEffect()) {
+    ExpressionPtr self = static_pointer_cast<Expression>(shared_from_this());
+    ExpressionPtrVec ev;
+    bool hasVoid = false;
+    int numConcat = 0;
+    bool ok = false;
+    if (m_op == '.') {
+      numConcat = getConcatList(ev, self, hasVoid);
+      ok = hasVoid || (numConcat > MAX_CONCAT_ARGS);
+    } else if (effect2 && m_op == T_CONCAT_EQUAL) {
+      prefix = stringBufferPrefix(cg, ar, m_exp1);
+      ok = prefix;
+      if (!ok) {
+        if (m_exp1->is(KindOfSimpleVariable)) {
+          ok = true;
+          ev.push_back(m_exp1);
+          numConcat++;
+        }
+      }
+      if (ok) {
+        numConcat += getConcatList(ev, m_exp2, hasVoid);
+        if (numConcat <= 2 && !prefix) {
+          return Expression::preOutputCPP(cg, ar, state);
+        }
+      }
+    }
+    if (ok) {
+      if (!cg.inExpression()) return true;
+
+      cg.wrapExpressionBegin();
+      std::string buf;
+      if (prefix) {
+        SimpleVariablePtr sv(static_pointer_cast<SimpleVariable>(m_exp1));
+        buf = stringBufferName(Option::TempPrefix, prefix,
+                               sv->getName().c_str());
+        m_cppTemp = "/**/";
+      } else if (numConcat) {
+        buf = m_cppTemp = genCPPTemp(cg, ar);
+        buf += "_buf";
+        if (numConcat > 1) {
+          cg_printf("StringBuffer %s;\n", buf.c_str());
+        }
+      } else {
+        m_cppTemp = "\"\"";
+      }
+
+      for (size_t i = 0; i < ev.size(); i++) {
+        ExpressionPtr exp = ev[i];
+        bool is_void = !exp->getActualType();
+        exp->preOutputCPP(cg, ar, 0);
+        if (!is_void) {
+          bool asLit = true;
+          if (numConcat > 1 || prefix) {
+            cg_printf("%s.appendWithTaint(", buf.c_str());
+          } else {
+            asLit = false;
+            cg_printf("CStrRef %s = (", m_cppTemp.c_str());
+          }
+          outputStringExpr(cg, ar, exp, asLit);
+          cg_printf(")");
+        } else {
+          exp->outputCPPUnneeded(cg, ar);
+        }
+        cg_printf(";\n");
+      }
+
+      if (numConcat > 1 && !prefix) {
+        cg_printf("CStrRef %s(%s.detachWithTaint());\n",
+                  m_cppTemp.c_str(), buf.c_str());
+        if (m_op == T_CONCAT_EQUAL) {
+          m_exp1->outputCPP(cg, ar);
+          cg_printf(" = %s;\n", m_cppTemp.c_str());
+        }
+      }
+      return true;
+    }
+  }
+
+  if (!isShortCircuitOperator()) {
+    return Expression::preOutputCPP(cg, ar, state);
+  }
+
+  if (!effect2) {
+    bool ret = m_exp1->preOutputCPP(cg, ar, 0);
+    if (state & FixOrder) {
+      ret = true;
+      if (cg.inExpression()) {
+        preOutputStash(cg, ar, state);
+      }
+    }
+    return ret;
+  }
+
+  bool fix_e1 = m_exp1->preOutputCPP(cg, ar, 0);
+  if (!cg.inExpression()) {
+    return fix_e1 || m_exp2->preOutputCPP(cg, ar, 0);
+  }
+
+  cg.setInExpression(false);
+  bool fix_e2 = m_exp2->preOutputCPP(cg, ar, 0);
+  cg.setInExpression(true);
+
+  if (fix_e2) {
+    cg.wrapExpressionBegin();
+    std::string tmp = genCPPTemp(cg, ar);
+    cg_printf("bool %s = (", tmp.c_str());
+    m_exp1->outputCPP(cg, ar);
+    cg_printf(");\n");
+    cg_indentBegin("if (%s%s) {\n",
+                   m_op == T_LOGICAL_OR || m_op == T_BOOLEAN_OR ? "!" : "",
+                   tmp.c_str());
+    m_exp2->preOutputCPP(cg, ar, 0);
+    if (isUnused()) {
+      if (m_exp2->outputCPPUnneeded(cg, ar)) cg_printf(";\n");
+    } else {
+      cg_printf("%s = (", tmp.c_str());
+      m_exp2->outputCPP(cg, ar);
+      cg_printf(");\n");
+    }
+    cg_indentEnd("}\n");
+    m_cppTemp = tmp;
+  } else if (state & FixOrder) {
+    preOutputStash(cg, ar, state);
+    fix_e1 = true;
+  }
+  return fix_e1 || fix_e2;
+}
+
 bool BinaryOpExpression::isOpEqual() {
  switch (m_op) {
  case T_CONCAT_EQUAL:
@@ -975,3 +1206,291 @@ bool BinaryOpExpression::isOpEqual() {
  return false;
 }

+bool BinaryOpExpression::outputCPPImplOpEqual(CodeGenerator &cg,
+                                              AnalysisResultPtr ar) {
+  if (m_exp1->is(Expression::KindOfArrayElementExpression)) {
+    ArrayElementExpressionPtr exp =
+      dynamic_pointer_cast<ArrayElementExpression>(m_exp1);
+    if (exp->isSuperGlobal() || exp->isDynamicGlobal()) return false;
+    if (TypePtr t = exp->getVariable()->getActualType()) {
+      TypePtr it(exp->getVariable()->getImplementedType());
+      if (t->is(Type::KindOfArray) &&
+          (!it ||
+           it->is(Type::KindOfArray) ||
+           Type::IsMappedToVariant(it) /* fast cast will kick in */)) {
+        return false;
+      }
+    }
+    // turning $a['elem'] Op= $b into $a.setOpEqual('elem', $b);
+    exp->getVariable()->outputCPP(cg, ar);
+    if (exp->getOffset()) {
+      cg_printf(".setOpEqual(%d, ", m_op);
+      exp->getOffset()->outputCPP(cg, ar);
+      cg_printf(", (");
+    } else {
+      cg_printf(".appendOpEqual(%d, (", m_op);
+    }
+    m_exp2->outputCPP(cg, ar);
+    cg_printf(")");
+    ExpressionPtr off = exp->getOffset();
+    if (off) {
+      ScalarExpressionPtr sc = dynamic_pointer_cast<ScalarExpression>(off);
+      if (sc) {
+        if (sc->isLiteralString()) {
+          String s(sc->getLiteralString());
+          int64 n;
+          if (!s.get()->isStrictlyInteger(n)) {
+            cg_printf(", true"); // skip toKey() at run time
+          }
+        }
+      }
+    }
+    cg_printf(")");
+
+    return true;
+  }
+  if (m_exp1->is(Expression::KindOfObjectPropertyExpression)) {
+    ObjectPropertyExpressionPtr var(
+      dynamic_pointer_cast<ObjectPropertyExpression>(m_exp1));
+    if (var->isValid()) return false;
+    var->outputCPPObject(cg, ar);
+    cg_printf("o_assign_op<%s,%d>(",
+              isUnused() ? "void" : "Variant", m_op);
+    var->outputCPPProperty(cg, ar);
+    cg_printf(", ");
+    m_exp2->outputCPP(cg, ar);
+    cg_printf("%s)", originalClassName(cg, true).c_str());
+    return true;
+  }
+
+  return false;
+}
+
+void BinaryOpExpression::outputCPPImpl(CodeGenerator &cg,
+                                       AnalysisResultPtr ar) {
+
+  if (isOpEqual() && outputCPPImplOpEqual(cg, ar)) return;
+
+  bool wrapped = true;
+  switch (m_op) {
+  case T_CONCAT_EQUAL:
+    if (const char *prefix = stringBufferPrefix(cg, ar, m_exp1)) {
+      SimpleVariablePtr sv = static_pointer_cast<SimpleVariable>(m_exp1);
+      if (m_exp2->hasCPPTemp()) {
+        cg_printf("%s.appendWithTaint(%s)",
+                  stringBufferName(Option::TempPrefix, prefix,
+                                   sv->getName().c_str()).c_str(),
+                  m_exp2->cppTemp().c_str());
+        return;
+      } else {
+        ExpressionPtrVec ev;
+        bool hasVoid = false;
+        getConcatList(ev, m_exp2, hasVoid);
+        if (!hasVoid) {
+          cg_printf("%s", stringBufferName(Option::TempPrefix, prefix,
+                                           sv->getName().c_str()).c_str());
+          outputStringBufExprs(ev, cg, ar);
+          return;
+        }
+      }
+    }
+    cg_printf("concat_assign");
+    break;
+  case '.':
+    {
+      ExpressionPtr self = static_pointer_cast<Expression>(shared_from_this());
+      ExpressionPtrVec ev;
+      bool hasVoid = false;
+      int num = getConcatList(ev, self, hasVoid);
+      if (num < 2) {
+        cg_printf("concat");
+        break;
+      }
+      always_assert(!hasVoid);
+      if (num <= MAX_CONCAT_ARGS) {
+        if (num == 2) {
+          cg_printf("concat(");
+        } else {
+          if (num > MAX_CONCAT_ARGS) ar->m_concatLengths.insert(num);
+          cg_printf("concat%d(", num);
+        }
+        for (size_t i = 0; i < ev.size(); i++) {
+          ExpressionPtr exp = ev[i];
+          if (i) cg_printf(", ");
+          outputStringExpr(cg, ar, exp, false);
+        }
+        cg_printf(")");
+      } else {
+        cg_printf("StringBuffer()");
+        outputStringBufExprs(ev, cg, ar);
+        cg_printf(".detachWithTaint()");
+      }
+    }
+    return;
+  case T_LOGICAL_XOR:         cg_printf("logical_xor");   break;
+  case '|':                   cg_printf("bitwise_or");    break;
+  case '&':                   cg_printf("bitwise_and");   break;
+  case '^':                   cg_printf("bitwise_xor");   break;
+  case T_IS_IDENTICAL:        cg_printf("same");          break;
+  case T_IS_NOT_IDENTICAL:    cg_printf("!same");         break;
+  case T_IS_EQUAL:            cg_printf("equal");         break;
+  case T_IS_NOT_EQUAL:        cg_printf("!equal");        break;
+  case '<':                   cg_printf("less");          break;
+  case T_IS_SMALLER_OR_EQUAL: cg_printf("not_more");      break;
+  case '>':                   cg_printf("more");          break;
+  case T_IS_GREATER_OR_EQUAL: cg_printf("not_less");      break;
+  case '/':                   cg_printf("divide");        break;
+  case '%':                   cg_printf("modulo");        break;
+  case T_INSTANCEOF:          cg_printf("instanceOf");    break;
+  case T_COLLECTION:          cg_printf("Object");        break;
+  default:
+    wrapped = !isUnused();
+    break;
+  }
+
+  if (wrapped) cg_printf("(");
+
+  ExpressionPtr first = m_exp1;
+  ExpressionPtr second = m_exp2;
+
+  // we could implement these functions natively on String and Array classes
+  switch (m_op) {
+  case '+':
+  case '-':
+  case '*':
+  case '/':
+    if (!first->outputCPPArithArg(cg, ar, m_op == '+')) {
+      TypePtr argType = first->hasCPPTemp() ?
+        first->getType() : first->getActualType();
+      bool flag = castIfNeeded(getActualType(), argType, cg, ar, getScope());
+      first->outputCPP(cg, ar);
+      if (flag) {
+        cg_printf(")");
+      }
+    }
+    break;
+  case T_SL:
+  case T_SR:
+    assert(first->getType()->is(Type::KindOfInt64));
+    first->outputCPP(cg, ar);
+    break;
+  case T_COLLECTION:
+    /* do nothing */
+    break;
+  default:
+    first->outputCPP(cg, ar);
+    break;
+  }
+
+  switch (m_op) {
+  case T_PLUS_EQUAL:          cg_printf(" += ");   break;
+  case T_MINUS_EQUAL:         cg_printf(" -= ");   break;
+  case T_MUL_EQUAL:           cg_printf(" *= ");   break;
+  case T_DIV_EQUAL:           cg_printf(" /= ");   break;
+  case T_MOD_EQUAL:           cg_printf(" %%= ");  break;
+  case T_AND_EQUAL:           cg_printf(" &= ");   break;
+  case T_OR_EQUAL:            cg_printf(" |= ");   break;
+  case T_XOR_EQUAL:           cg_printf(" ^= ");   break;
+  case T_SL_EQUAL:            cg_printf(" <<= ");  break;
+  case T_SR_EQUAL:            cg_printf(" >>= ");  break;
+  case T_BOOLEAN_OR:          cg_printf(" || ");   break;
+  case T_BOOLEAN_AND:         cg_printf(" && ");   break;
+  case T_LOGICAL_OR:          cg_printf(" || ");   break;
+  case T_LOGICAL_AND:         cg_printf(" && ");   break;
+  case T_COLLECTION:          /* print nothing */  break;
+  default:
+    switch (m_op) {
+    case '+':                   cg_printf(" + ");    break;
+    case '-':                   cg_printf(" - ");    break;
+    case '*':                   cg_printf(" * ");    break;
+    case T_SL:                  cg_printf(" << ");   break;
+    case T_SR:                  cg_printf(" >> ");   break;
+    default:
+      cg_printf(", ");
+      break;
+    }
+    break;
+  }
+
+  switch (m_op) {
+  case '+':
+  case '-':
+  case '*':
+  case '/':
+    if (!second->outputCPPArithArg(cg, ar, m_op == '+')) {
+      TypePtr argType = second->hasCPPTemp() ?
+        second->getType() : second->getActualType();
+      bool flag = castIfNeeded(getActualType(), argType, cg, ar, getScope());
+      second->outputCPP(cg, ar);
+      if (flag) {
+        cg_printf(")");
+      }
+    }
+    break;
+  case T_INSTANCEOF:
+    {
+      if (second->isScalar()) {
+        ScalarExpressionPtr scalar =
+          dynamic_pointer_cast<ScalarExpression>(second);
+        bool notQuoted = scalar && !scalar->isQuoted();
+        std::string s = second->getLiteralString();
+        if (s == "static" && notQuoted) {
+          cg_printf("FrameInjection::GetStaticClassName(fi.getThreadInfo())");
+        } else if (s != "") {
+          if (s == "self" && notQuoted) {
+            ClassScopeRawPtr cls = getOriginalClass();
+            if (cls) {
+              s = cls->getOriginalName();
+            }
+          } else if (s == "parent" && notQuoted) {
+            ClassScopeRawPtr cls = getOriginalClass();
+            if (cls && !cls->getOriginalParent().empty()) {
+              s = cls->getOriginalParent();
+            }
+          }
+          cg_printString(s, ar, shared_from_this());
+        } else {
+          second->outputCPP(cg, ar);
+        }
+      } else {
+        second->outputCPP(cg, ar);
+      }
+      break;
+    }
+  case T_PLUS_EQUAL:
+  case T_MINUS_EQUAL:
+  case T_MUL_EQUAL:
+    {
+      TypePtr t1 = first->getCPPType();
+      TypePtr t2 = second->getType();
+      if (t1 && !t1->is(Type::KindOfArray) &&
+          t2 && Type::IsCastNeeded(ar, t2, t1)) {
+        t1->outputCPPCast(cg, ar, getScope());
+        cg_printf("(");
+        second->outputCPP(cg, ar);
+        cg_printf(")");
+      } else {
+        second->outputCPP(cg, ar);
+      }
+      break;
+    }
+  case T_BOOLEAN_OR:
+  case T_BOOLEAN_AND:
+  case T_LOGICAL_AND:
+  case T_LOGICAL_OR:
+    if (isUnused()) {
+      cg_printf("(");
+      if (second->outputCPPUnneeded(cg, ar)) {
+        cg_printf(",");
+      }
+      cg_printf("false)");
+    } else {
+      second->outputCPP(cg, ar);
+    }
+    break;
+  default:
+    second->outputCPP(cg, ar);
+  }
+
+  if (wrapped) cg_printf(")");
+}
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,10 +14,10 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_BINARY_OP_EXPRESSION_H_
-#define incl_HPHP_BINARY_OP_EXPRESSION_H_
+#ifndef __BINARY_OP_EXPRESSION_H__
+#define __BINARY_OP_EXPRESSION_H__

-#include "hphp/compiler/expression/expression_list.h"
+#include <compiler/expression/expression_list.h>

 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////
@@ -41,7 +41,6 @@ public:
  virtual bool isRefable(bool checkError = false) const;
  bool isShortCircuitOperator() const;
  bool isLogicalOrOperator() const;
-  ExpressionPtr getStoreVariable() const { return m_exp1;}
  ExpressionPtr getExp1() { return m_exp1;}
  ExpressionPtr getExp2() { return m_exp2;}
  int getOp() const { return m_op;}
@@ -52,6 +51,13 @@ public:
  virtual ExpressionPtr unneededHelper();
  virtual bool canonCompare(ExpressionPtr e) const;

+  void preOutputStash(CodeGenerator &cg, AnalysisResultPtr ar,
+                      int state);
+  bool preOutputCPP(CodeGenerator &cg, AnalysisResultPtr ar,
+                    int state);
+
+  bool outputCPPImplOpEqual(CodeGenerator &cg, AnalysisResultPtr ar);
+
  static int getConcatList(ExpressionPtrVec &ev, ExpressionPtr exp,
                           bool &hasVoid);
  bool isAssignmentOp() const { return m_assign; }
@@ -71,4 +77,4 @@ private:
 ///////////////////////////////////////////////////////////////////////////////
 }

-#endif // incl_HPHP_BINARY_OP_EXPRESSION_H_
+#endif // __BINARY_OP_EXPRESSION_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,17 +14,17 @@
   +----------------------------------------------------------------------+
 */

-#include "hphp/compiler/expression/class_constant_expression.h"
-#include "hphp/compiler/analysis/class_scope.h"
-#include "hphp/compiler/analysis/file_scope.h"
-#include "hphp/compiler/analysis/constant_table.h"
-#include "hphp/compiler/analysis/code_error.h"
-#include "hphp/util/hash.h"
-#include "hphp/util/util.h"
-#include "hphp/compiler/option.h"
-#include "hphp/compiler/analysis/variable_table.h"
-#include "hphp/compiler/expression/scalar_expression.h"
-#include "hphp/compiler/expression/constant_expression.h"
+#include <compiler/expression/class_constant_expression.h>
+#include <compiler/analysis/class_scope.h>
+#include <compiler/analysis/file_scope.h>
+#include <compiler/analysis/constant_table.h>
+#include <compiler/analysis/code_error.h>
+#include <util/hash.h>
+#include <util/util.h>
+#include <compiler/option.h>
+#include <compiler/analysis/variable_table.h>
+#include <compiler/expression/scalar_expression.h>
+#include <compiler/expression/constant_expression.h>

 using namespace HPHP;

@@ -144,21 +144,11 @@ ExpressionPtr ClassConstantExpression::preOptimize(AnalysisResultConstPtr ar) {
    ExpressionPtr value = dynamic_pointer_cast<Expression>(decl);
    BlockScope::s_constMutex.unlock();

-    if (!value->isScalar() &&
-        (value->is(KindOfClassConstantExpression) ||
-         value->is(KindOfConstantExpression))) {
-      std::set<ExpressionPtr> seen;
-      do {
-        if (!seen.insert(value).second) return ExpressionPtr();
-        value = value->preOptimize(ar);
-        if (!value) return ExpressionPtr();
-      } while (!value->isScalar() &&
-               (value->is(KindOfClassConstantExpression) ||
-                value->is(KindOfConstantExpression)));
-    }
-
    ExpressionPtr rep = Clone(value, getScope());
+    bool annotate = Option::FlAnnotate;
+    Option::FlAnnotate = false; // avoid nested comments on getText
    rep->setComment(getText());
+    Option::FlAnnotate = annotate;
    rep->setLocation(getLocation());
    return replaceValue(rep);
  }
@@ -209,7 +199,7 @@ TypePtr ClassConstantExpression::inferTypes(AnalysisResultPtr ar,
 }

 unsigned ClassConstantExpression::getCanonHash() const {
-  int64_t val =
+  int64 val =
    hash_string(Util::toLower(m_varName).c_str(), m_varName.size()) -
    hash_string(Util::toLower(m_className).c_str(), m_className.size());
  return ~unsigned(val) ^ unsigned(val >> 32);
@@ -235,3 +225,79 @@ bool ClassConstantExpression::isDynamic() const {
  if (!m_valid) return true;
  return m_defScope->getConstants()->isDynamic(m_varName);
 }
+
+void ClassConstantExpression::outputCPPImpl(CodeGenerator &cg,
+                                            AnalysisResultPtr ar) {
+  if (m_class) {
+    cg_printf("get_class_constant(");
+    if (m_class->is(KindOfScalarExpression)) {
+      assert(strcasecmp(dynamic_pointer_cast<ScalarExpression>(m_class)->
+                        getString().c_str(), "static") == 0);
+      cg_printf("FrameInjection::GetStaticClassName(fi.getThreadInfo())");
+    } else {
+      cg_printf("get_static_class_name(");
+      m_class->outputCPP(cg, ar);
+      cg_printf(")");
+    }
+    cg_printf(", \"%s\")", m_varName.c_str());
+    return;
+  }
+
+  bool outsideClass = !isPresent();
+  if (m_valid) {
+    string trueClassName;
+
+    assert(m_defScope);
+    ClassScope *cls = dynamic_cast<ClassScope*>(m_defScope);
+    trueClassName = cls->getName();
+    assert(!trueClassName.empty());
+    if (outsideClass) {
+      cls->outputVolatileCheckBegin(cg, ar, getScope(), m_origClassName);
+    }
+    if (cls->getConstants()->isDynamic(m_varName)) {
+      cg_printf("%s%s->lazy_initializer(%s)->",
+                Option::ClassStaticsCallbackPrefix, cls->getId().c_str(),
+                cg.getGlobals(ar));
+      if (cg.isFileOrClassHeader()) {
+        if (getClassScope()) {
+          getClassScope()->addUsedClassFullHeader(ClassScopeRawPtr(cls));
+        } else {
+          getFileScope()->addUsedClassFullHeader(ClassScopeRawPtr(cls));
+        }
+      }
+    } else if (cg.isFileOrClassHeader()) {
+      if (getClassScope()) {
+        getClassScope()->addUsedClassConstHeader(ClassScopeRawPtr(cls),
+                                                 m_varName);
+      } else {
+        getFileScope()->addUsedClassConstHeader(ClassScopeRawPtr(cls),
+                                                m_varName);
+      }
+    }
+    cg_printf("%s%s%s%s",
+              Option::ClassConstantPrefix, cls->getId().c_str(),
+              Option::IdPrefix.c_str(), m_varName.c_str());
+    if (outsideClass) {
+      cls->outputVolatileCheckEnd(cg);
+    }
+  } else if (isRedeclared()) {
+    if (outsideClass) {
+      ClassScope::OutputVolatileCheckBegin(cg, ar, getScope(), m_origClassName);
+    }
+    const string &clsName = CodeGenerator::FormatLabel(m_className);
+    cg_printf("%s->%s%s->os_constant(\"%s\")", cg.getGlobals(ar),
+              Option::ClassStaticsCallbackPrefix,
+              clsName.c_str(), m_varName.c_str());
+    if (outsideClass) {
+      ClassScope::OutputVolatileCheckEnd(cg);
+    }
+  } else if (m_defScope) { // !m_valid && m_defScope -> derives from redeclaring
+    cg_printf("%s%s->os_constant(\"%s\")",
+              Option::ClassStaticsCallbackPrefix, m_defScope->getId().c_str(),
+              m_varName.c_str());
+  } else {
+    cg_printf("throw_fatal(\"unknown class constant %s::%s\")",
+              CodeGenerator::EscapeLabel(m_className).c_str(),
+              m_varName.c_str());
+  }
+}
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,11 +14,11 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_CLASS_CONSTANT_EXPRESSION_H_
-#define incl_HPHP_CLASS_CONSTANT_EXPRESSION_H_
+#ifndef __CLASS_CONSTANT_EXPRESSION_H__
+#define __CLASS_CONSTANT_EXPRESSION_H__

-#include "hphp/compiler/expression/static_class_name.h"
-#include "hphp/compiler/analysis/block_scope.h"
+#include <compiler/expression/static_class_name.h>
+#include <compiler/analysis/block_scope.h>

 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////
@@ -55,4 +55,4 @@ private:

 ///////////////////////////////////////////////////////////////////////////////
 }
-#endif // incl_HPHP_CLASS_CONSTANT_EXPRESSION_H_
+#endif // __CLASS_CONSTANT_EXPRESSION_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,15 +14,14 @@
   +----------------------------------------------------------------------+
 */

-#include "hphp/compiler/expression/closure_expression.h"
-#include "hphp/compiler/expression/parameter_expression.h"
-#include "hphp/compiler/expression/expression_list.h"
-#include "hphp/compiler/expression/simple_variable.h"
-#include "hphp/compiler/statement/function_statement.h"
-#include "hphp/compiler/statement/static_statement.h"
-#include "hphp/compiler/analysis/variable_table.h"
-#include "hphp/compiler/analysis/function_scope.h"
-#include "hphp/compiler/analysis/file_scope.h"
+#include <compiler/expression/closure_expression.h>
+#include <compiler/expression/parameter_expression.h>
+#include <compiler/expression/expression_list.h>
+#include <compiler/expression/simple_variable.h>
+#include <compiler/statement/function_statement.h>
+#include <compiler/analysis/variable_table.h>
+#include <compiler/analysis/function_scope.h>
+#include <compiler/analysis/file_scope.h>

 using namespace HPHP;

@@ -43,29 +42,10 @@ ClosureExpression::ClosureExpression
      (new ExpressionList(vars->getScope(), vars->getLocation()));
    // push the vars in reverse order, not retaining duplicates
    std::set<string> seenBefore;
-
-    // Because PHP is insane you can have a use variable with the same
-    // name as a param name.
-    // In that case, params win (which is different than zend but much easier)
-    ExpressionListPtr bodyParams = m_func->getParams();
-    if (bodyParams) {
-      int nParams = bodyParams->getCount();
-      for (int i = 0; i < nParams; i++) {
-        ParameterExpressionPtr par(
-          static_pointer_cast<ParameterExpression>((*bodyParams)[i]));
-        seenBefore.insert(par->getName());
-      }
-    }
-
    for (int i = vars->getCount() - 1; i >= 0; i--) {
      ParameterExpressionPtr param(
        dynamic_pointer_cast<ParameterExpression>((*vars)[i]));
      assert(param);
-      if (param->getName() == "this") {
-        // "this" is automatically included.
-        // Once we get rid of all the callsites, make this an error
-        continue;
-      }
      if (seenBefore.find(param->getName().c_str()) == seenBefore.end()) {
        seenBefore.insert(param->getName().c_str());
        m_vars->insertElement(param);
@@ -171,6 +151,9 @@ void ClosureExpression::analyzeProgram(AnalysisResultPtr ar) {
      return;
    }
    if (ar->getPhase() == AnalysisResult::AnalyzeFinal) {
+      if (m_func->getFileScope() != getFileScope()) {
+        getFileScope()->addUsedClosure(m_func->getFunctionScope());
+      }
      // closure function's variable table (not containing function's)
      VariableTablePtr variables = m_func->getFunctionScope()->getVariables();
      for (int i = 0; i < m_vars->getCount(); i++) {
@@ -186,13 +169,6 @@ void ClosureExpression::analyzeProgram(AnalysisResultPtr ar) {
      }
    }
  }
-
-  FunctionScopeRawPtr container = 
-    getFunctionScope()->getContainingNonClosureFunction();
-  if (container && container->isStatic()) {
-    m_func->getModifiers()->add(T_STATIC);
-  }
-
 }

 TypePtr ClosureExpression::inferTypes(AnalysisResultPtr ar, TypePtr type,
@@ -256,34 +232,6 @@ TypePtr ClosureExpression::inferTypes(AnalysisResultPtr ar, TypePtr type,
  return s_ClosureType;
 }

-bool ClosureExpression::hasStaticLocals() {
-  ConstructPtr cons(m_func);
-  return hasStaticLocalsImpl(cons);
-}
-
-bool ClosureExpression::hasStaticLocalsImpl(ConstructPtr root) {
-  if (!root) {
-    return false;
-  }
-  if (root->getFunctionScope() != m_func->getFunctionScope()) {
-    // new scope, new statics
-    return false;
-  }
-
-  for (int i = 0; i < root->getKidCount(); i++) {
-    ConstructPtr cons = root->getNthKid(i);
-    if (StatementPtr s = dynamic_pointer_cast<Statement>(cons)) {
-      if (s->is(Statement::KindOfStaticStatement)) {
-        return true;
-      }
-    }
-    if (hasStaticLocalsImpl(cons)) {
-      return true;
-    }
-  }
-  return false;
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 // code generation functions

@@ -296,3 +244,75 @@ void ClosureExpression::outputPHP(CodeGenerator &cg, AnalysisResultPtr ar) {
  }
  m_func->outputPHPBody(cg, ar);
 }
+
+bool ClosureExpression::preOutputCPP(CodeGenerator &cg, AnalysisResultPtr ar,
+                                     int state) {
+  FunctionScopeRawPtr cfunc(m_func->getFunctionScope());
+  bool output = false;
+  for (BlockScopePtr sc = cfunc->getOuterScope(); sc;
+       sc = sc->getOuterScope()) {
+    if (sc->is(BlockScope::ClassScope)) {
+      ClassScopePtr cls = boost::static_pointer_cast<ClassScope>(sc);
+      if (cls->isTrait()) {
+        output = true;
+        break;
+      }
+    }
+  }
+
+  if (!cg.inExpression()) {
+    return output || Expression::preOutputCPP(cg, ar, state);
+  }
+
+  if (output) {
+    cg.wrapExpressionBegin();
+    cfunc->outputCPPPreface(cg, ar);
+  }
+  return Expression::preOutputCPP(cg, ar, state) || output;
+}
+
+void ClosureExpression::outputCPPImpl(CodeGenerator &cg,
+                                      AnalysisResultPtr ar) {
+
+
+  FunctionScopeRawPtr cfunc(m_func->getFunctionScope());
+  VariableTablePtr vt(cfunc->getVariables());
+  ParameterExpressionPtrIdxPairVec useVars;
+  bool needsAnonCls = cfunc->needsAnonClosureClass(useVars);
+
+  const string &origName = m_func->getOriginalName();
+
+  if (needsAnonCls) {
+    cg_printf("%sClosure$%s(NEWOBJ(%sClosure$%s)(&%s%s, \"%s\"",
+              Option::SmartPtrPrefix, origName.c_str(),
+              Option::ClassPrefix, origName.c_str(),
+              Option::CallInfoPrefix, origName.c_str(),
+              origName.c_str());
+  } else {
+    // no use vars, so can use the generic closure
+    cg_printf("%sClosure(NEWOBJ(%sClosure)(&%s%s, \"%s\"",
+              Option::SmartPtrPrefix, Option::ClassPrefix,
+              Option::CallInfoPrefix, origName.c_str(),
+              origName.c_str());
+  }
+
+  bool hasEmit = false;
+  if (needsAnonCls) {
+    if (!useVars.empty()) cg_printf(", ");
+    BOOST_FOREACH(ParameterExpressionPtrIdxPair paramPair, useVars) {
+      ParameterExpressionPtr param(paramPair.first);
+      ExpressionPtr value((*m_values)[paramPair.second]);
+      if (!hasEmit) hasEmit = true;
+      else          cg_printf(", ");
+      bool ref = param->isRef() && value->isRefable();
+      if (ref) {
+        value->setContext(NoRefWrapper);
+        cg_printf("strongBind(");
+      }
+      value->outputCPP(cg, ar);
+      if (ref) cg_printf(")");
+    }
+  }
+
+  cg_printf("))");
+}
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,10 +14,10 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_CLOSURE_EXPRESSION_H_
-#define incl_HPHP_CLOSURE_EXPRESSION_H_
+#ifndef __CLOSURE_EXPRESSION_H__
+#define __CLOSURE_EXPRESSION_H__

-#include "hphp/compiler/expression/expression.h"
+#include <compiler/expression/expression.h>

 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////
@@ -32,6 +32,7 @@ public:
                    FunctionStatementPtr func, ExpressionListPtr vars);

  DECLARE_BASE_EXPRESSION_VIRTUAL_FUNCTIONS;
+  virtual bool preOutputCPP(CodeGenerator &cg, AnalysisResultPtr ar, int state);

  virtual ConstructPtr getNthKid(int n) const;
  virtual void setNthKid(int n, ConstructPtr cp);
@@ -40,18 +41,14 @@ public:
  FunctionStatementPtr getClosureFunction() { return m_func; }
  ExpressionListPtr getClosureVariables() { return m_vars; }
  ExpressionListPtr getClosureValues() { return m_values; }
-  bool hasStaticLocals();
-
 private:
  FunctionStatementPtr m_func;
  ExpressionListPtr m_vars;
  ExpressionListPtr m_values;

  static TypePtr s_ClosureType;
-
-  bool hasStaticLocalsImpl(ConstructPtr root);
 };

 ///////////////////////////////////////////////////////////////////////////////
 }
-#endif // incl_HPHP_CLOSURE_EXPRESSION_H_
+#endif // __CLOSURE_EXPRESSION_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,21 +14,21 @@
   +----------------------------------------------------------------------+
 */

-#include "hphp/compiler/expression/constant_expression.h"
-#include "hphp/compiler/analysis/file_scope.h"
-#include "hphp/compiler/analysis/block_scope.h"
-#include "hphp/compiler/analysis/class_scope.h"
-#include "hphp/compiler/analysis/function_scope.h"
-#include "hphp/compiler/analysis/constant_table.h"
-#include "hphp/compiler/analysis/variable_table.h"
-#include "hphp/compiler/analysis/code_error.h"
-#include "hphp/util/hash.h"
-#include "hphp/util/util.h"
-#include "hphp/compiler/option.h"
-#include "hphp/compiler/parser/parser.h"
-#include "hphp/util/parser/hphp.tab.hpp"
-#include "hphp/compiler/expression/scalar_expression.h"
-#include "hphp/runtime/ext/ext_misc.h"
+#include <compiler/analysis/file_scope.h>
+#include <compiler/expression/constant_expression.h>
+#include <compiler/analysis/block_scope.h>
+#include <compiler/analysis/class_scope.h>
+#include <compiler/analysis/function_scope.h>
+#include <compiler/analysis/constant_table.h>
+#include <compiler/analysis/variable_table.h>
+#include <compiler/analysis/code_error.h>
+#include <util/hash.h>
+#include <util/util.h>
+#include <compiler/option.h>
+#include <compiler/parser/parser.h>
+#include <util/parser/hphp.tab.hpp>
+#include <compiler/expression/scalar_expression.h>
+#include <runtime/ext/ext_misc.h>

 using namespace HPHP;

@@ -37,11 +37,10 @@ using namespace HPHP;

 ConstantExpression::ConstantExpression
 (EXPRESSION_CONSTRUCTOR_PARAMETERS,
- const string &name, bool hadBackslash, const string &docComment)
+ const string &name, const string &docComment)
  : Expression(EXPRESSION_CONSTRUCTOR_PARAMETER_VALUES(ConstantExpression)),
-    m_name(name), m_origName(name), m_hadBackslash(hadBackslash),
-    m_docComment(docComment), m_valid(false), m_dynamic(false),
-    m_visited(false), m_depsSet(false) {
+    m_name(name), m_docComment(docComment),
+    m_valid(false), m_dynamic(false), m_visited(false), m_depsSet(false) {
 }

 void ConstantExpression::onParse(AnalysisResultConstPtr ar,
@@ -101,7 +100,7 @@ bool ConstantExpression::getScalarValue(Variant &value) {
 }

 unsigned ConstantExpression::getCanonHash() const {
-  int64_t val = hash_string(Util::toLower(m_name).c_str(), m_name.size());
+  int64 val = hash_string(Util::toLower(m_name).c_str(), m_name.size());
  return ~unsigned(val) ^ unsigned(val >> 32);
 }

@@ -117,9 +116,11 @@ bool ConstantExpression::canonCompare(ExpressionPtr e) const {
 // static analysis functions

 Symbol *ConstantExpression::resolveNS(AnalysisResultConstPtr ar) {
+  bool ns = m_name[0] == '\\';
+  if (ns) m_name = m_name.substr(1);
  BlockScopeConstPtr block = ar->findConstantDeclarer(m_name);
  if (!block) {
-    if (!hadBackslash() && Option::WholeProgram) {
+    if (ns) {
      int pos = m_name.rfind('\\');
      m_name = m_name.substr(pos + 1);
      block = ar->findConstantDeclarer(m_name);
@@ -150,6 +151,8 @@ void ConstantExpression::analyzeProgram(AnalysisResultPtr ar) {
    }
  } else if (ar->getPhase() == AnalysisResult::AnalyzeFinal && m_dynamic) {
    getFileScope()->addConstantDependency(ar, m_name);
+    FunctionScopePtr scope = getFunctionScope();
+    if (scope) scope->setNeedsCheckMem();
  }
 }

@@ -194,7 +197,10 @@ ExpressionPtr ConstantExpression::preOptimize(AnalysisResultConstPtr ar) {
      }
    }
    ExpressionPtr rep = Clone(value, getScope());
+    bool annotate = Option::FlAnnotate;
+    Option::FlAnnotate = false; // avoid nested comments on getText
    rep->setComment(getText());
+    Option::FlAnnotate = annotate;
    rep->setLocation(getLocation());
    return replaceValue(rep);
  }
@@ -277,5 +283,59 @@ TypePtr ConstantExpression::inferTypes(AnalysisResultPtr ar, TypePtr type,
 // code generation functions

 void ConstantExpression::outputPHP(CodeGenerator &cg, AnalysisResultPtr ar) {
-  cg_printf("%s", getNonNSOriginalName().c_str());
+  cg_printf("%s", m_name.c_str());
+}
+
+void ConstantExpression::outputCPPImpl(CodeGenerator &cg,
+                                       AnalysisResultPtr ar) {
+  // special cases: STDIN, STDOUT, STDERR, INF, and NAN
+  if (m_name == "STDIN" || m_name == "STDOUT" || m_name == "STDERR") {
+    cg_printf("%s%s", Option::ConstantPrefix, m_name.c_str());
+    return;
+  }
+
+  if (m_name == "INF" || m_name == "NAN") {
+    if (cg.hasScalarVariant() && Option::UseScalarVariant) {
+      cg_printf("%s_varNR", m_name.c_str());
+    } else {
+      cg_printf("%s%s", Option::ConstantPrefix, m_name.c_str());
+    }
+    return;
+  }
+
+  string lower = Util::toLower(m_name);
+  bool requireFwDeclaration = false;
+  if (lower == "true" || lower == "false" || lower == "null") {
+    if (cg.hasScalarVariant()) {
+      cg_printf((Option::UseScalarVariant ? "%s_varNR" : "%s"), lower.c_str());
+    } else {
+      cg_printf("%s", lower.c_str());
+    }
+  } else if (m_valid) {
+    if (m_dynamic) {
+      cg_printf("getDynamicConstant(%s->%s%s, ",
+                cg.getGlobals(ar), Option::ConstantPrefix,
+                CodeGenerator::FormatLabel(m_name).c_str());
+      cg_printString(m_name, ar, shared_from_this());
+      cg_printf(")");
+    } else {
+      cg_printf("%s%s", Option::ConstantPrefix,
+                CodeGenerator::FormatLabel(m_name).c_str());
+      requireFwDeclaration = true;
+    }
+  } else {
+    cg_printf("getUndefinedConstant(");
+    cg_printString(CodeGenerator::FormatLabel(m_name).c_str(), ar,
+                   shared_from_this());
+    cg_printf(")");
+    requireFwDeclaration = true;
+  }
+
+  if (requireFwDeclaration && cg.isFileOrClassHeader()) {
+    if (getClassScope()) {
+      getClassScope()->addUsedConstHeader(m_name);
+    } else {
+      getFileScope()->addUsedConstHeader(m_name);
+    }
+  }
 }
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,10 +14,10 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_CONSTANT_EXPRESSION_H_
-#define incl_HPHP_CONSTANT_EXPRESSION_H_
+#ifndef __CONSTANT_EXPRESSION_H__
+#define __CONSTANT_EXPRESSION_H__

-#include "hphp/compiler/expression/expression.h"
+#include <compiler/expression/expression.h>

 #define CONSTANT(value) makeConstant(ar, value)

@@ -30,7 +30,6 @@ class ConstantExpression : public Expression, IParseHandler {
 public:
  ConstantExpression(EXPRESSION_CONSTRUCTOR_PARAMETERS,
                     const std::string &name,
-                     bool hadBackslash,
                     const std::string &docComment = "");

  DECLARE_BASE_EXPRESSION_VIRTUAL_FUNCTIONS;
@@ -51,18 +50,9 @@ public:
  virtual bool canonCompare(ExpressionPtr e) const;

  const std::string &getName() const { return m_name;}
-  const std::string &getOriginalName() const { return m_origName;}
-  const std::string getNonNSOriginalName() const {
-    auto nsPos = m_origName.rfind('\\');
-    if (nsPos == string::npos) {
-      return m_origName;
-    }
-    return m_origName.substr(nsPos + 1);
-  }
  const std::string &getDocComment() const {
    return m_docComment;
  }
-
  bool isNull() const;
  bool isBoolean() const;
  bool isDouble() const;
@@ -70,16 +60,13 @@ public:
  void pushConst(const std::string &name);
  void popConst();
  void setComment(const std::string &comment) { m_comment = comment;}
-  std::string getComment() { return m_comment;}
+  const std::string getComment() { return m_comment;}
  bool isValid() const { return m_valid; }
  bool isDynamic() const { return m_dynamic; }
-  bool hadBackslash() const { return m_hadBackslash; }
 private:

  Symbol *resolveNS(AnalysisResultConstPtr ar);
  std::string m_name;
-  std::string m_origName;
-  bool m_hadBackslash;
  std::string m_docComment;
  std::string m_comment; // for inlined constant name
  bool m_valid;
@@ -91,4 +78,4 @@ private:
 ///////////////////////////////////////////////////////////////////////////////
 }

-#endif // incl_HPHP_CONSTANT_EXPRESSION_H_
+#endif // __CONSTANT_EXPRESSION_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,16 +14,16 @@
   +----------------------------------------------------------------------+
 */

-#include "hphp/compiler/expression/dynamic_function_call.h"
-#include "hphp/compiler/analysis/code_error.h"
-#include "hphp/compiler/expression/expression_list.h"
-#include "hphp/compiler/expression/scalar_expression.h"
-#include "hphp/compiler/expression/simple_function_call.h"
-#include "hphp/compiler/analysis/function_scope.h"
-#include "hphp/compiler/analysis/class_scope.h"
-#include "hphp/util/util.h"
-#include "hphp/compiler/option.h"
-#include "hphp/compiler/analysis/variable_table.h"
+#include <compiler/expression/dynamic_function_call.h>
+#include <compiler/analysis/code_error.h>
+#include <compiler/expression/expression_list.h>
+#include <compiler/expression/scalar_expression.h>
+#include <compiler/expression/simple_function_call.h>
+#include <compiler/analysis/function_scope.h>
+#include <compiler/analysis/class_scope.h>
+#include <util/util.h>
+#include <compiler/option.h>
+#include <compiler/analysis/variable_table.h>

 using namespace HPHP;

@@ -34,7 +34,7 @@ DynamicFunctionCall::DynamicFunctionCall
 (EXPRESSION_CONSTRUCTOR_PARAMETERS,
 ExpressionPtr name, ExpressionListPtr params, ExpressionPtr cls)
  : FunctionCall(EXPRESSION_CONSTRUCTOR_PARAMETER_VALUES(DynamicFunctionCall),
-                 name, "", false, params, cls) {
+                 name, "", params, cls) {
 }

 ExpressionPtr DynamicFunctionCall::clone() {
@@ -84,7 +84,7 @@ ExpressionPtr DynamicFunctionCall::preOptimize(AnalysisResultConstPtr ar) {
      }
      return ExpressionPtr(NewSimpleFunctionCall(
        getScope(), getLocation(),
-        name, false, m_params, cls));
+        name, m_params, cls));
    }
  }
  return ExpressionPtr();
@@ -103,7 +103,11 @@ TypePtr DynamicFunctionCall::inferTypes(AnalysisResultPtr ar, TypePtr type,
    }
  }

-  m_nameExp->inferAndCheck(ar, Type::Some, false);
+  if (!m_class && m_className.empty()) {
+    m_nameExp->inferAndCheck(ar, Type::Variant, false);
+  } else {
+    m_nameExp->inferAndCheck(ar, Type::String, false);
+  }

  if (m_params) {
    for (int i = 0; i < m_params->getCount(); i++) {
@@ -116,6 +120,8 @@ TypePtr DynamicFunctionCall::inferTypes(AnalysisResultPtr ar, TypePtr type,
 ///////////////////////////////////////////////////////////////////////////////
 // code generation functions
 void DynamicFunctionCall::outputPHP(CodeGenerator &cg, AnalysisResultPtr ar) {
+  outputLineMap(cg, ar);
+
  if (m_class || !m_className.empty()) {
    StaticClassName::outputPHP(cg, ar);
    cg_printf("::");
@@ -138,3 +144,172 @@ void DynamicFunctionCall::outputPHP(CodeGenerator &cg, AnalysisResultPtr ar) {
  if (m_params) m_params->outputPHP(cg, ar);
  cg_printf(")");
 }
+
+bool DynamicFunctionCall::preOutputCPP(CodeGenerator &cg, AnalysisResultPtr ar,
+    int state) {
+  bool nonStatic = !m_class && m_className.empty();
+  if (!nonStatic && !m_class && !m_classScope && !isRedeclared()) {
+    // call to an unknown class
+    // set m_noStatic to avoid pointlessly wrapping the call
+    // in STATIC_CLASS_NAME_CALL()
+    m_noStatic = true;
+    cg.pushCallInfo(-1);
+    bool ret = FunctionCall::preOutputCPP(cg, ar, state);
+    cg.popCallInfo();
+    return ret;
+  }
+  // Short circuit out if inExpression() returns false
+  if (!cg.inExpression()) return true;
+
+  cg.wrapExpressionBegin();
+
+  m_ciTemp = cg.createNewLocalId(shared_from_this());
+
+  if (!m_classScope && !m_className.empty() && m_cppTemp.empty() &&
+      !isSelf() && ! isParent() && !isStatic()) {
+    // Create a temporary to hold the class name, in case it is not a
+    // StaticString.
+    m_clsNameTemp = cg.createNewLocalId(shared_from_this());
+    cg_printf("CStrRef clsName%d(", m_clsNameTemp);
+    cg_printString(m_origClassName, ar, shared_from_this());
+    cg_printf(");\n");
+  }
+
+  if (m_class) {
+    int s = m_class->hasEffect() || m_nameExp->hasEffect() ?
+      FixOrder : 0;
+    m_class->preOutputCPP(cg, ar, s);
+  }
+  m_nameExp->preOutputCPP(cg, ar, 0);
+
+  if (nonStatic) {
+    cg_printf("const CallInfo *cit%d;\n", m_ciTemp);
+    cg_printf("void *vt%d;\n", m_ciTemp);
+    cg_printf("get_call_info_or_fail(cit%d, vt%d, ", m_ciTemp, m_ciTemp);
+
+    if (m_nameExp->is(Expression::KindOfSimpleVariable)) {
+      m_nameExp->outputCPP(cg, ar);
+    } else {
+      cg_printf("(");
+      m_nameExp->outputCPP(cg, ar);
+      cg_printf(")");
+    }
+    cg_printf(");\n");
+  } else {
+    cg_printf("MethodCallPackage mcp%d;\n", m_ciTemp);
+    if (m_class) {
+      if (m_class->is(KindOfScalarExpression)) {
+        assert(strcasecmp(dynamic_pointer_cast<ScalarExpression>(m_class)->
+                          getString().c_str(), "static") == 0);
+        cg_printf("CStrRef cls%d = "
+                  "FrameInjection::GetStaticClassName(fi.getThreadInfo())",
+                  m_ciTemp);
+      } else {
+        cg_printf("C%sRef cls%d = ",
+                  m_class->getActualType() &&
+                  m_class->getActualType()->is(Type::KindOfString) ?
+                  "Str" : "Var", m_ciTemp);
+        m_class->outputCPP(cg, ar);
+      }
+    } else if (m_classScope) {
+      cg_printf("CStrRef cls%d = ", m_ciTemp);
+      cg_printString(m_classScope->getId(), ar, shared_from_this());
+    } else {
+      cg_printf("CStrRef cls%d = ", m_ciTemp);
+      cg_printString(m_className, ar, shared_from_this());
+    }
+    cg_printf(";\n");
+
+    cg_printf("CStrRef mth%d = ", m_ciTemp);
+    if (m_nameExp->is(Expression::KindOfSimpleVariable)) {
+      m_nameExp->outputCPP(cg, ar);
+    } else {
+      cg_printf("(");
+      m_nameExp->outputCPP(cg, ar);
+      cg_printf(")");
+    }
+    cg_printf(";\n");
+
+    bool dynamic = true;
+    if (!m_class) {
+      ClassScopeRawPtr origClass = getOriginalClass();
+      if (!origClass) {
+        dynamic = false;
+      } else {
+        FunctionScopeRawPtr origFunc = getOriginalFunction();
+        if (origFunc) {
+          if (origFunc->isStatic() ||
+              (m_classScope != origClass &&
+               (m_className.empty() || !origClass->derivesFrom(
+                 ar, m_className, true, true)))) {
+            dynamic = false;
+          }
+        }
+      }
+    }
+
+    if (dynamic) {
+      if ((m_class && (!m_class->getActualType() ||
+                       !m_class->getActualType()->is(Type::KindOfString))) ||
+          !getOriginalFunction() ||
+          !getOriginalClass() ||
+          getOriginalFunction()->isStatic()) {
+        cg_printf("mcp%d.dynamicNamedCall(cls%d, mth%d);\n",
+                  m_ciTemp, m_ciTemp, m_ciTemp);
+      } else {
+        cg_printf("mcp%d.isObj = true;\n", m_ciTemp);
+        cg_printf("mcp%d.rootObj = this;\n", m_ciTemp);
+        cg_printf("mcp%d.name = &mth%d;\n", m_ciTemp, m_ciTemp);
+        cg_printf("o_get_call_info_ex(cls%d, mcp%d);\n", m_ciTemp, m_ciTemp);
+      }
+    } else {
+      cg_printf("mcp%d.staticMethodCall(cls%d, mth%d);\n",
+                m_ciTemp,
+                m_ciTemp, m_ciTemp);
+
+      if (m_classScope) {
+        cg_printf("%s%s.%sget_call_info(mcp%d);\n",
+                  Option::ClassStaticsCallbackPrefix,
+                  m_classScope->getId().c_str(),
+                  Option::ObjectStaticPrefix, m_ciTemp);
+      } else if (isRedeclared()) {
+        cg_printf("g->%s%s->%sget_call_info(mcp%d);\n",
+                  Option::ClassStaticsCallbackPrefix, m_className.c_str(),
+                  Option::ObjectStaticPrefix, m_ciTemp);
+      } else {
+        not_reached();
+      }
+    }
+    cg_printf("const CallInfo *cit%d = mcp%d.ci;\n", m_ciTemp, m_ciTemp);
+  }
+
+  if (m_params && m_params->getCount() > 0) {
+    cg.pushCallInfo(m_ciTemp);
+    m_params->preOutputCPP(cg, ar, 0);
+    cg.popCallInfo();
+  }
+
+  if (state & FixOrder) {
+    cg.pushCallInfo(m_ciTemp);
+    preOutputStash(cg, ar, state);
+    cg.popCallInfo();
+  }
+
+  return true;
+}
+
+void DynamicFunctionCall::outputCPPImpl(CodeGenerator &cg,
+                                        AnalysisResultPtr ar) {
+  bool method = false;
+  if (m_class || !m_className.empty()) {
+    if (!m_class && !m_classScope && !isRedeclared()) {
+      const string &name = CodeGenerator::EscapeLabel(m_className);
+      cg_printf("throw_fatal(\"unknown class %s\")", name.c_str());
+      return;
+    }
+    method = true;
+  }
+
+  cg_printf("(cit%d->", m_ciTemp);
+  outputDynamicCall(cg, ar, method);
+}
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,10 +14,10 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_DYNAMIC_FUNCTION_CALL_H_
-#define incl_HPHP_DYNAMIC_FUNCTION_CALL_H_
+#ifndef __DYNAMIC_FUNCTION_CALL_H__
+#define __DYNAMIC_FUNCTION_CALL_H__

-#include "hphp/compiler/expression/function_call.h"
+#include <compiler/expression/function_call.h>

 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////
@@ -32,9 +32,10 @@ public:

  DECLARE_BASE_EXPRESSION_VIRTUAL_FUNCTIONS;
  ExpressionPtr preOptimize(AnalysisResultConstPtr ar);
+  bool preOutputCPP(CodeGenerator &cg, AnalysisResultPtr ar, int state);
 };

 ///////////////////////////////////////////////////////////////////////////////
 }

-#endif // incl_HPHP_DYNAMIC_FUNCTION_CALL_H_
+#endif // __DYNAMIC_FUNCTION_CALL_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,11 +14,11 @@
   +----------------------------------------------------------------------+
 */

-#include "hphp/compiler/expression/dynamic_variable.h"
-#include "hphp/compiler/analysis/block_scope.h"
-#include "hphp/compiler/analysis/code_error.h"
-#include "hphp/compiler/analysis/variable_table.h"
-#include "hphp/compiler/analysis/file_scope.h"
+#include <compiler/expression/dynamic_variable.h>
+#include <compiler/analysis/block_scope.h>
+#include <compiler/analysis/code_error.h>
+#include <compiler/analysis/variable_table.h>
+#include <compiler/analysis/file_scope.h>

 using namespace HPHP;

@@ -95,3 +95,9 @@ void DynamicVariable::outputPHP(CodeGenerator &cg, AnalysisResultPtr ar) {
  m_exp->outputPHP(cg, ar);
  cg_printf("}");
 }
+
+void DynamicVariable::outputCPPImpl(CodeGenerator &cg, AnalysisResultPtr ar) {
+  cg_printf("variables->get(");
+  m_exp->outputCPP(cg, ar);
+  cg_printf(")");
+}
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,10 +14,10 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_DYNAMIC_VARIABLE_H_
-#define incl_HPHP_DYNAMIC_VARIABLE_H_
+#ifndef __DYNAMIC_VARIABLE_H__
+#define __DYNAMIC_VARIABLE_H__

-#include "hphp/compiler/expression/expression.h"
+#include <compiler/expression/expression.h>

 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////
@@ -40,4 +40,4 @@ private:
 ///////////////////////////////////////////////////////////////////////////////
 }

-#endif // incl_HPHP_DYNAMIC_VARIABLE_H_
+#endif // __DYNAMIC_VARIABLE_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,11 +14,11 @@
   +----------------------------------------------------------------------+
 */

-#include "hphp/compiler/expression/encaps_list_expression.h"
-#include "hphp/compiler/expression/expression_list.h"
-#include "hphp/compiler/expression/binary_op_expression.h"
-#include "hphp/compiler/analysis/code_error.h"
-#include "hphp/runtime/base/builtin_functions.h"
+#include <compiler/expression/encaps_list_expression.h>
+#include <compiler/expression/expression_list.h>
+#include <compiler/expression/binary_op_expression.h>
+#include <compiler/analysis/code_error.h>
+#include <runtime/base/builtin_functions.h>

 using namespace HPHP;

@@ -136,3 +136,55 @@ void EncapsListExpression::outputPHP(CodeGenerator &cg, AnalysisResultPtr ar) {

  if (m_type == '`') cg_printf(")");
 }
+
+static void outputListElement(ExpressionPtr exp, CodeGenerator &cg,
+                              AnalysisResultPtr ar) {
+  if (exp->is(Expression::KindOfScalarExpression)) {
+    TypePtr actType = exp->getActualType();
+    bool str = actType && actType->is(Type::KindOfString);
+    if (!str) cg_printf("toString(");
+    exp->outputCPP(cg, ar);
+    if (!str) cg_printf(")");
+  } else {
+    exp->outputCPP(cg, ar);
+  }
+}
+
+void EncapsListExpression::outputCPPImpl(CodeGenerator &cg,
+                                         AnalysisResultPtr ar) {
+  if (m_type == '`') cg_printf("f_shell_exec(");
+
+  if (m_exps) {
+    int n = m_exps->getCount();
+    always_assert(n > 0);
+    if (n == 1) {
+      ExpressionPtr exp = (*m_exps)[0];
+      outputListElement(exp, cg, ar);
+    } else if (n <= MAX_CONCAT_ARGS) {
+      if (n == 2) {
+        cg_printf("concat(");
+      } else {
+        cg_printf("concat%d(", n);
+      }
+      for (int i = 0; i < n; i++) {
+        ExpressionPtr exp = (*m_exps)[i];
+        if (i > 0) cg_printf(", ");
+        outputListElement(exp, cg, ar);
+      }
+      cg_printf(")");
+    } else {
+      cg_printf("StringBuffer()");
+      for (int i = 0; i < n; i++) {
+        ExpressionPtr exp = (*m_exps)[i];
+        cg_printf(".addWithTaint(");
+        outputListElement(exp, cg, ar);
+        cg_printf(")");
+      }
+      cg_printf(".detachWithTaint()");
+    }
+  } else {
+    cg_printf("\"\"");
+  }
+
+  if (m_type == '`') cg_printf(")");
+}
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,11 +14,11 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_ENCAPS_LIST_EXPRESSION_H_
-#define incl_HPHP_ENCAPS_LIST_EXPRESSION_H_
+#ifndef __ENCAPS_LIST_EXPRESSION_H__
+#define __ENCAPS_LIST_EXPRESSION_H__

-#include "hphp/compiler/expression/expression.h"
-#include "hphp/compiler/analysis/analysis_result.h"
+#include <compiler/expression/expression.h>
+#include <compiler/analysis/analysis_result.h>

 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////
@@ -46,4 +46,4 @@ private:

 ///////////////////////////////////////////////////////////////////////////////
 }
-#endif // incl_HPHP_ENCAPS_LIST_EXPRESSION_H_
+#endif // __ENCAPS_LIST_EXPRESSION_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,28 +14,28 @@
   +----------------------------------------------------------------------+
 */

-#include "hphp/compiler/expression/expression.h"
-#include "hphp/compiler/analysis/code_error.h"
-#include "hphp/compiler/parser/parser.h"
-#include "hphp/util/parser/hphp.tab.hpp"
-#include "hphp/util/util.h"
-#include "hphp/compiler/analysis/class_scope.h"
-#include "hphp/compiler/analysis/function_scope.h"
-#include "hphp/compiler/expression/scalar_expression.h"
-#include "hphp/compiler/expression/constant_expression.h"
-#include "hphp/compiler/expression/expression_list.h"
-#include "hphp/compiler/expression/simple_variable.h"
-#include "hphp/compiler/expression/assignment_expression.h"
-#include "hphp/compiler/expression/array_pair_expression.h"
-#include "hphp/compiler/expression/array_element_expression.h"
-#include "hphp/compiler/expression/object_property_expression.h"
-#include "hphp/compiler/expression/unary_op_expression.h"
-#include "hphp/compiler/analysis/constant_table.h"
-#include "hphp/compiler/analysis/variable_table.h"
-#include "hphp/compiler/expression/function_call.h"
-#include "hphp/compiler/analysis/file_scope.h"
-#include "hphp/util/hash.h"
-#include "hphp/runtime/base/array/array_iterator.h"
+#include <compiler/expression/expression.h>
+#include <compiler/analysis/code_error.h>
+#include <compiler/parser/parser.h>
+#include <util/parser/hphp.tab.hpp>
+#include <util/util.h>
+#include <compiler/analysis/class_scope.h>
+#include <compiler/analysis/function_scope.h>
+#include <compiler/expression/scalar_expression.h>
+#include <compiler/expression/constant_expression.h>
+#include <compiler/expression/expression_list.h>
+#include <compiler/expression/simple_variable.h>
+#include <compiler/expression/assignment_expression.h>
+#include <compiler/expression/array_pair_expression.h>
+#include <compiler/expression/array_element_expression.h>
+#include <compiler/expression/object_property_expression.h>
+#include <compiler/expression/unary_op_expression.h>
+#include <compiler/analysis/constant_table.h>
+#include <compiler/analysis/variable_table.h>
+#include <compiler/expression/function_call.h>
+#include <compiler/analysis/file_scope.h>
+#include <util/hash.h>
+#include <runtime/base/array/array_iterator.h>

 using namespace HPHP;

@@ -144,7 +144,7 @@ bool Expression::hasSubExpr(ExpressionPtr sub) const {
 Expression::ExprClass Expression::getExprClass() const {
  ExprClass cls = Classes[m_kindOf];
  if (cls == Update) {
-    ExpressionPtr k = getStoreVariable();
+    ExpressionPtr k = getNthExpr(0);
    if (!k || !(k->hasContext(OprLValue))) cls = Expression::None;
  }
  return cls;
@@ -308,6 +308,22 @@ FunctionScopeRawPtr Expression::getOriginalFunction() {
  return scope ? scope->getContainingFunction() : FunctionScopeRawPtr();
 }

+string Expression::originalClassName(CodeGenerator &cg, bool withComma) {
+  ClassScopeRawPtr cls = getOriginalClass();
+  string ret = withComma ? ", " : "";
+  if (cls) {
+    if (cls == getClassScope()) {
+      return ret + "s_class_name";
+    }
+    return ret + Option::ClassPrefix + cls->getId() + "::s_class_name";
+  } else if (FunctionScopePtr funcScope = getOriginalFunction()) {
+    if (!funcScope->inPseudoMain()) {
+      return ret + "empty_string";
+    }
+  }
+  return withComma ? "" : "null_string";
+}
+
 void Expression::resetTypes() {
  m_actualType     .reset();
  m_expectedType   .reset();
@@ -506,7 +522,7 @@ ExpressionPtr Expression::MakeConstant(AnalysisResultConstPtr ar,
                                       const std::string &value) {
  ConstantExpressionPtr exp(new ConstantExpression(
                              scope, loc,
-                              value, false));
+                              value));
  if (value == "true" || value == "false") {
    if (ar->getPhase() >= AnalysisResult::PostOptimize) {
      exp->m_actualType = Type::Boolean;
@@ -531,11 +547,11 @@ void Expression::CheckPassByReference(AnalysisResultPtr ar,
 }

 unsigned Expression::getCanonHash() const {
-  int64_t val = hash_int64(getKindOf());
+  int64 val = hash_int64(getKindOf());
  for (int i = getKidCount(); i--; ) {
    ExpressionPtr k = getNthExpr(i);
    if (k) {
-      val = hash_int64(val ^ (((int64_t)k->getKindOf()<<32)+k->getCanonID()));
+      val = hash_int64(val ^ (((int64)k->getKindOf()<<32)+k->getCanonID()));
    }
  }

@@ -687,7 +703,7 @@ ExpressionPtr Expression::MakeScalarExpression(AnalysisResultConstPtr ar,
    ExpressionListPtr el(new ExpressionList(scope, loc,
                                            ExpressionList::ListKindParam));

-    for (ArrayIter iter(value.toArray()); iter; ++iter) {
+    for (ArrayIter iter(value); iter; ++iter) {
      ExpressionPtr k(MakeScalarExpression(ar, scope, loc, iter.first()));
      ExpressionPtr v(MakeScalarExpression(ar, scope, loc, iter.second()));
      if (!k || !v) return ExpressionPtr();
@@ -701,7 +717,7 @@ ExpressionPtr Expression::MakeScalarExpression(AnalysisResultConstPtr ar,
  } else if (value.isNull()) {
    return MakeConstant(ar, scope, loc, "null");
  } else if (value.isBoolean()) {
-    return MakeConstant(ar, scope, loc, value.toBoolean() ? "true" : "false");
+    return MakeConstant(ar, scope, loc, value ? "true" : "false");
  } else {
    return ScalarExpressionPtr
      (new ScalarExpression(scope, loc, value));
@@ -710,6 +726,487 @@ ExpressionPtr Expression::MakeScalarExpression(AnalysisResultConstPtr ar,

 ///////////////////////////////////////////////////////////////////////////////

+bool Expression::outputLineMap(CodeGenerator &cg, AnalysisResultPtr ar,
+                               bool force /* = false */) {
+  switch (cg.getOutput()) {
+  case CodeGenerator::TrimmedPHP:
+    if (cg.getStream(CodeGenerator::MapFile) &&
+        cg.usingStream(CodeGenerator::PrimaryStream)) {
+      cg.useStream(CodeGenerator::MapFile);
+      cg_printf("%d => '%s:%d',", cg.getLineNo(CodeGenerator::PrimaryStream),
+                getLocation()->file, getLocation()->line1);
+      cg.useStream(CodeGenerator::PrimaryStream);
+    }
+    break;
+  case CodeGenerator::ClusterCPP:
+    {
+      if (!force &&
+          !(getLocalEffects() & (Construct::CanThrow|
+                                 Construct::AccessorEffect|
+                                 Construct::DiagnosticEffect))) {
+        return false;
+      }
+      int line = cg.getLineNo(CodeGenerator::PrimaryStream);
+      LocationPtr loc = getLocation();
+      if (loc) {
+        ar->recordSourceInfo(cg.getFileName(), line, loc);
+        if (cg.getPHPLineNo() != loc->line1) {
+          cg.setPHPLineNo(loc->line1);
+          cg_printf("LINE(%d,", loc->line1);
+          return true;
+        }
+      }
+    }
+    break;
+  default:
+    break;
+  }
+  return false;
+}
+
+bool Expression::outputCPPArithArg(CodeGenerator &cg, AnalysisResultPtr ar,
+                                   bool arrayOk) {
+  TypePtr at = getActualType();
+  if (at &&
+      (at->is(Type::KindOfString) ||
+       at->is(Type::KindOfObject) ||
+       (at->is(Type::KindOfArray) && !arrayOk)) &&
+      (!hasCPPTemp() || getCPPType()->isExactType())) {
+    if (!hasCPPTemp() && !getCPPType()->isExactType()) {
+      TypePtr et = getExpectedType();
+      setExpectedType(TypePtr());
+      setActualType(getCPPType());
+      outputCPP(cg, ar);
+      setActualType(at);
+      setExpectedType(et);
+    } else {
+      cg_printf("(Variant)(");
+      outputCPP(cg, ar);
+      cg_printf(")");
+    }
+    return true;
+  }
+
+  return false;
+}
+
+void Expression::outputCPPCast(CodeGenerator &cg, AnalysisResultPtr ar) {
+  if (m_expectedType) {
+    m_expectedType->outputCPPCast(cg, ar, getScope());
+  }
+}
+
+void Expression::outputCPPDecl(CodeGenerator &cg, AnalysisResultPtr ar) {
+  TypePtr type = m_actualType;
+  if (!type) type = Type::Variant;
+  type->outputCPPDecl(cg, ar, getScope());
+}
+
+std::string Expression::genCPPTemp(CodeGenerator &cg, AnalysisResultPtr ar) {
+  std::ostringstream os;
+  os << Option::TempPrefix << cg.createNewLocalId(shared_from_this());
+  return os.str();
+}
+
+void Expression::preOutputStash(CodeGenerator &cg, AnalysisResultPtr ar,
+                                int state) {
+  if (hasCPPTemp() || isScalar()) return;
+  bool fastCast = needsFastCastTemp(ar);
+  if (!isLocalExprAltered() && !hasEffect() &&
+      !fastCast && !(state & StashAll)) {
+    return;
+  }
+
+  bool killCast = false;
+
+  TypePtr srcType, dstType, dstType0;
+  bool needsCast = getTypeCastPtrs(ar, srcType, dstType);
+
+  bool isLvalue = (m_context & LValue);
+  bool isTemp = isTemporary();
+
+  bool isReferenced = true;
+
+  if (fastCast) {
+    isTemp = true;
+    killCast = true;
+    dstType0 = dstType;
+    dstType = Type::Variant;
+    isReferenced = couldCppTypeBeReferenced();
+  } else if (needsCast) {
+    isTemp = true;
+  } else {
+    killCast = true;
+    dstType = srcType;
+  }
+
+  if (dstType) {
+    if (isUnused()) {
+      dstType.reset();
+    } else switch (dstType->getKindOf()) {
+        case Type::KindOfAny:
+        case Type::KindOfSome:
+          dstType = Type::Variant;
+          break;
+        default:
+          break;
+      }
+  }
+
+  bool eltOrPropArg = hasContext(InvokeArgument) &&
+    (is(KindOfArrayElementExpression) || is(KindOfObjectPropertyExpression));
+  bool constRef = dstType &&
+    ((m_context & (RefValue|RefParameter)) ||
+     (isTemp && !dstType->isPrimitive()) || eltOrPropArg ||
+     (isLvalue && dynamic_cast<FunctionCall*>(this)));
+
+  cg.wrapExpressionBegin();
+  // make LINE macro separate to not interfere with persistance of expression.
+  // and because nested LINE macros dont work
+  if (outputLineMap(cg, ar)) cg_printf("0);\n");
+
+  if (constRef) {
+    cg_printf("const ");
+  }
+
+  if (dstType) {
+    bool inlinedRefReturn = hasAllContext(LValue|ReturnContext) &&
+      !hasAnyContext(InvokeArgument|RefValue);
+    bool refParam = hasContext(RefValue) &&
+      !hasAnyContext(InvokeArgument|AssignmentRHS|ReturnContext) &&
+      (is(KindOfObjectPropertyExpression) ||
+       is(KindOfArrayElementExpression));
+    if (inlinedRefReturn) {
+      cg_printf("Variant");
+    } else if (refParam) {
+      cg_printf("VRefParamValue");
+    } else {
+      dstType->outputCPPDecl(cg, ar, getScope());
+    }
+    std::string t = genCPPTemp(cg, ar);
+    const char *ref =
+      (!inlinedRefReturn &&
+       (isLvalue || constRef) &&
+       !(state & ForceTemp)) ? "&" : "";
+    /*
+      Note that double parens are necessary:
+      type_name1 tmp27(type_name2(foo));
+      type_name1 tmp28((type_name2(foo)));
+
+      tmp27 is a function returning a type_name1 taking a parameter of
+      type type_name2 (not what we want!)
+
+      tmp28 is an object of type type_name1, initialized by type_name2(foo)
+    */
+    cg_printf(" %s%s((", ref, t.c_str());
+
+    /*
+      In c++ a temporary bound to a reference gets the lifetime of the
+      reference.
+      So "const Variant &tmp27 = foo()" generates a temporary, and binds it
+      to v, with the lifetime of v.
+      But "const Variant &tmp27 = ref(foo())", creates a temporary, binds it
+      to ref's parameter, returns a reference to that, and binds that to v;
+      but the temporary gets destroyed at the end of the statement.
+
+      So we clear the ref context here, and output the ref when we output the
+      use of the temporary (top of outputCPP, below), but in that case, we also
+      need to set the lval context, otherwise, rvalAt would be generated for
+      array elements and object properties.
+    */
+    int save = m_context;
+    if (inlinedRefReturn) {
+      cg_printf("strongBind(");
+    } else if (refParam) {
+      m_context &= ~RefParameter;
+    } else if (hasContext(RefValue)) {
+      m_context &= ~RefValue;
+      if (is(KindOfObjectPropertyExpression) ||
+          (is(KindOfArrayElementExpression) &&
+           !(m_context & InvokeArgument))) {
+        m_context |= LValue;
+        m_context &= ~NoLValueWrapper;
+      }
+    }
+
+    TypePtr et = m_expectedType;
+    TypePtr at = m_actualType;
+    TypePtr it = m_implementedType;
+    if (killCast) {
+      m_actualType = dstType;
+      m_implementedType.reset();
+      m_expectedType.reset();
+    }
+    outputCPP(cg, ar);
+    if (killCast) {
+      m_actualType = at;
+      m_expectedType = et;
+      m_implementedType = it;
+    }
+    m_context = save;
+
+    if (inlinedRefReturn) cg_printf(")");
+    cg_printf("));\n");
+    if (!refParam && constRef &&
+        (isLvalue || hasContext(DeepReference) || hasContext(UnsetContext))) {
+      dstType->outputCPPDecl(cg, ar, getScope());
+      cg_printf(" &%s_lv = const_cast<", t.c_str());
+      dstType->outputCPPDecl(cg, ar, getScope());
+      cg_printf("&>(%s);\n", t.c_str());
+      t += "_lv";
+    }
+    if (fastCast) {
+      assert(dstType0);
+      assert(srcType == m_implementedType);
+      dstType = dstType0;
+
+      if (constRef && !dstType->isPrimitive()) {
+        cg_printf("const ");
+      }
+      dstType->outputCPPDecl(cg, ar, getScope());
+      cg_printf(" %s%s_vv = ",
+                dstType->isPrimitive() ? "" : "&",
+                t.c_str());
+
+      int closeParen = 0;
+      string method = Type::GetFastCastMethod(
+        m_actualType, isReferenced, constRef);
+      if (!Type::SameType(m_actualType, dstType)) {
+        dstType->outputCPPCast(cg, ar, getScope());
+        cg_printf("(");
+        closeParen++;
+        if (m_actualType->is(Type::KindOfObject)) {
+          method = "getObjectDataOrNull";
+        } else if (m_actualType->is(Type::KindOfString)) {
+          method = "getStringDataOrNull";
+        } else if (m_actualType->is(Type::KindOfArray)) {
+          method = "getArrayDataOrNull";
+        }
+      } else if (m_actualType->isSpecificObject()) {
+        cg_printf("(");
+        closeParen++;
+        m_actualType->outputCPPFastObjectCast(
+            cg, ar, getScope(), constRef);
+        cg_printf("(");
+        closeParen++;
+      }
+
+      cg_printf("%s.%s()", t.c_str(), method.c_str());
+
+      for (int i = 0; i < closeParen; i++) cg_printf(")");
+      cg_printf(";\n");
+
+      t += "_vv";
+    }
+    m_cppTemp = t;
+  } else {
+    if (outputCPPUnneeded(cg, ar)) {
+      cg_printf(";\n");
+    }
+    m_cppTemp = "null";
+  }
+}
+
+bool Expression::preOutputCPP(CodeGenerator &cg, AnalysisResultPtr ar,
+                              int state) {
+  if (isScalar()) {
+    return false;
+  }
+
+  bool paramList =
+    is(KindOfExpressionList) &&
+    static_cast<ExpressionList*>(this)->getListKind() ==
+    ExpressionList::ListKindParam;
+
+  bool stashAll = state & StashAll;
+  state &= ~StashAll;
+  bool doStash = (state & FixOrder) != 0 || needsFastCastTemp(ar);
+  bool ret = doStash;
+  int kidState = (state & ~(StashKidVars|StashVars|FixOrder|ForceTemp));
+  if (state & StashKidVars) kidState |= StashVars;
+  int lastEffect = -1, i;
+  int n = getKidCount();
+  if (hasEffect()) {
+    int j;
+    for (i = j = 0; i < n; i++) {
+      ExpressionPtr k = getNthExpr(i);
+      if (k && !k->isScalar()) {
+        if (k->hasEffect()) {
+          lastEffect = i;
+          if (!j && (n > 1 || paramList) && k->isTemporary() &&
+              (!k->hasContext(ExistContext) ||
+               (!k->is(KindOfObjectPropertyExpression) &&
+                !k->is(KindOfArrayElementExpression)))) {
+            j++;
+          }
+        }
+        j++;
+      }
+    }
+    if (lastEffect >= 0 && j > 1) {
+      kidState |= FixOrder;
+      if (stashAll) {
+        lastEffect = n - 1;
+      }
+      ret = true;
+    }
+  }
+
+  if (!ret || cg.inExpression()) {
+    if (paramList) kidState |= FixOrder;
+    bool skipLast = !stashAll;
+    int lastState = kidState | StashByRef;
+    if (stashAll) lastState |= StashVars;
+    for (i = 0; i <= lastEffect; i++) {
+      ExpressionPtr k = getNthExpr(i);
+      if (k && !k->isScalar()) {
+        int s = kidState;
+        if (i == n - 1 && skipLast) s = 0;
+        bool noEffect = false;
+        if (m_kindOf == KindOfExpressionList) {
+          ExpressionList *el = static_cast<ExpressionList*>(this);
+          if (i >= el->getOutputCount()) {
+            s = lastState = 0;
+            noEffect = true;
+          }
+        }
+        if (k->is(KindOfSimpleVariable)) {
+          skipLast = false;
+        }
+        if (k->preOutputCPP(cg, ar, i == lastEffect ? lastState : s)) {
+          ret = true;
+          if (!cg.inExpression()) break;
+        }
+        if (noEffect) {
+          k->outputCPPUnneeded(cg, ar);
+          k->setCPPTemp("0");
+          cg_printf(";\n");
+        }
+      }
+    }
+  }
+
+  if (doStash) {
+    if (cg.inExpression()) {
+      preOutputStash(cg, ar, state);
+    }
+  }
+
+  return ret;
+}
+
+static bool checkOffsetChain(CodeGenerator &cg, ExpressionPtr e,
+                             bool &needsRefTemp) {
+  bool isArray = e->is(Expression::KindOfArrayElementExpression);
+  if (isArray || e->is(Expression::KindOfObjectPropertyExpression)) {
+    if (cg.hasReferenceTemp()) {
+      bool lval =
+        e->hasContext(Expression::LValue) ||
+        e->hasContext(Expression::RefValue) ||
+        e->hasContext(Expression::DeepReference) ||
+        e->hasContext(Expression::UnsetContext);
+
+      if (isArray) {
+        if (!lval && !e->hasContext(Expression::InvokeArgument) &&
+            !static_pointer_cast<ArrayElementExpression>(e)->isSuperGlobal()) {
+          TypePtr type = e->getNthExpr(0)->getActualType();
+          if (!type ||
+              (!type->is(Type::KindOfString) && !type->is(Type::KindOfArray))) {
+            needsRefTemp = true;
+          }
+        }
+      } else {
+        if (lval &&
+            !static_pointer_cast<ObjectPropertyExpression>(e)->isValid()) {
+          needsRefTemp = true;
+        }
+      }
+    }
+    if (ExpressionPtr e1 = e->getNthExpr(1)) {
+      if (e1->hasEffect()) return true;
+    }
+    return checkOffsetChain(cg, e->getNthExpr(0), needsRefTemp);
+  }
+  return e->hasEffect();
+}
+
+bool Expression::preOutputOffsetLHS(CodeGenerator &cg,
+                                    AnalysisResultPtr ar,
+                                    int state) {
+  bool ret = (state & FixOrder);
+  bool needRefTemp = false;
+  if (!hasContext(AccessContext)) {
+    if (!ret) {
+      ret = checkOffsetChain(cg, getNthExpr(0), needRefTemp);
+      if (!ret &&
+          (m_context & (LValue | OprLValue |
+                        RefValue | DeepReference | RefParameter))) {
+        if (ExpressionPtr e1 = getNthExpr(1)) {
+          if (e1->hasEffect()) {
+            ret = true;
+          }
+        }
+      }
+    }
+  }
+
+  // check to see if this elem has a CSE substitution
+  // or is a chain root. in this case, we need to force a temp
+  // since we will be taking a reference out, if we need to
+  // fix our order
+  bool forceTemp = false;
+  bool hasCse = false;
+  ExpressionPtr p(getCanonCsePtr());
+  if (p && p->hasCPPCseTemp()) {
+    assert(p->isChainRoot() && !isChainRoot());
+    if (!isLocalExprAltered()) return false;
+    hasCse = forceTemp = true;
+  } else if (hasCPPCseTemp() && isChainRoot()) {
+    forceTemp = isLocalExprAltered();
+  }
+
+  if (!ret) {
+    if (hasCse) return false;
+    if (needRefTemp && cg.inExpression()) {
+      cg.wrapExpressionBegin();
+    }
+    return Expression::preOutputCPP(cg, ar, state) || needRefTemp;
+  }
+
+  if (forceTemp) {
+    // if a cast was needed, then no need to force temp
+    TypePtr srcType, dstType;
+    if (getTypeCastPtrs(ar, srcType, dstType)) {
+      forceTemp = false;
+    }
+  }
+
+  if (cg.inExpression()) {
+    cg.wrapExpressionBegin();
+    state |= FixOrder;
+
+    if (!hasCse) {
+      if (ExpressionPtr e0 = getNthExpr(0)) {
+        e0->preOutputCPP(cg, ar, state & ~(StashVars));
+      }
+
+      if (ExpressionPtr e1 = getNthExpr(1)) {
+        e1->preOutputCPP(cg, ar, state & ~(StashVars));
+      }
+    }
+
+    if (!hasContext(AccessContext)) {
+      if (!(m_context & (AssignmentLHS | OprLValue |
+                         ExistContext | UnsetContext))) {
+        if (forceTemp) state |= ForceTemp;
+        Expression::preOutputStash(cg, ar, state);
+      }
+    }
+  }
+
+  return true;
+}
+
 void Expression::collectCPPTemps(ExpressionPtrVec &collection) {
  if (isChainRoot()) {
    collection.push_back(static_pointer_cast<Expression>(shared_from_this()));
@@ -843,6 +1340,59 @@ ExpressionPtr Expression::getCanonCsePtr() const {
  return ExpressionPtr();
 }

+bool Expression::preOutputCPPTemp(CodeGenerator &cg, AnalysisResultPtr ar,
+    bool emitTemps) {
+  ExpressionPtrVec temps;
+  collectCPPTemps(temps);
+  if (temps.empty()) return false;
+  if (emitTemps) {
+    for (ExpressionPtrVec::iterator it(temps.begin());
+        it != temps.end();
+        ++it) {
+      ExpressionPtr p(*it);
+      if (p->hasCPPCseTemp()) continue;
+
+      p->m_cppCseTemp = genCPPTemp(cg, ar);
+      TypePtr t;
+      bool needsStorage = Expression::GetCseTempInfo(ar, p, t);
+      bool useConst = !p->hasContext(Expression::LValue);
+      bool isString = t && t->is(Type::KindOfString);
+      const char *s = isString ? "String" : "Variant";
+      if (!isString) {
+        cg_printf("%s%s *%s%s;\n",
+                  useConst ? "const " : "",
+                  s,
+                  Option::CseTempVariablePrefix,
+                  p->m_cppCseTemp.c_str());
+        if (needsStorage) {
+          cg_printf("%s %s%s;\n",
+                    s,
+                    Option::CseTempStoragePrefix,
+                    p->m_cppCseTemp.c_str());
+        }
+      } else {
+        cg_printf("%s %s%s;\n",
+                  s,
+                  Option::CseTempVariablePrefix,
+                  p->m_cppCseTemp.c_str());
+      }
+    }
+  }
+  return true;
+}
+
+bool Expression::outputCPPBegin(CodeGenerator &cg, AnalysisResultPtr ar) {
+  preOutputCPPTemp(cg, ar, !cg.inExpression());
+  cg.setInExpression(true);
+  return preOutputCPP(cg, ar, 0);
+}
+
+bool Expression::outputCPPEnd(CodeGenerator &cg, AnalysisResultPtr ar) {
+  bool ret = cg.wrapExpressionEnd();
+  cg.setInExpression(false);
+  return ret;
+}
+
 bool Expression::getTypeCastPtrs(
    AnalysisResultPtr ar, TypePtr &srcType, TypePtr &dstType) {
  srcType = m_actualType;
@@ -858,3 +1408,309 @@ bool Expression::getTypeCastPtrs(
  return dstType && srcType && ((m_context & LValue) == 0) &&
      Type::IsCastNeeded(ar, srcType, dstType);
 }
+
+bool Expression::needsFastCastTemp(AnalysisResultPtr ar) {
+  if (is(KindOfSimpleVariable)) return false;
+  if (!canUseFastCast(ar))      return false;
+  if (hasAnyContext(ExistContext|AccessContext) &&
+      (is(KindOfObjectPropertyExpression) ||
+       is(KindOfArrayElementExpression))) {
+    return false;
+  }
+  assert(m_actualType);
+  return !m_actualType->isPrimitive();
+}
+
+bool Expression::couldCppTypeBeReferenced() {
+  if (is(KindOfDynamicVariable)) return true;
+  SimpleVariablePtr p(
+    dynamic_pointer_cast<SimpleVariable>(
+      shared_from_this()));
+  BlockScopeRawPtr scope(getScope());
+  VariableTablePtr vt(scope ? scope->getVariables() : VariableTablePtr());
+  // a simple variable could have its CPP type referenced if:
+  //   it could be aliased or,
+  //   it is a non-lval parameter or,
+  //   the scope it lives in has a dynamic variable or contains extract()
+  // note that we default to true (the conservative case) if no symbol
+  // or variable table is found
+  return p ?
+    (p->couldBeAliased() ||
+     (!p->getSymbol() ||
+      (p->getSymbol()->isParameter() && !p->getSymbol()->isLvalParam())) ||
+     (!vt || (vt->getAttribute(VariableTable::ContainsDynamicVariable) ||
+              vt->getAttribute(VariableTable::ContainsExtract)))) :
+    !isTemporary();
+}
+
+bool Expression::canUseFastCast(AnalysisResultPtr ar) {
+  TypePtr srcType, dstType;
+  getTypeCastPtrs(ar, srcType, dstType);
+  // if the impl type is Variant and the actual type is known
+  // with a fast cast method, and we have a dst type that
+  // is not Variant (in CPP), then we have something to benefit
+  // from doing a fast cast and should emit one.
+  if (m_implementedType &&
+      Type::IsMappedToVariant(m_implementedType) &&
+      m_actualType &&
+      Type::HasFastCastMethod(m_actualType) &&
+      dstType &&
+      !Type::IsMappedToVariant(dstType)) {
+    if (m_assertedType) return true;
+    if (is(KindOfSimpleVariable) &&
+        static_cast<SimpleVariable*>(this)->isGuarded()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool Expression::outputCPPGuardedObjectPtr(CodeGenerator &cg) {
+  if (is(KindOfSimpleVariable) &&
+      static_cast<SimpleVariable*>(this)->isGuarded()) {
+    TypePtr at = getActualType();
+    if (at && at->is(Type::KindOfObject)) {
+      TypePtr it = getImplementedType();
+      if (it && !it->is(Type::KindOfObject)) {
+        TypePtr et = getExpectedType();
+        if (!et || !et->is(Type::KindOfObject)) {
+          cg_printf(".getObjectData()");
+          return true;
+        }
+      }
+      cg_printf(".get()");
+      return true;
+    }
+  }
+  return false;
+}
+
+void Expression::outputCPPInternal(CodeGenerator &cg, AnalysisResultPtr ar) {
+  if (hasError(Expression::BadPassByRef)) {
+    cg_printf("throw_fatal(\"bad pass by reference\")");
+    return;
+  }
+  int closeParen = 0;
+  TypePtr srcType, dstType;
+  bool needsCast = getTypeCastPtrs(ar, srcType, dstType);
+
+  bool useFastCast = false;
+  bool isReferenced = true;
+  bool isLval = (m_context & LValue);
+
+  if (canUseFastCast(ar)) {
+    useFastCast = true;
+    isReferenced = couldCppTypeBeReferenced();
+  }
+
+  if (needsCast) {
+    assert(dstType);
+    bool isSpecObj = m_actualType && m_actualType->isSpecificObject();
+    if (!useFastCast ||
+        !Type::SameType(m_actualType, dstType) ||
+        isSpecObj) {
+      if (useFastCast && isSpecObj) {
+        if (!Type::SameType(m_actualType, dstType)) {
+          dstType->outputCPPCast(cg, ar, getScope());
+          cg_printf("(");
+          closeParen++;
+        } else {
+          // specific object is special, since we do not have
+          // a fast cast method into a specific object on Variant,
+          // we must emit an additional (but also fast) cast.
+          // In the end, the cast will look like (for example):
+          //
+          //    (const X&)(v_var.asCObjRef())
+
+          cg_printf("(");
+          closeParen++;
+          m_actualType->outputCPPFastObjectCast(cg, ar, getScope(), !isLval);
+          cg_printf("(");
+          closeParen++;
+        }
+      } else {
+        dstType->outputCPPCast(cg, ar, getScope());
+        cg_printf("(");
+        closeParen++;
+      }
+    }
+  } else {
+    if (hasContext(RefValue) && !hasContext(NoRefWrapper) &&
+        isRefable()) {
+      if (hasContext(RefParameter)) {
+        cg_printf("strongBind(");
+      } else {
+        cg_printf("ref(");
+      }
+      useFastCast = false; // cannot ref() or strongBind() a non-variant
+      closeParen++;
+    }
+    if (is(Expression::KindOfArrayElementExpression)) {
+      if (((m_context & LValue) || ((m_context & RefValue) &&
+                                    !(m_context & InvokeArgument))) &&
+          !(m_context & NoLValueWrapper)) {
+        isLval = true;
+        cg_printf("lval(");
+        closeParen++;
+      }
+    }
+  }
+
+  bool needsDeref = false;
+  if (hasCPPCseTemp()) {
+    TypePtr t;
+    GetCseTempInfo(
+        ar,
+        static_pointer_cast<Expression>(shared_from_this()),
+        t);
+    if (!t || !t->is(Type::KindOfString)) needsDeref = true;
+    if (isChainRoot()) {
+      if (!needsDeref) {
+        cg_printf("(%s%s = (",
+            Option::CseTempVariablePrefix, m_cppCseTemp.c_str());
+        closeParen += 2;
+      } else {
+        cg_printf("(*(%s%s = &(",
+            Option::CseTempVariablePrefix, m_cppCseTemp.c_str());
+        closeParen += 3;
+      }
+    }
+  }
+
+  if (hasCPPCseTemp() && !isChainRoot()) {
+    if (needsDeref) cg_printf("(*");
+    cg_printf("%s%s",
+        Option::CseTempVariablePrefix, m_cppCseTemp.c_str());
+    if (needsDeref) cg_printf(")");
+  } else {
+    outputCPPImpl(cg, ar);
+  }
+
+  if (useFastCast) {
+    assert(srcType == m_implementedType);
+    string method;
+    if (!Type::SameType(m_actualType, dstType)) {
+      if (m_actualType->is(Type::KindOfObject)) {
+        method = "getObjectDataOrNull";
+      } else if (m_actualType->is(Type::KindOfString)) {
+        method = "getStringDataOrNull";
+      } else if (m_actualType->is(Type::KindOfArray)) {
+        method = "getArrayDataOrNull";
+      }
+    }
+    if (method.empty()) {
+      method = Type::GetFastCastMethod(
+        m_actualType, isReferenced,
+        !isLval && !(m_context & UnsetContext));
+    }
+    cg_printf(".%s()", method.c_str());
+  }
+
+  for (int i = 0; i < closeParen; i++) {
+    cg_printf(")");
+  }
+
+  string comment;
+  if (is(Expression::KindOfScalarExpression)) {
+    ScalarExpressionPtr exp =
+      dynamic_pointer_cast<ScalarExpression>(shared_from_this());
+      comment = exp->getComment();
+  } else if (is(Expression::KindOfConstantExpression)) {
+    ConstantExpressionPtr exp =
+      dynamic_pointer_cast<ConstantExpression>(shared_from_this());
+      comment = exp->getComment();
+  }
+
+  if (!comment.empty()) {
+    if (cg.inComments()) {
+      cg_printf(" (%s)", comment.c_str());
+    } else {
+      cg_printf(" /* %s */", comment.c_str());
+    }
+  }
+}
+
+bool Expression::outputCPPUnneeded(CodeGenerator &cg, AnalysisResultPtr ar) {
+  if (hasEffect() && m_cppTemp.empty()) {
+    setUnused(true);
+    outputCPP(cg, ar);
+    return true;
+  }
+  return false;
+}
+
+void Expression::outputCPP(CodeGenerator &cg, AnalysisResultPtr ar) {
+  bool inExpression = cg.inExpression();
+  bool wrapped = false;
+  TypePtr et = m_expectedType;
+  TypePtr at = m_actualType;
+  TypePtr it = m_implementedType;
+  if (isUnused()) {
+    if (et) {
+      m_expectedType.reset();
+    }
+    if (it) {
+      m_implementedType.reset();
+      m_actualType = it;
+    }
+  }
+
+  if (!inExpression) {
+    wrapped = outputCPPBegin(cg, ar);
+  }
+
+  ExpressionPtr p(getCanonCsePtr());
+  if (p && p->hasCPPCseTemp() && !hasCPPCseTemp()) {
+    assert(p->isChainRoot() && !isChainRoot());
+    m_cppCseTemp = p->m_cppCseTemp;
+  }
+
+  if (!m_cppTemp.empty()) {
+    bool ref = hasContext(RefValue) &&
+      !hasContext(NoRefWrapper) &&
+      (hasAnyContext(ReturnContext|AssignmentRHS|RefParameter) ||
+       !(is(KindOfObjectPropertyExpression) ||
+         is(KindOfArrayElementExpression))) &&
+      isRefable();
+    if (ref) {
+      if (m_context & RefParameter) {
+        cg_printf("strongBind(");
+      } else {
+        cg_printf("ref(");
+      }
+    }
+    cg_printf("%s", m_cppTemp.c_str());
+    if (ref)     cg_printf(")");
+  } else {
+    bool linemap = outputLineMap(cg, ar);
+    if (linemap) cg_printf("(");
+    outputCPPInternal(cg, ar);
+    if (linemap) cg_printf("))");
+  }
+
+  m_implementedType = it;
+  m_actualType = at;
+  m_expectedType = et;
+
+  if (!inExpression) {
+    if (wrapped) cg_printf(";");
+    cg.wrapExpressionEnd();
+    cg.setInExpression(inExpression);
+  }
+}
+
+void Expression::outputCPPExistTest(CodeGenerator &cg, AnalysisResultPtr ar,
+                                    int op) {
+  switch (op) {
+  case T_ISSET:  cg_printf("isset("); break;
+  case T_EMPTY:  cg_printf("empty("); break;
+  default: assert(false);
+  }
+  outputCPP(cg, ar);
+  cg_printf(")");
+}
+void Expression::outputCPPUnset(CodeGenerator &cg, AnalysisResultPtr ar) {
+  cg_printf("unset(");
+  outputCPP(cg, ar);
+  cg_printf(")");
+}
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,12 +14,12 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_EXPRESSION_H_
-#define incl_HPHP_EXPRESSION_H_
+#ifndef __EXPRESSION_H__
+#define __EXPRESSION_H__

-#include "hphp/compiler/construct.h"
-#include "hphp/compiler/analysis/type.h"
-#include "hphp/compiler/analysis/analysis_result.h"
+#include <compiler/construct.h>
+#include <compiler/analysis/type.h>
+#include <compiler/analysis/analysis_result.h>

 #define EXPRESSION_CONSTRUCTOR_BASE_PARAMETERS                          \
  BlockScopePtr scope, LocationPtr loc, Expression::KindOf kindOf
@@ -36,7 +36,8 @@
  virtual ExpressionPtr clone();                                        \
  virtual TypePtr inferTypes(AnalysisResultPtr ar, TypePtr type,        \
                             bool coerce);                              \
-  virtual void outputPHP(CodeGenerator &cg, AnalysisResultPtr ar);
+  virtual void outputPHP(CodeGenerator &cg, AnalysisResultPtr ar);      \
+  virtual void outputCPPImpl(CodeGenerator &cg, AnalysisResultPtr ar)
 #define DECLARE_EXPRESSION_VIRTUAL_FUNCTIONS                            \
  DECLARE_BASE_EXPRESSION_VIRTUAL_FUNCTIONS;                            \
  virtual ConstructPtr getNthKid(int n) const;                          \
@@ -75,7 +76,6 @@ class Variant;
    x(ConstantExpression, Const),               \
    x(EncapsListExpression, None),              \
    x(ClosureExpression, None),                 \
-    x(YieldExpression, None),                   \
    x(UserAttribute, None)

 class Expression : public Construct {
@@ -172,7 +172,6 @@ public:
  }
  bool hasSubExpr(ExpressionPtr sub) const;
  virtual void setComment(const std::string &) {}
-  virtual std::string getComment() { return ""; }
  /**
   * Set this expression's error flags.
   */
@@ -182,20 +181,42 @@ public:
  bool hasError(Error error) const { return m_error & error; }

  ExprClass getExprClass() const;
-  virtual ExpressionPtr getStoreVariable() const { return ExpressionPtr(); }
  void setArgNum(int n);

  /**
   * Implementing Construct.
   */
+  virtual void outputCPP(CodeGenerator &cg, AnalysisResultPtr ar);
+  virtual void outputCPPImpl(CodeGenerator &cg, AnalysisResultPtr ar) = 0;
+  void outputCPPCast(CodeGenerator &cg, AnalysisResultPtr ar);
+  virtual void outputCPPDecl(CodeGenerator &cg, AnalysisResultPtr ar);
+
+  virtual void outputCPPExistTest(CodeGenerator &cg, AnalysisResultPtr ar,
+                                  int op);
+  virtual void outputCPPUnset(CodeGenerator &cg, AnalysisResultPtr ar);
+  virtual void preOutputStash(CodeGenerator &cg, AnalysisResultPtr ar,
+                              int state);
+  virtual bool outputCPPUnneeded(CodeGenerator &cg, AnalysisResultPtr ar);
+  bool outputCPPBegin(CodeGenerator &cg, AnalysisResultPtr ar);
+  bool outputCPPEnd(CodeGenerator &cg, AnalysisResultPtr ar);
  void collectCPPTemps(ExpressionPtrVec &collection);
  void disableCSE();
  bool hasChainRoots();
+  bool preOutputCPPTemp(CodeGenerator &cg, AnalysisResultPtr ar,
+                        bool emitTemps);
+  virtual bool preOutputCPP(CodeGenerator &cg, AnalysisResultPtr ar,
+                            int state);
+  bool preOutputOffsetLHS(CodeGenerator &cg, AnalysisResultPtr ar,
+                          int state);
+  bool hasCPPTemp() const { return !m_cppTemp.empty(); }
+  const std::string &cppTemp() const { return m_cppTemp; }
  std::string genCPPTemp(CodeGenerator &cg, AnalysisResultPtr ar);
+  void setCPPTemp(const std::string &s) { m_cppTemp = s; }
  BlockScopeRawPtr getOriginalScope();
  void setOriginalScope(BlockScopeRawPtr scope);
  ClassScopeRawPtr getOriginalClass();
  FunctionScopeRawPtr getOriginalFunction();
+  std::string originalClassName(CodeGenerator &cg, bool withComma);

  /**
    * For generic walks
@@ -222,6 +243,10 @@ public:
  }
  ExpressionPtr getNextCanonCsePtr() const;
  ExpressionPtr getCanonCsePtr() const;
+  bool needsCSE() const {
+    ExpressionPtr p(getCanonCsePtr());
+    return p && p->hasCPPCseTemp();
+  }
  ExpressionPtr getCanonTypeInfPtr() const;

  /**
@@ -365,6 +390,7 @@ public:
  static bool GetCseTempInfo(
      AnalysisResultPtr ar, ExpressionPtr p, TypePtr &t);

+  bool outputCPPArithArg(CodeGenerator &cg, AnalysisResultPtr ar, bool arrayOk);
  bool isUnused() const { return m_unused; }
  void setUnused(bool u) { m_unused = u; }
  ExpressionPtr fetchReplacement();
@@ -374,6 +400,8 @@ public:
   * Correctly compute the local expression altered bit
   */
  void computeLocalExprAltered();
+
+  bool outputCPPGuardedObjectPtr(CodeGenerator &cg);
 protected:
  static bool IsIdentifier(const std::string &value);

@@ -392,6 +420,10 @@ protected:
  TypePtr m_expectedType; // null if the same as m_actualType
  TypePtr m_implementedType; // null if the same as m_actualType
  TypePtr m_assertedType;
+  std::string m_cppTemp;
+  std::string m_cppCseTemp;
+
+  bool hasCPPCseTemp() const { return !m_cppCseTemp.empty(); }

  TypePtr inferAssignmentTypes(AnalysisResultPtr ar, TypePtr type,
                               bool coerce, ExpressionPtr variable,
@@ -400,9 +432,13 @@ protected:
                TypePtr expectedType);
  void setDynamicByIdentifier(AnalysisResultPtr ar,
                              const std::string &value);
+  bool outputLineMap(CodeGenerator &cg, AnalysisResultPtr ar,
+                     bool force = false);
+
  void resetTypes();
 private:
  static ExprClass Classes[];
+  void outputCPPInternal(CodeGenerator &cg, AnalysisResultPtr ar);

  /**
   * Returns true if a type cast is needed, and sets src/dst type
@@ -410,6 +446,10 @@ protected:
  bool getTypeCastPtrs(
      AnalysisResultPtr ar, TypePtr &srcType, TypePtr &dstType);

+  bool couldCppTypeBeReferenced();
+  bool needsFastCastTemp(AnalysisResultPtr ar);
+  bool canUseFastCast(AnalysisResultPtr ar);
+
  BlockScopeRawPtr m_originalScope;
  ExpressionPtr m_canonPtr;
  ExpressionPtr m_replacement;
@@ -418,4 +458,4 @@ protected:
 ///////////////////////////////////////////////////////////////////////////////
 }

-#endif // incl_HPHP_EXPRESSION_H_
+#endif // __EXPRESSION_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,16 +14,16 @@
   +----------------------------------------------------------------------+
 */

-#include "hphp/compiler/expression/expression_list.h"
-#include "hphp/compiler/expression/scalar_expression.h"
-#include "hphp/compiler/expression/simple_variable.h"
-#include "hphp/compiler/expression/unary_op_expression.h"
-#include "hphp/compiler/expression/binary_op_expression.h"
-#include "hphp/compiler/analysis/variable_table.h"
-#include "hphp/compiler/expression/array_pair_expression.h"
-#include "hphp/compiler/analysis/function_scope.h"
-#include "hphp/runtime/base/array/array_init.h"
-#include "hphp/compiler/parser/parser.h"
+#include <compiler/expression/expression_list.h>
+#include <compiler/expression/scalar_expression.h>
+#include <compiler/expression/simple_variable.h>
+#include <compiler/expression/unary_op_expression.h>
+#include <compiler/expression/binary_op_expression.h>
+#include <compiler/analysis/variable_table.h>
+#include <compiler/expression/array_pair_expression.h>
+#include <compiler/analysis/function_scope.h>
+#include <runtime/base/array/array_init.h>
+#include <compiler/parser/parser.h>

 using namespace HPHP;

@@ -210,7 +210,7 @@ bool ExpressionList::getScalarValue(Variant &value) {
          Variant v;
          bool ret1 = name->getScalarValue(n);
          bool ret2 = val->getScalarValue(v);
-          if (!(ret1 && ret2)) return false;
+          if (!(ret1 && ret2)) return ExpressionPtr();
          init.set(n, v);
        }
      }
@@ -494,6 +494,144 @@ void ExpressionList::outputPHP(CodeGenerator &cg, AnalysisResultPtr ar) {
  }
 }

+void ExpressionList::preOutputStash(CodeGenerator &cg, AnalysisResultPtr ar,
+                                    int state) {
+  if (hasCPPTemp() || m_kind == ListKindParam || m_arrayElements) {
+    return;
+  }
+  int n = m_exps.size();
+  int i = m_kind == ListKindLeft ? 0 : n - 1;
+  if (m_exps[i]->hasCPPTemp() &&
+      Type::SameType(getType(), m_exps[i]->getType())) {
+    setUnused(true);
+    outputCPP(cg, ar);
+    cg_printf(";\n");
+    m_cppTemp = m_exps[i]->cppTemp();
+  }
+  return Expression::preOutputStash(cg, ar, state);
+}
+
+bool ExpressionList::preOutputCPP(CodeGenerator &cg, AnalysisResultPtr ar,
+                                  int state) {
+  if (m_kind == ListKindParam && !m_arrayElements) {
+    return Expression::preOutputCPP(cg, ar, state|StashKidVars);
+  }
+
+  unsigned n = m_exps.size();
+  bool inExpression = cg.inExpression();
+  if (!inExpression && (state & FixOrder)) {
+    return true;
+  }
+
+  cg.setInExpression(false);
+  bool ret = false;
+  if (m_arrayElements) {
+    /*
+     * would like to do:
+     *  ret = Expression::preOutputCPP(cg, ar, state);
+     * but icc has problems with the generated code.
+     */
+    ret = hasEffect();
+  } else if (n > 1 && m_kind == ListKindLeft) {
+    ret = true;
+  } else {
+    for (unsigned int i = 0; i < n; i++) {
+      if (m_exps[i]->preOutputCPP(cg, ar, 0)) {
+        ret = true;
+        break;
+      }
+    }
+    if (!ret) {
+      ExpressionPtr e = m_exps[n - 1];
+      if (hasContext(LValue) && !hasAnyContext(RefValue|InvokeArgument) &&
+          !(e->hasContext(LValue) &&
+            !e->hasAnyContext(RefValue|InvokeArgument))) {
+        ret = true;
+      } else if (hasContext(RefValue) &&
+                 !e->hasAllContext(LValue|ReturnContext) &&
+                 !e->hasContext(RefValue)) {
+        ret = true;
+      }
+    }
+  }
+
+  if (!inExpression) return ret;
+
+  cg.setInExpression(true);
+  if (!ret) {
+    if (state & FixOrder) {
+      preOutputStash(cg, ar, state);
+      return true;
+    }
+    return false;
+  }
+
+  cg.wrapExpressionBegin();
+  if (m_arrayElements) {
+    setCPPTemp(genCPPTemp(cg, ar));
+    outputCPPInternal(cg, ar, true, true);
+  } else {
+    unsigned ix = isUnused() ? (unsigned)-1 :
+      m_kind == ListKindLeft ? 0 : n - 1;
+    for (unsigned int i = 0; i < n; i++) {
+      ExpressionPtr e = m_exps[i];
+      if (i != ix) e->setUnused(true);
+      e->preOutputCPP(cg, ar, i == ix ? state : 0);
+      if (i != ix) {
+        if (e->outputCPPUnneeded(cg, ar)) {
+          cg_printf(";\n");
+        }
+        e->setCPPTemp("/**/");
+        continue;
+      }
+      /*
+        We inlined a by-value function into the rhs of a by-ref assignment.
+      */
+      bool noRef = hasContext(RefValue) &&
+        !e->hasAllContext(LValue|ReturnContext) &&
+        !e->hasContext(RefValue) &&
+        !e->isTemporary() &&
+        Type::IsMappedToVariant(e->getActualType());
+      /*
+        If we need a non-const reference, but the expression is
+        going to generate a const reference, fix it
+      */
+      bool lvSwitch =
+        hasContext(LValue) && !hasAnyContext(RefValue|InvokeArgument) &&
+        !(e->hasContext(LValue) &&
+          !e->hasAnyContext(RefValue|InvokeArgument));
+
+      if (e->hasAllContext(LValue|ReturnContext) && i + 1 == n) {
+        e->clearContext(ReturnContext);
+      }
+
+      if (noRef || lvSwitch || (!i && n > 1)) {
+        e->Expression::preOutputStash(cg, ar, state | FixOrder | StashAll);
+        if (!(state & FixOrder)) {
+          cg_printf("id(%s);\n", e->cppTemp().c_str());
+        }
+      }
+      if (e->hasCPPTemp() &&
+          Type::SameType(e->getGenType(), getGenType())) {
+        string t = e->cppTemp();
+        if (noRef) {
+          cg_printf("CVarRef %s_nr = wrap_variant(%s);\n",
+                    t.c_str(), t.c_str());
+          t += "_nr";
+        }
+
+        if (lvSwitch) {
+          cg_printf("Variant &%s_lv = const_cast<Variant&>(%s);\n",
+                    t.c_str(), t.c_str());
+          t += "_lv";
+        }
+        setCPPTemp(t);
+      }
+    }
+  }
+  return true;
+}
+
 unsigned int ExpressionList::checkLitstrKeys() const {
  assert(m_arrayElements && !m_collectionType);
  std::set<string> keys;
@@ -514,3 +652,235 @@ unsigned int ExpressionList::checkLitstrKeys() const {
  return keys.size();
 }

+bool ExpressionList::hasNonArrayCreateValue(
+  bool arrayElements /* = true */, unsigned int start /* = 0 */) const {
+  for (unsigned int i = start; i < m_exps.size(); i++) {
+    ExpressionPtr value = m_exps[i];
+    if (arrayElements) {
+      ArrayPairExpressionPtr ap =
+        dynamic_pointer_cast<ArrayPairExpression>(m_exps[i]);
+      value = ap->getValue();
+    }
+    assert(value);
+    if (value->hasContext(RefValue)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void ExpressionList::outputCPPUniqLitKeyArrayInit(
+  CodeGenerator &cg, AnalysisResultPtr ar, bool litstrKeys, int64 num,
+  bool arrayElements /* = true */, unsigned int start /* = 0 */) {
+  if (arrayElements) assert(m_arrayElements && !m_collectionType);
+  unsigned int n =  m_exps.size();
+  cg_printf("array_createv%c(%" PRId64 ", ", litstrKeys ? 's' : 'i', num);
+  always_assert(n - start == num);
+  for (unsigned int i = start; i < n; i++) {
+    ExpressionPtr exp = m_exps[i];
+    always_assert(exp);
+    ExpressionPtr name;
+    ExpressionPtr value = exp;
+    if (arrayElements) {
+      ArrayPairExpressionPtr ap =
+        dynamic_pointer_cast<ArrayPairExpression>(m_exps[i]);
+      name = ap->getName();
+      value = ap->getValue();
+    }
+    if (name) {
+      always_assert(litstrKeys);
+      cg_printf("toSPOD(");
+      name->outputCPP(cg, ar);
+      cg_printf("), ");
+    }
+    cg_printf("toVPOD(");
+    if (value->isScalar()) {
+      always_assert(!cg.hasScalarVariant());
+      cg.setScalarVariant();
+      if (!Option::UseScalarVariant) cg_printf("VarNR(");
+      value->outputCPP(cg, ar);
+      if (!Option::UseScalarVariant) cg_printf(")");
+      cg.clearScalarVariant();
+    } else {
+      bool wrap = Expression::CheckVarNR(value, Type::Variant);
+      if (wrap) cg_printf("VarNR(");
+      value->outputCPP(cg, ar);
+      if (wrap) cg_printf(")");
+    }
+    cg_printf(")");
+    if (i < n-1) {
+      cg_printf(", ");
+    } else {
+      cg_printf(")");
+    }
+  }
+}
+
+bool ExpressionList::outputCPPArrayCreate(CodeGenerator &cg,
+                                          AnalysisResultPtr ar,
+                                          bool isVector,
+                                          bool pre) {
+  assert(pre == !m_cppTemp.empty());
+  if (!Option::GenArrayCreate || cg.getOutput() == CodeGenerator::SystemCPP) {
+    return false;
+  }
+  if (hasNonArrayCreateValue()) return false;
+
+  unsigned int n = isVector ? m_exps.size() : 0;
+  bool uniqLitstrKeys = false;
+  if (isVector) {
+    n = m_exps.size();
+  } else {
+    n = checkLitstrKeys();
+    if (n > 0 && n == m_exps.size()) uniqLitstrKeys = true;
+  }
+  if (isVector) {
+    if (ar->m_arrayIntegerKeyMaxSize < (int)n) ar->m_arrayIntegerKeyMaxSize = n;
+  } else if (uniqLitstrKeys) {
+    if (ar->m_arrayLitstrKeyMaxSize < (int)n) ar->m_arrayLitstrKeyMaxSize = n;
+  } else {
+    return false;
+  }
+  if (pre) {
+    Expression::preOutputCPP(cg, ar, StashKidVars);
+    cg_printf("ArrayInit %s(", m_cppTemp.c_str());
+    outputCPPUniqLitKeyArrayInit(cg, ar, uniqLitstrKeys, n);
+    cg_printf(");\n");
+  } else {
+    outputCPPUniqLitKeyArrayInit(cg, ar, uniqLitstrKeys, n);
+  }
+  return true;
+}
+
+bool ExpressionList::outputCPPInternal(CodeGenerator &cg,
+                                       AnalysisResultPtr ar,
+                                       bool needed, bool pre) {
+  bool needsComma = false;
+  bool anyOutput = false;
+  if (m_arrayElements) {
+    if (!m_collectionType) {
+      bool isVector = true;
+      for (unsigned int i = 0; i < m_exps.size(); i++) {
+        ArrayPairExpressionPtr ap =
+          dynamic_pointer_cast<ArrayPairExpression>(m_exps[i]);
+        if (ap->getName()) {
+          isVector = false;
+          break;
+        }
+      }
+      if (outputCPPArrayCreate(cg, ar, isVector, pre)) return true;
+      cg_printf("ArrayInit");
+      if (pre) {
+        cg_printf(" %s", m_cppTemp.c_str());
+      }
+      cg_printf("(%d)", (int)m_exps.size());
+      if (pre) cg_printf(";\n");
+      needsComma = true;
+      anyOutput = true;
+    } else {
+      cg_printf("CollectionInit");
+      if (pre) {
+        cg_printf(" %s", m_cppTemp.c_str());
+      }
+      cg_printf("(%d, %luLL)", m_collectionType, m_exps.size());
+      if (pre) cg_printf(";\n");
+      needsComma = true;
+      anyOutput = true;
+    }
+  }
+
+  bool trailingComma = false;
+  unsigned i = 0, s = m_exps.size();
+  unsigned ix = m_kind == ListKindLeft ? 0 : s - 1;
+  bool uniqueStringKeys =
+    m_arrayElements && !m_collectionType &&
+    (checkLitstrKeys() == s); // TODO integer keys as well
+  for ( ; i < s; i++) {
+    if (ExpressionPtr exp = m_exps[i]) {
+      if (pre) {
+        exp->preOutputCPP(cg, ar, 0);
+        cg_printf("%s", m_cppTemp.c_str());
+      }
+      if (needsComma) {
+        cg_printf(m_arrayElements ? "." : ", ");
+        trailingComma = true;
+      }
+      if (m_arrayElements) {
+        ArrayPairExpressionPtr ap =
+          dynamic_pointer_cast<ArrayPairExpression>(exp);
+        if (ap->isRef()) {
+          cg_printf("setRef(");
+          // The value itself shouldn't be wrapped with ref() any more.
+          ap->getValue()->setContext(NoRefWrapper);
+        } else {
+          cg_printf(uniqueStringKeys ? "add(" : "set(");
+        }
+        exp->outputCPP(cg, ar);
+        cg_printf(")");
+        if (pre) {
+          cg_printf(";\n");
+        }
+        needsComma = true;
+      } else if (m_kind != ListKindParam && (i != ix || !needed)) {
+        needsComma = exp->outputCPPUnneeded(cg, ar);
+      } else {
+        bool wrap =
+          exp->hasCPPTemp() &&
+          hasContext(LValue) && !hasAnyContext(RefValue|InvokeArgument) &&
+            !(exp->hasContext(LValue) &&
+              !exp->hasAnyContext(RefValue|InvokeArgument));
+        if (wrap) cg_printf("const_cast<Variant&>(");
+        bool noRef = !exp->hasCPPTemp() &&
+          hasContext(RefValue) &&
+          !exp->hasAllContext(LValue|ReturnContext) &&
+          !exp->hasContext(RefValue) &&
+          !exp->isTemporary() &&
+          Type::IsMappedToVariant(exp->getActualType());
+        if (noRef) cg_printf("wrap_variant(");
+        exp->outputCPP(cg, ar);
+        if (noRef) cg_printf(")");
+        if (wrap) cg_printf(")");
+        needsComma = true;
+      }
+      if (needsComma) {
+        trailingComma = false;
+        anyOutput = true;
+      }
+    }
+  }
+  if (trailingComma) {
+    cg_printf("id(0)");
+  }
+  if (m_arrayElements && !pre) {
+    cg_printf(".create()");
+    anyOutput = true;
+  }
+  return anyOutput;
+}
+
+void ExpressionList::outputCPPImpl(CodeGenerator &cg, AnalysisResultPtr ar) {
+  bool wrapped = m_kind == ListKindWrapped ||
+    (m_kind == ListKindComma && getCount() > 1);
+  if (wrapped) cg_printf("(");
+  outputCPPInternal(cg, ar, true, false);
+  if (wrapped) cg_printf(")");
+}
+
+bool ExpressionList::outputCPPUnneeded(CodeGenerator &cg,
+                                       AnalysisResultPtr ar) {
+  bool inExpression = cg.inExpression();
+  bool wrapped = false;
+  if (!inExpression) {
+    cg.setInExpression(true);
+    wrapped = preOutputCPP(cg, ar, 0);
+  }
+
+  bool ret = outputCPPInternal(cg, ar, false, false);
+
+  if (!inExpression) {
+    if (wrapped) cg_printf(";\n");
+    cg.wrapExpressionEnd();
+    cg.setInExpression(inExpression);
+  }
+  return ret || wrapped;
+}
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,10 +14,10 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_EXPRESSION_LIST_H_
-#define incl_HPHP_EXPRESSION_LIST_H_
+#ifndef __EXPRESSION_LIST_H__
+#define __EXPRESSION_LIST_H__

-#include "hphp/compiler/expression/expression.h"
+#include <compiler/expression/expression.h>

 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////
@@ -33,8 +33,8 @@ public:
    ListKindLeft
  };

-  explicit ExpressionList(EXPRESSION_CONSTRUCTOR_PARAMETERS,
-                          ListKind kind = ListKindParam);
+  ExpressionList(EXPRESSION_CONSTRUCTOR_PARAMETERS,
+                 ListKind kind = ListKindParam);

  // change case to lower so to make it case insensitive
  void toLower();
@@ -85,6 +85,19 @@ public:

  virtual bool canonCompare(ExpressionPtr e) const;

+  void preOutputStash(CodeGenerator &cg, AnalysisResultPtr ar,
+                      int state);
+  bool preOutputCPP(CodeGenerator &cg, AnalysisResultPtr ar,
+                    int state);
+  bool outputCPPUnneeded(CodeGenerator &cg, AnalysisResultPtr ar);
+  bool hasNonArrayCreateValue(bool arrayElements = true,
+                              unsigned int start = 0) const;
+  void outputCPPUniqLitKeyArrayInit(CodeGenerator &cg,
+                                    AnalysisResultPtr ar,
+                                    bool litstrKeys,
+                                    int64 max,
+                                    bool arrayElements = true,
+                                    unsigned int start = 0);
  /**
   * Checks whether the expression list contains only literal strings and
   * (recursive) arrays of literal strings. Also returns the list of strings
@@ -95,6 +108,10 @@ public:
 private:
  void optimize(AnalysisResultConstPtr ar);
  unsigned int checkLitstrKeys() const;
+  bool outputCPPArrayCreate(CodeGenerator &cg, AnalysisResultPtr ar,
+                            bool isVector, bool pre);
+  bool outputCPPInternal(CodeGenerator &cg,
+                         AnalysisResultPtr ar, bool needed, bool pre);

  ExpressionPtrVec m_exps;
  int m_outputCount;
@@ -105,4 +122,4 @@ private:

 ///////////////////////////////////////////////////////////////////////////////
 }
-#endif // incl_HPHP_EXPRESSION_LIST_H_
+#endif // __EXPRESSION_LIST_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,28 +14,28 @@
   +----------------------------------------------------------------------+
 */

-#include "hphp/compiler/expression/function_call.h"
-#include "hphp/util/util.h"
-#include "hphp/util/logger.h"
-#include "hphp/compiler/expression/scalar_expression.h"
-#include "hphp/compiler/analysis/code_error.h"
-#include "hphp/compiler/analysis/function_scope.h"
-#include "hphp/compiler/analysis/file_scope.h"
-#include "hphp/compiler/analysis/variable_table.h"
-#include "hphp/compiler/statement/statement.h"
-#include "hphp/compiler/statement/method_statement.h"
-#include "hphp/compiler/statement/exp_statement.h"
-#include "hphp/compiler/statement/return_statement.h"
-#include "hphp/compiler/statement/statement_list.h"
-#include "hphp/compiler/analysis/class_scope.h"
-#include "hphp/compiler/expression/expression_list.h"
-#include "hphp/compiler/expression/array_pair_expression.h"
-#include "hphp/compiler/expression/simple_variable.h"
-#include "hphp/compiler/expression/simple_function_call.h"
-#include "hphp/compiler/expression/parameter_expression.h"
-#include "hphp/compiler/expression/assignment_expression.h"
-#include "hphp/compiler/expression/unary_op_expression.h"
-#include "hphp/util/parser/hphp.tab.hpp"
+#include <compiler/expression/function_call.h>
+#include <util/util.h>
+#include <util/logger.h>
+#include <compiler/expression/scalar_expression.h>
+#include <compiler/analysis/code_error.h>
+#include <compiler/analysis/function_scope.h>
+#include <compiler/analysis/file_scope.h>
+#include <compiler/analysis/variable_table.h>
+#include <compiler/statement/statement.h>
+#include <compiler/statement/method_statement.h>
+#include <compiler/statement/exp_statement.h>
+#include <compiler/statement/return_statement.h>
+#include <compiler/statement/statement_list.h>
+#include <compiler/analysis/class_scope.h>
+#include <compiler/expression/expression_list.h>
+#include <compiler/expression/array_pair_expression.h>
+#include <compiler/expression/simple_variable.h>
+#include <compiler/expression/simple_function_call.h>
+#include <compiler/expression/parameter_expression.h>
+#include <compiler/expression/assignment_expression.h>
+#include <compiler/expression/unary_op_expression.h>
+#include <util/parser/hphp.tab.hpp>

 using namespace HPHP;

@@ -44,15 +44,15 @@ using namespace HPHP;

 FunctionCall::FunctionCall
 (EXPRESSION_CONSTRUCTOR_BASE_PARAMETERS,
- ExpressionPtr nameExp, const std::string &name, bool hadBackslash,
- ExpressionListPtr params, ExpressionPtr classExp)
+ ExpressionPtr nameExp, const std::string &name, ExpressionListPtr params,
+ ExpressionPtr classExp)
  : Expression(EXPRESSION_CONSTRUCTOR_BASE_PARAMETER_VALUES),
    StaticClassName(classExp), m_nameExp(nameExp),
    m_ciTemp(-1), m_params(params), m_valid(false),
    m_extraArg(0), m_variableArgument(false), m_voidReturn(false),
    m_voidWrapper(false), m_redeclared(false),
    m_noStatic(false), m_noInline(false), m_invokeFewArgsDecision(true),
-    m_arrayParams(false), m_hadBackslash(hadBackslash),
+    m_arrayParams(false),
    m_argArrayId(-1), m_argArrayHash(-1), m_argArrayIndex(-1) {

  if (m_nameExp &&
@@ -204,14 +204,15 @@ void FunctionCall::analyzeProgram(AnalysisResultPtr ar) {
        }
      }
    }
+    if (getContext() & RefValue) {
+      FunctionScopePtr fs = getFunctionScope();
+      if (fs) fs->setNeedsCheckMem();
+    }
  }
 }

 struct InlineCloneInfo {
-  explicit InlineCloneInfo(FunctionScopePtr fs)
-    : func(fs)
-    , callWithThis(false)
-  {}
+  InlineCloneInfo(FunctionScopePtr fs) : func(fs), callWithThis(false) {}

  FunctionScopePtr              func;
  StringToExpressionPtrMap      sepm;
@@ -583,3 +584,183 @@ TypePtr FunctionCall::checkParamsAndReturn(AnalysisResultPtr ar,

  return type;
 }
+
+bool FunctionCall::preOutputCPP(CodeGenerator &cg, AnalysisResultPtr ar,
+                                int state) {
+  optimizeArgArray(ar);
+  bool noLSB = m_noStatic || (!m_class && m_className.empty()) ||
+    isSelf() || isParent();
+  if (!noLSB) {
+    if (m_funcScope && !m_funcScope->usesLSB()) {
+      noLSB = true;
+    }
+  }
+  if (noLSB || isUnused()) {
+    return Expression::preOutputCPP(cg, ar, state);
+  }
+
+  if (!cg.inExpression()) {
+    return true;
+  }
+  Expression::preOutputCPP(cg, ar, state & ~FixOrder);
+  cg.wrapExpressionBegin();
+  if (m_classScope) {
+    string className = m_classScope->getId();
+    cg_printf("fi.setStaticClassName(%s%s::s_class_name);\n",
+              Option::ClassPrefix, className.c_str());
+  } else {
+    m_clsNameTemp = cg.createNewLocalId(shared_from_this());
+    cg_printf("CStrRef clsName%d(", m_clsNameTemp);
+    cg_printString(m_origClassName, ar, shared_from_this());
+    cg_printf(");\n");
+    cg_printf("fi.setStaticClassName(clsName%d);\n", m_clsNameTemp);
+  }
+  m_noStatic = true;
+  preOutputStash(cg, ar, FixOrder);
+  m_noStatic = false;
+  cg_printf("fi.resetStaticClassName();\n");
+
+  if (!(state & FixOrder)) {
+    cg_printf("id(%s);\n", cppTemp().c_str());
+  }
+
+  return true;
+}
+
+void FunctionCall::outputDynamicCall(CodeGenerator &cg,
+                                     AnalysisResultPtr ar, bool method) {
+  const char *kind = method ? "Meth" : "Func";
+  const char *var = method ? "mcp" : "vt";
+
+  int pcount = m_params ? m_params->getCount() : 0;
+  if (canInvokeFewArgs()) {
+    if (Option::InvokeWithSpecificArgs) {
+      cg_printf("get%s%dArgs())(%s%d, ", kind, pcount, var, m_ciTemp);
+    } else {
+      cg_printf("get%sFewArgs())(%s%d, ", kind, var, m_ciTemp);
+    }
+    if (pcount) {
+      for (int i = 0; i < pcount; i++) {
+        (*m_params)[i]->setContext(NoRefWrapper);
+      }
+      cg_printf("%d, ", pcount);
+      cg.pushCallInfo(m_ciTemp);
+      FunctionScope::OutputCPPArguments(m_params, FunctionScopePtr(),
+                                        cg, ar, 0, false);
+      cg.popCallInfo();
+    } else {
+      cg_printf("0");
+    }
+    if (!Option::InvokeWithSpecificArgs) {
+      for (int i = pcount; i < Option::InvokeFewArgsCount; i++) {
+        cg_printf(", null_variant");
+      }
+    }
+  } else {
+    cg_printf("get%s())(%s%d, ", kind, var, m_ciTemp);
+
+    if (pcount) {
+      cg.pushCallInfo(m_ciTemp);
+      FunctionScope::OutputCPPArguments(m_params, FunctionScopePtr(),
+                                        cg, ar, -1, false);
+      cg.popCallInfo();
+    } else {
+      cg_printf("Array()");
+    }
+  }
+
+  cg_printf(")");
+}
+
+void FunctionCall::outputCPP(CodeGenerator &cg, AnalysisResultPtr ar) {
+  optimizeArgArray(ar);
+  bool staticClassName = false;
+  bool noLSB = !m_cppTemp.empty() || m_noStatic ||
+    (!m_class && m_className.empty()) ||
+    isSelf() || isParent() || isStatic();
+  if (!noLSB) {
+    if (m_funcScope && !m_funcScope->usesLSB()) {
+      noLSB = true;
+    }
+  }
+  if (!noLSB) {
+    if (!m_className.empty()) {
+      cg_printf("STATIC_CLASS_NAME_CALL(");
+      if (m_classScope) {
+        string className = m_classScope->getId();
+        cg_printf("%s%s::s_class_name, ",
+                  Option::ClassPrefix, className.c_str());
+      } else {
+        assert(m_clsNameTemp >= 0);
+        cg_printf("clsName%d, ", m_clsNameTemp);
+      }
+    } else {
+      cg_printf("STATIC_CLASS_INVOKE_CALL(mcp%d.getClassName(), ",
+          m_ciTemp);
+    }
+    if (m_voidReturn) m_voidWrapper = true;
+    staticClassName = true;
+  }
+
+  if (m_voidReturn) clearContext(RefValue);
+  TypePtr eType = getExpectedType();
+  bool wrap = m_voidWrapper && m_cppTemp.empty() && !isUnused();
+  if (wrap) {
+    cg_printf("(");
+    setExpectedType(TypePtr());
+  }
+  Expression::outputCPP(cg, ar);
+  if (wrap) {
+    setExpectedType(eType);
+    if (eType && !Type::IsMappedToVariant(eType)) {
+      if (eType->is(Type::KindOfBoolean)) {
+        cg_printf(", false)");
+      } else if (eType->isInteger()) {
+        cg_printf(", 0)");
+      } else if (eType->is(Type::KindOfDouble)) {
+        cg_printf(", 0.0)");
+      } else if (eType->is(Type::KindOfString)) {
+        cg_printf(", empty_string)");
+      } else {
+        cg_printf(", ");
+        eType->outputCPPCast(cg, ar, getScope());
+        cg_printf("(null))");
+      }
+    } else {
+      cg_printf(", null)");
+    }
+  }
+
+  if (staticClassName) {
+    cg_printf(")");
+  }
+}
+
+void FunctionCall::optimizeArgArray(AnalysisResultPtr ar) {
+  if (m_extraArg <= 0 || m_argArrayId >= 0) return;
+  int paramCount = m_params->getOutputCount();
+  int iMax = paramCount - m_extraArg;
+  bool isScalar = true;
+  for (int i = iMax; i < paramCount; i++) {
+    ExpressionPtr param = (*m_params)[i];
+    if (!param->isScalar()) {
+      isScalar = false;
+      break;
+    }
+  }
+  if (isScalar) {
+    ExpressionPtr argArrayPairs =
+      ExpressionListPtr(new ExpressionList(getScope(), getLocation()));
+    for (int i = iMax; i < paramCount; i++) {
+      ExpressionPtr param = (*m_params)[i];
+      argArrayPairs->addElement(
+        ArrayPairExpressionPtr(new ArrayPairExpression(
+                                 getScope(), param->getLocation(),
+                                 ExpressionPtr(), param, false)));
+    }
+    string text;
+    m_argArrayId =
+      ar->registerScalarArray(false, getFileScope(), argArrayPairs,
+                              m_argArrayHash, m_argArrayIndex, text);
+  }
+}
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,11 +14,11 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_FUNCTION_CALL_H_
-#define incl_HPHP_FUNCTION_CALL_H_
+#ifndef __FUNCTION_CALL_H__
+#define __FUNCTION_CALL_H__

-#include "hphp/compiler/analysis/function_scope.h"
-#include "hphp/compiler/expression/static_class_name.h"
+#include <compiler/analysis/function_scope.h>
+#include <compiler/expression/static_class_name.h>

 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////
@@ -30,11 +30,13 @@ DECLARE_BOOST_TYPES(FunctionCall);
 class FunctionCall : public Expression, public StaticClassName {
 protected:
  FunctionCall(EXPRESSION_CONSTRUCTOR_BASE_PARAMETERS, ExpressionPtr nameExp,
-               const std::string &name, bool hadBackslash,
-               ExpressionListPtr params, ExpressionPtr classExp);
+               const std::string &name, ExpressionListPtr params,
+               ExpressionPtr classExp);
 public:
  void analyzeProgram(AnalysisResultPtr ar);

+  // overriding Expression::outputCPP to implement void wrapper
+  virtual void outputCPP(CodeGenerator &cg, AnalysisResultPtr ar);
  virtual bool isRefable(bool checkError = false) const { return true;}
  virtual bool isTemporary() const;

@@ -47,25 +49,21 @@ public:

  const std::string &getName() const { return m_name; }
  const std::string &getOriginalName() const { return m_origName; }
-  const std::string getNonNSOriginalName() const {
-    auto nsPos = m_origName.rfind('\\');
-    if (nsPos == string::npos) {
-      return m_origName;
-    }
-    return m_origName.substr(nsPos + 1);
-  }
  ExpressionPtr getNameExp() const { return m_nameExp; }
  const ExpressionListPtr& getParams() const { return m_params; }
  void setNoInline() { m_noInline = true; }
+  bool preOutputCPP(CodeGenerator &cg, AnalysisResultPtr ar,
+                    int state);
  void deepCopy(FunctionCallPtr exp);

  FunctionScopeRawPtr getFuncScope() const { return m_funcScope; }
  bool canInvokeFewArgs();
  void setArrayParams() { m_arrayParams = true; }
  bool isValid() const { return m_valid; }
-  bool hadBackslash() const { return m_hadBackslash; }

 protected:
+  void outputDynamicCall(CodeGenerator &cg,
+                         AnalysisResultPtr ar, bool method);
  ExpressionPtr m_nameExp;
  std::string m_name;
  std::string m_origName;
@@ -89,7 +87,6 @@ protected:
  unsigned m_noInline : 1;
  unsigned m_invokeFewArgsDecision : 1;
  unsigned m_arrayParams : 1;
-  bool m_hadBackslash;

  // Extra arguments form an array, to which the scalar array optimization
  // should also apply.
@@ -117,4 +114,4 @@ protected:

 ///////////////////////////////////////////////////////////////////////////////
 }
-#endif // incl_HPHP_FUNCTION_CALL_H_
+#endif // __FUNCTION_CALL_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,20 +14,20 @@
   +----------------------------------------------------------------------+
 */

-#include "hphp/compiler/expression/include_expression.h"
-#include "hphp/util/parser/hphp.tab.hpp"
-#include "hphp/compiler/analysis/code_error.h"
-#include "hphp/compiler/analysis/file_scope.h"
-#include "hphp/compiler/analysis/function_scope.h"
-#include "hphp/compiler/statement/statement_list.h"
-#include "hphp/compiler/option.h"
-#include "hphp/compiler/expression/expression_list.h"
-#include "hphp/compiler/expression/binary_op_expression.h"
-#include "hphp/compiler/analysis/class_scope.h"
-#include "hphp/compiler/parser/parser.h"
-#include "hphp/compiler/analysis/variable_table.h"
-#include "hphp/compiler/expression/scalar_expression.h"
-#include "hphp/util/util.h"
+#include <compiler/expression/include_expression.h>
+#include <util/parser/hphp.tab.hpp>
+#include <compiler/analysis/code_error.h>
+#include <compiler/analysis/file_scope.h>
+#include <compiler/analysis/function_scope.h>
+#include <compiler/statement/statement_list.h>
+#include <compiler/option.h>
+#include <compiler/expression/expression_list.h>
+#include <compiler/expression/binary_op_expression.h>
+#include <compiler/analysis/class_scope.h>
+#include <compiler/parser/parser.h>
+#include <compiler/analysis/variable_table.h>
+#include <compiler/expression/scalar_expression.h>
+#include <util/util.h>

 using namespace HPHP;

@@ -39,7 +39,9 @@ IncludeExpression::IncludeExpression
  : UnaryOpExpression(
      EXPRESSION_CONSTRUCTOR_PARAMETER_VALUES(IncludeExpression),
      exp, op, true),
-    m_documentRoot(false), m_depsSet(false) {
+    m_documentRoot(false), m_privateScope(false),
+    m_privateInclude(false), m_module(false),
+    m_depsSet(false) {
 }

 ExpressionPtr IncludeExpression::clone() {
@@ -55,7 +57,7 @@ ExpressionPtr IncludeExpression::clone() {

 static string get_include_file_path(const string &source,
                                    const string &var, const string &lit,
-                                    bool documentRoot) {
+                                    bool documentRoot, bool relative) {
  if (var.empty()) {
    // absolute path
    if (!lit.empty() && lit[0] == '/') {
@@ -69,7 +71,7 @@ static string get_include_file_path(const string &source,

    struct stat sb;
    // relative path to containing file's directory
-    if (source.empty() && (stat(lit.c_str(), &sb) == 0)) {
+    if (source.empty() && (relative || stat(lit.c_str(), &sb) == 0)) {
      return lit;
    }

@@ -77,11 +79,13 @@ static string get_include_file_path(const string &source,
    string resolved;
    if (pos != string::npos) {
      resolved = source.substr(0, pos + 1) + lit;
-      if (stat(resolved.c_str(), &sb) == 0) {
+      if (relative || stat(resolved.c_str(), &sb) == 0) {
        return resolved;
      }
    }

+    if (relative) return "";
+
    // if file cannot be found, resolve it using search paths
    for (unsigned int i = 0; i < Option::IncludeSearchPaths.size(); i++) {
      string filename = Option::IncludeSearchPaths[i] + "/" + lit;
@@ -154,22 +158,15 @@ static void parse_string_arg(ExpressionPtr exp, string &var, string &lit) {

 string IncludeExpression::CheckInclude(ConstructPtr includeExp,
                                       ExpressionPtr fileExp,
-                                       bool &documentRoot) {
+                                       bool &documentRoot,
+                                       bool relative) {
  string container = includeExp->getLocation()->file;
  string var, lit;
  parse_string_arg(fileExp, var, lit);
  if (lit.empty()) return lit;

-  if (var == "__DIR__") {
-    var = "";
-    // get_include_file_path will check relative to the current file's dir
-    // as long as the first char isn't a /
-    if (lit[0] == '/') {
-      lit = lit.substr(1);
-    }
-  }
-
-  string included = get_include_file_path(container, var, lit, documentRoot);
+  string included = get_include_file_path(container, var, lit,
+                                          documentRoot, relative);
  if (!included.empty()) {
    if (included == container) {
      Compiler::Error(Compiler::BadPHPIncludeFile, includeExp);
@@ -183,7 +180,8 @@ string IncludeExpression::CheckInclude(ConstructPtr includeExp,
 void IncludeExpression::onParse(AnalysisResultConstPtr ar, FileScopePtr scope) {
  /* m_documentRoot is a bitfield */
  bool dr = m_documentRoot;
-  m_include = CheckInclude(shared_from_this(), m_exp, dr);
+  m_include = CheckInclude(shared_from_this(), m_exp,
+                           dr, m_privateScope && !dr);
  m_documentRoot = dr;
  if (!m_include.empty()) ar->parseOnDemand(m_include);
 }
@@ -198,12 +196,20 @@ FileScopeRawPtr IncludeExpression::getIncludedFile(
 }

 std::string IncludeExpression::includePath() const {
-  return m_include;
+  if (m_documentRoot || !m_privateScope) return m_include;
+
+  Variant v;
+  if (m_exp && m_exp->getScalarValue(v) &&
+      v.isString()) {
+    return v.toString()->data();
+  }
+  return "";
 }

 bool IncludeExpression::isReqLit() const {
  return !m_include.empty() &&
-    m_op == T_REQUIRE_ONCE && isDocumentRoot();
+    m_op == T_REQUIRE_ONCE &&
+    (isDocumentRoot() || isPrivateScope());
 }

 bool IncludeExpression::analyzeInclude(AnalysisResultConstPtr ar,
@@ -214,6 +220,13 @@ bool IncludeExpression::analyzeInclude(AnalysisResultConstPtr ar,
    Compiler::Error(Compiler::PHPIncludeFileNotFound, self);
    return false;
  }
+  if (m_module || m_privateInclude) {
+    Lock l(BlockScope::s_constMutex);
+    if (m_module) file->setModule();
+    if (m_privateInclude) {
+      file->setPrivateInclude();
+    }
+  }

  FunctionScopePtr func = getFunctionScope();
  if (func && file->getPseudoMain()) {
@@ -233,10 +246,11 @@ void IncludeExpression::analyzeProgram(AnalysisResultPtr ar) {
      }
    }
  }
-
-  VariableTablePtr var = getScope()->getVariables();
-  var->setAttribute(VariableTable::ContainsLDynamicVariable);
-  var->forceVariants(ar, VariableTable::AnyVars);
+  if (!m_privateScope) {
+    VariableTablePtr var = getScope()->getVariables();
+    var->setAttribute(VariableTable::ContainsLDynamicVariable);
+    var->forceVariants(ar, VariableTable::AnyVars);
+  }

  UnaryOpExpression::analyzeProgram(ar);
 }
@@ -245,7 +259,8 @@ ExpressionPtr IncludeExpression::preOptimize(AnalysisResultConstPtr ar) {
  if (ar->getPhase() >= AnalysisResult::FirstPreOptimize) {
    if (m_include.empty()) {
      bool dr = m_documentRoot;
-      m_include = CheckInclude(shared_from_this(), m_exp, dr);
+      m_include = CheckInclude(shared_from_this(), m_exp,
+                               dr, m_privateScope && !dr);
      m_documentRoot = dr;
      m_depsSet = false;
    }
@@ -271,6 +286,9 @@ ExpressionPtr IncludeExpression::postOptimize(AnalysisResultConstPtr ar) {
          return replaceValue(rep->clone());
        }
      }
+      if (!hhvm || !Option::OutputHHBC) {
+        m_exp.reset();
+      }
    } else {
      m_include = "";
    }
@@ -289,3 +307,53 @@ TypePtr IncludeExpression::inferTypes(AnalysisResultPtr ar, TypePtr type,
 void IncludeExpression::outputPHP(CodeGenerator &cg, AnalysisResultPtr ar) {
  UnaryOpExpression::outputPHP(cg, ar);
 }
+
+void IncludeExpression::outputCPPImpl(CodeGenerator &cg,
+                                      AnalysisResultPtr ar) {
+  // Includes aren't really supported in system mode
+  if (cg.getOutput() == CodeGenerator::SystemCPP) {
+    cg_printf("true");
+    return;
+  }
+  const char *vars = m_privateScope ?
+    "lvar_ptr(LVariableTable())" : "variables";
+  bool require = (m_op == T_REQUIRE || m_op == T_REQUIRE_ONCE);
+  bool once = (m_op == T_INCLUDE_ONCE || m_op == T_REQUIRE_ONCE);
+  if (!m_include.empty()) {
+    FileScopePtr fs = ar->findFileScope(m_include);
+    if (fs) {
+      if (!fs->canUseDummyPseudoMain(ar)) {
+        if (!fs->needPseudoMainVariables()) {
+          vars = "NULL";
+        }
+        cg_printf("%s%s(%s, %s, %s)", Option::PseudoMainPrefix,
+                  fs->pseudoMainName().c_str(),
+                  once ? "true" : "false",
+                  vars, cg.getGlobals(ar));
+      } else {
+        cg_printf("true");
+      }
+      return;
+    }
+  }
+
+  // include() and require() need containing file's directory
+  string currentDir = "\"\"";
+  if (m_loc && m_loc->file && *m_loc->file) {
+    string file = m_loc->file;
+    size_t pos = file.rfind('/');
+    if (pos != string::npos) {
+      currentDir = '"';
+      currentDir += file.substr(0, pos + 1);
+      currentDir += '"';
+    }
+  }
+
+  // fallback to dynamic include
+  cg_printf("%s(", require ? "require" : "include");
+  m_exp->outputCPP(cg, ar);
+  cg_printf(", %s, %s, %s)",
+            once ? "true" : "false",
+            vars,
+            currentDir.c_str());
+}
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,10 +14,10 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_INCLUDE_EXPRESSION_H_
-#define incl_HPHP_INCLUDE_EXPRESSION_H_
+#ifndef __INCLUDE_EXPRESSION_H__
+#define __INCLUDE_EXPRESSION_H__

-#include "hphp/compiler/expression/unary_op_expression.h"
+#include <compiler/expression/unary_op_expression.h>

 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////
@@ -28,7 +28,7 @@ class IncludeExpression : public UnaryOpExpression, public IParseHandler {
 public:
  static std::string CheckInclude(ConstructPtr includeExp,
                                  ExpressionPtr fileExp,
-                                  bool &documentRoot);
+                                  bool &documentRoot, bool relative);

 public:
  IncludeExpression(EXPRESSION_CONSTRUCTOR_PARAMETERS,
@@ -44,6 +44,12 @@ public:
  bool isReqLit() const;
  void setDocumentRoot() { m_documentRoot = true;}
  bool isDocumentRoot() const { return m_documentRoot;}
+  void setPrivateScope() { m_privateScope = true; }
+  bool isPrivateScope() const { return m_privateScope; }
+  void setPrivateInclude() { m_privateInclude = true; }
+  bool isPrivateInclude() const { return m_privateInclude; }
+  void setModule() { m_module = 1; }
+  bool isModule() const { return m_module; }
  std::string includePath() const;
  FileScopeRawPtr getIncludedFile(AnalysisResultConstPtr) const;
 private:
@@ -58,6 +64,9 @@ private:
   * privateInclude means this is the *only* reference to the included file
   */
  unsigned m_documentRoot : 1;
+  unsigned m_privateScope : 1;
+  unsigned m_privateInclude : 1;
+  unsigned m_module : 1;
  unsigned m_depsSet : 1;
  std::string m_include;

@@ -66,4 +75,4 @@ private:

 ///////////////////////////////////////////////////////////////////////////////
 }
-#endif // incl_HPHP_INCLUDE_EXPRESSION_H_
+#endif // __INCLUDE_EXPRESSION_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,16 +14,16 @@
   +----------------------------------------------------------------------+
 */

-#include "hphp/compiler/expression/list_assignment.h"
-#include "hphp/compiler/expression/assignment_expression.h"
-#include "hphp/compiler/expression/expression_list.h"
-#include "hphp/compiler/analysis/file_scope.h"
-#include "hphp/compiler/analysis/function_scope.h"
-#include "hphp/compiler/expression/array_element_expression.h"
-#include "hphp/compiler/expression/object_property_expression.h"
-#include "hphp/compiler/expression/unary_op_expression.h"
-#include "hphp/compiler/expression/binary_op_expression.h"
-#include "hphp/util/parser/hphp.tab.hpp"
+#include <compiler/expression/list_assignment.h>
+#include <compiler/expression/assignment_expression.h>
+#include <compiler/expression/expression_list.h>
+#include <compiler/analysis/file_scope.h>
+#include <compiler/analysis/function_scope.h>
+#include <compiler/expression/array_element_expression.h>
+#include <compiler/expression/object_property_expression.h>
+#include <compiler/expression/unary_op_expression.h>
+#include <compiler/expression/binary_op_expression.h>
+#include <util/parser/hphp.tab.hpp>

 using namespace HPHP;

@@ -73,9 +73,7 @@ static ListAssignment::RHSKind GetRHSKind(ExpressionPtr rhs) {
    case Expression::KindOfObjectMethodExpression:
    case Expression::KindOfNewObjectExpression:
    case Expression::KindOfAssignmentExpression:
-    case Expression::KindOfExpressionList:
    case Expression::KindOfIncludeExpression:
-    case Expression::KindOfYieldExpression:
      return ListAssignment::Regular;

    case Expression::KindOfListAssignment:
@@ -108,24 +106,9 @@ static ListAssignment::RHSKind GetRHSKind(ExpressionPtr rhs) {
    case Expression::KindOfQOpExpression:
      return ListAssignment::Checked;

-    // invalid context
-    case Expression::KindOfArrayPairExpression:
-    case Expression::KindOfParameterExpression:
-    case Expression::KindOfModifierExpression:
-    case Expression::KindOfUserAttribute:
-      always_assert(false);
-
-    // non-arrays
-    case Expression::KindOfScalarExpression:
-    case Expression::KindOfConstantExpression:
-    case Expression::KindOfClassConstantExpression:
-    case Expression::KindOfEncapsListExpression:
-    case Expression::KindOfClosureExpression:
-      return ListAssignment::Null;
+    default: break;
  }
-
-  // unreachable for known expression kinds
-  always_assert(false);
+  return ListAssignment::Null;
 }

 static bool AssignmentCouldSet(ExpressionListPtr vars, ExpressionPtr var) {
@@ -148,10 +131,9 @@ static bool AssignmentCouldSet(ExpressionListPtr vars, ExpressionPtr var) {

 ListAssignment::ListAssignment
 (EXPRESSION_CONSTRUCTOR_PARAMETERS,
- ExpressionListPtr variables, ExpressionPtr array, bool rhsFirst /* = false */)
+ ExpressionListPtr variables, ExpressionPtr array)
  : Expression(EXPRESSION_CONSTRUCTOR_PARAMETER_VALUES(ListAssignment)),
-    m_variables(variables), m_array(array), m_rhsKind(Regular),
-    m_rhsFirst(rhsFirst) {
+    m_variables(variables), m_array(array), m_rhsKind(Regular) {
  setLValue();

  if (m_array) {
@@ -219,7 +201,7 @@ void ListAssignment::analyzeProgram(AnalysisResultPtr ar) {
 }

 ConstructPtr ListAssignment::getNthKid(int n) const {
-  switch (m_rhsFirst ? 1 - n : n) {
+  switch (n) {
    case 0:
      return m_variables;
    case 1:
@@ -236,7 +218,7 @@ int ListAssignment::getKidCount() const {
 }

 void ListAssignment::setNthKid(int n, ConstructPtr cp) {
-  switch (m_rhsFirst ? 1 - n : n) {
+  switch (n) {
    case 0:
      m_variables = boost::dynamic_pointer_cast<ExpressionList>(cp);
      break;
@@ -281,3 +263,154 @@ void ListAssignment::outputPHP(CodeGenerator &cg, AnalysisResultPtr ar) {
    cg_printf(")");
  }
 }
+
+static string getArrRef(const string &arrTmp, int index) {
+  if (arrTmp == "null_variant") return arrTmp;
+  return arrTmp + "[" + lexical_cast<string>(index) + "]";
+}
+
+bool ListAssignment::outputCPPAssignment(CodeGenerator &cg,
+                                         AnalysisResultPtr ar,
+                                         const string &arrTmp, bool subRef) {
+  if (!m_variables) return false;
+
+  bool ret = false;
+  for (int i = m_variables->getCount() - 1; i >= 0; --i) {
+    ExpressionPtr exp = (*m_variables)[i];
+    if (exp) {
+      if (exp->is(Expression::KindOfListAssignment)) {
+        ListAssignmentPtr sublist = dynamic_pointer_cast<ListAssignment>(exp);
+        string subTmp;
+        if (arrTmp == "null_variant") {
+          subTmp = arrTmp;
+        } else {
+          subTmp = genCPPTemp(cg, ar);
+          cg_printf("Variant %s((%s(%s[%d])));\n",
+                    subTmp.c_str(), subRef ? "strongBind" : "",
+                    arrTmp.c_str(), i);
+        }
+        if (sublist->outputCPPAssignment(cg, ar, subTmp, subRef)) ret = true;
+      } else {
+        ret = true;
+        bool done = false;
+        if (exp->is(Expression::KindOfArrayElementExpression)) {
+          ArrayElementExpressionPtr arrExp =
+            dynamic_pointer_cast<ArrayElementExpression>(exp);
+          if (!arrExp->isSuperGlobal() && !arrExp->isDynamicGlobal()) {
+            arrExp->getVariable()->outputCPP(cg, ar);
+            if (arrExp->getOffset()) {
+              cg_printf(".set(");
+              arrExp->getOffset()->outputCPP(cg, ar);
+              cg_printf(", ");
+            } else {
+              cg_printf(".append(");
+            }
+            cg_printf("%s);\n", getArrRef(arrTmp, i).c_str());
+            done = true;
+          }
+        } else if (exp->is(Expression::KindOfObjectPropertyExpression)) {
+          ObjectPropertyExpressionPtr var(
+            dynamic_pointer_cast<ObjectPropertyExpression>(exp));
+          if (!var->isValid()) {
+            var->outputCPPObject(cg, ar);
+            cg_printf("o_set(");
+            var->outputCPPProperty(cg, ar);
+            cg_printf(", %s, %s);\n",
+                      getArrRef(arrTmp, i).c_str(),
+                      getClassScope() ? "s_class_name" : "empty_string");
+            done = true;
+          }
+        }
+        if (!done) {
+          exp->outputCPP(cg, ar);
+          cg_printf(" = %s;\n", getArrRef(arrTmp, i).c_str());
+        }
+      }
+    }
+  }
+  return ret;
+}
+
+void ListAssignment::preOutputVariables(CodeGenerator &cg,
+                                        AnalysisResultPtr ar,
+                                        int state) {
+  for (int i = 0, c = m_variables->getCount(); i < c; ) {
+    if (ExpressionPtr exp = (*m_variables)[i++]) {
+      if (i == c) {
+        state = 0;
+      }
+      if (exp->is(Expression::KindOfListAssignment)) {
+        static_pointer_cast<ListAssignment>(exp)->
+          preOutputVariables(cg, ar, state);
+      } else {
+        exp->preOutputCPP(cg, ar, state);
+      }
+    }
+  }
+}
+
+bool ListAssignment::preOutputCPP(CodeGenerator &cg, AnalysisResultPtr ar,
+                                  int state) {
+  assert(m_array);
+
+  if (!cg.inExpression()) return true;
+
+  if (m_variables) {
+    preOutputVariables(cg, ar, m_variables->hasEffect() ||
+                       m_array->hasEffect() ? FixOrder : 0);
+  }
+  m_array->preOutputCPP(cg, ar, 0);
+
+  bool isArray = false, notArray = false;
+  bool simpleVar = m_array->is(KindOfSimpleVariable) &&
+    !static_pointer_cast<SimpleVariable>(m_array)->getAlwaysStash();
+  bool needsUse = false;
+  if (TypePtr type = m_array->getActualType()) {
+    isArray = type->is(Type::KindOfArray);
+    notArray = !isArray &&
+      (type->isPrimitive() ||
+       m_rhsKind == Null ||
+      (m_rhsKind == Checked && (type->is(Type::KindOfString) ||
+                                type->is(Type::KindOfObject))));
+  }
+  cg.wrapExpressionBegin();
+  if (outputLineMap(cg, ar)) cg_printf("0);\n");
+  if (notArray && isUnused()) {
+    if (m_array->outputCPPUnneeded(cg, ar)) cg_printf(";\n");
+    m_cppTemp = "null";
+  } else {
+    m_cppTemp = genCPPTemp(cg, ar);
+    needsUse = simpleVar || m_array->isTemporary();
+    const char *decl;
+    if (isArray && m_array->getCPPType()->is(Type::KindOfArray)) {
+      decl = needsUse ? "CArrRef" : "Array";
+    } else {
+      decl = needsUse ? "CVarRef" : "Variant";
+    }
+    cg_printf("%s %s((", decl, m_cppTemp.c_str());
+    m_array->outputCPP(cg, ar);
+    cg_printf("));\n");
+  }
+  std::string tmp;
+  if (notArray) {
+    tmp = "null_variant";
+    if (needsUse) cg_printf("id(%s);\n", m_cppTemp.c_str());
+    needsUse = false;
+  } else if (m_rhsKind != Checked || isArray) {
+    tmp = m_cppTemp;
+  } else {
+    tmp = genCPPTemp(cg, ar);
+    cg_printf("CVarRef %s(f_is_array(%s)?%s:null_variant);\n",
+              tmp.c_str(), m_cppTemp.c_str(), m_cppTemp.c_str());
+    needsUse = true;
+  }
+  if (!outputCPPAssignment(cg, ar, tmp, simpleVar) && needsUse) {
+    cg_printf("id(%s);\n", tmp.c_str());
+  }
+
+  return true;
+}
+
+void ListAssignment::outputCPPImpl(CodeGenerator &cg, AnalysisResultPtr ar) {
+  not_reached();
+}
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,12 +14,12 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_LIST_ASSIGNMENT_H_
-#define incl_HPHP_LIST_ASSIGNMENT_H_
+#ifndef __LIST_ASSIGNMENT_H__
+#define __LIST_ASSIGNMENT_H__

-#include "hphp/compiler/expression/expression.h"
-#include "hphp/compiler/expression/simple_variable.h"
-#include "hphp/compiler/analysis/variable_table.h"
+#include <compiler/expression/expression.h>
+#include <compiler/expression/simple_variable.h>
+#include <compiler/analysis/variable_table.h>

 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////
@@ -35,8 +35,7 @@ public:
    Null
  };
  ListAssignment(EXPRESSION_CONSTRUCTOR_PARAMETERS,
-                 ExpressionListPtr variables, ExpressionPtr array,
-                 bool rhsFirst = false);
+                 ExpressionListPtr variables, ExpressionPtr array);

  DECLARE_EXPRESSION_VIRTUAL_FUNCTIONS;

@@ -44,17 +43,20 @@ public:

  ExpressionListPtr getVariables() const { return m_variables; }
  ExpressionPtr getArray() const { return m_array; }
-  bool isRhsFirst() { return m_rhsFirst; }
 private:
  ExpressionListPtr m_variables;
  ExpressionPtr m_array;
  RHSKind m_rhsKind;
-  bool m_rhsFirst;

  void setLValue();
+  bool outputCPPAssignment(CodeGenerator &cg, AnalysisResultPtr ar,
+                           const std::string &arrTmp, bool subRef);
+
+  void preOutputVariables(CodeGenerator &cg, AnalysisResultPtr ar, int state);
+  bool preOutputCPP(CodeGenerator &cg, AnalysisResultPtr ar, int state);
 };

 ///////////////////////////////////////////////////////////////////////////////
 }

-#endif // incl_HPHP_LIST_ASSIGNMENT_H_
+#endif // __LIST_ASSIGNMENT_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,8 +14,8 @@
   +----------------------------------------------------------------------+
 */

-#include "hphp/compiler/expression/modifier_expression.h"
-#include "hphp/util/parser/hphp.tab.hpp"
+#include <compiler/expression/modifier_expression.h>
+#include <util/parser/hphp.tab.hpp>

 using namespace HPHP;

@@ -134,3 +134,20 @@ void ModifierExpression::outputPHP(CodeGenerator &cg, AnalysisResultPtr ar) {
    }
  }
 }
+
+void ModifierExpression::outputCPPImpl(CodeGenerator &cg,
+                                       AnalysisResultPtr ar) {
+  /**
+   * Not sure if we can bar access coding errors...
+  if (isPublic()) {
+    cg_printf("public: ");
+  } else if (isProtected()) {
+    cg_printf("protected: ");
+  } else {
+    cg_printf("private: ");
+  }
+  */
+  cg_printf("public: ");
+
+  if (isStatic()) cg_printf("static ");
+}
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,10 +14,10 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_MODIFIER_EXPRESSION_H_
-#define incl_HPHP_MODIFIER_EXPRESSION_H_
+#ifndef __MODIFIER_EXPRESSION_H__
+#define __MODIFIER_EXPRESSION_H__

-#include "hphp/compiler/expression/expression.h"
+#include <compiler/expression/expression.h>

 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////
@@ -26,7 +26,7 @@ DECLARE_BOOST_TYPES(ModifierExpression);

 class ModifierExpression : public Expression {
 public:
-  explicit ModifierExpression(EXPRESSION_CONSTRUCTOR_PARAMETERS);
+  ModifierExpression(EXPRESSION_CONSTRUCTOR_PARAMETERS);

  DECLARE_BASE_EXPRESSION_VIRTUAL_FUNCTIONS;

@@ -52,4 +52,4 @@ private:
 ///////////////////////////////////////////////////////////////////////////////
 }

-#endif // incl_HPHP_MODIFIER_EXPRESSION_H_
+#endif // __MODIFIER_EXPRESSION_H__
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,14 +14,14 @@
   +----------------------------------------------------------------------+
 */

-#include "hphp/compiler/expression/new_object_expression.h"
-#include "hphp/compiler/expression/scalar_expression.h"
-#include "hphp/compiler/expression/expression_list.h"
-#include "hphp/compiler/analysis/code_error.h"
-#include "hphp/compiler/analysis/class_scope.h"
-#include "hphp/compiler/analysis/function_scope.h"
-#include "hphp/compiler/option.h"
-#include "hphp/compiler/analysis/variable_table.h"
+#include <compiler/expression/new_object_expression.h>
+#include <compiler/expression/scalar_expression.h>
+#include <compiler/expression/expression_list.h>
+#include <compiler/analysis/code_error.h>
+#include <compiler/analysis/class_scope.h>
+#include <compiler/analysis/function_scope.h>
+#include <compiler/option.h>
+#include <compiler/analysis/variable_table.h>

 using namespace HPHP;

@@ -32,7 +32,7 @@ NewObjectExpression::NewObjectExpression
 (EXPRESSION_CONSTRUCTOR_PARAMETERS,
 ExpressionPtr variable, ExpressionListPtr params)
  : FunctionCall(EXPRESSION_CONSTRUCTOR_PARAMETER_VALUES(NewObjectExpression),
-                 variable, "", false, params, variable),
+                 variable, "", params, variable),
    m_dynamic(false) {
  /*
    StaticClassName takes care of parent & self properly, so
@@ -157,9 +157,231 @@ TypePtr NewObjectExpression::inferTypes(AnalysisResultPtr ar, TypePtr type,
 // code generation functions

 void NewObjectExpression::outputPHP(CodeGenerator &cg, AnalysisResultPtr ar) {
+  outputLineMap(cg, ar);
+
  cg_printf("new ");
  m_nameExp->outputPHP(cg, ar);
  cg_printf("(");
  if (m_params) m_params->outputPHP(cg, ar);
  cg_printf(")");
 }
+
+void NewObjectExpression::preOutputStash(CodeGenerator &cg,
+                                         AnalysisResultPtr ar, int state) {
+  if (hasCPPTemp()) return;
+  if (!m_receiverTemp.empty()) {
+    TypePtr e = getExpectedType();
+    if (!e || !Type::IsCastNeeded(ar, getActualType(), e)) {
+      bool unused = isUnused();
+      setUnused(true);
+      outputCPPImpl(cg, ar);
+      setUnused(unused);
+      setCPPTemp(m_receiverTemp);
+      cg_printf(";\n");
+      return;
+    }
+  }
+  optimizeArgArray(ar);
+  FunctionCall::preOutputStash(cg, ar, state);
+}
+
+void NewObjectExpression::outputCPPImpl(CodeGenerator &cg,
+                                        AnalysisResultPtr ar) {
+  string &cname = isSelf() || isParent() ? m_name : m_origName;
+  bool outsideClass = !isPresent();
+  if (m_classScope &&
+      (m_classScope->isAbstract() ||
+       m_classScope->isTrait() ||
+       m_classScope->isInterface())) {
+    cg_printf("throw_fatal(\"Cannot instantiate %s %s\").toObject()",
+              m_classScope->isTrait() ? "trait" :
+              m_classScope->isInterface() ? "interface" : "abstract class",
+              CodeGenerator::EscapeLabel(
+                m_classScope->getOriginalName()).c_str());
+    return;
+  }
+
+  if (!m_name.empty() && m_classScope && !m_dynamic) {
+    ClassScopePtr cls = m_classScope;
+
+    const string& lClassName = cls->getId();
+    bool skipCreate = cls->canSkipCreateMethod(ar);
+    if (skipCreate && m_params && m_params->getCount()) {
+      cg_printf("(");
+      for (int i = 0; i < m_params->getCount(); i++) {
+        ExpressionPtr e = (*m_params)[i];
+        if (!e->isScalar() && !e->hasCPPTemp()) {
+          cg_printf("id(");
+          e->outputCPP(cg, ar);
+          cg_printf("), ");
+        }
+      }
+    }
+    if (m_receiverTemp.empty()) {
+      if (outsideClass) {
+        cls->outputVolatileCheckBegin(cg, ar, getScope(), cname);
+      }
+      cg_printf("%s%s(((%s%s*)%s%s())",
+                Option::SmartPtrPrefix, lClassName.c_str(),
+                Option::ClassPrefix, lClassName.c_str(),
+                Option::CreateObjectOnlyPrefix, lClassName.c_str());
+    } else {
+      cg_printf("((%s%s*)%s.get()",
+                Option::ClassPrefix, lClassName.c_str(),
+                m_receiverTemp.c_str());
+    }
+
+
+    if (skipCreate) {
+      assert(!m_params || m_params->getOutputCount() == 0);
+    } else {
+      cg_printf("->create(");
+      FunctionScope::OutputCPPArguments(m_params, m_funcScope, cg, ar,
+                                        m_extraArg, m_variableArgument,
+                                        m_argArrayId, m_argArrayHash,
+                                        m_argArrayIndex);
+      cg_printf(")");
+    }
+
+    if (cls->needsEnableDestructor(ar)) {
+      cg_printf("->clearNoDestruct()");
+    }
+    if (m_receiverTemp.empty()) {
+      cg_printf(")");
+      if (outsideClass) {
+        cls->outputVolatileCheckEnd(cg);
+      }
+    } else {
+      if (!isUnused()) {
+        cg_printf(", %s", m_receiverTemp.c_str());
+      }
+      cg_printf(")");
+    }
+    if (skipCreate && m_params && m_params->getCount()) {
+      cg_printf(")");
+    }
+  } else {
+    bool wrap = false;
+    wrap = m_actualType && m_actualType->is(Type::KindOfVariant) &&
+      !m_expectedType && !m_implementedType;
+    if (wrap) {
+      cg_printf("((Variant)");
+    }
+    cg_printf("id(obj%d)", m_objectTemp);
+    if (wrap) {
+      cg_printf(")");
+    }
+  }
+}
+
+bool NewObjectExpression::preOutputCPP(CodeGenerator &cg, AnalysisResultPtr ar,
+                                       int state) {
+  if (m_classScope &&
+      (m_classScope->isAbstract() ||
+       m_classScope->isInterface() ||
+       m_classScope->isTrait())) {
+    return false;
+  }
+
+  string &cname = isSelf() || isParent() ? m_name : m_origName;
+  if (m_name.empty() || !m_classScope || m_dynamic) {
+    // Short circuit out if inExpression() returns false
+    if (!cg.inExpression()) return true;
+
+    if (m_nameExp) m_nameExp->preOutputCPP(cg, ar, 0);
+    cg.wrapExpressionBegin();
+    m_ciTemp = cg.createNewLocalId(shared_from_this());
+    m_objectTemp = cg.createNewLocalId(shared_from_this());
+    cg_printf("Object obj%d(", m_objectTemp);
+    if (isRedeclared()) {
+      bool outsideClass = !isPresent();
+      if (outsideClass) {
+        ClassScope::OutputVolatileCheckBegin(cg, ar, getScope(), cname);
+      }
+      cg_printf("g->%s%s->createOnly()", Option::ClassStaticsCallbackPrefix,
+                m_name.c_str());
+      if (outsideClass) {
+        ClassScope::OutputVolatileCheckEnd(cg);
+      }
+    } else {
+      cg_printf("create_object_only(");
+      if (isStatic()) {
+        cg_printf("FrameInjection::GetStaticClassName(fi.getThreadInfo())");
+      } else if (!cname.empty()) {
+        cg_printString(cname, ar, getScope(), true);
+      } else if (m_nameExp->is(Expression::KindOfSimpleVariable)) {
+        m_nameExp->outputCPP(cg, ar);
+      } else {
+        cg_printf("(");
+        m_nameExp->outputCPP(cg, ar);
+        cg_printf(")");
+      }
+      cg_printf(")");
+    }
+    cg_printf(");\n");
+    cg_printf("MethodCallPackage mcp%d;\n", m_ciTemp);
+    cg_printf("mcp%d.construct(obj%d);\n", m_ciTemp, m_objectTemp);
+    cg_printf("const CallInfo *cit%d = mcp%d.ci;\n", m_ciTemp, m_ciTemp);
+
+    int pcount = m_params ? m_params->getCount() : 0;
+    if (pcount > 0) {
+      cg.pushCallInfo(m_ciTemp);
+      m_params->preOutputCPP(cg, ar, 0);
+      cg.popCallInfo();
+    }
+
+    cg_printf("(cit%d->", m_ciTemp);
+    outputDynamicCall(cg, ar, true);
+    cg_printf(";\n");
+    if (!m_classScope ||
+        m_classScope->derivesFromRedeclaring() ||
+        m_classScope->hasAttribute(ClassScope::HasDestructor, ar)) {
+      cg_printf("obj%d.get()->clearNoDestruct();\n", m_objectTemp);
+    }
+
+    if (state & FixOrder) {
+      cg.pushCallInfo(m_ciTemp);
+      preOutputStash(cg, ar, state);
+      cg.popCallInfo();
+    }
+
+    return true;
+  } else {
+    bool tempRcvr = true;
+
+    bool paramEffect = false;
+    if (m_params && m_params->getCount() > 0) {
+      for (int i = m_params->getCount(); i--; ) {
+        if (!(*m_params)[i]->isScalar()) {
+          paramEffect = true;
+          break;
+        }
+      }
+    }
+
+    if (!paramEffect) {
+      tempRcvr = false;
+    }
+
+    if (tempRcvr && cg.inExpression()) {
+      bool outsideClass = !isPresent();
+      cg.wrapExpressionBegin();
+      m_receiverTemp = genCPPTemp(cg, ar);
+      cg_printf("%s%s %s = ",
+                Option::SmartPtrPrefix, m_classScope->getId().c_str(),
+                m_receiverTemp.c_str());
+      if (outsideClass) {
+        m_classScope->outputVolatileCheckBegin(cg, ar, getScope(), cname);
+      }
+      cg_printf("%s%s()",
+                Option::CreateObjectOnlyPrefix,
+                m_classScope->getId().c_str());
+      if (outsideClass) {
+        m_classScope->outputVolatileCheckEnd(cg);
+      }
+      cg_printf(";\n");
+    }
+
+    return FunctionCall::preOutputCPP(cg, ar, state) || tempRcvr || isUnused();
+  }
+}
@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   | HipHop for PHP                                                       |
   +----------------------------------------------------------------------+
-   | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com)     |
+   | Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com)         |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -14,10 +14,10 @@
   +----------------------------------------------------------------------+
 */

-#ifndef incl_HPHP_NEW_OBJECT_EXPRESSION_H_
-#define incl_HPHP_NEW_OBJECT_EXPRESSION_H_
+#ifndef __NEW_OBJECT_EXPRESSION_H__
+#define __NEW_OBJECT_EXPRESSION_H__

-#include "hphp/compiler/expression/function_call.h"
+#include <compiler/expression/function_call.h>

 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////
@@ -31,7 +31,9 @@ public:

  DECLARE_BASE_EXPRESSION_VIRTUAL_FUNCTIONS;

+  bool preOutputCPP(CodeGenerator &cg, AnalysisResultPtr ar, int state);
  virtual bool isRefable(bool checkError = false) const { return checkError; }
+  void preOutputStash(CodeGenerator &cg, AnalysisResultPtr ar, int state);
  bool isTemporary() const { return true; }
 private:
  bool m_dynamic;
@@ -41,4 +43,4 @@ private:

 ///////////////////////////////////////////////////////////////////////////////
 }
-#endif // incl_HPHP_NEW_OBJECT_EXPRESSION_H_
+#endif // __NEW_OBJECT_EXPRESSION_H__
--- a/Mostrar Mais
+++ b/Mostrar Mais