This makes passing them around cheaper. There is now a table (see
front/codemap.rs) that is needed to transform such an uint into an
actual filename/line/col location.

Also cleans up the span building in the parser a bit.

This way, it won't have to go through a bunch of calls for each
byte fetched.

building rustllvm.

symbols because of an Object.o in a .a and one outside. A similar
problem happens for the non-shared part of libpthread.

This patch moves the -whole-archive/-no-whole-archive to include just the
llvm libs.

The typestate checker (if it's uncommented) now correctly rejects a
trivial example program that has an uninitialized variable.

I think this is sufficient to eliminate multiple evaluation and the
possibility of accidental miscompilation from the logging macros.

I think just about every type can be used as a block result now. There's quite
a proliferation of tests here, but they all test slightly different things and
some are split out to remain XFAILed. The tests of generic vectors are still
XFAILed because generic aliased boxes still don't work in general.

This was removed because of the repetition, but doing single-byte
reads in terms of read_bytes (which allocates a vec) is needlessly
slow. This change speeds up parsing by 22%.

(Eventually, we won't be able to escape handling the buffering in the
stdlib itself.)

(undocumented, only used for profiling the parser)

No functions should be called for log statements that turn out to be
inactive.

Nicer parsing of self-calls (expr_self_method nodes inside expr_call
nodes, rather than a separate expr_call_self) makes typechecking
tractable.  We can now write self-calls that take arguments and return
values (see: test/run-pass/obj-self-*.rs).

'rustc -ls [cratelib]' will now dump out a list of symbols defined by
the crate, as well as a short description of what they are.

It was creating non-multiple-of-four section sizes, which, for some
reason, presumably by LLVM, were clipped, rather than padded, to be a
multiple of four.

New one is less stateful, easier to work with.