Add Paul to AUTHORS.

Parser fix: 'fail' was eating the next token that came after it.

Switch pretty printer to new vec syntax

stdlib: Remove transitional extfmt.RT module

Return a better result from blocks. Closes issue #377

Blocks return in a copy of the result of their ending expression, not the
direct result of the ending expression, as that may be a local variable which
gets zeroed by drop_slot.

Register new snapshots.

Rename aux.rs to auxiliary.rs since win32 doesn't like files named "aux". Really.

Update a couple tests that slipped through.

Fix snap rules to depend more correctly on rustc$(X) not rustc.

Merge remote branch 'origin/master' into HEAD

Conflicts:
src/comp/middle/trans.rs

Rewrite everything to use [] instead of vec() in value position.

Begin vec() -> [] transition.

make the return-checker happy about pretty::pp::base_indent

Fix get_os and get_arch

get_os and get_arch were failing to return a value in the error
case; they were also assuming that strings are indexed from 1. No
idea how they ever worked, but anyway, fixed.

Two tests that the typechecker correctly unifies type arguments in patterns with their expected tag types

Started adding support for return checking and non-returning function annotations

* Reorganized typestate into several modules.

* Made typestate check that any function with a non-nil return type
  returns a value. For now, the check is a warning and not an error
  (see next item).

* Added a "bot" type (prettyprinted as _|_), for constructs like be, ret, break, cont, and
  fail that don't locally return a value that can be inspected. "bot"
  is distinct from "nil". There is no concrete syntax for _|_, while
  the concrete syntax for the nil type is ().

* Added support to the parser for a ! annotation on functions whose
  result type is _|_. Such a function is required to have either a
  fail or a call to another ! function that is reached in all control
  flow paths. The point of this annotation is to mark functions like
  unimpl() and span_err(), so that an alt with a call to err() in one
  case isn't a false positive for the return-value checker. I haven't
  actually annotated anything with it yet.

* Random bugfixes:

* * Fixed bug in trans::trans_binary that was throwing away the
    cleanups for nested subexpressions of an and or or
    (tests: box-inside-if and box-inside-if2).

** In typeck, unify the expected type arguments of a tag with the
   actual specified arguments.

Noticed that metadata::Encode::enc_sty didn't have a case for ty_task, so I added one (though this wasn't causing the problem I was seeing...

Added .bz2 and stage1 directory to .gitignore

add dl/ and .pyc files to .gitignore

rustc: Fix indentation in typeck::check_lit()

rustc: Don't rebuild the call expression in typeck::replace_expr_type()

rustc: Don't unpack annotations in trans::lval_generic_fn()

Be a bit noisier about being in a transition.

Let the snapshot-file parser parse empty T lines, since they are used to start a transition.

rustc: Make the parser use the interner

Replace --bitcode with the canonical --emit-llvm

Add automatic exe generation capabilities. Add --bitcode flag to generate only an LLVM bitcode file.

rustc: Factor out the code that interns types into an "interner" data structure

rustc: Don't rebuild AST patterns during typechecking

rustc: Replace the redundant typeck::node_ann_ty_params() with ty::ann_to_type_params()

rustc: Make the type collection pass no longer rebuild the AST

rustc: Fix indentation in ty_param_count_and_ty_for_def()

rustc: Add an item_ann() accessor function

rustc: Wait until generic glue is actually emitted to define it as internal

The verifier was not liking this when generating unoptimized bitcode. Per LLVM
docs it is not valid for function declarations to be marked internal, but
their implementations may be.

rustc: Rename 'Unify' modules to 'unify'

Remove xfail-boot lines from tests

Remove CFG_OCAMLC_OPT

rustc: Use walk instead of fold for the first item collection pass

rustc: Change "Collect" to "collect"

Add a regression test for issue #374 (XFAILed)

WIP

fix a long line that i forgot to commit

Mark IDENT tokens that are followed by ::

So that the type parser won't go off and try to parse a vec
type when it sees vec::init_op.

rustllvm: Free TargetMachine in LLVMRustWriteOutputFile

rustc: Dispose intrinsics memory buffer

rustc: Dispose the intrinsics LLVMModuleRef

Add a flag to run the compiler under valgrind

rt: Don't overshoot the end of the logging spec during parsing

rt: Allocate room for null terminator in logging spec

rustc: Look types up in the side table

Remove rustboot from the repository.

rustc: Write nil types into the node type table wherever plain_ann() is used

'with' no longer a token; whitespace police.

Plus renaming the anonymous objects test to a more descriptive name,
and XFAILing it because it doesn't work yet.

More anon obj work; whitespace police in middle::fold

Passing args to middle::fold::fold_expr_anon_obj by reference to be
consistent with the other folds; adding a dummy fold_expr_anon_obj to
typeck to be filled in later.

Use new module namespace syntax.

More work toward anonymous objects.

Bug fixes.

Fixed infinite loop on anonymous objects in parser; added
expr_anon_obj to walk.rs; fixed syntax of test case.

More progress on anonymous objects.

Still segfaulting on the method-overriding.rs test, though.

Correct capitalization of "Option".

Starting on support for anonymous objects.  Just syntax so far.

Add support for 'T' transition snapshots, which are identical to S snapshots except they tell the makefile to stop at stage1.

rustc: Move replace_expr_type() from ty to typeck, as it's only used in the latter

rustc: Fix long lines in typeck.rs

rustc: Get ann_to_type_params() on board the ann_to_ty_param_substs_opt_and_ty() train

rustc: Make all type lookups go through the one ty::ann_to_ty_param_substs_opt_and_ty() function

rustc: Write types contained in "trivial annotations" to the table

rustc: Change ty::triv_ann() to take a node ID instead of a full annotation

rustc: lowercase the link and link::write modules

Slight adjustments to shape, rename to type_glue.rs.

rustc: Add write_type() wherever ann_types are written, except for triv_ann()

Remove reserved word tests (since reserved words were removed)

Ping me if you disagree, but I think that in a language that's as
in-flux as rust currently is, it is silly to try and enforce a single
future-compatibility. The reserved words didn't work well with the
parser refactor, so I dropped them for the time being. We can,
eventually, bring them back as type-only reserved words.

Safeguard against using statement or item keywords as value ids

This prevents insane things like 'auto while = 2', which would parse
in the previous revision, but then break when you tried to mutate it
with 'while = 10'.

Make the parser more careful about keywords

Keywords are now only recognized in contexts where they are valid. The
lexer no longer recognizes them, all words are lexed as IDENT tokens,
that get interpreted by the parser.

rustc: Fix the type of node_types; stub the write_type function

rustc: Remove a minor rustboot workaround in typeck::resolve_local_types_in_block()

Fix naming of libc that was mangled by recent module changes

It doesn't appear that rustc makes use of these strings so it didn't actually
break anything yet.

rustc: Make typeck::instantiate_path() not return an annotation

Implement module namespaces

Module names no longer clash with type and value names. The
tokenizer/parser still needs to be taught to be more careful in
identifying keywords, so that we can use 'str' and 'vec' and so as
module names.

Extend crate format to allow multiple definitions for a single name

The type/value namespace distinction pretty much works now. Module
namespace is up next.

Make module indices hold a list of items

This way, they can support having both a type and a value
of the same name.

Move capture checking into resolve.rs

Drops capture.rs. The new algorithm also checks for captures function
arguments and obj fields.

Change resolve to use walk instead of fold

Possibly, at some point, we should add a state-passing variant of
walk, or a wrapper that makes it easier to thread state. (See the
repetetive pop_state_for_* functions in this commit.)

Ensure visit_ty is called on type parameters during walk

Add visit_arm and visit_method to walk.rs

The resolver needs to update its state for individual arms and
methods.

Change fuzzer to match new module standards

Rename std.extfmt.CT to std.extfmt.RT to ct and rt

Temporarily duplicate the entire RT module, leaving it with the old name to
accomodate the stage0 compiler. Will be removed after the next snapshot.

rustc: Flatten recursive vectors in trans::simplify_type(). Prevents an infinite loop.

rustc: Beginnings of a "shape" module to convert types to shapes

rustc: Make ty::expr_ann() terser

rustc: Pass a node type table around, unused as of yet

Add stats option and lazily emit glue.

etc: Update rust.vim with new keywords; color types differently from keywords

Add snap-stageN targets.

Register new snapshots for incompatible-syntax transition.

Fix mistaken replacements in error-pattern comments in tests

Downcase std modules again, move to :: for module dereferencing

This should be a snapshot transition.

Transitional change to make extfmt output lowercase module name

Change module dereference syntax from . to ::

This will need to be a snapshot.

Remove some truly wrong logic in parse_constrs

Keep resolve data in external hash table, rather than embedded defs

One step closer to removing fold and having a single, immutable AST.
Resolve still uses fold, because it has to detect and transform
expr_field expressions. If we go through on our plan of moving to a
different syntax for module dereferencing, the parser can spit out
expr_field expressions, and resolve can move to walk.

(I am truly sorry for the things I did in typestate_check.rs. I expect
we'll want to change that to walk as well in the near future, at which
point it should probably pass around a context record, which could
hold the def_map.)