move fs routines to c-stack-stdlib

rip out unused task pointers

move comm functions out of rust abi

purge log_err

update vec libs to use c-stack-cdecl calling convention

Register snapshots

Revert "Register snapshots"

This reverts commit 6e40f705c167860a976aed9c6a69ed70cf56e6a7.

Revert "Register snapshots"

This reverts commit 24a6d334b7e2e7fd2f6f4aa67e3f717af2c93999.

Register snapshots

Register snapshots

Add commentary about -znoexecstack

Make sure librustrt.so is linked with a non-executable stack.

Fixes #798.

Fix an insane rt build error running 'make check -j3'

Remove a test binary that shouldn't exist

Add Austin Seipp to AUTHORS.txt

Make sure $CFG_LLVM_CONFIG is set to $CFG_LLVM_ROOT/bin/llvm-config

On my machine I have two LLVM builds, one of regular HEAD and one
for Rust in ~/rust-llvm - by default CFG_LLVM_CONFIG is set to
/usr/local/bin/llvm-config which is wrong, because the probe for it
initially happens earlier in configure and succeeds (so putvar is called.)

This causes it to be emitted twice into the Makefile but the second
instance wins.

Update src/etc/gyp-uv

Make instructions more accurate. Make the sed commands work on linux.

Upgrade libuv to 179f475b2ad64729feb0422f06ce133cb364482a

Remove hack to break the AST fold cycle. Closes #998

Get 'make tidy' to work rustllvm and rt again

Register snapshots

Cycle-collect objects

update trans_c_stack_native_call() to use type_of_explicit_args()

currently trans_c_stack_native_call() had some ad-hoc code for
determining the type of the arguments. this code was not in
agreement with the rest of trans. now it uses the same code path.

add get_type_desc to list of exported funcs

add get_type_desc function to library

avoid extra load for by_mutable_ref parameters

Free vectors during cc sweep

Record the internal reference count of environment boxes. Closes #981

Clean up character pattern in float.rs

This is actually a test to see if I fixed the bot.

Be more careful when parsing block calls

Previously, the parser would try to interpret this as a block call:

    if true {} // No semicolon
    {|i, am, a, block|};

Which, though unlikely, might come up in practice.

Remove some semicolons after block calls

The remaining ones can be removed after the next snapshot. (Or
we can let the next pretty-print pass take care of them.)

Change the way block calls are parsed, mark them as block-calls.

This makes it possible to omit the semicolon after the block, and will
cause the pretty-printer to properly print such calls (if
pretty-printing of blocks wasn't so broken). Block calls (with the
block outside of the parentheses) can now only occur at statement
level, and their value can not be used. When calling a block-style
function that returns a useful value, the block must be put insde the
parentheses.

Issue #1054

Drop support for iter, put, and for-each

Closes #1056

Remove remaining uses of iter and for-each

Issue #1056

Move ast_util::pat_bindings over to new iter system.

Issue #1056

Remove last uses of iterators from stdlib

Issue #1056

Move hash table iteration over to block-taking functions

Issue #1056

Register new snapshot

(For block argument syntax.)

Support Ruby-style block argument syntax

Issue #1054

Run perf on the stage 2 compiler

Restore broken tests in stdtest::test

Remove unused empty_fn_ty from rustc::front::test

Give native functions proto_bare

Remove temporary fn# syntax

Remove typeck::proto_to_ty_proto

Register snapshots

Get windows working under the bare function regime

Had to ignore some task failure tests due to the current implementation
of spawn which guarantees that there's always something in the spawned
task that needs to be unwound.

Fixed some win-specific build problems.

Don't allow fn@ items

fn@ is intended to be caputring but isn't implemented.

Merge ast::proto_shared and ast::proto_closure

Now they are both just proto_shared and proto_shared takes an
argument indicating that it is sugared as 'lambda'

Rename ast::proto_fn to ast::proto_shared

Make fn denote a bare function. Convert fn to fn@ as needed

Parse obj methods as proto_bare

I don't know if this is the right thing to do, but it works
and it lets 'fn' always mean proto_bare

Tweak typecheck to enforce covariance on higher-order function arguments

Remove type coercion from fn to block

fn is a proper subtype of block now

Give subtype relationships to function types

Bare functions can coerce to blocks

Bare functions can coerce to shared closures

Revert "Remove the environment argument from bare functions"

This reverts commit 1b0f1f0b79fb29d28bcabb7a8468f4a5a95c0712.

Split parsing of fn proto between types, items and anons

The meaning of various fn incantations is going to get temporarily confusing

Drop the 2 from the spawn*2 functions

Issue #1022

Rename std::task::spawn_inner to unsafe_spawn_inner

Delete the rest of the old, unused spawn functions.

Issue #1022

Stop exporting unsafe spawn functions

Issue #1022

Convert the test runners to typesafe spawn

Issue #1022

Convert std::aio to new spawn functions

Issue #1022

XFAIL task-perf-word-count-generic

This can't be done with bare functions.

Issue #1022

Convert tests to use bare-fn spawn

Issue #1022

Add safe versions of spawn using bare functions

Currently they just wrap the unsafe versions. Will need to be rewritten
eventually.

Issue #1022

Convert DPRINT to LOG in rust_cc.cpp and add more logging

Un-xfail-fast some tests

check-fast is more reliable now.

Change run-pass/lots-a-fail.rs from xfail-fast to xfail-win32

All failing tasks leak on windows now

Fix the problem with check-fast randomly failing

Trans has been assuming that tag node id's are unique across crates and they
are not so, depending on which way the wind is blowing, it would choose to use
a crate-local tag variant instead of the correct one from std.

No test case since I can't come up with a reliable one that compiles in a
reasonable amount of time.

Register new snapshots

Remove the last vestiges of main.ll

Closes #992

Don't rely on main.ll anymore

I'll remove the actual file after I register a snapshot.

Issue #992

Output linker errors, when linking fails

Get rid of taskpointer-passing throughout the compiler

Only intrinsics still take a dummy taskptr. We'll have to do some
makefile stunts to snapshot a version without taskptrs-in-intrinsics.

Issue #466

Do not pass taskpointers to "rust" native functions

Issue #466

Remove taskptr argument from upcalls

Issue #466

Remove spawn_wrap and main_wrap kludges

This isn't needed now that our functions are cdecl (and was apparently
only still working by accident).

Issue #992

Use snap runtime, and the old main.o, for stage1

This is intended to be reverted again after I register the next
snapshot.

Fail nicer when the parser doesn't find an expected string literal

Closes #1028

Fix parse error in constrained-type-missing-check.rs

Register snapshots

Introduce fn@ as a synonym for fn

make ctags targets phony

Immutable and mutable? are covariant on their inner types

Whereas [mutable T] is invariant with respect to T, [T] and [mutable? T]
are covariant with respect to T.

Add a math module to the standard lib

I need some rudimentary stdlib stuff for the tutorial.

Closes #1042

Don't try to build an LLVM switch on floats

Closes #1046

Add a print and println to std::io

doc: Fix parse errors in list examples in documentation

doc: Update 'alt' documentation to remove 'case' keyword

doc: 'alt' expressions no longer require parens

doc: 'if' expressions no longer require parens

doc: 'for' and 'for each' no longer use parens

doc: Fix typo (s/pay/may/)

Enforce variance rules for mutable types

Add a variance transform for calculation of recursive variance

Introduce covariance, contravariance and invariance to the type unifier

This will be used to resolve some problems with mutable? covariance and also
to implement function subtyping

Don't unify from mutable? to immutable

Immutable is supposed to be a subtype of mutable-huh.

Split record_var_binding into methods for expected and actual

This allows unify to maintain the same subtype relationship between
expected and actual throughout unify, which we are going to need
for mutable? and for function types.