id stringlengths 8 11 | text stringlengths 32 472 | label stringclasses 5
values | label_id int64 0 4 |
|---|---|---|---|
rust_1423 | llvm-dis does not work on our generated .bc files anymore | If you save a `.bc` with the `--save-temps` compiler switch, the file isn't accepted by `llvm-dis` anymore. It says `unknown type in type table`. This removes a very valuable debugging angle. It used to work. Unless someone has an idea what this might be, we'l... | medium | 2 |
rust_1424 | Simplify the rope:bal1 test | It takes a long time to run. Every time I see it I wonder what's going on. | labels: E-easy, A-testsuite | low | 3 |
rust_1425 | Allow overloaded literals | `let i: uint = 0` is not valid and this frustrates almost everybody. Maybe there's some compromise that solves the biggest problem. | labels: A-type-system | medium | 2 |
rust_1426 | Export all tag variants | Most people would like exporting a tag to export all variants, while preserving some way to only export some. | medium | 2 |
rust_1427 | Eliminate dot in nullary-tag variant patterns | Nobody likes it, but there's no agreement on how to fix it. | medium | 2 |
rust_1428 | Rename tag to something else. Possibly 'enum' | medium | 2 |
rust_1429 | Eliminate the disambiguating :: in id::<int> | Remembering when you have to put `::` before type parameters is difficult. Nobody likes it. | labels: E-hard | medium | 2 |
rust_1430 | Separate tag variants by comma | `tag x {a; b; c}` should look like `tag {a, b, c}` to make it closer to record syntax. | labels: E-easy | low | 3 |
rust_1431 | Ensure consistent naming of predicates in std and core | We discussed this on IRC and decided that names of simple boolean predicates in std and core should start with "is_" or similarly be expressed using a "small question word" The notable exception are generally established predicate names like "lt", "ge", etc. This... | question | 4 |
rust_1432 | allow recursive object methods | It's a bit obnoxious when writing an object type that can return instances of itself that we need a tag to break up the recursion: ``` tag foo_tag = foo; type foo = obj { fn get_children() -> [foo_tag]; }; obj new_foo() { fn get_children() -> [foo_tag] { [] } } ``` It'd be much n | medium | 2 |
rust_1433 | Add support for hexadecimal float literals | We need to be able to parse the output of printf's %a for proper support of mathematical constants without loss of precision (i.e. 0x1.fffffffffffffp+1023_f64 syntax) | labels: A-frontend, E-easy | question | 4 |
rust_1434 | Stop flushing stdout every time a line is logged | In rust_srv::log we're flushing stdout every log line. It's only done to make sure all the output is captured when the process fails, so we should instead flush just once, possibly in ~rust_srv. | labels: A-runtime, E-easy, I-slow | low | 3 |
rust_1435 | Stop defining NVALGRIND when valgrind isn't found | I forget exactly why we started defining NVALGRIND, but using it creates a situation where you can build the runtime without the needed valgrind support (if configure doesn't find valgrind); then if you later try to valgrind rust code it will report bogus errors. | la... | question | 4 |
rust_1436 | Implement indefinite-extent iface dicts | They are currently always stack-allocated, which doesn't work when you want to bind a function that takes a bounded parameter. Will also have to make this work for unique functions somehow. | medium | 2 |
rust_1437 | Implement cast-to-iface | `myvalue as myiface` should, if `myvalue` is of a type that has an impl of `myiface` in scope, copy the value into a boxed representation, along with the dict needed to treat it as myiface. Values of such a type can have methods called on them, which will be resolved through the | medium | 2 |
rust_1438 | Fix re-exporting of impls | You currently can't re-export an impl from a module. (Maybe it accidentally works in-crate, but it's definitely broken cross-crate.) | medium | 2 |
rust_1439 | Add some useful interfaces to the core and std libs | To find out whether they work well, we should try to actually use them. `to_str` and `seq` are some obvious candidates. If #1438 is resolved, we can provide a `core::impl::common` module that exports impls for common interfaces of built-in types, so you'd only need ... | medium | 2 |
rust_1441 | Documentation links on wiki front page are broken | From https://github.com/graydon/rust/wiki -- in the Documentation section -- the "HTML" and "PDF" links for "Latest snapshot" are both broken. I get a github "page not found" error. | medium | 2 |
rust_1442 | Find out why core::float needs explicit exports | core::float imports from fXY::\* which in turn re-exports predicates and functions from cmath. Turns out the predicates somehow do not get exported unless one uses explicit export statements. This is a bug and it needs to be investigated where this is coming from. | lab... | medium | 2 |
rust_1443 | Segfault with generic functions | The below code segfaults for me. Any further reduction seems to remove the problem. ``` fn baz<T, U>(s: T, f: block(T) -> U) { f(s); } fn foo<T>(x: T) { baz(x, {|_e| 0 }); } fn main() { foo(0); } ``` | labels: I-crash | high | 1 |
rust_1444 | rustc's --test flag should imply --bin | Crate's that have the #[crate_type = "lib"] attribute are compiled as libs even when compiling with --test. This is probably not intuitive. | labels: E-easy, A-driver, A-testsuite | low | 3 |
rust_1445 | Fix make dist | Make dist probably doesn't work anymore, and we need it before doing a release. | medium | 2 |
rust_1446 | Have the bots run make distcheck | medium | 2 |
rust_1447 | Reorganize the directory structure of librustc and the driver | The driver is now just a small stub that calls librustc, but the source still lives under comp. These two things should be separated. I suggest moving librustc to src/librustc and driver.rs to src/rustc-driver. | labels: E-easy, C-cleanup | low | 3 |
rust_1448 | Macro errors are reported at def, not use | If you write something like `#debug["%u", 10]`, the type error (unsigned vs signed int) gets reported in `core.rs`, at the definition of `#debug`, rather than at the point of use. This is very confusing and makes you think something is fundamentally wrong in the Rust librarie... | medium | 2 |
rust_1449 | Dependencies for C++ files in rt are wrong | I am not 100% sure why, but the autogeneration of dependencies for the C++ files in rt definitely do not work. Changing a header file, for example, does not cause all the files that include that header to be recompiled. I would be inclined to just have `*.cpp` depend on `*.h... | medium | 2 |
rust_1451 | bare fn types in record unification produces unexpected errors | In the following source: ``` type T = { mutable f: fn@() }; type S = { f: fn@() }; fn fooS(t: S) { } fn fooT(t: T) { } fn bar() { } fn main() { let x: fn@() = bar; fooS({f: x}); fooS({f: bar}); let x: fn@() = bar; fooT({mutable f: x}); fooT({mutable f: ba... | medium | 2 |
rust_1452 | cargo: Add the ability to run tests | labels: C-enhancement | low | 3 |
rust_1453 | Create a continuous integration server for building rustpkg packages | I would like to know when packages break. We can possibly extend rustbot to do this. | labels: C-enhancement, P-medium | low | 3 |
rust_1454 | redesign task API to use sendable fns and be more approachable | I am currently working on redesigning the task API to use sendfn and be more approachable. However, doing so exposed some bugs in sendfn so this is really blocked on me fixing those bugs. Just wanted to get an issue in the tracker for it. The basic change... | medium | 2 |
rust_1455 | spawning a bare fn doesn't work | This should work: ``` fn foo() { } fn bar() { task::spawn(foo); } ``` but it doesn't right now, because you get an error message that you are moving out of a static item. This is reasonable, as spawn's parameter is declared with move mode, but the rule doesn't make sense in this | medium | 2 |
rust_1457 | Dismantle std::unstable | core and std have extfmt and test modules which just provide compiler support and aren't intended to provide a user-facing API. We should have some convention for where they should be hidden away. In particular, "test" is a module where I would like to put useful things for writi | labels: E-e... | question | 4 |
rust_1458 | pp omits parens needed to disambiguate call-with-block sugar | This is a passing Rust program: ``` fn plus_one(f: block() -> int) -> int { ret f() + 1; } fn ret_plus_one() -> fn(block() -> int) -> int { ret plus_one; } fn main() { let z = (ret_plus_one()) {|| 2}; assert z == 3; } ``` The pretty-printer omits the parens... | medium | 2 |
rust_1459 | log (fail, 2) hits an LLVM assertion | ``` fn main() { log (fail, 2); } ``` Assertion failed: ((i >= FTy->getNumParams() || FTy->getParamType(i) == Args[i]->getType()) && "Calling a function with a bad signature!"), function init, file /Users/jruderman/code/rust/src/llvm/lib/VMCore/Instructions.cpp, line 274. | medium | 2 |
rust_1460 | "error: internal compiler error ty_fn_args() called on non-fn type" | ``` fn main() { {|i| if i == 1 { }}; } ``` Result: ``` error: internal compiler error ty_fn_args() called on non-fn type ``` Expected: ``` error: expressions with block type can only appear in callee or (by-ref) argument position ``` | high | 1 |
rust_1461 | "warning: Captured variable 'x' not used in closure" presages a crash | ``` fn main() { let x = ~1; let lam_move = lambda[move x]() { }; lam_move(); } ``` While compiling: ``` 3:32 warning: Captured variable 'x' not used in closure ``` While running: ``` malloc: *** error for object 0x1: pointer being freed was not all... | high | 1 |
rust_1462 | non-exhaustive match failure in typeck::lookup_method | ``` fn f<T: copy>(t: T) { t.x; } ``` Result: ``` upcall fail 'non-exhaustive match failure', ../src/comp/middle/typeck.rs:1554 ``` Expected: ``` error: attempted access of field x on type 'a, but no method implementation was found ``` I guess the loop in lookup_me... | medium | 2 |
rust_1463 | "upcall fail 'option none'" with recursive iface impl? | Replacing "e" with "self" in src/test/run-pass/iface-to-str.rs causes an internal compiler error. Here's a slightly reduced testcase: ``` fn ignore_block(_b: block(str)->str) { } iface to_str{ fn to_str() -> str; } impl to_str<T: to_str> of to_str for [T] { fn to... | high | 1 |
rust_1464 | rustc hang with infinite recursion in ty::fold_ty | rustc hangs trying to compile this program: ``` import comm::*; fn f() { let p = port(); send(recv(p), chan(p)); } ``` Seems to be infinite recursion in: ``` 510 vec::map::_83cc742242c22cda 510 middle::ty::fold_ty::anon2725 510 middle::ty::fold_ty::_c9621faf7679b838 5... | medium | 2 |
rust_1465 | internal compiler error fail called with unsupported type _|_ | ``` fn main() { fail do { fail } while true; } ``` Gives me ``` error: internal compiler error fail called with unsupported type _|_ ``` | question | 4 |
rust_1466 | RUST_CC_ZEAL crash: too much recursion in walk_uniq | ``` fn main() { let _x = @{a: @10, b: ~true}; } ``` When run with RUST_CC_ZEAL=1, this program crashes. The crash looks like it's due to too much recursion in ``` shape::data<cc::irc, shape::ptr>::walk_uniq(). ``` It's also suspicious that the cycle collector hits a... | high | 1 |
rust_1467 | Anonymous function with upvar trips assert in trans | ``` fn main() { let x = 3; (fn() { assert x == 3; })(); } ``` Result: ``` rust: upcall fail 'Assertion cx.fcx.llupvars.contains_key(did.node) failed', ../src/comp/middle/trans.rs:2688 rust: domain main @0x7fe932819a00 root task failed ``` Expected? ``` error: attemp... | medium | 2 |
rust_1469 | rebind-fn.rs crashes with RUST_CC_ZEAL=1 | src/test/run-pass/rebind-fn.rs crashes when run with RUST_CC_ZEAL=1. | labels: I-crash | high | 1 |
rust_1471 | Generic type can't be inferred through lambda block | ``` type actor<T> = { unused: bool }; type self<T> = { unused: bool }; fn act<T:send>(+behavior: sendfn(self<T>)) -> actor<T> { {unused: true} } tag in { preprocess([u8]); exit; } fn mk() -> actor<in> { act {|self| } } fn main() { } ``` ``` ../src/test/run-pass/bloc... | medium | 2 |
rust_1472 | Check that rustc's output is writable before linking | If the final output file is not writable we end up failing with a cryptic linker error and a dump of the gcc command line. This could largely be avoided by doing some check before running the linker. | labels: E-easy, A-linkage, A-driver | low | 3 |
rust_1474 | Block style autodetection should take upvars into account | This is a slight variation on #1467: ``` fn main() { let x = 3; fn blah(_a: fn()) {} blah({|| log(error, x); }); } ``` Compiling that crashes when trans tries to resolve the upvar for `x` inside the block. I guess typeck should refuse to convert something that... | medium | 2 |
rust_1475 | Add many more tests for iface and impl | Also for error conditions. | medium | 2 |
rust_1476 | expected error scanner is too imprecise | The code in compiletest which scans for expected errors when you use the `//!` mechanism to associate an error with a particular line is not very smart. It just looks for a filename, line number, and the string `error` or `warning`. This sometimes causes it to fail tests that d... | low | 3 |
rust_1478 | Don't log in the red zone | It requires too much stack | labels: A-runtime | medium | 2 |
rust_1479 | Update spawn example in language doc | This is wrong: https://github.com/graydon/rust/blob/master/doc/rust.texi#L1534 | labels: E-easy | low | 3 |
rust_1480 | Leak with sendfn | This leaks: ``` tag maybe_pointy { none; p(@pointy); } type pointy = { mutable a : maybe_pointy, d : sendfn()->(), }; fn empty_pointy() -> @pointy { ret @{ mutable a : none, d : sendfn()->(){}, } } fn main() { let v = empty_pointy(); v.a = p(v); } ``` | medium | 2 |
rust_1481 | better error message when there is a missing semicolon with an expression | Something like: ``` fn foo() { task::spawn {|| } //! ERROR type mismatch: expected '()' but got 'tast' bar(); } fn bar() { } ``` will yield an error something like the one above. It would be better if it said, "statement with non-unit return ty... | low | 3 |
rust_1482 | Leaks when failures occur during unwinding | If a failure occurs during unwinding or executing a resource, we potentially leak. This is blocking #1078 (which also includes a reference to a testcase). | labels: A-codegen | medium | 2 |
rust_1483 | deprecate 'obj' in docs | The obj system will be removed in a near-future version of rust, as we have a typeclass system now that goes a fair ways beyond what the obj system did. Not first release, but soon. In our own code we're leaving it active for the 0.1 release just to avoid totally destabilizing th | labels: E-e... | question | 4 |
rust_1484 | remove 'obj' system | Most uses of the obj system should, at this point, be replaceable with uses of the iface/impl system, with some degree of improved performance to boot. Try this in our own code (libstd and rustc) and see how far it can get. If complete, remove 'obj' support from the compiler. | labels: E-easy, C-c... | question | 4 |
rust_1485 | Transfer rust to mozilla administrative group on github | It's still under 'graydon'. The time has come for it to graduate, you egotistical fellow! | medium | 2 |
rust_1486 | Generate rustdoc output instead of naturaldocs in build | This requires getting the output from rustdoc to a credible enough state that we can stand looking at its output instead of naturaldocs, rewriting the existing naturaldocs comments to rustdoc attributes, and adding some makefile logic to do the deed. | labels: T... | low | 3 |
rust_1487 | allow for native mod functions to initialize records | Some C libraries want you to create a structure on the stack and pass it off to be initialized by some function. Right now the typestate requires all structures to be fully defined before being passed to a function, so I'm finding myself having to write: ``` type f... | low | 3 |
rust_1488 | Remove the global variables that store the discriminant IDs per variant | Consider removing global variables that store the discriminant IDs per variant as they are likely not really needed. See pull request #1397. | labels: C-cleanup, A-codegen | low | 3 |
rust_1489 | Add a mechanism to set the max stack size | Right now we can recurse until memory runs out. There should probably be a way to control the maximum stack size, with some default value | labels: A-runtime, E-easy | low | 3 |
rust_1490 | move rust-mode.el to src/etc/emacs/ | It's currently living over in marijn's "temporary" repo https://github.com/marijnh/rust-mode but has long since become the only emacs mode that can speak rust, so.. | labels: E-easy, C-cleanup | low | 3 |
rust_1492 | Should it be possible to use a boxed iface type for a parameter bounded on itself? | I.e. ``` iface foo { fn foo(); } fn do_foo<T: fooable>(x: T) { x.foo(); } fn do_foo_with_foo(x: foo) { do_foo(x); } // Does not compile ``` The reason that does not compile is that no dictionary can be passed for type `foo`, since that... | medium | 2 |
rust_1493 | make boxes self-describing | Today we have a map that maps from each box allocation to a type descriptor describing its payload. This requires hashtable lookups on malloc/free and seems inefficient. However, to do cycle collection or any form of GC, boxes DO need to be self-describing. Therefore, I propose w | labels: ... | medium | 2 |
rust_1494 | Impl resolution may try to access unresolved types | When collecting the set of impls in a mod that hasn't been resolved yet, you get an error when one of the impls implements an iface, since the ty_path for the iface doesn't have a def associated with it yet. This should probably be fixed by moving the gathering of im... | medium | 2 |
rust_1495 | rt: remove set_min_stack | This function is not really safe to use as implemented and is only used in some tests that should no longer need it. | labels: A-runtime, E-easy, C-cleanup | low | 3 |
rust_1496 | Collect benchmark numbers for 0.1 | We need to know how our numbers now compare to those from last summer and those from gcc. | medium | 2 |
rust_1497 | rt: Add a way to configure the runtime environment from the command line | We have several environment variables defined in rust_env.cpp for controlling the runtime. It would be nice if this could be done from the command line as well. See thoughtpolice's comments in #1489. | labels: A-runtime, E-easy, C-enhancement | low | 3 |
rust_1498 | convert shape code to be visitor glue | I would like to do away with the shape code and instead have the compiler generator "visitor glue", which is glue code that walks the data structure and invokes methods on a visitor. The methods would be encoded as a struct of functions. This could replace the logging, universal ... | low | 3 |
rust_1499 | custom tag discriminants not considered in the shape code | I just realized that the shape code knows nothing about custom tag discriminants. I would prefer to fix this by fixing #1498. | labels: A-runtime | medium | 2 |
rust_1501 | `core::float::consts::pi` does not work | Whereas `core::f64::consts::pi` does. `float` import all from `f64`/`f32`, and exports `consts`, so it should be available. Probably some bug in re-exporting modules. | medium | 2 |
rust_1503 | Bounds check error in typecheck when compiling alt-expression | Compiling this code: ``` rust fn cmp() -> int { alt(option::some('a'), option::none::<char>) { (option::some(_), _) { fail; } // Works if this next case is commented out (_, option::some(_)) { fail; } } } fn main() { log(error, cmp()); } ``` yields the err... | medium | 2 |
rust_1504 | Allow 'give up on this function scope, continue with next' errors in typeck | Currently, when the check phase comes across something it really can't type, it bails out entirely and aborts the compilation. It should not be too hard to set it up to continue typechecking other function blocks, since those are mostly separ... | low | 3 |
rust_1505 | Parser doesn't handle fn@ or fn~ expr as statement | It tries to parse it as a fn item, and gets confused. There's already some code to handle this for plan `fn() {...}` exprs, it can be extended to handle these forms. | medium | 2 |
rust_1506 | Inner attributes not supported on all item types, including fn | While `mod { #[attr]; }` works, `fn { #[attr]; }` does not. This style of attribute is very desirable for rustdoc. | labels: A-frontend, E-easy | question | 4 |
rust_1507 | Improve type error messages | - The type errors sometimes fall back to the nameless (unpacked) names for named types. This is especially awkward for tags and such, where it uses metadata::tyencode to produce a (mostly unreadable) string. Find out why it doesn't see the type's proper name. - Module-qualify the | medium | 2 |
rust_1508 | Allow C code to call into Rust code | There are probably a number of things needed to make this happen: Scheduler: - Instead of reusing the scheduler's stack to call C code, we'll want each scheduler thread to hold a cache of big stacks, give each task a pointer to a C stack, a stack of C contexts and a stack of Rust |... | medium | 2 |
rust_1509 | Reduce the Rust stack red zone | Right now the stack red zone is 20K on all platforms, which is ~20K larger than we would like. Several considerations: - The dynamic linker performs lazy binding in the red zone. Lazy binding can be turned off. - Landing pads call _Unwind_Resume in the red zone. We can probably c | labe... | low | 3 |
rust_1510 | Need custom discriminant tests in the pretty printer | Right now, they don't get pretty printed at all! What needs to be done: - First, add a test or two to `test/pretty` with the `pp-exact` directive, as described [in the wiki](https://github.com/mozilla/rust/wiki/Note-testsuite). - Second, modify the pretty printer i... | medium | 2 |
rust_1511 | C-like tags should be castable to int with or without custom discriminants | This type checks (`tag-disr-val-shape.rs`): ``` enum color { red = 0; green = 1; blue = 2; black = 3; white = 4; } fn main() { assert uint::to_str(red as uint, 10u) == #fmt["%?", red]; assert uint::to_str(green as uint, 10u) == #fmt["%?", gree... | medium | 2 |
rust_1512 | Revoke Rust's claim to the `.rc` file extension on GitHub | Fun fact: Rust is the 21st-most-popular language on Github: https://github.com/languages/Rust Even Linus Torvalds uses Rust! https://github.com/torvalds/subsurface/graphs/languages This is just a papercut, but it would be nice if GitHub were told not to count ... | low | 3 |
rust_1513 | pandoc: unrecognized option `--section-divs' | When building doc/rust.html I get a pandoc error using version 1.5.11 | medium | 2 |
rust_1514 | GitHub's markdown doesn't understand commented out examples in tutorial | See: https://github.com/mozilla/rust/blob/master/doc/tutorial/syntax.md There are code examples prefixed with # that don't appear in the website version. We should probably try to make our markdown displays correctly on github. | labels: C-cleanu... | low | 3 |
rust_1516 | Closures can't be declared as diverging functions | This looks inferrable. ``` fn main() { let early_error: fn@(str) -> ! = {|msg| fail }; } ``` ``` ../src/test/run-pass/infer-closure.rs:2:38: 4:5 warning: unable to infer kind of closure, defaulting to block ../src/test/run-pass/infer-closure.rs:2 let early_error: fn@(... | medium | 2 |
rust_1517 | Run tutorial code fragments as part of make check | See #1514. marijnh has cleverly arranged for the tutorial fragments to be executable. We should run them as part of the test suite. | labels: A-testsuite | medium | 2 |
rust_1518 | Add syntax highlighting to rust-lang.org's code snippet | labels: E-easy, C-enhancement | low | 3 |
rust_1519 | rust-lang.org says rust is BSD licensed, when it is MIT | The bulk of the rust codebase is under the MIT license. | medium | 2 |
rust_1520 | Support a very basic form of operator overloading | (RFC) We could add interfaces `core::num` and `core::deref`, with the first implementing methods `add`, `sub`, `mult`, `div`, `rem`, `neg`, and probably a few more, and the second only `deref`. The compiler can then resolve operators `+`, `-`, `*`, `/`, `%`, and `[x]`... | question | 4 |
rust_1523 | Library support for go-like deferred function | I recently wrote the following to get some behavior like a 'finally' block: ``` resource finally(ch: comm::chan<monitor_msg>) { comm::send(ch, done); } let _finally = finally(ch); ``` What I really wanted to write was: ``` defer {|| comm::send(ch, done); } ``` Or somethin... | question | 4 |
rust_1524 | Wrong default filename for --lib --emit-llvm -S | ``` x86_64-unknown-linux-gnu/stage1/bin/rustc ../src/test/run-pass/hello.rs --emit-llvm -S --lib ``` Outputs a file named `../src/test/run-pass/hello.` instead of `../src/test/run-pass/hello.ll`. It does contain llasm as expected. | labels: A-frontend, E-easy | low | 3 |
rust_1525 | str::unsafe_from_bytes should be unsafe | It's not an unsafe function, but it's not safe. In general our string functions need some scrutiny. | labels: E-easy | low | 3 |
rust_1526 | Memory corruption with --emit-llvm -S on linux | ``` x86_64-unknown-linux-gnu/stage1/bin/rustc --emit-llvm -S --target=x86_64-unknown-linux-gnu --lib -o test.ll ../src/comp/rustc.rc ``` Results in: ``` *** glibc detected *** x86_64-unknown-linux-gnu/stage1/bin/rustc: double free or corruption (!prev): 0x000000001e3341d... | medium | 2 |
rust_1527 | Stack growth defeats optimization | After adding a call to fib(42) in shootout-fibo's main function. Without -O: ``` real 0m3.098s user 0m3.080s sys 0m0.010s ``` With -O: ``` real 0m5.799s user 0m5.770s sys 0m0.020s ``` Edit: When tasks do a lot of calculations without using a lot of stack, the effects of growing a | l... | medium | 2 |
rust_1528 | Functions written in expression style are slower than imperative style | This takes 4.7s: ``` use std; fn ack(m: int, n: int) -> int { if m == 0 { ret n + 1 } else { if n == 0 { ret ack(m - 1, 1) } else { ret ack(m - 1, ack(m, n - 1)); } } } fn main(args: [str]) { // FIXME: #1527 sys::set_min_stack(1000000u); let n = i... | medium | 2 |
rust_1529 | Have some form of destructing if | Having to constantly write code like this: ``` alt optional_value { some (value) { do something; } _ {/*do nothing*/} } ``` Is unnecessary verbose in my opinion, and gets annoying to have to constantly write. I would like to be able to say something like: ``` if (let some(value) | la... | low | 3 |
rust_1530 | rust: task ran out of stack | This program fails under rust as of rev 7e6ce6637e7. I've reduced it a bit, but not hugely - I the issue is the recursive reference to the state tag. I don't know if the program is valid (I've reduced it a lot too). ``` herugrim::~/code/csv $ RUST_LOG=rustc=0,::rt::backtrace rust | high | 1 |
rust_1531 | core::* listed four times in RUST_LOG=? | ``` Crate log map: core::u64 core::uint core::int core::task core::str std::map::chained std::test std::ebml std::smallintmap std::getopts std::uv std::io core::u64 core::uint core::int core::task core::str rustc::util::common rustc::middle::resolve rustc::back::rpath rustc::mi... | low | 3 |
rust_1532 | pretty printer for uints sometimes drops the "u" suffix | If I run `rustc --pretty normal` with this input (`tag-disr-val-shape.rs`): ``` // xfail-pretty Issue #1510 tag color { red = 0xff0000; green = 0x00ff00; blue = 0x0000ff; black = 0x000000; white = 0xFFFFFF; } fn main() { assert uint::to_str(red as uint, 10u) == ... | medium | 2 |
rust_1533 | Change rustc crate crate_type to "lib". Stop passing --lib | The main rustc crate is always used as a library now. To do this we probably want to fix #1444 as well so we don't have to pass --bin when testing. | labels: E-easy, C-cleanup | low | 3 |
rust_1535 | Crash in shape code during tag comparison | The second comparison crashes. Probably due to weird alignment. ``` tag modlist = [int]; fn main() { let ml = modlist([]); assert ml == modlist([]); assert ml == modlist([]); } ``` ``` ==27842== Thread 2: ==27842== Invalid read of size 8 ==27842== at 0x50FA892: shape::ctxt<sh... | high | 1 |
rust_20383 | mkinstall.sh failure | Some time between f673e9841 and 84f5ad8679, I stopped being able to run 'make install', with the following error. I can start bisecting if that is useful, but the problem may be more obvious to someone more familiar with the build system. ``` gen-installer: looking for programs g | low | 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.