closed Issues

bind's glue function should tail-call its target

implement lambda blocks

implement 'break' and 'cont' statements.

Complete name-mangling rules for linkage

libuv bindings in stdlib

595

communication-alt statements

Task links, failure trapping.

Signal-trap table

configure runtime ABI by platform

implement stack growth check

implement 'big' type

synthesize check and prove stmts for type-carried typestate constraints

propagate constraints during copying

floating point support

support native C++ modules w/ thiscall

flesh out the syntactic extension system

move yield and join into standard library

Implement buffer-growing send

implement flush

permit imports in fn, iter, obj scope

strings in pattern-alt statements

Implement type 'any' and alt-type

Bind meta wildcards to selected meta value once crate is chosen

Forwarding functions (from object coercions) should tail-call target

FreeBSD support

64-bit OS X support

Asm support

'exception Lexer.Lex_err("bad trailing utf-8 byte", _)' compiling test/run-pass/utf8.rs

Add a "platform-specific C types" module to std lib.

Add swig binding and/or C-compiler-fe-based bindings generator

Compiler should have more comments

Interface narrowings don't yet work

string equality should be based on contents not identity

Give type parameters kind constraints, and check them.

No way to change mutable fields of a tag arm.

Remove vicious hack for runtime-calculated state-ness in derived type descriptors.

Several FIXMEs in lib-deque.rs test.

Add top-level makefile plus (non-autoconf) configure script

Force a GC right prior to task death.

Implement #fmt extension in rustc.

Implement a getopt module

Teach rustc about native modules and general C calls

Teach rustc to do tail calls

Teach rustc to do vec-append / growth

Teach rustc about spawning and tasks

Implement the occurs check for type unification

add typestate pass to rustc

add effect-checking pass to rustc

add kind system and kind-checking pass to rustc

implement gc in rustc

add fail-unwind machinery to rustc

add debug info to rustc

Change statement to expression in docs

Escape analysis

Extend lexer to cover non-ASCII unicode cases

Make the glue tables in trans not sensitive to cname

implement 'use' for rustc

support dtors in rustc

Rustc thinks there's a cyclic import in lib

Can't return from inside a block

"file not found" error message should be friendlier

rustc -pp lib/_str.rs corrupts memory

Stack not aligned on "main"

Nested clean-up-requiring blocks in loop (sometimes) segfault [rustc]

Try to reuse cleanup code when appropriate

Generic vector reads read from the wrong place

Compiler allows tail calls to functions with aliased arguments

unresolved name conflict

Unused functions in objects can affect whether self calls compile

Use MCStreamer to emit object files

Intern types

Implement "walk"

Store types in a side table

Assigning a function to a variable causes an assertion failure

SSA problem when using log_err with a computed string

Compiler warning for "condition is always true"

Use correct extension when the output path is not provided to rustc

static exhaustiveness checking

Separate namespaces for types and values

Separate namespaces for types and values

Compiler crash on using a const

'for each' doesn't seem to be typechecked

--shared should be a crate directive

Print a backtrace on failure

'ret none;' should typecheck

Can't leave off type parameters in tag patterns

Closing over an outer function arg is not caught by capture pass

internal error instead of type error on "some_vector.some_field_name"

clang does not like rust_box's flexible array

Bindings with the same name on the same level are not caught

Unexpected behavior importing nested modules with the same name

implicit block values as function bodies don't actually get returned

Conditional jump or move depends on uninitialized value in rustc

Binding non-alias arguments with type parameters fails in llvm

Run the ll verifier before the optimizer

Incorrect block results from intermediate tuple

assert(false) causes Valgrind problems

Unused variables should be reported as warnings

Inefficient ref counting in else if expressions

Reconfiguring should preserve CFG_* settings

Incorrect ref counting on nested block expressions

Receiving from a port doesn't block correctly.

Logging a tuple causes an LLVM assertion to fail

Warn or error on path statements

Lots of things are passing typechecking that shouldn't

alias analysis pass in rustc

Unique boxes

Move and swap operators

Resource types

inline keyword and llvm section for exported inline bitcode

Unsafe blocks and sub-language

Fuzzer

Implement 'note'

Extend typestate system to cover non-init preds

object extension, overriding

Full macro system

Pretty-printing wraps trailing paren

Pretty-printing injects new lines for line-trailing comments

Pretty-printing binops should have lower affinity somehow

Pretty-printing support for words that aren't broken relative to their neighbour

Pretty-print crate files

Implement log for more types

write a tutorial for the docs

unit test machinery

website

website

make trans contexts into objects

Add support for binding a method off an impl

-L sysroot should be default

Error messages should follow a consistent style

put librustrt and librustllvm in stageN directories of build

Print out the offending line on error

rustc shouldn't stop after the first error

rpath binaries so no LD_LIBRARY_PATH is needed

make all error messages lowercase

rustc should know how to run the linker on all platforms

try to ensure all errors use spans

make sure every FIXME in the code has an issue open for it

Disallow binding to alias parameters

Multiline strings

Or-patterns

if/alt expressions don't understand how to return functions that fail

Implement "fail EXPR" for convenience

Implement per-symbol and per-crate versioned-API support

Serialize the non-exported metadata into the crate as well, for documentation purposes.

Get dynamic loading working

Perform meta tag matching to bind to crates

Allow assignment to aliases only when they were declared mutable

Port to x64 at least, not just x86.

Allow tasks to return values

Remove rustboot "trans_const_lval bug" workaround

Have human-readable source for vec append glue

Experiment with moving the task pointer to thread local storage

Compile pattern matches to switch statements

Accept .<> as well as [] for type parameters

Allow pattern matching over structural types

Allow multiple vars to be declared in one declaration

move librustrt.so and librustllvm.so into sysroot

make target-run compiled artifacts per-arch

Allocating memory from rust involves 5 layers of indirection

rustc -S --emit-llvm should emit LLVM assembler

Eliminate the builder objects in lib/llvm and trans

Make all of our GEPs InBoundsGEPs

Typechecker does not require LHS of assignment to be an lval

Variable sized function arguments don't fail until trans

Resolve should make sure variables aren't used before they're declared

internal error "imports and matches don't agree" on multiple glob-import when at least one source is from a different crate

Using the result of an assignment expression results in an LLVM assert

Typechecker doesn't properly check assignment operations

Implement an alias analysis pass

Extend metadata to items, not just crates

Automatically 'bind' generic functions when their value is taken

More robust support for conditional compilation

Find a solid way to pass span info around trans

Modules can't be defined inside of functions

Context switching doesn't pass valgrind on OS X when built with Clang

Task startup makes cross-language/module fastcalls

Context creation doesn't respect stack alignment

Pretty-printer prints comments above a case too late

upcall_vec_append can crash when self-appending

Fix pretty-printing of anonymous objects

Binary operations are not type checked

Pretty printer comment drift in tag definitions

std::term needs better detection of color terminals

Internal compiler error when trying to spawn a native function as a task

Unable to pass channels across more than one task

Implement M:N task to OS thread scheduling.

Remove upcall_join

Directly call glue functions when we can instead of picking them out of the type descriptor

Passing "none" to an &mutable option::t[T] leaks

Typechecking if apparently doesn't require a boolean.

equal_type_structures should just be ==

Figure out and implement task lifetime rules.

Incorrect type in 'mismatched types' error

Cache results of type_has_pointers

Change "mutable?" to something else ("const"?) and fix covariance/invariance

Tagged union typechecking regression

Cannot spawn task with channel and string

Valueless ret expression in block tail position doesn't parse

Build NSIS installer for rust toolchain on windows

Instantiating the type parameters of a function without calling it fails in LLVM

Insert yield checks at appropriate places

native types should not all be the same type

Experiment with interpreted glue

Bake in default sysroots appropriately

Make rustc installable with make install

Use fastisel at -O0

move entire communication system into library

Assert failure with 1-argument #fmt call

Convert rustc over to interior vectors and remove exterior vectors

improve make performance

Implement overloading

Investigate LLVM ARC optimizations

Implement a copy operator and make it mandatory in some cases

Adding support for extending objects with new fields

Adding support for 'degenerate' anonymous objects

Adding support for extending objects with methods that contain simple self-calls

Alias analysis should take move ops into account

Use move semantics for function and block returns

Adding support for extending objects with methods that override existing methods in the presence of self-calls

Implement dropping predicates in typestate

Wrong types reported in some let binding type errors

Replace some native module syntax with attributes

Write swap in assembly instead of C++

Type inference not working in anonymous functions

Duplicate alt patterns ignored

Support static linking crates

Add global variables to unsafe

Implement log in rust

Add support for slices

figure out what to do with iterators

GEP instead of pointer-to-int and add and back

Tool to detect/display function dependencies in Rust crates

Pull glue out of trans

Split rustc into libraries

Better error when types differ only by their boxiness

lib-sha1 segfaults only at -O0

Reformat under the major agreed syntax changes

Interior vector syntax should be [T]

Add ternary operator

Typechecking doesn't enforce communication immutability requirements

Merge rust_kernel and rust_domain

Allow arbitrary constant expressions to be assigned to const items

Allow vector constants

Poor error when iterator name missing in for loop

Some forms of float literal don't parse

Relational binops on unit type are nonsensical

Crash comparing ports, channels, tasks

rustc happily compiles non-boolean branch expressions which assert at runtime

Implement something like copy & move analysis

rust_task::kill appears to just wake the task

Current LLVM trunk incompatible with librustrt.

switch from rand to isaac

perf bot

Start running runtime test suite again

Replace common::new_seq_hash with std::smallintmap

Postconditions on function return types

port constructors with types don't parse correctly.

Require that the RHS of a move be a local variable

Deadlock in upcall_vec_append/upcall_malloc

Add warning when return is used

Add 1:1 Scheduling Mode

Worker threads shouldn't busy wait

"Instruction does not dominate all uses" when translating fixed point combinator

Add support for pinning tasks to a certain worker thread

Add task wakeup callback

Eliminate copies when initializing a local from a temporary

Can't define types as resources

typecheck segfault on failure to unify

Remove rc_base

Remove much of the crate file evaluation infrastructure

Allow crate link attributes to contain nested meta items

Restore or remove the --depend flag

Attributes for native items

Conditional compilation for native items

Support all literal types in ast::meta_item

Create a mechanism to merge config files into the crate compilation environment

Add warnings and errors when the crate 'link' attribute looks malformed

fail #fmt("%s", str_var) causes an LLVM assertion

Passing a type parameter to a tag constructor that doesn't expect one isn't checked

Remove rust_scheduler parameter from rust_vec contructor

"cannot determine a type for this expression" should be non-fatal

Nil literal doesn't parse in some situations

Encode/decode meta_name_values with non-string values

"error: cyclic import"

The "log" does not output anything to the console, but the "log_err" outputs.

Better error when main is not defined

Windows does not respect RUST_SEED environment variable

Incorrect span for mismatched type error during FRU

Compound assignment between boxed types results in LLVM assertion failure

Transitive dependencies between crates don't work in the metadata reader

type-parameterized functions not specialized when passed as argument

Add a configure flag to force using gcc instead of clang

Add environment variable to set stack size

"Calling a function with a bad signature!" when I forget to specify iter's out type

trans_put - 'non-exhaustive match failure'

Type-parameterized 'vec_omit' produces incorrect result

Import pattern alternatives

Binding bare function arguments with type parameters fails in llvm

Improve error message for unexpected EOF

record update should auto-dereference

Race condition in port shutdown

Only autoderef through one box

bounds check failure in trans

Variable shadowing behaves weirdly

Spans for view items are fairly inaccurate

syntax::fold::make_fold leaks

pprust::print_if does not anticipate evil

constrained-type.rs fails to parse again

'Assertion i == total failed' in str::char_len

Ambiguity in proposed pattern syntax

Warning for vecname(0) could be more helpful

Export consts across crates

Matching a struct pattern should autoderef

Cannot infer a type for this case

Internal compiler error in instantiate

Assertion failure: out_arg.mode != ty::mo_val

"unsafe" doesn't sound unsafe enough

Destination-passing style

Typestate isn't working for bind

type "(option[int])[]" does not round-trip

expr "(@1).x" does not round-trip

pretty-printer turns #macro(...) into tup()

pretty-printer screws up recs

Matching on a str should compare content, not identity

pretty-printer omits semicolon needed to disambiguate unary op

parser rejects "fail []"

Parser rejects "if (ret) { }"

Compiler crashes displaying error line when compiling .rc files

Move semantics for cross-task operations

pretty-printer moves comments from inside array literal to outside

Type of function tail expressions not inferred correctly

Per-thread Task Lists

Move mode arguments

Cannot build while offline

Use a single memory region

rt: fatal, 'chan->task == task' failed in upcall_del_chan

main can't return int

Add source level debugging info to LLVM output

Generate gcov coverage data

"typed" pretty printing mode fails with "unresolved name" for macros with variables

Remove distinction between pred and fn

Preconditions on arguments don't satisfy subsequent calls with the same precondition

Accessing an upvar in a for-each loop in an iterator triggers bounds check failure in trans

Defining a function that takes arguments inside a for-each loop fails during trans

Double-free of ivecs when sending across channel

"quick start" wiki pages for the 3 major platforms

This compiles and shouldn't.

LLVM generates an undefined instruction for this test

Correct "backwarding" behavior for self-calls in extended objects

Overriding a method with one of a different type compiles and shouldn't

quick_sort returns incorrect results

Self-calls in non-object context should fail with a helpful error message

Report unresolved identifiers only once per function

Bad type error message with parameterized types

Invalid memory access in fs::list_dir

Use millisecond resolution for --time-passes

Test run-pass/lib-run does not work on windows

task-comm-11.rs doesn't work

Segfault when wrapping an anon obj in more than one layer

Not all paths return a value

Test runner needs to be able to run unexported tests

Build bots need a 'try' branch

Add support for #[deprecated] attribute

Enforce correct types for channels

alias pass crashes when it needs to autoderef through multiple boxes

Test run-pass/lib-io doesn't work on mac

| (bottom) in an expression alt or if doesn't typecheck

Loop constructs without parens

Memory leak when declaring chans at the bottom of functions

Names of function types shouldn't allow parameter names

Test suite picks up too many files.

Restore the ability to build run-pass/run-fail/bench tests without running them

Test runner should run tests in parallel

run-pass/compile-fail, etc test runners no longer obey CFG_RUSTC_FLAGS

Investigate running tests under helgrind

task-comm-15 fails when run with multiple threads

Add a build option to run compiler tests under gdb

Automatically determine the number of CPU Cores

Compile tests race on environment variables when run in parallel

crash: "Out of stack space, sorry" with structural recursive type

crash: "UNREACHABLE executed at ObjectFile.cpp:52"

--lib should produce reasonable output file names

Resolve resolves loop collection expr in wrong context

Stop allowing duplicate label names in record types

Nullary tags can be passed by mutable alias

crash: upcall fail 'non-exhaustive match failure', src/comp/middle/resolve.rs:1148

Investigate running tests under Address Sanitizer

rustc segfaults when fed an empty file

Beginning-of-line detection in pretty-printer isn't reliable

Bring the runtime tests up to date and start running them

bind can't rebind an already bound function

Compile tests need to capture stderr

Typechecker overly restrictive on binding functions with type parametric arguments

Spawn of type inferred variable trips error in typechecker

Using methods in a first-class manner doesn't work

pp non-convergence: empty line becomes two empty lines

pp screws up typestate assertions

anonymous obj expression-statement is rejected

parser rejects "ret ::f()"

Channels leak when sent over channels

pp+parser disagree about parens around "fail" in callee position

This code takes suspciously long to converge

"let f = @f;" causes iloop/irecurse

"alt ret" hits an error in llvm: "cast<Ty>() argument of incompatible type!"

"i + ret i" hits assertion "Cannot create binary operator with two operands of differing type!"

Calling an iter (as if it were a function) hits llvm assert

non-exhaustive match failure in alias::check_for_each

"put put ()" hits llvm assert "Invalid type for pointer element!"

trans_put 'non-exhaustive match failure' in non-iter fn

"Calling a function with a bad signature!" with uncalled type-parameteric function

LLVM assert "May only branch on boolean predicates!" with bang predicate

ret-bang variant trips llvm assert "Invalid constantexpr cast!"

"pointer being freed was not allocated" when triggering out-of-stack-space compiler bug

implicit ret is incorrectly allowed in bang function

When running tests in parallel, test runner does not display colors

Conflict between ports and tasks wanting to destroy channels

"this function takes x arguments but y arguments were supplied" shouldn't be fatal

Temporaries generated in alt expression have longer lifetime than expected

Loops try to clean up uninitialized variables

Dynamic size check calculation should be exhaustive.

Add pretty-printer tests to the test suite

Typechecker doesn't propagate collection item type in for [each]

LLVM module verifier breakage for loop in alt in iter

Tags with more than one variant are always 4 byte aligned

Functions should be able to initialize their arguments

alt discriminant of type bang -> "Ptr must be a pointer to Val type!"

Box contents are always 4 byte aligned

Calling a function in for-each position triggers llvm assertion

test/run-pass/if-ret.rs passes only with optimization turned on

rustc requires executable stack

Combine xfail-stage1/2/3 into just 'xfail'

configure script doesn't fall back to gcc if a bad version of clang is available

Typechecker should stop this

Type inference for capturing nested functions requires type variables to be resolved prematurely

Lambdas sometimes leak

Upvars in lambdas can be written to, with silly results

Can't build with clang on Ubuntu

nil values takes up space

Pretty printer adds newlines after comments in tag declarations

Testing randomly hanging for long periods of time

bounds check failure in trans (again)

Anonymous objects from nothing

Unary negation not properly typechecked

trans trips assertion when using result of bottom-typed do-while

Object equality behaves weird on linux

ivec self-append has illegal memory access

Allow multiple imports and exports per statement

Dereference on single element tags ignores visibility of constructor

Typestate apparently doesn't handle loops...

Cannot bind native functions

rustc fails whlie linking files if the source file path begins with ./ or ../

Methods that are added to an object at the same time should be able to refer to each other

Bind glue should make a direct call if the target is statically known

Typestate too strict for multi-var let

cont in while continues without re-checking the loop condition

Test runner fails to report failures

Typechecker error messages don't use type abbreviations

Iterators don't seem to work for polymorphic types

Typechecker should be able to infer these types

Add a way to suppress unused-variable warnings

Typechecker is too conservative in determining whether a tag type is dynamically sized

Type error messages lose tag names

Type error messages lose tag names

Build is broken when optimization is turned off

Support ranges in patterns

Binding patterns with sub-patterns

Add an environment to the type context that records inited-ness information from typestate

Pretty-printer can't disambiguate alts followed by ( from function calls

type_kind missing case for tuples

Pretty-printer doesn't preserve blank lines

zero_alloca outputs invalid bitcode in some cases

Output TIME_PASSES info in a format that doesn't confuse emacs

Figure out why emacs sometimes can't parse file/line/char error info

Task cleanup code needs to know more about closure env to clean it up

Experiment with annotating args as "noalias" if we can prove it

Mark functions as "readnone" or "readonly"

Pretty-printer is still adding extra whitespace in places

Restrict lambda-blocks to occuring as function call arguments

Implement named (item) closures

Resolve a bunch of interactions between closures and typestate

Test runner periodically deadlocks on linux

Interior strings

Introduce slots; remove mutable boxes/vectors/record fields/object fields

Introduce pattern guards

Correctly handle closing over variables in alias analysis

Switch from SHA-1 to MD4 or something else cheap

Numeric literals allow trailing underscores

fail in plain block doesn't translate

Function precondition not maintained for subsequent calls

Make ivecs heap-only

Dinstinguish between within-crate export, and crate-external export

Rustc should at the very least warn you if you export something that doesn't exist.

package management system

Return type isn't inferred for nil-type blocks

Implement nominal records

Typechecker should not check argument types after it finds incorrect # of params

Implement purity inference

std::unreachable

blocks not checked for all paths returning

Bad error message when using a type that wasn't imported

Implement or remove literals as constraint arguments

Test stdtest::os::test_getenv_big is not valgrind clean on mac

String literals should be constant

Lambda blocks with no arguments are not pretty-printed correctly

Allow record fields to be constraint arguments

Pretty printer could use heuristics to detect pointless line breaks

Destructuring let can cause 'illegal instruction'

make getenv/setenv safe

Alt arm variant names are resolved in the wrong scope

for is copying the vector elements, should alias them

Mystery windows bug (potential memory corruption) is still there

Track record fields in typestate

Warn about unused imports

pretty-printer does not preserve parens in (10).x

pretty-printer does not parenthesize ret expr in callee position

LLVM error with "break" in loop condition

'Assertion !cx.terminated failed' involving obj/with

'Assertion !cx.terminated failed' involving nested rets

"Invalid cast" on some uses of bottom

src/run-pass/task-comm-5.rs occasionally segfaults

Missing error "some control paths may return to the caller" in this case

Can't bind type-parametric functions to function arguments

Const declarations aren't typechecked

typeck hang with structural recursive type

nil in native hits LLVM assert "Invalid cast!"

bind crash

Build failed with "undefined reference" GCC 4.6.1

Indentation of pretty-printed blocks is terrible

Native function link name isn't used

Native function link name should be an attribute

Native "llvm" modules don't work

Implement unwinding for Windows

Make unwinding more efficient

Decide what to do when on task double-failure

Can't instantiate an object while extending it

Block type-inference sometimes fails

Typestate crashes on this program

Leave off block cleanups when the end of the block is unreachable

Maybe move should be a unary op?

Implement return-by-reference

pretty-printer does not preserve parens in (a = 10).x;

pretty-printer loses parens in "alt (fail) { ... }"

pretty-printer changes meaning of assert expr in callee position

Can't spawn a temporary closure

pretty-printer loses disambiguation semi before "(0).x"

non-exhaustive match failure in trans_rec

Detect last use of a local, move out of it if possible

Change fail to unreachable() in compiler and libraries

pretty-printer should parenthesize this expr_assert

pretty-printer should parenthesize expr_cast in callee position

pretty-printer loses parens in "if (1 == fail) { }"

"fail fail" hangs in trans

"error: internal compiler error sequence_element_type called on non-sequence value"

"internal compiler error Translating unsupported cast."

recursive check breaks typestate's mind

"Assertion failed: (alloc->magic == MAGIC)"

"Invalid cast" with log ret

Compiler segfaults after printing error in some tests

Wierd segfault in compiler when certain tests are included in check-fast

compiletest needs to check error code for compile-fail tests

Move-mode arguments are not unwound correctly

Unexplained alt + expression block failure

warn about unused variables from patterns

"fail fail" internal compiler error

LLVM asserts involving 'ret' as a function argument

Rust programs crash when dividing by zero

double free on unwind

LLVM assert with "put break"

LLVM assert with plain "put;"

typestate hang: record update with "fail"

LLVM assert with "let c <- fail;"

rustc should delete the source file on a type error

type_is_pod is missing an arm for ty_uniq

pretty-printer loses parens around expr_fail in cast

Lexer is too eager to treat - as unary negation

parser or pretty-printer problem with do-while loop as lvalue

do..while conditions are not type-checked

unreachable str concat causes llvm assert

ret guard makes the LLVM verifier sad

Windows build is broken when optimization is turned off

Emacs does not like typestate error messages

maybe_auto_unbox hang with uniq

generic function mishandles unique pointer

Incorrect kind checking for local initializer

Mutable keyword on reference arguments is redundant

Assignment to generic argument doesn't validate

Remove 'deprecated mutable type constructors'

Remove unused fields from rust_tydesc

'Predicate type_is_unique_box(bcx, uniq_ty) failed'

invalid free with uniq-by-ref

'non-exhaustive match failure' in fold_ty (inner constraint)

Parser rejects some uses of inner constraints

Return-by-reference round-trip failure

LLVM assert with "bind id(fail)"

Lexer truncates u64 literals outside u32 range

mutable fields subvert purity

LLVM assert with generic uniq assign

Unique boxes containing pinned kinds should be shared kinds

temporary unique boxes and vectors should be moved into tags

glue_drop crash

Leak with cycle through closure

cycle collection crash

RUST_CC_ZEAL crashes the compiler

Shared-kind typarams shouldn't be copyable

Implicit copy of pinned kind runs destructor twice

Make sure implicit copies don't copy non-copyable types

Move compiletest from test/ to src/

Don't allow record extension from resource types

Get rid of glue.o

Implement C stacks

Get rid of main.ll

Resources can't be put into tags

Update development policy to relax rules on committer agreements

Function return does not always perform a move

test/run-pass/alt-range is still wonky on windows

Build directory structure doesn't support target executables

Cycle collector doesn't collect rustc::syntax::fold

Rename libstd.so to libruststd.so

Errors inside macros use unreliable line/column references

obj methods can't be type polymorphic independently of the obj

Detect when a record, tuple, or call can write in-place

make check dependencies are busted

Valgrind doesn't understand writing arguments to another stack

Segfault in rustc with --time-passes due to binding generically to unit

Pass immediates by value, rather than by reference

Update windows installer

Windows installer license text doesn't fit in window

Figure out what we're going to do instead of rpath on windows

Find a way to take or drop temporaries without spilling them

Add permute to standard library

Add float support to #fmt

str_to_float converts fractional values in reverse

bump LLVM on rust-mac1 when it comes back online

trans_eager_binop should use ty::type_is_float

Add random float generation to stdlib

dyld: Library not loaded: @rpath/libstd.dylib - when doing make check

ld: symbol(s) not found for architecture i386

Make vectors and strings immediate again

Implement bare functions

Implicit return double-frees in some situations

crash: upcall fail 'non-exhaustive match failure', ../src/comp/middle/resolve.rs:528

Failure parsing malformed crate directive

baffling error: "expected fn() -> native but found fn() -> native (types differ)"

Binding a single-variant nullary tag does not work

Comparison of by-ref single-variant nullary tag does not work

Higher-order generic functions disobey kind system

Problem with generics and bare functions

Add math module to stdlib

Line numbers in stack traces

Alt matching on float literals is broken

Non-boxed recursive tag constructor fails to compile with "Out of stack space"

Allow tests to be ignored conditionally

$PATH for running compiletest.exe is not correct on windows

Rewrite spawn again

Make a decision about fn@/lambda and fn&/block

Support Ruby-style block arguments

alias analysis does not recognize mutable object fields as unsafe roots

Get rid of iterators

compiletest test runner doesn't always catch all of stdout

fns using c-stack-cdecl native ABI cannot be used as values

fns using c-stack-cdecl native ABI cannot be called from outside crate

Change the bare fn calling convention and representation

Cycle collector doesn't collect unique pointers

Cycle collector doesn't run resource destructors

Change the syntax for type parameter kinds

Make LLVM a git submodule

Allow referencing non-function symbols in native modules

Allow items at the crate top level and in 'directory' modules

Install man pages as part of make install

Warn when specifying a kind bound that's too narrow

Write rustdoc

Move task notification out of the runtime

Add operator 'as' (type cast) to documentation

(NaN == x) and (NaN < x) and (x < NaN) are true for all x:float

Floating point comparisons in Rust do not follow IEEE 754

Add 'argument mode adapter' functions to std

Rename list's "car"/"cdr" to "head"/"tail"

Rename log_err to print

Clean up logging output

float::from_str returns 0 for one space, and NaN for multiple spaces

Document RUST_LOG

Simplify attribute parsing

Libcore and libstd split, with linking to core by default.

Add 'companion mods' to the language docs

Add pattern guards to the language docs

Better documentation for building on Windows

Document resource types

int::from_str("-1") == -253 and other bugs

Two io tests fail when running as root

List: make head/tail's expectation of a non-empty list visible in the type system

Document pattern ranges

Is there a way to specify crate attributes in a single .rs file?

Make type annotation for consts optional

Add sort to stdlib

Record field is corrupted when passing from fn(x<int>) to fn(x<T>)

mod std can't import option::t as option then re-export it

Re-exports do not work across crates

Is there any reason to allow 'import name;'

Tutorial unclear regarding backslash preceeding newlines in string literals

Make function arguments immutable again

Tutorial unclear regarding attributes/annotations

Implement a Rust REPL

Make configure script accept --prefix

#[test] items are not being configured out in a non-test build

More informative error messages when using #[test] or #fmt without std

Task system is embarrassingly unexpressive

Rust needs ropes

rust.pdf fails to build when src directory is absolute

crash: recursive tag with vector -> out of stack space, sorry

"missing crate link meta 'name'" warning seems to be saying the wrong thing

Remove --check-unsafe flag

Remove --no-typestate flag

Make the code in the tutorial runnable somehow

Alias checker seems to get confused by lib/rope.rs

Something about make perf is broken

Make libuv a git submodule

crash: "Ptr must be a pointer to Val type!"

Basic 'Hello World' Port/Channel example causes abort/memory leak

Friendly error when submodules not expanded

Implement versioned library naming and rename libruststd back to libstd

Native "c-stack-stdcall" does not work

Configure libuv in the configure script

Native functions declared multiple times generate incorrect LLVM declarations

Potential Typechecker issue when storing lambda in variable

c-stack-cdecl assumes arguments are passed on stack

Replace the constant functions in std with actual constants

bot.rust-lang.org misconfiguration results in 404s

Native pointer vectors

Bogus "unreachable pattern" error with ranges

test/bench/task-perf-word-count is broken

Pointer addition results in compiler crash

bind'ing a native function behaves incorrectly

unsafe::reinterpret_cast can cause valgrind errors

Toplevel macros

Revise the kind system

Use wrappers for native functions

#cfg conditional compilation does not work in object expressions

Two intrinsics call C functions on the Rust stack

Resource flag is larger than necessary

Predicate failure during translation of call to native returning generic type

lock_held_by_current_thread is probably not threadsafe

Error when forgetting a :: when specializing a generic is confusing

Actually implement block scope safety checks

Implement the task tree and task killing using messages

Consolidate rt's three definitions of rust_fn

Optimize native wrappers

Prohibit in-scope consts from use as variable names in binders, like nullary tags

Implicit return of last expression doesn't work

Add a note on incorrect trailing semicolon

configure should fail if subcommands fail

Write a pygments lexer so that we get syntax highlighting on github

The empty record type can be declared but not instantiated

std: implement pow, floor, ceil

Stop walking all of AST on every pass

Inner attributes must before any item

ty::type_needs_drop is inaccurate

Unsafe blocks make their contents pure?

Remove auth directives

Language ref sales pitch says that C functions are unsafe

rustc crash: "option none" at src/lib/option.rs

foo(...)->f as b should be tail callable if both are aliases of the same type

Keyword table in the manual uses a bizarre, change-hostile format

Cannot build on Fedora: wrong CPUTYPE?

Wiki "Development policy": Clarify sentence

Some floating point math functions produce different results on windows

Standard library documentation is outdated

Build continually runs make on LLVM

Add support for no_split_stack attribute to LLVM. Use it on main

Typeclass/interface implementation

Compile error with ambiguous shortcut import resolving

OS X Lion's uname -m does not lie

linux/mac bots fail on 64-bit run-pass/bind-native-printf

make -j8 on the build bots

Turn off the tinderbox scripts

Bots not collecting perf data

rust-mac1 bot has issues

rustc: 'option none' at src/lib/option.rs:34

64-bit windows build.

RFC: (export foo::*) re-export all contents of module

Build doesn't work when target-triples does not contain host triple

Review and update wiki FAQ pages for 0.1 release

Split Module Definitions

#[cfg_attr]

Last-use analysis does not handle blocks correctly

Test run-pass/send-iloop fails occasionally

Rust crashes when port queues are full

Typechecking is twice as slow on x86_64

Compiling to an output file with the same name as a native function hits LLVM assert

Compiler should take more care about literal representation

fsync not implemented on windows

Merge stdtest with std

Implement more communication primitives

str::bytes documentation should mention that the returned vec is not null-terminated

Leak with do loops

Typestate doesn't track initialization through closures

Give std::task::task_notification a shorter name

bind allows data to be moved multiple times

ASM debugging still stringify's AST nodes even when it is disabled

Mark a few bytes at the end of every stack VALGRIND_MAKE_MEM_NOACCESS

Variables used in when still considered unused

Avoid checking control paths that will never be reached

scrutinize hash functions: << precedence often misused

Tag constructors should be considered pure

objects with floats crash on windows

Tags should be represented using null ptrs where possible

Allow constant expressions to refer to other constants

add special syntax for mutable variable declarations

Cut features out of our LLVM build

lambdas and blocks should both have optional type decls

Implement crate_type attribute

Figure out a different way to allow crate-level and directory-level modules

Clarify story on native functions

Pretty-print in place

Unresolvable names in other modules fail hard

Implement complex numbers

make on windows - mingw 20111118 fails

crash: Assertion cx.fcx.llobjfields.contains_key(did.node) failed at src/comp/middle/trans.rs:2914

Tutorial: please clarify "mutable vector"

getopts should use result::t

'make all' only builds stage 1

build broken on os x

Decouple #[link_name = ""] and #[link_args]

Make a new attribute for the #[link_name = ""] special case

Investigate a segmentation fault in link::link_binary

Add testing supports tests those need multiple compile commands

invalid format string causes leaked memory in rust main loop

Link with ld instead of gcc

Allow link_args attributes on crates

Disable locking in memory_region when RUSTRT_TRACK_ALLOCATIONS=0

Add #[link_type="object"] to link against object files

Put all the trans_* modules under an umbrella trans module

rustc crash with upcall fail "option none"

Should 5.f parse as a float literal, or expr_field(int literal, "f")?

OS X generates warning about compact debug info for __morestack

Add caching to tag_variant

llvm-config sometimes doesn't provide the correct include directory

deal with .dSYM on os x

Go over std and core and add pure declarations

Type casts should be considered as pure where possible

Return address at the bottom of stack should be 0

Use __morestack to switch to the C stack

Remove stack alignment from core::task::unsafe_spawn_inner

Rewrite upcall_new_stack/del_stack to follow the standard upcall convention

#[link_name = ""] should be an error even when #[nolink]

Fix failing tests on windows

Use quotes to improve error messages

Importing a module that does not exist fails hard

Add valgrind guard bytes to the end of the stack again

fix setenv and getenv (especially on os x)

from_strs should return option::t<T>

Add debug representation of strings

Add debug representation of objects

Add debug representation of enums

Fix debug representation of arrays of structs

Add debug representation of function types

Add debug representation of resources

Building with debugging causes test failures on i686-unknown-linux-gnu

Name mangling mistakes with -g

Rust snapshot binaries aren't recognized by RHEL5

os x / make check-fast bug that seems to effect invoke-external-native

"char": make "to_lower"/"to_upper" work for non-ASCII characters

"char": add a type and function for Unicode Character Categories

change map::new_hash to mk_hash

swap arg order of vec::init_fn

cargo: auto-fetch default sources file from rust-lang.org

cargo: list packages matching name

cargo: shortcut for adding a source

cargo: dependency-resolution

cargo: extract json from crate files

cargo: refresh source index from remote crates

cargo: add $HOME/.cargo/lib to rustc default search path

Bogus span identified with unmatched import

Make the initial obstack size very small

JSON: add support for "null"

stdlib/json.rs is written in a very inefficient style

std::unicode::icu: add libicu character category functions

"char": implement "is_whitespace" and "maybe_digit" using "std::unicode::icu"

#fmt float broken on Ubuntu Precise

Libcore: move "io" to libcore

Unwinding can still sometimes leak memory

#fmt uses wrong default precision for float

fix machine type equality

Expose floating point environment and handle fp exceptions

New logging macros #info and #debug do not work

Prominent instructions on how to register a package with cargo-central

Type unification error messages excessively mystifying

Request for source addition

split stdtest into stdtest/coretest

invalid location with #debug type error

odd issue with #fmt and floats

kind checker does not recognize implicit returns

make rustdoc handle imports and exports

support explicit discriminant numbers on tag variants

rustc, rustdoc: give nicer feedback when no arguments are given

make check and install should depend on all

change "when" to "if" in pattern guards

Allow tuples and other irrefutable patterns in parameter specifications

Last use doesn't consider closure bodies properly

trans.rs assertion error compiling code

make all no longer works after make clean

passing rust records by value to native functions broken

warn when int or uint is used in a native type decl

rustc: errors should not display runtime boilerplate logging

Add fixed sized arrays for native module records

Set up FreeBSD bot