id stringlengths 8 11 | text stringlengths 32 472 | label stringclasses 5
values | label_id int64 0 4 |
|---|---|---|---|
rust_782 | When running tests in parallel, test runner does not display colors | The control characters seem to cause strange artifacts so colors are disabled. | labels: E-easy, A-testsuite | low | 3 |
rust_783 | Conflict between ports and tasks wanting to destroy channels | Test case: ``` use std; import std::task; fn a() { fn doit() { fn b(c: chan[chan[int]]) { let p = port[int](); task::send(c, chan(p)); } let p = port[chan[int]](); spawn b(chan(p)); task::recv(p); } let i = 0; while i < 100 { doit(); i += 1; } } fn main() {... | medium | 2 |
rust_784 | "this function takes x arguments but y arguments were supplied" shouldn't be fatal | Instead it should go on and typecheck the rest of the function. | labels: E-easy, A-type-system | low | 3 |
rust_785 | Temporaries generated in alt expression have longer lifetime than expected | ``` { alt gimmeboxes() { _ { } } // The thing returned from gimmeboxes is still refed here } ``` I would not expect it to outlive the alt expression. Will produce a better test case later. | medium | 2 |
rust_787 | Loops try to clean up uninitialized variables | ``` while true { let x = alt true { true { break } _ { "whatever" } }; } ``` Under valgrind results in: ``` ==18230== Thread 10: ==18230== Conditional jump or move depends on uninitialised value(s) ==18230== at 0x8048858: glue_drop2 (in /home/banderson/Dev/rust/build/test... | medium | 2 |
rust_788 | Dynamic size check calculation should be exhaustive. | It currently misses resources, probably among other things. | medium | 2 |
rust_789 | Add pretty-printer tests to the test suite | labels: A-testsuite | medium | 2 |
rust_790 | Typechecker doesn't propagate collection item type in for [each] | Both of these loops don't typecheck, although it should be deducable what the type of `u` is: ``` iter x() -> int { put 1; put 2; } fn main() { for each u in x() { log_err u == 1; } for u in ~[1, 2, 3] { log_err u == 2; } } ``` | medium | 2 |
rust_791 | LLVM module verifier breakage for loop in alt in iter | This code produces: ``` Stored value type does not match pointer operand type! store i1 false, i32* %0 i32Broken module found, compilation aborted! Stack dump: 0. Running pass 'Function Pass Manager' on module 'rust_out'. 1. Running pass 'Module Verifier' on funct... | medium | 2 |
rust_792 | Tags with more than one variant are always 4 byte aligned | Because of this code: ``` fn T_tag(&type_names tn, uint size) -> TypeRef { auto s = "tag_" + uint::to_str(size, 10u); if (tn.name_has_type(s)) { ret tn.get_type(s); } auto t = T_struct(~[T_int(), T_array(T_i8(), size)]); tn.associate(s, t); ret t; } ``` Tags a... | medium | 2 |
rust_793 | Functions should be able to initialize their arguments | This came up in the course of writing comms as a library. I want to be able to write this: ``` fn recv_into(v : &T) { rustrt::port_recv(unsafe::reinterpret_cast(ptr::addr_of(v)), **raw_port); } fn recv() -> T { let x : T; self.recv_into(x); ret x; } ``` `recv_int... | low | 3 |
rust_794 | alt discriminant of type bang -> "Ptr must be a pointer to Val type!" | ``` fn f() -> ! { fail } fn g() -> int { alt f() { true { 1 } false { 0 } }; } fn main() { g(); } ``` Assertion failed: (getOperand(0)->getType() == cast<PointerType>(getOperand(1)->getType())->getElementType() && "Ptr must be a pointer to Val type... | medium | 2 |
rust_795 | Box contents are always 4 byte aligned | Because the ref count is 4 bytes, we misalign 8 byte aligned box structures. | medium | 2 |
rust_796 | Calling a function in for-each position triggers llvm assertion | ``` fn f() -> int { ret 4; } fn main() { for each i in f() { } } ``` This should fail in the typechecker. | labels: A-type-system | medium | 2 |
rust_797 | test/run-pass/if-ret.rs passes only with optimization turned on | Without -O, you get ``` Basic Block in function '_ZN3fooE' does not have terminator! label %5 LLVM ERROR: Broken module, no Basic Block terminator! ``` | medium | 2 |
rust_798 | rustc requires executable stack | Trying to build on a fedora system I got: stage0/rustc: error while loading shared libraries: librustrt.so: cannot enable executable stack as shared object requires: Permission denied | labels: O-linux | medium | 2 |
rust_799 | Combine xfail-stage1/2/3 into just 'xfail' | xfail-stage0 is no longer used, and in practice xfail-stage1, 2, and 3 are always used together | labels: A-testsuite | medium | 2 |
rust_800 | configure script doesn't fall back to gcc if a bad version of clang is available | The configure script prefers to use clang over gcc, but if it finds the wrong version of clang it just fails. It should instead print a warning and fall back to gcc. | labels: E-easy | low | 3 |
rust_802 | Typechecker should stop this | ``` tag foo = int; fn main() { let x = foo(1); if x == -1 { } } ``` This program should not compile, but it does. | labels: A-type-system | medium | 2 |
rust_803 | Type inference for capturing nested functions requires type variables to be resolved prematurely | The following program ought to typecheck: ``` fn main() { let e = @{mutable refs: ~[], n: 0}; lambda() { log_err e.n; }; e.refs += ~[1]; } ``` but is rejected with: ```nubs/lambda-infer-fail.rs:5:16:5:17: error: cannot de... | medium | 2 |
rust_804 | Lambdas sometimes leak | <pre>fn main() { let x = @0; lambda() { log_err *x; }; } </pre> leaks memory. Interestingly, <pre> fn main() { let x = @0; let f = lambda() { log_err *x; }; } </pre> does not. | medium | 2 |
rust_805 | Upvars in lambdas can be written to, with silly results | Right now, if you write to an upvar in a copying closure, the value in the closure will be changed. This means that subsequent invocations of the function will see that value but the enclosing scope will not. This kind of sucks. We should disallow writes to vari... | medium | 2 |
rust_807 | Can't build with clang on Ubuntu | Clang doesn't know how to link on Ubuntu (and aparently other Linuxes), erroring with ``` /usr/bin/ld: cannot find crtbeginS.o: No such file or directory ``` | labels: O-linux | medium | 2 |
rust_808 | nil values takes up space | Right now we represent the () type as a one bit integer. () shouldn't take up any space. In theory we should be able to use an empty llvm struct type, but there are some issues that come up. Making that change doesn't actually just work. Compiling with optimization, LLVM decides | labels: I... | medium | 2 |
rust_809 | Pretty printer adds newlines after comments in tag declarations | <pre> tag foo { foo; // a foo. bar; } fn main() { } </pre> will becomes <pre> tag foo { foo; // a foo. bar; } fn main() { } </pre> This will happen every time, increasing the amount of whitespace each time the pretty printer is run. | labels: A-pretty | medium | 2 |
rust_810 | Testing randomly hanging for long periods of time | I think it might be sio-ctx.rs, but I'm not sure. Around the hang I see this output: ``` ... test [run-pass] ../src/test/run-pass/simple-obj.rs ... ok test [run-pass] ../src/test/run-pass/sio-client.rs ... ignored test [run-pass] ../src/test/run-pass/sio-ctx.rs ... ``... | medium | 2 |
rust_811 | bounds check failure in trans (again) | This snippet of code fails to compile due to a bounds check failure in trans. In my version, it's at line 998. It's the `some(id)` alt case in `get_tydesc`. ``` fn test00_start(ch: chan_t[int], message: int) { send(ch, message); } ``` `chan_t` is defined as follows, where `task_i | medium | 2 |
rust_812 | Anonymous objects from nothing | Is there a reason why we'd want to be able to create an anonymous object from nothing, rather than extending an existing one? For example, should we support being able to do this: ``` fn main() { // Anonymous object that doesn't extend an existing one. let my_obj = obj () { fn fo | question | 4 |
rust_813 | Unary negation not properly typechecked | <pre> fn main() { -"foo"; } </pre> produces <pre> rustc: Constants.cpp:1747: static llvm::Constant* llvm::ConstantExpr::getNeg(llvm::Constant*, bool, bool): Assertion `C->getType()->isIntOrIntVectorTy() && "Cannot NEG a nonintegral value!"' failed. </pre> | labels: A-type-syste... | medium | 2 |
rust_814 | trans trips assertion when using result of bottom-typed do-while | <pre> fn main() { let x: int = do { fail } while (true); } </pre> results in <pre> rt: 439d:main:main: upcall fail 'Assertion !*terminated failed', ../src/comp/lib/llvm.rs:927 </pre> Tim, you've fixed this for a bunch of other cases; do you have time to... | medium | 2 |
rust_815 | Object equality behaves weird on linux | This works on mac and windows, not linux: ``` let o1 = obj () { }; let o2 = obj () { }; assert (o1 != o2); assert (!(o1 == o2)); ``` | labels: O-linux | medium | 2 |
rust_816 | ivec self-append has illegal memory access | This conversion of run-pass/vec-self-append fails to valgrind: ``` use std; import std::ivec; fn main() { // Make sure we properly handle repeated self-appends. let a: [int] = ~[0]; let i = 20; let expected_len = 1u; while i > 0 { log_err ivec::len(a); assert (ivec::len(a) =... | medium | 2 |
rust_817 | Allow multiple imports and exports per statement | For example, allow something like "export foo, bar, baz;" and "import foo, bar, baz from quux;" I don't really care about the syntax. | labels: A-frontend | medium | 2 |
rust_818 | Dereference on single element tags ignores visibility of constructor | Exporting a tag type but not the constructors for it is a simple way to construct abstract data types. (This is how it is done in Haskell.) This works in rust as well, but only for tags with multiple constructors. If the tag has only a single constr... | medium | 2 |
rust_819 | Typestate apparently doesn't handle loops... | ``` fn test00_start(ch: _chan[int], message: int, count: int) { log "Starting test00_start"; let i: int = 0; while i < count { log "Sending Message"; send(ch, message); i = i + 1; } log "Ending test00_start"; } ``` `send` uses move-mode for the second argument, which means... | medium | 2 |
rust_820 | Cannot bind native functions | ``` native "rust" mod rustrt { fn task_yield(); } fn main() { bind rustrt::task_yield(); } ``` This fails with the error message `upcall fail 'LHS of bind expr didn't have a function type?!', ../src/comp/middle/typeck.rs:2065`. | medium | 2 |
rust_821 | rustc fails whlie linking files if the source file path begins with ./ or ../ | <pre> sully@anansi:~/src/rust/build [master]$ s1 ./stage1/rustc ./test.rs gcc: .o: No such file or directory <input>:0:0:0:0: error: linking with gcc failed with code 256 <input>:0:0:0:0: note: gcc arguments: -L./stage1/lib -Lrt -lrustrt ./... | medium | 2 |
rust_822 | Methods that are added to an object at the same time should be able to refer to each other | In general, it doesn't work to have a method A referring to another method B that is being added to an object at the same time as A is. Fix this. | medium | 2 |
rust_823 | Bind glue should make a direct call if the target is statically known | Right now it always puts it in the closure and does an indirect call. LLVM can't see through it. | labels: E-easy | low | 3 |
rust_824 | Typestate too strict for multi-var let | I'd like this to work: ``` let x = 10, y = x; ``` Currently, the initializer for y is checked in an environment where neither variable has been defined, so typestate rejects this line. | medium | 2 |
rust_825 | `cont` in `while` continues without re-checking the loop condition | ``` fn main() { let i = 1; while i > 0 { log_err i; i -= 1; cont; } } ``` | medium | 2 |
rust_826 | Test runner fails to report failures | Probably because of the race condition on task join. Fortunately the runtime seems abort after detecting a memory leak, so you do get an indication that something failed. | labels: A-testsuite | medium | 2 |
rust_828 | Typechecker error messages don't use type abbreviations | Since we got rid of cnames (for good reason, as I understand it), typechecker error messages always use the full structural types, which is sucky. Patrick says he has a plan for fixing this that isn't high priority right now. Creating this bug to track. We proba... | medium | 2 |
rust_829 | Iterators don't seem to work for polymorphic types | <pre> iter iter2<@T>() -> T { } fn main() { for each i: int in iter2() { } } </pre> fails with <pre> rustc: Instructions.cpp:192: void llvm::CallInst::init(llvm::Value*, llvm::ArrayRef<llvm::Value*>, const llvm::Twine&): Assertion `(i >= FTy->getNumParams() || FTy->g... | medium | 2 |
rust_831 | Typechecker should be able to infer these types | ``` fn send_recv_fn() { let p = comm::port::<int>(); let c = comm::chan::<int>(p); comm::send(c, 42); assert(comm::recv(p) == 42); } ``` `comm::port` has the type `fn<~T> () -> port<T>` and `comm::chan` has the type `fn<~T> fn(port<T>) -> chan<T>`. This program fails to... | medium | 2 |
rust_832 | Add a way to suppress unused-variable warnings | Sometimes, a function needs to have an argument that it doesn't use (for example, if it's passed to `foldl` or another higher-order function). In this case, it would be good to have a naming convention for unused arguments that would suppress the "unused variable" warnin... | low | 3 |
rust_833 | Typechecker is too conservative in determining whether a tag type is dynamically sized | It considers a tag to be dynamically sized if any of its type parameters are dynamically sized, even if none of the arms of the tag directly include the type. Probably what we should do is check the arms of the datatype to see whic... | medium | 2 |
rust_834 | Type error messages lose tag names | Typechecker error messages don't contain the name of tags but instead things like "tag:0:2r45334232". This is a relative of #828 but should be able to be fixed without it. It's really annoying. | labels: A-type-system | medium | 2 |
rust_835 | Type error messages lose tag names | Tag names aren't included in type error messages. This is similar to #828 but should be much easier to fix. | labels: A-type-system | medium | 2 |
rust_836 | Build is broken when optimization is turned off | While building stage1/lib/libstd.so: ``` rustc: /home/marijn/prog/llvm/include/llvm/Support/Casting.h:194: typename llvm::cast_retty<To, From>::ret_type llvm::cast(const Y&) [with X = llvm::FrameIndexSDNode, Y = llvm::SDNode*, typename llvm::cast_retty<To, From>::ret_ty... | question | 4 |
rust_837 | Support ranges in patterns | `1 ... 3` (numeric literal followed by three dots and a numeric literal) indicates a pattern that matches any literal in the given range. I hope the use of `...` here doesn't conflict with macro syntax. | question | 4 |
rust_838 | Binding patterns with sub-patterns | Implement `x@{y, _}` to mean 'bind x to the whole record, y to the content of field y'. Any pattern can be prefixed with `var@` to bind the whole thing. | medium | 2 |
rust_839 | Add an environment to the type context that records inited-ness information from typestate | Add an environment that maps the node ID for each call site to a map from each local variable in the stack frame to its inited-ness as computed by typestate. Then, the back-end can use this for GC root computing purposes. | medium | 2 |
rust_840 | Pretty-printer can't disambiguate alts followed by ( from function calls | From std::lib::task: ``` alt notify { some(c) { (**task_ptr).notify_enabled = 1u8; (**task_ptr).notify_chan = *c; } none {} }; (*regs).esp = align_down((*regs).esp - 12u32) - 4u32; ``` Without the trailing semi, the parens are interpreted as a f... | medium | 2 |
rust_841 | type_kind missing case for tuples | <pre> fn foo[A](x: &A) {} fn main() { foo((0, 2)); } </pre> results in <input>:0:0:0:0: error: internal compiler error missed case: (int,int) | labels: A-type-system | high | 1 |
rust_842 | Pretty-printer doesn't preserve blank lines | I think it used to but it must have broke. The following turns into a wall of code: ``` let cfilename = cinfo.ident; let cdata = cinfo.data; // Claim this crate number and cache it let cnum = e.next_crate_num; e.crate_cache.insert(ident, cnum); e.next_crate_num += 1; // Now... | medium | 2 |
rust_843 | zero_alloca outputs invalid bitcode in some cases | The following program results in an error like this when compiled: ``` alignment argument of memory intrinsics must be a constant int call void @llvm.memset.p0i8.i32(i8* %25, i8 0, i32 %92, i32 select (i1 icmp ult (i32 ptrtoint (i32* getelementptr ({ i1, i32 }* null, ... | medium | 2 |
rust_844 | Output TIME_PASSES info in a format that doesn't confuse emacs | Currently, it tries to interpret the timing messages as errors and gets upset. I'd like to turn on TIME_PASSES as a kind of progress bar, but that does not currently work as it makes navigating the errors very painful. | labels: A-frontend, E-easy | low | 3 |
rust_845 | Figure out why emacs sometimes can't parse file/line/char error info | Sometimes, it considers the `:line` part or even the whole `:line:char` part as part of the filename, and fails to find the file. I haven't been able to recognize a pattern in the messages that go wrong. The way emacs parses error messages is quite ... | medium | 2 |
rust_846 | Task cleanup code needs to know more about closure env to clean it up | This program currently leaks because the function env containing a pointer is freed simply with free, without iterating over its contents. Which also raises the question of whether `migrate_alloc` should recursively migrate all sub-allocs. ``` use ... | question | 4 |
rust_847 | Experiment with annotating args as "noalias" if we can prove it | LLVM arguments accept "noalias", which is nice. We can do type-based alias analysis to set it. | labels: C-enhancement, A-codegen | low | 3 |
rust_848 | Mark functions as "readnone" or "readonly" | LLVM can reason about purity and do nice things like CSE… if we give it the information. | labels: E-easy, A-codegen | low | 3 |
rust_850 | Pretty-printer is still adding extra whitespace in places | Diffs from a recent reformat: ``` item_obj(_obj, [ty_param], /* constructor id */node_id); item_res(_fn, - /* dtor */ + + /* dtor */ node_id, - /* dtor id */ + + /* dtor id */ [ty_param], ``` ``` noreturn; // functions with return type _|_ that always // raise... | medium | 2 |
rust_851 | Restrict lambda-blocks to occuring as function call arguments | Right now they are permitted anywhere. | medium | 2 |
rust_852 | Implement named (item) closures | We should probably be able to have named functions that can close over their environments. I think we definitely want named copying closures. There shouldn't be anything fundamentally difficult about this, although these are items that behave differently that other items, and thu | lab... | low | 3 |
rust_853 | Resolve a bunch of interactions between closures and typestate | The interaction between closures and typestate has a bunch of missing pieces. Blocks can deinitialize upvars and can close over things with constraints on them, which is problematic. Tim knows better than I do what the potential issues are. | medium | 2 |
rust_854 | Test runner periodically deadlocks on linux | labels: A-testsuite, O-linux | medium | 2 |
rust_855 | Interior strings | We should have interior strings so that we can send strings over channels with a minimum of fuss. Most of the infrastructure for interior vectors can be reused. | medium | 2 |
rust_856 | Introduce slots; remove mutable boxes/vectors/record fields/object fields | IIRC we agreed upon the notion of a "slot", which is a simple way to create a mutable interior value. This lets us abstract over the mutable and immutable vectors without the subtyping relation that "mutable?" introduces, which is painful (and ... | critical_bug | 0 |
rust_857 | Introduce pattern guards | Probably with syntax something like: ``` alt (some 5) { some y when y > 3 { ... } some y { ... } none { ... } } ``` | medium | 2 |
rust_858 | Correctly handle closing over variables in alias analysis | It currently ignores the possibility of closing functions assigning to (or taking the value of) local variables. | medium | 2 |
rust_859 | Switch from SHA-1 to MD4 or something else cheap | SHA-1 is high in the profiles (4.8%). We don't need the strong cryptographic properties AFAICT. | labels: E-easy, A-linkage, I-slow | low | 3 |
rust_860 | Numeric literals allow trailing underscores | ``` let i = 0_______; ``` Works just fine. Likewise: ``` let i = 0_______i; ``` | labels: A-frontend, E-easy | low | 3 |
rust_861 | fail in plain block doesn't translate | ``` fn main() { { fail; } } ``` ``` upcall fail 'Assertion !*terminated failed', ../src/comp/lib/llvm.rs:936 ``` | medium | 2 |
rust_862 | Function precondition not maintained for subsequent calls | Similar to #694: ``` pred p(j: int) -> bool { true } fn f(i: int, j: int) : p(j) -> int { j } fn g(i: int, j: int) : p(j) -> int { f(i, j) } ``` ``` ../src/test/run-pass/typestate.rs:8:37:8:44: error: Unsatisfied precondition constraint (for example, p(j)[../s... | medium | 2 |
rust_863 | Make ivecs heap-only | As discussed on IRC I think it'd make sense to make ivecs heap-only. This makes the mental model (not to mention the generated code) simpler. This also makes sense for C++ folks; they can just think of ivecs as `std::vector`. The "SmallVector" optimization (where some elements go | medium | 2 |
rust_864 | Dinstinguish between within-crate export, and crate-external export | Sometimes we'll have modules within a library/crate that needs to refer to "private" things from other modules, but we may not want to export as part of the public API. We should have a way to support this. | labels: C-enhancement | question | 4 |
rust_865 | Rustc should at the very least warn you if you export something that doesn't exist. | medium | 2 |
rust_866 | package management system | Having a package management system like Perl CPAN, [Ruby gems](http://rubygems.org), and [Python's PyPI](http://pypi.python.org/pypi) would really simplify developing programs with rust. Ruby even has a couple other useful libraries built on top of gems, such as [bundler](http:// | medium | 2 |
rust_868 | Return type isn't inferred for nil-type blocks | ``` fn f<T>(g: block() -> T) -> T { g() } fn main() { let x = f({ | | 10 }); // No-worky - cannot determine a type for this expression f({ | | }); // Also no-worky f({ | | ()}); // Yeah-worky let _: () = f({ | | }); } ``` | labels: A-type-system | medium | 2 |
rust_869 | Implement nominal records | We should have nominal records at least as an option, in addition to structural records, whether or not we get rid of structural records. A nominal record could be declared with `record` instead of `type`, like, for example: ``` record path_ = {global: bool, idents: [ident], type | medium | 2 |
rust_871 | Typechecker should not check argument types after it finds incorrect # of params | Right now, if you forget a parameter, you first get an error about the wrong number of parameters, and then more errors about the mismatched types of the parameters you provided. | labels: A-type-system | medium | 2 |
rust_872 | Implement purity inference | As per what I wrote in [Proposal for predicate language](https://github.com/graydon/rust/wiki/Proposal-for-predicate-language), the compiler should be able to infer that some functions declared with `fn` are pure (that is, they satisfy the rules used for checking `pure fn`-declar | labels: ... | low | 3 |
rust_873 | std::unreachable | We need a function in the standard library that indicates unreachable code, specifically for the following case: ``` fn f() -> int { while true { ... } std::unreachable() } ``` Typestate can't prove that the while loop terminates, so the user has to do it themselves. Implement un | labels: E-easy, C-... | low | 3 |
rust_874 | blocks not checked for all paths returning | ``` fn force(f: &block() -> int) -> int { f() } fn main() { force({| | }); } ``` compiles, but shouldn't. | medium | 2 |
rust_876 | Bad error message when using a type that wasn't imported | Compiling this program: ``` use std; import std::vec::*; fn main() { let y; let x : char = last(y); } ``` yields a compiler internal error: `'get_id_ident: can't find item in ext_map'`. The error arises when trying to print out a unification error (`char` doesn... | medium | 2 |
rust_877 | Implement or remove literals as constraint arguments | Right now, I can't write: ``` fn f(x:int) : int::le(0, x) -> ... ``` because even though the AST supports literals as constraint args, the source and metadata parsers don't. I could work around this by writing: ``` fn f(x:int) : nonnegative(x) -> ... pure fn nonneg... | question | 4 |
rust_878 | Test stdtest::os::test_getenv_big is not valgrind clean on mac | labels: E-easy, A-testsuite, O-macos | low | 3 |
rust_879 | String literals should be constant | Currently string literals are allocated and copied from constant C strings on instantiation, which is quite wasteful. | medium | 2 |
rust_880 | Lambda blocks with no arguments are not pretty-printed correctly | `{ | | }` is pretty-printed without a space between the bars, which is subsequently interpreted as logical or. | labels: A-pretty | medium | 2 |
rust_881 | Allow record fields to be constraint arguments | Seems harmless to me, and would save some code clutter. Example: ``` check type_has_static_size(cx.ccx, m.output); ``` | medium | 2 |
rust_882 | Pretty printer could use heuristics to detect pointless line breaks | The most glaring example is ``` r = {some long expression that did not fit on a line}; ``` ... where the line break doesn't even create any space. But there are other situations, like ``` let foo = {multiline: record, literal: 100}; ``` Here the lite... | medium | 2 |
rust_883 | Destructuring let can cause 'illegal instruction' | See patch 1339d0543407d653842503704642fb34f8e6a82d , which was needed to work around this issue. Only happens when optimization is turned on. | medium | 2 |
rust_884 | make getenv/setenv safe | These functions are not threadsafe (maybe the Windows ones are - not sure), so we need to figure out a way to expose them in a safe way. | medium | 2 |
rust_885 | Alt arm variant names are resolved in the wrong scope | ``` tag u { myvariant(int); } fn main() { alt myvariant(10) { myvariant(myvariant) { } } } ``` The binding called `myvariant` will shadow the tag variant by that name. It shouldn't. | medium | 2 |
rust_886 | `for` is copying the vector elements, should alias them | The alias analysis already assumes this, and it seems a better approach anyway (copying every single element can be very expensive) | medium | 2 |
rust_887 | Mystery windows bug (potential memory corruption) is still there | Patch 985ef59efd971f1d6b9bf4b5e484b75733e00444 makes the windows build (and only the windows build) fail with a bunch of bogus alias errors. The compiler somehow decides that `some` (the constructor of `option::t`) takes its argument by _mutable_ alias.... | medium | 2 |
rust_888 | Track record fields in typestate | It seems harmless to also allow typestate constraints to mention immutable fields of records -- for example, letting you write: ``` check type_has_static_size(cx.tcx, t); ``` instead of ``` let tcx = cx.tcx; check type_has_static_size(tcx, t); ``` | medium | 2 |
rust_889 | Warn about unused imports | I don't see a bug for this already, but it would be nice to have a warning for unused imports. | labels: E-easy, A-type-system | low | 3 |
rust_890 | pretty-printer does not preserve parens in (10).x | ``` fn main() { (10).x; } ``` becomes ``` fn main() { 10.x; } ``` which does not parse. | labels: A-pretty | medium | 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.