through syntax error when you to `del` a var stored in a closure

add option to tester script to skip specified tests

Conflicts:
	src/codegen/ast_interpreter.cpp
	src/runtime/types.cpp

Update INSTALLING.md

add "sudo" before apt-get
It seems a typo?

add StackRoot<> and #defines for DECREF

add a variadic template ctor that delegates to T's constructor (making things potentially a bit more compact for constructing rooted boxes)

Misc fixes for virtualenv / pip

+ fix a test failing because of a slightly different error message than cpython 2.7.8

Previously we would say that they were coming from the same
file as they are executed in, typically on line 1, which would
give a misleading traceback saying that the module docstring
threw the error.

Now, do what CPython does and say that the file is "<string>",
and don't display the source line.

The method is pretty hacky right now, where it only makes this
adjustment when generating the traceback.  Instead we should probably
get rid of storing the BoxedModule in the sourceinfo in the first place,
and just passing around the relevant info (fn, locals, globals, etc).

Conflicts:
	src/codegen/ast_interpreter.cpp
	src/codegen/irgen/irgenerator.cpp
	src/codegen/pypa-parser.cpp

in merge:
- with_ctxclass_instance_attrs now succeeds due to d1387d74
- merge ~conflict in LangPrimitive opcodes

Remove dbg -O and release -n configurations.

Just for dev; leave Travis-CI the way it is for now.

They test what happens when a weakref's referent gets collected, but
I guess in certain build configurations we would keep the object alive
due to some sort of different memory layout (got saved in a CSR or
a stack slot that didn't get rewritten, etc).

Adding some extra function calls seems to help, though it's hard to tell
how reliable it is.

Misc fixes for pip part 3

Use cpythons isinstance and issubclass implementation

Use the pypa parser as the default parser.

and let the interpreter actually do a cls lookup when encountering a ClsAttribute node...

but both args have to fit into an int...

This commit removes our implementation of this functions,
because they could not handle mixing of old and new style classes.
And having two implementations with very similar name but different
results is very confusing.
Also adds __subclasscheck__ and __instancecheck__ support

Switches the meaning of -x.
In addition update to latest pypa version

Previously it was UNTRACKED and the object's gcHandler would scan
it if necessary.  This worked ok most of the time but caused issues
when we subclass from an extension class: the memory for those classes
are allocated conservatively, which meant that a gc handler wasn't
called.

One potential approach would be to allocate extension objects as PYTHON
allocations but with a gcHandler that both scans conservatively and also
knows about the attrs array.  But for now it seems easier to allocate the
attrs array as a PRECISE array (which means it gets scanned) rather than
UNTRACKED, since it will automatically get picked up (and provide better
gc safety in general and remove one of the odd gc cases).

I didn't realize that we weren't using PRECISE at all and that it wasn't
completely working, so this change also required setting kind_data for
PRECISE allocations, and fixing the way we keep this updated during
gc_realloc.

- Add some more time functions
- Workaround for logging for now, to not try to show the caller frame
- Copy over everything in LIBPYSTON in the cmake build
  (useful for django to copy over things like templates)
- Allow str/unicode subclasses in more places
- Add a BoxedFile gc handler
- PyLong_FromString
- set.difference
- iter(iter(""))

cache BoxedString*'s for a module's constant AST_TYPE::Str nodes.  emit the pointers to these BoxedString's in the generated IR

Cache pypa parsed AST to disk

Conflicts:
	src/core/ast.h
	src/core/cfg.cpp
	test/tests/sys_test.py

This lets class & function definitions become ordinary assignments in
the CFG, which simplifies our invariants and fixes problems with the
interaction between definedness analysis and block-terminating
"invoke"s.

Add a simple 'code' type (ex f.func_code), and some related
things like f.func_defaults.

This implementation isn't super performant or consistent, but
I think these particular features are relatively rarely used?