by expanding our test harness to be closer to how the tests get
run under pytest (which we don't support yet)

Also fix a couple minor things that this turned up.  There is a lot more
to be found here: the new harness supports many more of the sqlalchemy
tests, a number of which aren't working for us.  Also there is some
sort of issue with the current tests that we run, since repeating the tests
multiple times will end up crashing.

Fix set comparisons

Allow changing the number of default arguments

We already supported changing the values, but not the number
of them.  The main trickiness here is
- We had been assuming that the number of defaults was immutable,
  so I had to find the places that we used it and add invalidation.
- We assumed that all functions based on the same source function would
  have the same number of defaults.

For the first one, I found all the places that looked at the defaults array,
which should hopefully be all the places that need invalidation.

One tricky part is that we will embed the num_defaults data into code produced
by the LLVM tier, and we currently don't have any mechanism for invalidating
those functions.  This commit side-steps around that since the only functions that
we can inline are the builtins, and those you aren't allowed to change the defaults
anyway.  So I added a "can_change_defaults" flag.

For the second part, I moved "num_defaults" from the CLFunction (our "code" object)
to the BoxedFunction (our "function" object), and then changed the users to pull
it from there.

Implment some PyNumber_XXX function, to enable "test_operator"

PrintVisitor: use raw_ostream

Implement some PyNumber_XXX function, most of the code are copy from CPython with some Pyston changes

Type system fix: need to add unpacking to the type system

Used a hardcoded CXX exception style in the non-rewriteable case.

ie concerning things like:
  a, b = 1, 2

The irgen phase already knows how to do unpacking in a type-analyzed
way (a and b will be of type int), but type speculation needed to
have that added.

rewrite oldstyle class getattro

Optionally move objects around in memory to prepare Pyston for a moving collector.

Last few fixes to make sqlalchemy_declarative work

This will reallocate all objects in the small heap and update
all references that were pointing to this object.

This is not functional yet, there are still references that we are not
tracking at other points in the program, so it's still gated behind the
MOVING_GC flag.

- Refactor the stack logic into a separate data structure ChunkedStack,
  keep the push function that deals with marking as functionality specific
  to a subclass of ChunkedStack (no virtual, just reuse code).
- Add an additional (disabled) phase that maps out the reference graph
  reachable objects after the sweep phase. Prepare moving all objects in
  the small heap.

Also, rename TraceStack to TraversalWorklist because the fact
that we're using a stack is an implementation detail.

Moving gcs will need this to update pointers. There should not be any
extra dereference, it will just happen on the other side of the
function.

Use templates to avoid direct (void**) casts -- make sure we're always
passing an pointer of the form T**.

It's easier to tell the two constants apart if they are different.

They tends to time out or just make the test suite run for longer. They definitely times out
when running a prototype moving gc.

Scan constants written into compiled code.

A GC could happen during the rewrite.

Scan rewriters for interior pointers

We need to do this because the ICInvalidator pointers are stored inside
Pyston heap objects.

Some improvments that let test_index could pass

Sqlalchemy compatibility fixes

Sqlalchemy subclasses set, and overrides __init__ and does some
custom initialization there.  We were doing the initialization in
__new__, which works most of the time, except if a generator was
passed since then sqlalchemy's initialization will see what looks
like an empty generator since we already consumed it.

So move the initialization to init.  Except for frozenset which still
needs to do it in new.

In CPython, str.add directly throws a TypeError since it is implemented
as a sq_concat.  sqlalchemy relies on being able to do str()+MyStr() and
use MyStr.__radd__ to handle the addition.  We were throwing a TypeError
but not implementing it in sq_concat.

So instead, return NotImplemented instead of directly throwing a TypeError.
This makes '+' more compatible but str.__add__ a bit less compatible.