some improvements in intNew

Misc fixes for sqlalchemy

It would memorize whether or not to call __getattr__, and didn't do enough
guarding to make sure that that was the case.

need to free the metaclasses in the same collection.

A discrepancy between irgen and type_analysis was causing an assertion.  The
difference was that irgen will do full type inference for things that get put
into closures (ie in the parent scope), but type_analysis was bailing and
just saying that it was unknown.

Support the "decorator" library

`print >>None` goes to stdout, and printing to things without write()
functions should throw exceptions.

by converting to our DICT_BACKED hidden class strategy.

Set a flag on the class, rather than having to specify a whitelist.
Even though this is pretty annoying I think it's still worth it.

ie exec and eval statements are supposed to start with the future
flags of the scope in which they are called.  Our flags currently
get applied after parsing, which for the most part is fine, except
print_statement which actually changes the result of parsing.

ie `exec "print(1, 2)"` could either be parsed as a function call,
which will print "1 2", or as a print statement of a tuple, which
prints out "(1, 2)".  So thread the future flags through the parsing
stages as well.

Try to fix set-dtor segfault

The line of a decorated function is the decorator

This is the test for the fix in vinzenz/libpypa#49

fix Makefile to be able to 'make' after 'make clean'

The issue is that the set destructor, which is marked as "safe",
will try to access the type object.  But a safe destructor is not
allowed to assume that any objects are alive, including its own class.

We do actually force the class to be alive during a safe destructor,
but the tp_mro field was not so lucky.  We could try to address this by
saying again that types have ordered finalizers, which will cause them
to also keep their references alive.  But this doesn't completely work
since it will cause issues with objects that have actual ordered finalizers.

So for now, just remove type-check from the destructor.

Properly handle METH_COEXIST

By importing the cpython implementations of add_methods / add_members /
add_getset.

Set cls->has_getattribute for extension classes

Misc small fixes for lxml

this got introduced in c9598857 for getattr

this is how cpython does it.
The implementation of PyImport_ImportModule is still very different and I haven't verified it any further
but at least this now lets "from lxml import objectify" work (it internally imports "lxml.etree")

Also remove a few asserts when assembly generation failed
and teach type_analysis about None and while there cache the scope result.

use it for attrwrapper_cls (This gets also often called for real dicts but the implement the mapping already)

This is an optimization but also fixes an lxml issue:
it calls AttrWrapper::getitem even though an error is currenly set. (which would assert if we do a callFunc call for the getitem)

Fix repr() of oldstyle class infinite recursion. add _PyErr_BadInternalCall and PyCFunction_GetFlags

before it produced the following exception:
TypeError: unicode() got multiple values for keyword argument 'encoding'

Copy in the rest of CPython's tests

Some xrange improvments

Gc fix

Add missing tp_iter and tp_iternext functions

1) instead of hooking loadConst to automatically find GC references,
   add an API for specifically saying that a reference needs to be tracked
   (I think/hope there aren't more that do this)
2) change the way we store the gc references so that it's O(#references) to
   scan them instead of O(#ics).

I think this is actually pretty decent, as long as we don't
depend on the class's gc pointers being dereferenceable.
We could go back to having the finalization-ordering algorithm
handle this part, but it gets tricky when the class can refer
back to instances of itself (the situation that prompted this).