give up on matching Zend's error messges
Add map(), filter(), zip() APIs for collections
@override-unit-failures Initial support for <?hh typedefs and shapes

Adds runtime support for non-class typehints.  Typedefs are
introduced using type statements, and autoloaded via a new autoload
map entry.  Shapes are parsed but the structure is currently thrown
away and treated as arrays at runtime.  This extends the NamedEntity
structure to sometimes cache 'NameDefs', which are either Typedef*'s
or Class*'s.  VerifyParamType now has to check for typedefs if an
object fails a class check, or when checking non-Object types against
a non-primitive type name that isn't a class.
ContEnter needs to depend on the frame pointer

ContEnter used rVmFp without making it visible in SSA.  This
didn't cause any issues yet because I've never tried to inline
functions that contain a ContEnter.
Allow script to be run without -z option

I switched to using a temporary directory for the test run, but never wrote a way to use the existing bad tests. Now it just copies the bad tests to ##all## and runs them there.

Should I rename this script? ##tools/zend_tests.py## or something?
Someone might want to run this test in another timezone
disable broken tests

@bsimmers says they are bad. I'll disable while I debug.

  mv test/zend/good/zend/bug31102* test/zend/bad/zend/
  mv test/zend/good/zend/ns_029* test/zend/bad/zend/
  mv test/zend/good/zend/ns_030* test/zend/bad/zend/
Make NaN -> int casting explicit

See the task for details, but the bottom line is that casting NaN to an
int in PHP is passed straight through to the hardware's
convert-floating-point-to-scalar instruction. This implementation
explicitly spells out the Intel instruction's behavior. The ARM
instruction always outputs zero instead, resulting in inconsistency.

To be clear, I'm OK with not checking this in. For one thing, I'd bet
that if you compiled Zend on ARM, it would cast NaN to zero (I haven't
tried it). The advantage that this gets us is consistent output on all
platforms.
expose return type constraint (aka hint) from the AST to the runtime and reflection

This is the first part of the work to expose type constraint and generic all the way to reflection. This first DIFF exposes the return type with generic types coming next.
Avoid stack overflow on super-large expressions of binary operators.

A small change to optimize very simple binary operators in the parser. This avoids building very large parse trees for super-large expressions and folds binary operators involving two scalars directly in the parser. I've limited this to simple scalars since it's easy to prove they don't have anything too interesting going on in the other analysis phases leading up to BinaryOpExpression's normal folding. This works for all binary operators.
Partition the tc into hot/cold sections

We already generate the data for this, so lets use it.
DecRefKillThis needs the frame as an SSA dependency

We couldn't see this during ActRec elimination for inlining,
leading to bugs where the wrong this pointer would be decref'd and
then zero'd.  Also take the opportunity to remove a boolean parameter.
RFC: Pass the assembler to use to unlikelyIfBlock

In tx64, a common bug (for me) was to accidentally type "a."
instead of "astubs." when writing code inside an UnlikelyIfBlock,
since your fingers get used to the former.  More generally, it seems
like we should abstract the target assembler from actual codegen in
most cases (we currently really do this in the IR only insofar as
"m_a" might be pointing at "m_astubs", but it's only safe sometimes).

This is just an RFC, because otoh there are less significant chunks of
direct assembler code in codegen.cpp, and maybe it doesn't matter much
unless we also switch "m_as" to be "a".  Thoughts?
Move a couple zend tests back to bad
Prevent elimination of stores to generator params

After some recent cleanup to generators, local analysis was
able to remove some stores that it shouldnt have done, because
it didnt take account of the fact that the locals were
generator parameters.
Specialized code generation for more of the ConvXxxToDbl instructions.

Rather than using just two general purpose helpers, there are now some specialized helpers and more inline code. Also, the flags in ir.h are now more accurate.
Fix an exception safety issue for undefined properties in vectortranslator

I think the only case where we currently don't spillstack as
part of a vector translation is CGetM of a defined property.  However,
this can still raise exceptions in the unlikely case of an unset
property.  For now, just spill before any vector translation---a
follow up diff relaxes this to not do it in cases where we know the
property can't be undefined.  Presumably later we'll push the
spillstacks into the unlikely paths for these translations (or put
them in unwind handlers)---currently we can't handle control flow
where the join point has a different stack.
Some comments about use of rVmFp and rVmSp in codegen

We shouldn't be using these registers directly nearly as much
as was appropriate in tx64.
Use hphpc-inferred object property types to avoid KindOfUninit checks

The frontend appears to alread pessimize its prediction of
object property types whenever an UnsetContext might affect a given
property.  We can use this to avoid checking for KindOfUninit when
doing specialized prop gets in the vectortranslator.  This is
hopefully going to be worth more than it sounds, because it will let
us avoid a spillStack, which is a use of the frame and will prevent an
inlined getter from removing the ActRec (unless we implement some kind
of sinking for frames).
Clean up ArrayData APIs for mutable iteration

Replaces the awkward getFullPos() and setFullPos() methods with a more
intuitive advanceFullPos() method. This refactoring also reduces the number
of virtual calls made when doing mutable iteration on an array.