id stringlengths 8 11 | text stringlengths 32 472 | label stringclasses 5
values | label_id int64 0 4 |
|---|---|---|---|
rust_418 | Full macro system | Once syntax extension is working (issue #38), implement a "real" macro system, for some definition of "real". Doesn't have to be state of the art, just the basics (some form of hygiene and/or gensym, various quoters and splicers, a short macro-definition form). | labels: C-enhancement, A-syntaxext | low | 3 |
rust_419 | Pretty-printing wraps trailing paren | Not sure why, but pretty printing an expr list (foo, bar) will often produce: ``` (foo, bar ); ``` Ideally the ) would be considered part of the final token in the list, indivisible from wherever it gets wrapped to. | labels: A-pretty | medium | 2 |
rust_420 | Pretty-printing injects new lines for line-trailing comments | Pretty printing a list like this: ``` rec(foo, // comment 1 bar, // comment 2 baz) ``` Turns into this: ``` rec(foo, // comment 1 bar, // comment 2 baz) ``` Which is close, but not quite right. It seems to be always opening a new line for a line-comment; ma... | medium | 2 |
rust_421 | Pretty-printing binops should have lower affinity somehow | When printing a binop expression containing fn calls, we wind up wrapping rather late: ``` foo(a, b, c) + bar(d, e, f) ``` will sometimes print as ``` foo(a, b, c) + bar(d, e, f) ``` rather than ``` foo(a, b, c) + bar(d, e, f) ``` or similar (+ could be on the... | medium | 2 |
rust_422 | Pretty-printing support for words that aren't broken relative to their neighbour | Given the way the pretty printer is structured, generating a token at a time, it'd probably be useful to have token types that the pretty printer considered effectively "indivisible" with the word before (or after, or both) them. Otherwi... | question | 4 |
rust_423 | Pretty-print crate files | Not a huge issue since our crates are still relatively small, but crates and crate directives are not presently supported. Probably should be. | labels: A-pretty | question | 4 |
rust_424 | Implement log for more types | Currently, log works for integral, floating point, and string types. It will raise an error in trans on other types. We should add support for other types. | labels: A-runtime | question | 4 |
rust_427 | write a tutorial for the docs | Currently we just throw the user into a reference manual and hope for the best. A tutorial section would be good. | low | 3 |
rust_428 | unit test machinery | We want the language to ship with an integrated unit-testing system of sorts. Nothing too fancy, just a "no excuses" sort of entrypoint _in_ the language plus some driver logic to collect tests and make a binary that shells out to a runner with a stock interface. Possibly copy D | labels: A-front... | medium | 2 |
rust_429 | website | At some point we need to actually flesh out rust-lang.org to be more than just a github project page. Use the github-pages system (http://pages.github.com/) with a CNAME to rust-lang.org. And a labs VM for dynamic content (perf measurements and such). | medium | 2 |
rust_430 | website | At some point we need to actually flesh out rust-lang.org to be more than just a github project page. Use the github-pages system (http://pages.github.com/) with a CNAME to rust-lang.org. And a labs VM for dynamic content (perf measurements and such). | medium | 2 |
rust_431 | make trans contexts into objects | Nobody should have to write cx.fcx.lcx.ccx.tcx. Everyone winces when they see it. Fix this. Put the contexts in objects that pick such things up from their parents. No functional changes, just a whole lot of shoving stuff around. | labels: E-easy, C-cleanup | low | 3 |
rust_435 | Add support for binding a method off an impl | Make it legal to do the following: ``` obj foo() { fn add5(n: int) -> int { ret n + 5; } } fn add5(n: int) -> int { ret n + 5; } fn main() { let fiveplusseven = bind add5(7); log_err fiveplusseven(); // Can't do this currently let my_foo = foo(); let fiveplusseven_too = bi... | question | 4 |
rust_436 | -L sysroot should be default | The sysroot should be searched for the standard library by default. | labels: E-easy | low | 3 |
rust_437 | Error messages should follow a consistent style | We've decided for now that error messages should begin with a lowercase letter. Variable names and type names should follow a consistent format; I've started using backquotes following Markdown, but single quotes would work too. | labels: A-frontend, E-easy, C-cleanup | low | 3 |
rust_438 | put librustrt and librustllvm in stageN directories of build | Currently all stages use the same C++ libs. This can make snapshot migration hard, and requires over-large LD_LIBRARY_PATHs. Make copies of them in stage0 ... stage1 when building. | labels: E-easy | low | 3 |
rust_439 | Print out the offending line on error | When rustc emits an error, we should print out the offending line. | labels: E-easy | low | 3 |
rust_440 | rustc shouldn't stop after the first error | After the first error, we should keep going in some cases. As a first stab at this, we could abandon the current function and try to resolve/typecheck other functions. | labels: A-driver | medium | 2 |
rust_441 | rpath binaries so no LD_LIBRARY_PATH is needed | use of rpath and $ORIGIN when linking, and we won't need LD_LIBRARY_PATH settings at all. implement this. | labels: E-easy, A-linkage | low | 3 |
rust_442 | make all error messages lowercase | We have mixed case error messages. Make them all lower case. | labels: E-easy, C-cleanup | low | 3 |
rust_443 | rustc should know how to run the linker on all platforms | And preferably `ld`, not `gcc`. | labels: A-frontend, E-easy | low | 3 |
rust_444 | try to ensure all errors use spans | We have a bunch of cases of sess.err in the code that ought to be sess.span_err -- that is, they should carry a source position indicating the origin of the error. Fix these. | labels: E-easy, C-cleanup | low | 3 |
rust_445 | make sure every FIXME in the code has an issue open for it | Also make sure the issue number is noted next to the FIXME. This requires periodic re-checking. | labels: E-easy, C-cleanup | low | 3 |
rust_446 | Disallow binding to alias parameters | This is unsafe (until we have interior/nonescaping lambdas). | labels: E-easy | low | 3 |
rust_448 | Multiline strings | We should support multiline strings, possibly both by backslashing escapes and with Python-style triple-quoted strings. | labels: A-frontend, E-easy | question | 4 |
rust_449 | Or-patterns | It would be nice to be able to do something like: ``` alt (thingie) { case (foo) case (something_much_like_foo) { ... } ... } ``` or even ``` case (foo | something_much_like_foo) { ... } ``` (Feel free to close this if it's a dup of an existing issue. I heard it was on the featur | labels: A-frontend | medium | 2 |
rust_452 | if/alt expressions don't understand how to return functions that fail | In the following example the first arm of the if expression doesn't translate: ``` fn f() -> ! { fail } fn g() -> int { auto x = if (true) { f() } else { 10 }; ret x; } ``` Trans thinks that f() returns int (because x is int) and tries to copy the ... | medium | 2 |
rust_454 | Implement "fail EXPR" for convenience | `log_err "Going down in flames..."; fail;"` code is very common. It'd be nice to able to optionally supply an error message with `fail` statements. | labels: E-easy | low | 3 |
rust_456 | Implement per-symbol and per-crate versioned-API support | Currently we have very weak support for user-meaningful version numbers; a per-crate version number that is possibly mangled into the crate compilation name, but nothing else. Ideally we'd be using a symbol-versioning approach similar to the GNU-style @@vers st... | question | 4 |
rust_457 | Serialize the non-exported metadata into the crate as well, for documentation purposes. | Currently front::eval throws away all non-exported metadata while interpreting the crate directives. This is not right; it should store the non-exported stuff in the crate as well, tagged differently but still extractable by tools... | low | 3 |
rust_458 | Get dynamic loading working | For syntax extensions (and possibly semantic extensions) to load in from external crates, we need to dynamically load them. Currently the library-scanning machinery is a bit too weak to handle this, and there's no os-level interface in the standard library for fetching symbols fr | labels:... | low | 3 |
rust_459 | Perform meta tag matching to bind to crates | Currently 'use std' is resolved by unambiguously opening libstd.so (or .dylib, .dll) in each of the library search paths. This is inadequate. We should be opening all relevant crates and scanning the metadata sections looking for meta tag matches. | labels: A-frontend, A-li... | medium | 2 |
rust_460 | Allow assignment to aliases only when they were declared mutable | Right now, the word 'mutable' after the & symbol is simply skipped by the parser. Will need to remember that an alias is mutable, and disallow assigning to them when it is not. | medium | 2 |
rust_461 | Port to x64 at least, not just x86. | Hopefully we can get to a point where we only need a ucontext impl to port to a new platform. Still not quite at this stage yet. | medium | 2 |
rust_463 | Allow tasks to return values | Right now tasks are all void. If we could return values from tasks, it would make the "go do this asynchronously and get back to me" pattern a lot easier. It would require changes to the type system though (task becomes task[T]), but most of the plumbing is in place to return a v | medium | 2 |
rust_464 | Remove rustboot "trans_const_lval bug" workaround | There's a lot of obsolete `auto f = foo; g(f);` code to work around the fact that you couldn't say `g(foo);` when `foo` was a function in rustboot. We should remove this. | labels: E-easy, C-cleanup | low | 3 |
rust_465 | Have human-readable source for vec append glue | Currently vec append glue is LLVM bitcode `vec_append.ll`. This isn't very human-readable. | labels: A-runtime, C-cleanup | low | 3 |
rust_466 | Experiment with moving the task pointer to thread local storage | We currently thread the task pointer through all Rust functions, which increases register pressure and makes calls slightly more expensive. It may well be cheaper to put it in thread-local storage. We should experiment with this. | labels: A-runtime | medium | 2 |
rust_467 | Compile pattern matches to switch statements | Right now pattern matching is always O(n) in the number of cases. This is suboptimal. Tags should be compiled to switch statements. | labels: I-slow | medium | 2 |
rust_468 | Accept .<> as well as [] for type parameters | I think ES4-style `option.<int>` type parameters have reached consensus. The `>>` ambiguity should be fixed as well; easiest solution IMO is just to define right shift as two consecutive greater-than signs. | labels: A-frontend, E-easy | low | 3 |
rust_469 | Allow pattern matching over structural types | We should be able to pattern match over tups and recs in particular. | labels: A-frontend | medium | 2 |
rust_470 | Allow multiple vars to be declared in one declaration | Allowing `auto a, b;` would be a nice convenience. | labels: A-frontend | medium | 2 |
rust_473 | move librustrt.so and librustllvm.so into sysroot | having them in their own non-stageN directories makes many things more delicate than necessary | medium | 2 |
rust_474 | make target-run compiled artifacts per-arch | once in sysroot, librustrt.so should be built as stageN/lib/$arch/librustrt.so and recompiled for every target in the targets list for the current compiler. rustc and librustllvm should probably only be compiled for every host in the host list. Or, if we're lucky, we only h... | medium | 2 |
rust_475 | Allocating memory from rust involves 5 layers of indirection | Allocating memory from rust involves 5 layers of indirection upcall_malloc -> rust_task::malloc -> rust_dom::malloc -> memory_region::malloc -> rust_srv::malloc -> malloc And rust_srv::malloc is virtual. | labels: A-runtime, I-slow | medium | 2 |
rust_476 | `rustc -S --emit-llvm` should emit LLVM assembler | For compatibility with clang and for debugging convenience, `rustc -S --emit-llvm` should disassemble the bitcode. | labels: A-frontend, E-easy | low | 3 |
rust_477 | Eliminate the builder objects in lib/llvm and trans | Very large objects slow down typechecking and add vtable dispatch overhead for no real benefit that I can see. Instead of `bcx.build.Foo(…)` we could just have functions like `Foo(bcx, …)`. This is a mechanical change. | labels: E-easy, C-cleanup | low | 3 |
rust_478 | Make all of our GEPs InBoundsGEPs | All of our GEP instructions are really InBoundsGEPs. Using InBoundsGEPs makes it more likely for SROA to succeed. LLVM often mops up, but this takes some of the pressure off it. | labels: E-easy | low | 3 |
rust_479 | Typechecker does not require LHS of assignment to be an lval | Assigning to something that isn't an lval produces an error in trans, not during typechecking: fn main() { 5 = 1; } produces the error: fail.rs:2:1:2:2: error: internal compiler error unimplemented expr variant in trans_lval: 5 | labels: A-frontend | high | 1 |
rust_480 | Variable sized function arguments don't fail until trans | Trying to compile "fn test[X](X l) { }" results in "upcall fail 'arg.mode != ty::mo_val', ../src/comp/middle/trans.rs:736" | labels: A-type-system | medium | 2 |
rust_481 | Resolve should make sure variables aren't used before they're declared | Typestate usually errors out when this happens, but the message is confusing. This should be picked up in resolve. | medium | 2 |
rust_482 | internal error "imports and matches don't agree" on multiple glob-import when at least one source is from a different crate | For example: use std; import std::vec::_; import alternate_supplier::_; ``` mod alternate_supplier { fn swap() {} } fn main() { swap() } ``` The internal error occurs when trying to generate an ... | medium | 2 |
rust_483 | Using the result of an assignment expression results in an LLVM assert | I am not sure what the correct behavior should be (parse error, typecheck error, working like in C), but I am pretty sure this isn't it. | labels: A-type-system | medium | 2 |
rust_484 | Typechecker doesn't properly check assignment operations | The typechecker treats assignment operations exactly like normal assignment and thus does not require that the values are of the appropriate type for the operation being performed. auto x = tup(1, 5); x += tup(3, 5); will pass typechecking but trip an LLVM asse... | medium | 2 |
rust_486 | Implement an alias analysis pass | One of the nice things about our type system is that we have very strong alias information. We can feed this information to LLVM to help guide its optimizations. | labels: A-LLVM, I-slow | medium | 2 |
rust_487 | Extend metadata to items, not just crates | Crates support attributes through the `meta` statement. To support conditional compilation, among other things, we want to allow attributes on all items. Instead of using the meta statement, attributes will be applied using syntaxes like the following ``` #[foo] mod bar { } `... | question | 4 |
rust_488 | Automatically 'bind' generic functions when their value is taken | Currently this doesn't work: ``` fn generic[T](&T x) -> vec[T] { ret [x]; } fn main() { auto f = generic; log_err f(1).(0); } ``` It could, though -- the compiler has enough type information available when the value of `generic` is taken to statically a... | medium | 2 |
rust_489 | More robust support for conditional compilation | Use item attributes to support conditional compilation. Items marked with a certain attribute, e.g. `#[cfg(test)]` will only be translated when rustc is passed a flag for the 'test' configuration. Remove the target_os hack (as used in std.rc) | question | 4 |
rust_492 | Find a solid way to pass span info around trans | The current approach (8cbdaf4f93ecc775727d334890014ca929ad2b36) puts a span in the block_ctxt record, probably because that's already being passed around. The two have very little to do with each other though, and the re-creating of block contexts makes it very easy to ... | low | 3 |
rust_493 | Modules can't be defined inside of functions | While pretty much useless, the following should work: ``` fn f() { mod m { } } ``` Currently fails in typestate. | labels: A-frontend, C-enhancement | low | 3 |
rust_494 | Context switching doesn't pass valgrind on OS X when built with Clang | labels: A-runtime | medium | 2 |
rust_495 | Task startup makes cross-language/module fastcalls | This isn't safe, in general. | labels: A-runtime | medium | 2 |
rust_496 | Context creation doesn't respect stack alignment | labels: A-runtime, I-crash | high | 1 |
rust_497 | Pretty-printer prints comments above a case too late | In parser.rs, we now have... ``` case ( //the lexer can't tell the different kinds of stars apart ) : token::BINOP(token::STAR)) { glob = true; p.bump(); } ``` The comment used to be above the case, but ends up being printed after the "case (" part has already been... | medium | 2 |
rust_498 | upcall_vec_append can crash when self-appending | use std; import std::vec; fn main() { let vec[int] a = [0]; auto i = 20; while (i > 0) { a += a; i -= 1; } } I suspect, but haven't confirmed, the following: If a vector that is in the process of self-appending (v += v) grows, we can realloc the existing vector pointer ... | high | 1 |
rust_499 | Fix pretty-printing of anonymous objects | Right now they just pretty-print as `anon obj`. Fix this. | labels: A-pretty | medium | 2 |
rust_500 | Binary operations are not type checked | This fails in trans: ``` fn main() { auto x = true; auto y = 1; auto z = x + y; } ``` | labels: A-type-system | medium | 2 |
rust_501 | Pretty printer comment drift in tag definitions | The pretty printer caused the following comment drift in the ast definitions: expr_assign(@expr /\* TODO: @expr|is_lval _/, @expr, ann); became expr_assign(@expr, /_ TODO: @expr|is_lval */@expr, ann); | labels: A-pretty | medium | 2 |
rust_502 | std::term needs better detection of color terminals | Right now it just checks the value of $TERM, leaving lots of users unable to see rustc's awesome colored errors | labels: C-enhancement | low | 3 |
rust_506 | Internal compiler error when trying to spawn a native function as a task | I see 'internal compiler error ret_ty_of_fn_ty() called on non-function type' when trying to compile: native "rust" mod rustrt { fn uvtask(); } fn iotask() { let task iothread = spawn rustrt::uvtask(); } | high | 1 |
rust_507 | Unable to pass channels across more than one task | Test case is approximately as follows: 1. create a channel and pass it to a new task 2. have the new task pass the channel to another new task 3. from that newest task, send on the channel 4.receive on the original task Expected: successful exit of program Actual: - w... | medium | 2 |
rust_508 | Implement M:N task to OS thread scheduling. | labels: A-runtime | medium | 2 |
rust_509 | Remove upcall_join | This is dead code now that join has been moved to the standard library. | labels: C-cleanup | low | 3 |
rust_510 | Directly call glue functions when we can instead of picking them out of the type descriptor | We always pull type glue out of a type descriptor to call it, even when the type descriptor in question is statically known. This makes debugging the generated code harder and makes LLVM do more work than it needs to to clean ... | question | 4 |
rust_511 | Passing "none" to an &mutable option::t[T] leaks | Just what it says: if a alias parameter has type `mutable option::t[T]` for some `T`, passing a literal `none` to it leaks. | medium | 2 |
rust_513 | Typechecking if apparently doesn't require a boolean. | I accidentally wrote `if(path_is_absolute)` instead of `if(path_is_absolute(p))` and got an LLVM assertion error instead of a rust type error. This doesn't seem right to me. | labels: A-type-system | medium | 2 |
rust_514 | equal_type_structures should just be == | But last time I tried that, it exposed a bug in translation of cmp glue. So we should fix that. | medium | 2 |
rust_515 | Figure out and implement task lifetime rules. | Originally tasks were going to be lexically scoped, so they die as soon as the task variable goes out of scope on the parent task. This is counter-intuitive to a lot of people, so we might have a list of child tasks and refer to them by handles instead. This also would le... | medium | 2 |
rust_516 | Incorrect type in 'mismatched types' error | ``` fn main() { auto x = true; auto y = 1; auto z = x + y; } ``` reports "error: mismatched types: expected bool but found bool (types differ)". Should be "bool but found int". Also, the reported span encompasses the entire binop when it should probably just cover the y vari... | medium | 2 |
rust_517 | Cache results of type_has_pointers | At least 16.1% of translation time is spent in that function. | medium | 2 |
rust_518 | Change "mutable?" to something else ("const"?) and fix covariance/invariance | AIUI the general consensus was that we should implement a mutable "slot" type. This is basically equivalent to an interior record with one mutable field. This allows us to remove the `mutable?` botch. | labels: C-cleanup, A-type-system | low | 3 |
rust_519 | Tagged union typechecking regression | Checkout 612f447e698ad127f57af1900e82923b8f5fee9b in my fork and try to build. I see the following error: ../src/lib/aio.rs:50:8:50:17: error: mismatched types: expected port[iorequest] but found port[iorequest](types differ) This used to work a few days ago but I've lost track o | high | 1 |
rust_520 | Cannot spawn task with channel and string | <input>:0:0:0:0: error: internal compiler error unexpected type in trans::deep_copy: str Testcase: type ctx = chan[int]; fn iotask(ctx cx, str ip) { } fn main() { let port[int] p = port(); spawn iotask(chan(p), "localhost"); } | high | 1 |
rust_521 | Valueless ret expression in block tail position doesn't parse | ``` fn f() { auto x = alt (true) { case (true) { 10 } case (false) { ret } }; } ``` Parser expects ret to be followed by a semicolon. Using `ret ()` works as expected. | medium | 2 |
rust_522 | Build NSIS installer for rust toolchain on windows | The NSIS ( http://nsis.sourceforge.net ) installer is probably the best bet for deployment on windows. Make a basic package that installs rustc and the docs and libs to C:\Program Files\Rust or such. | low | 3 |
rust_523 | Instantiating the type parameters of a function without calling it fails in LLVM | ``` fn f1[T](int x) { log x; } fn main() { auto f2 = f1[str]; } ``` results in rustc: Instructions.cpp:962: void llvm::StoreInst::AssertOK(): Assertion `getOperand(0)->getType() == cast<PointerType>(getOperand(1)->getType())->getElementT... | medium | 2 |
rust_524 | Insert yield checks at appropriate places | labels: A-runtime, E-hard, A-concurrency, P-medium | medium | 2 |
rust_526 | native types should not all be the same type | Currently all types declared as 'native' wind up as the same type in the type checker. This is wrong. They should be considered nominal types. | labels: A-type-system | medium | 2 |
rust_527 | Experiment with interpreted glue | We spend lots of time generating glue, even for stuff like cmp glue that is cold. We could emit a declarative description of the type and have a generic "cmp" function that uses that description. | medium | 2 |
rust_528 | Bake in default sysroots appropriately | We should bake in a default sysroot into the binary where rustc looks for all of its stuff (stdlib, glue, etc). | labels: A-frontend | medium | 2 |
rust_529 | Make rustc installable with `make install` | This depends on issue #528. `make install` should do the right thing. | medium | 2 |
rust_530 | Use fastisel at -O0 | Clang does this and it should buy us some compile perf for debugging. | medium | 2 |
rust_531 | move entire communication system into library | Ports, channels and tasks are going to sink into library features. This includes send and receive operators, as well as communication-alt expressions. | labels: A-runtime, A-type-system | medium | 2 |
rust_532 | Assert failure with 1-argument #fmt call | `#fmt("test")` results in "upcall fail 'Assertion start <= end failed" | labels: A-frontend, E-easy | low | 3 |
rust_533 | Convert rustc over to interior vectors and remove exterior vectors | We should convert rustc over to interior vectors and remove exterior vectors. | medium | 2 |
rust_534 | improve make performance | Make appears slow to start, and per-target execution is slow. Speed this up. | medium | 2 |
rust_535 | Implement overloading | Synopsis: ``` mod foo { overload fn f(int x) { log x; } } mod bar { overload fn f(str s) { log s; } } import foo::f; import bar::f; fn main() { f(3); f("hello world"); } ``` Result: ``` 3 hello world ``` | labels: A-frontend | medium | 2 |
rust_536 | Investigate LLVM ARC optimizations | LLVM now has optimizations for reference counting (yay!). We should look into this. | labels: A-LLVM, I-slow, E-hard | medium | 2 |
rust_537 | Implement a copy operator and make it mandatory in some cases | For what cases, we aren't sure at the moment. | medium | 2 |
rust_538 | Adding support for extending objects with new fields | This will be a pretty big feature, involving the parser and, importantly, the resolver as well as the typechecking and translation passes. Currently xfail'd test: src/test/run-pass/anon-objs-with-fields.rs. | question | 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.