open Issues

Thread a session or semantic context through IL

abstract common patterns in AST formatters

add an IL type checker

GC control word for mutable closures

add dwarf sibling links

Perform proper refcounting on imported crate-cache entries.

Add fast path to bypass upcall_require on crate cache hit.

Only form import stubs for referenced imports.

perform refcounts on exteriors in llvm

Classify spill / vreg address roles

vec and str slicing

Pretty-printer legwork

Walker legwork

complete typestate constraint-to-key mapping

support non-init output slots on STMT_call

elide calls to empty glue

move more slots to vregs

proper CFI and dwarf engine to use it

teach dwarf to find vregs

alias legwork

clean up exception use in backend

implement detached-send

structured compare

typecheck missing returns

encode and decode predicates and constraints via dwarf

Single-element vec / str append.

type parameter inference

Permit use before import

record type inference failing

type checker doesn't reject missing record fields

Complete type checker

Support generic tags in pattern-alt statements

Add tests for pattern-alt statements.

record type inference failing

switch mul/div/mod by mach type

Add a type descriptor to all closures

Something is wrong with bind-obj-ctor.rs

Implement hash intrinsic

Kill off TYSPEC_callable

replace uses of list-ref-append list building with Queue.add

change foo-to-string formatting paths to use Fmt module

Report proper errors on item name conflict and write more tests

Multi-line comments

move lib caches to session

Use a more sensible heuristic to detect default-target

Proper error reporting in the cexp evaluator

Rename the array helpers in parser.ml

Encode interior mutable-ness in dwarf

Encode dwarf slot dies for dynamic-sized slots (or slots in dynamic-sized frames)

Dwarf legwork

Enforce prohibition on write-aliasing immutable slots in effect system

Prohibit non-tag-ctors in tag pattern arms

Figure out why tags get rebuilt in compares-not-equal order, and fix

Complete name-mangler

Complete support for iterator-block nesting

Capture type parameters in bind, factor code shared with obj ctors

Handle indirect spawns (and binding clones)

Add alloca interface to x86-be

Finish operator 'as'

Handle tail-calls out of an obj fn or closure

STMT_decl doesn't take type parameters

Prohibit put statements in general functions

Teach typechecker that uint is <plusable>.

Something broken when translating mutable aliases of vec.

Translate items-as-lvals correctly.

Fix type-parameterized object methods.

The calling convention in rustboot needs adjustment

Items losing type parameters over course of typechecking pass.

Make vecs indexable by both int and uint

I'm already using the name "Rust"

"Unknown load command" in libstd.dylib

"Fatal error: exception Assert_failure("boot/me/trans.ml", 2912, 6)" with return from for-each block

Build fails on Fedora 12

Add "how to contribute" section to wiki.

Crash with lazy-initted vec

2 calls to std._vec.len causes "mismatched type-params" error

Crash when appending to _vec.alloc'ed vector

add LLVM bindings for self-hosted compiler

unrecognized quad 41 with iter

Auto-dereference crashes rustboot

Crash in rustboot on bad type conversion in ret

One method calling another crashes rustboot

Channel send leaks memory

Temporary chan in send fails to typecheck

Can write to immutable parts of a type.

Support breaking out of for each loops

Unparenthesized expressions aren't allowed in casts

"Non-aligned pointer being freed" with port[tup(str)]

"while(i!=-1)" causes "Unsatisfied precondition constraint"

Adding _int.to_str triples time to compile standard library

'use std' in module imported by crate corrupts things

Task that outlives root task leaks memory

Spawning a function from inside a module hits "unhandled indirect-spawn"

time for a mailing list?

switch to suffix forms of mach literals

Operator Precedence

Backend Bug

Parameterized tags null out the type-parameter-typed value.

State effect calculation too aggressive.

Segfault when logging string in wildcard branch of pattern alt on type-parameterized multi-variant tag type

Calling get() method of std.deque causes a segfault.

lib-deque.rs test fails on winnt and darwin.

Ref.Type.Constr and the STAR token

Multiline comments mess with parser's line number state.

timeout value in stmt_alt_port.alt_port_else

Infinite hang when channel incompletely read

Untitled

Change dwarf to avoid nesting CUs

fix non-zero VMA and LMA in .debug_info and .debug_abbrev elf sections

Native types should have crate-relative identifiers

Cannot call tag value constructors for tag type imported from another crate.

Pointers stored on the stack aren't word-aligned

Shift binops appear to mutate their right operand.

Creating a tuple of a parameterized string leaks memory

bootstrap compiler ignores unknown names

"rustc" with no arguments crashes

Tag types should be internally stored nominally, not structurally

Vec growth glue not treated as user-level when it could be.

rustboot: order of types in error message is not correct

tail call causes memory leak in certain circumstances

Can't export an imported type in a .rs file referred to by a .rc

Back-edge check (Semant.is_back_edge) is too strong

String concatenation misses the last character sometimes

Use the user's names when reporting complex types

Appending the result of a function call to a vector fails

Passing function items as lvals fails

Typechecker doesn't infer a type for parse_seq in rustc

rustboot compile error with OCaml 3.12

Use the return value of a function to infer a type for the "ret" statement

Use the type of the discriminant when inferring types for pattern arms

'make check' reports 'cfg: incompatible LLVM version 2.8, expected 2.8svn'

"get_element_ptr 4 on dynamic-size cell" assertion in trans when binding type-params

Crash in glue$copy$$g14$t1$P1

duplicate .debug_line sections

relax impure effect checking

uint accepts negative numbers

compile-fail tests ignore pattern after the first :

Teach rustc to deal with argv

Cascading else-ifs

Get generic tags working

Implement derived type descriptors in rustc

Get generic objects working in rustc

Get generic closures working in rustc

Teach rustc to do FRU

Teach rustc about iterators

Fix fixed-point iteration in type unification

Implement SHA1 in standard library

Escape analysis

Polymorphic types don't seem to work across crate boundaries

"fail" should have no output edges

bind-obj-ctor: Binding object constructors doesn't work

drop-parametric-closure-on-bound-box fails

foreach-nested-* fail

foreach-put-structured fails

generic-fn-twice fails

generic-recursive-tag fails

generic-tag-alt fails

generic-tag-values fails

integral-indexing fails

imported modules aren't exported

Makefile sometimes errors out without notice

Hello World

Add debug representation of trait objects

Rustdoc needs to handle conditional compilation somehow

rustdoc should be able to build documentation from compiled crates

Match checking has quadratic average complexity

Tracking issue for inherent associated types

type-check lang items

Audit for binary IEEE 754-2008 compliance on relevant platforms

Re-enable debuginfo tests on Android

-Zunpretty=identified runs too early

write!(wr,"foo") is 10% to 72% slower than wr.write("foo".as_bytes())

Weird borrowck issues with &mut &mut [u8]

Should types that contain zero-length vectors of themselves be allowed?

Link using the linker directly

Type inference fails to determine closure argument type

floating point intrinsics may clobber errno in unrelated code

Disallow duplicated extern declarations

Private items with a public reexport could suggest the public path in privacy error message

Tracking Issue for auto traits (auto_traits) -- formerly called opt-in built-in traits (optin_builtin_traits)

Line-based breakpoints in inline functions don't show correct source

-Zunpretty=expanded does not preserve hygiene

Consider aggressively avoiding generating memcpys for moves if we can avoid it

Compile ignored tests rather than skipping

rustdoc doesn't substitute type parameters

rustdoc: provide summary views

replace the implementation of inline functions

Better temporary lifetimes (tracking issue for RFC 66)

Tracking issue for stmt_expr_attributes: Add attributes to expressions, etc.

rustdoc: do something about reexported items

rustdoc: reexported type aliases are not preserved in function signatures

rustdoc: Allow customizing the crate list sidebar.

Expected type for closure arguments not inferred through two nested func calls

make use of LLVM's scoped noalias metadata

MinGW's linker does not create a reloc section for DYNAMICBASE executables

Unused assignment warning should trigger for structs

Improve error messages involving type aliases

program without libc (without std lib) leads to cryptic error

backtraces broken on the Android bot

LLVM bindings have become incorrect in places.

Unable to export unmangled dll entry points for stdcall

Recursive traits should be allowed when boxing

Investigate how LLVM deals with huge stack frames

rustdoc output directory structure leaks home directory structure

DST/custom coercions

No way to have + or * as separator token in macros

"Ghost" methods in rustdoc for cross-crate trait impls

Cleanup and consolidate operator/method dispatch code

Unexpected trait behavior with default_type_params

Lifetime error messages should have better spans

monomorphization recursion limit error should be caught earlier

Coherence and blanket impls interact in a suboptimal fashion with generic impls

Surpress, mark, or order superflous trait resolution type errors correctly

Method lookup goes down the auto-deref rabbit hole when it doesn't need to

Poor performance returning enums larged than a word. Possibly poor code generation?

Unboxed closure types look weird in error messages

Spurious test out-of-stack test failure on Android

Permit impl methods whose bounds cannot be satisfied to have no body

Parse and accept type equality constraints in where clauses

Fully generalize cmp instances

Conditional compilation based on crate_type

Use of ty macro non-terminal in trait bounds

cache the results of type projection and normalization

Can't write non-overlapping blanket impls that involve associated type bindings

Package debug libstd with binaries

where clauses are only elaborated for supertraits, and not other things

Normalization of projections in trait bounds on associated types

Cannot infer closure type with higher-ranked lifetimes inside Box::new

Improve docs rendering performance by addressing PageSpeed Insights issues

GDB should break on panic

deny(warnings) doesn't affect all warnings, only those generated through the lint system

Consider making std::thread::Builder reusable

Revise usage of LLVM lifetime intrinsics

Trait bounds are not yet enforced in type definitions

Stability checker doesn't recurse down reexports properly

&mut self borrow conflicting with itself.

The compiler should report publicly exported type names if possible

Treatment of regions in trait matching is perhaps too simplistic

Rustdoc links to std library types can bypass the facade

Rustdoc should indicate variance on lifetime/type parameters

assoc types: type inference works with UFCS but not with method calls

Output of independent artefacts might differ depending on unrelated options

Deref coercion not working for Box<Trait>

Public items re-exported publicly in the same crate could have inlined docs

Can’t declare lifetime for closure that returns a reference

Could type inference insert coercions to accommodate box desugaring?

Resolve shorthand projections (T::A-style associated type paths) based solely on type, instead of a Def

Error messages are odd for delegating traits

Deref coercion from String to &str doesn't seem to always work

Extend #[bench] with memory usage

Comparison operators have higher precedence than range operator ..

Consider using llvm.invariant.* intrinsics for immutable memory

Incorrect / Inconsistent behavior of deref coercion with {}

unused-features only warns unused non-language features

Poor interaction between int fallback and other flow of type information

region-outlives obligations lead to uninformative/undecipherable region inference failures

Variables bound with different modes in patterns

error: overflow evaluating the requirement <_ as core::iter::Iterator>::Item

Type inferencer probably could figure this case out (associated types)

Order of operands to equality expression matters when inferring a AsRef implementation

Coherence error messages can be inscrutable

Trait impls from where clauses (ParamEnv) take precedence over freestanding trait impls

Numeric fallbacks don't work when inherent methods are involved

regression: dead heap allocations aren't optimized out anymore

name-based comparison in new label-shadowing check has likely hygiene issues.

rustdoc: Pain points of reexports

TLS dtor panics abort the process

docs for Traits get duplicated because of different types

dead code (+ unused assignment, etc) warnings in macros do more harm than good

Missing docs lint ineffectual in test builds

Separate unstable feature errors from other lints in output

Uninhabited-ness isn't propagated through nesting

Rustdoc considers *const T and *mut T different

Add opensearch support to doc.rust-lang.org

Associated const references using UFCS can bypass check_static_recursion

method call fails to upcast trait objects, resulting in overlong borrows

Cannot macro_use a macro that uses an internal macro

type parameter not constrained when using closure bounds

Overflow with use of Self in inherent impl on trait

Unable to export not mangled symbol in an executable as libraries can do

"type ... too big for the current architecture" error reported without span pointing to type

Order-dependent type inference failure with match

lint “non_upper_case_globals” wrongly warns the consumer

Pretty Printing on *-windows-gnu broken because .debug_gdb_scripts is not emitted

Benchmarks are run when just executing tests, leading to very slooooow tests

non-hygienic lifetime-shadowing check can make macros non-modular

Default impls are not restricted to same module (or submodule) as the trait

rust-lang repos that do not declare licenses

Mutable reference not re-borrowed by binary operator

Tools for dumping information about .rlibs

Implied bounds on nested references + variance = soundness hole

Enable segfault / bus error handlers on more UNIX platforms

Rustdoc: pages are being overwritten on the file systems with case-insensitive names

MSVC: support LTCG native libraries in rlibs

No error despite of multiple applicable methods in scope

Closures should always implement the all applicable Fn* traits.

Meta tracking issue for branch hints (RFC 1131)

Indicate which version of MSVC Rust was built with

Add optional iterations output to libtest benchmark

Clarify story on libm bindings

Installer on OS X displays wrong install sizes

Can't infer the type of index

Rust .msi installer ignores current install

Confusing error messages when invariant type is involved

Weird inference failure with unary minus

Inference failure with int inference variable

#[derive] sometimes uses incorrect bounds (aka lack of "perfect derive")

Abort on some large allocation requests, Panic on other

Deref coercions do not work with blocks

The generic-enum-with-different-disr-sizes test fails in LLDB

str and [u8] should hash the same

Failure to fulfill higher-kinded "outlives" predicate could have better error message

Move HashMap to liballoc

Emit warnings on parameter list in closures after {

Correctly handle dllimport on Windows

Inference fails when a type using a default also implements Deref.

macOS packages and Windows MSIs are not signed

Tracking issue for Ipv{4,6}Addr convenience methods

Tracking issue for string patterns

add pop() to HashSet etc.?

FreeBSD i386 test failures

Tracking issue for crates that are compiler dependencies

False ambiguity due to overlap between higher-ranked and other where clause

DST coercions fall over with UFCS

FreeBSD x86_64 test failures

[MSVC] cl.exe doesn't support static relocations with large address awareness.

Type inference problem with lifetimes and assoiated types

Add an overview toggle to rustdoc lib output

Local ambiguity in macro definition

TLS destructors on the main thread are not always run

Nonparametric dropck (tracking issue for RFC 1238)

rustc OSX LC_LOAD_DYLIB paths are broken

Teach make-tidy to detect unused *.rs files

Range expressions: discrepancies between rustc and parser-lalr

Rust tries to be too helpful with impl suggestions, sometimes being unhelpful

associated type not normalized when a where-clause is present

#[repr(C)] enum bit width determination algo does not match that of the C compiler

Have rustdoc create hyperlinks on items in compiled code examples

Error when casting a function is not informative

Can't import super

Higher-ranked lifetime bounds give confusing errors

Wrong error message (or type system bug) for unsatisfied trait bound

dropck doc oversights / revision

Dead code warning should provide some help for making the code public in library crates

Associated item projections across crate boundaries slightly broken

#[macro_export] stops macro's documentation tests from working

Consider having special debugger pretty printers/handling for Unique/Shared/NonZero

println! sometimes panics in drop methods

fs::remove_dir_all rarely succeeds for large directories on windows

Provide a way of linking libgcc statically

Tracking issue for #[bench] and benchmarking support

Produce packaging guidelines

Tracking issue for thread_local stabilization

Tracking issue for log_syntax, trace_macros

Tracking issue for concat_idents

Tracking issue for link_llvm_intrinsics

Tracking issue for the linkage feature

Improve MIR match generation so that we more effecitvely rule out inapplicable match-pairs

Tracking issue for Fn traits (unboxed_closures & fn_traits feature)

Tracking issue for fundamental feature

Tracking issue for internal feature no_core

Tracking issue for box_patterns feature

Add the GDB pretty-printers to the Windows Rust installation

Tracking issue for RFC 2532, "Associated type defaults"

Tracking issue for allowing overlapping implementations for marker trait

Vec's reallocation strategy needs settling

thread_local macro stability precludes safe async signal handling

Mutable references as function arguments generate inefficient code in trivial cases

Codegen for a large static array uses a lot of memory

Desugared x.index(y) is not equivalent to x[y]

Debug trait for tuples, array/slices, Vec, String (etc?) do not respect width parameter

Add levenshtein distance based suggestions everywhere

UFCS can bypass trait stability

concurrent rustdoc usage can lead to bad times

Error messages about lifetimes for mutable Iterator are cryptic.

Potential optimization: eager nulling of Weak references

Avoid type mismatch error where a variable is bound with different ref-ness

Manual does not define "data reached through a shared reference".

bad diagnostic when macro tries to use stmt as expr

Some std::collections types are unnecessarily invariant

Compiler bug with cyclic weak references on Windows

Fine-tune binary heap sifting logic

VecDeque's iterator could be optimized

Allow deprecating a re-export

Struct and variant constructors are not generic over lifetimes like regular functions.

Improve typed pretty printing

-C link-args and -C llvm-args can't pass arguments with spaces

Linking to rustc_llvm with --llvm-root

Fulfillment context should support DAGs better, integrate with caching better

Bad macro usage error message does not include correct error location

Rustdoc search box fails accessability guidelines

rustdoc's search-index.js file is huge for large projects

Tracking issue for ? operator and try blocks (RFC 243, question_mark & try_blocks features)

The Vec should not needlessly overallocate capacity if it is guaranteed to fail.

Add rustc --emit=link-info for staticlib link-line output

Guard pages are disabled on musl.

Specifying linkage on externs silently removes indirection

Named functions don't implement Debug

Can't Unify Super Generic Code

create_dir_all can't create directories through a dangling symlink.

Compiletest doesn't pass environment variables to emscripten tests

HashSet operations against another HashSet should allow for differing hash algorithms

Implementation of traits on functions ignored after function call

"cannot move out of" error using == with Box<Trait>, where no move is needed

Normalization fails with where clauses on methods

Windows paths should not be prefixed with \?\ when displayed

Closure return type not deduced from bounds if the type is wrapped.

-msvc distribution has unused import libraries

Tracking issue for specialization (RFC 1210)

Allow linking against dylibs in LTO mode

Error to enable feature gate prevents error from incorrect placement of feature gate

It should be possible to override the dsymutil path

Surprising lifetime inference with closures

fn pointer coercion fails for method on type with lifetime

Include images in rustdoc output

Trait implementation docs list methods that can't be called

doc inclusion (reexport) changes order of impl blocks

GDB hangs when debugging exe compiled with 1.9nightly under Windows

Tracking issue for integer methods for Wrapping

Specialization: allow some projection when typechecking an impl

Support death tests in libtest

unresolved symbol imports in -pie musl binaries

incorrect DW_AT_location for static

DWARF omits typedef

Better diagnostics for error: can't find crate for ... [E0463]

Lint for types where cleanup before drop is desirable

Intern strings in metadata

Add an "inherits" key or similar to JSON target specs

Pluggable panic implementations (tracking issue for RFC 1513)

Allocator traits and std::heap

DWARF doesn't distinguish struct, tuple, and tuple struct

Do move forwarding on MIR

inconsistent stepping in gdb

gdb needs to know what traits a type implements

DWARF does not describe closure type

DWARF doesn't describe use declarations

trait objects with late-bound regions and existential bounds are resolved badly

Missing auto-load script in gdb

DWARF does not mention Self type

rustc::lint could use some helper functions for working with macros

linking staticlib files into shared libraries exports all of std::

Add additional LoopUnswitch and LICM passes

Suggest move closures when a Sync bound is not satisfied through a closure

Lint against leading 0 in integer literals

Unhelpful error message for specialization-related type projection failures.

confusing lifetime inference

method has an incompatible type for trait due to lifetimes has too wide a span

Error E0301 "the parameter type T may not live long enough" could explain where the lifetime requirement comes from

Weird integer inference failure

"Unexpected end of macro invocation" error in nested macro has misleading span, doesn't specify which macro

Unable to achieve aligned writes

Trailing semicolon silently ignored in expr macro

Cannot create function reference with parameters that don't have to outlive the functions lifetime

Parameter names in foreign functions, function pointer types and trait methods are not resolved / validated

The meta fragment specifier is considered as a single TT.

[rustdoc] Rustdoc should prevent long file names.

cargo doc should render crate examples and link to them on main documentation page

Immutable borrow as argument for mutable borrow does not compile

Provide mechanism for documenting known bugs or shortcomings

"invalid subrange count" compiling [(); 1 << 63] with -g enabled

Make --export-dynamic the default option when linking executables.

slice::sort_by_key has more restrictions than slice::sort_by

Lint against transmutes which could be as casts.

Higher-ranked lifetime causes inconsistent behavior with trait bounds.

Associated type equality not followed through multiple traits

Rust is overflowing on recursive trait evaluation where it didn't before

[rustbuild] do not delete sysroot directory

Match expressions use O(n) stack space with n branches in debug mode

An unused generic parameter should be a warning at the definition site.

Type mismatch between associated type and concrete type which are the same type.

Improve documentation search fuzziness

Package gdb with Rust

Linker error for cdylib with panic=abort (Undefined symbol "_rust_eh_personality_catch")

Bootstrap fails due to system LLVM libffi link error

Cause a debug break when a panic occurs on Windows.

Add intrinsic to force-monomorphize; or some other solution for Index

Generate HTML versions of man pages

BTreeSet and BTreeMap append optimization

macros: Trailing expression statement macros expand inconsistently

#[may_dangle], a refined dropck escape hatch (tracking issue for RFC 1327)

Wrapping<_> implements ShX<usize> but wrapping_shX takes u32

rust-call call ABI is not feature gated at call-sites

Cannot link to --crate-type dylib

u32 saturating_mul with small constant is slower than a multiply+compare

u32 saturating_mul+compare slower than u64 mul+compare

"Type annotations needed" with mixed lifetimes in trait bounds

path attribute on modules is useless in nested modules

Rust should allow specifying a custom .def file

Make LLVM better at using XMM registers to perform structure moves

Tracking issue for promoting ! to a type (RFC 1216)

Test runner interacts badly with redirected child process

type_id is not crate-independent with object associated types

Verify that the AST does not have DUMMY_SP

unsatisfyable HKL error message prints broken bound (for<'b> 'b : )

Tracking issue for future-incompatibility lint patterns_in_fns_without_body

Add is_empty function to ExactSizeIterator

array.push(Foo { ... }) should construct Foo in-place

Bad codegen: unnecessary on-stack copy in WebRender 2

Only the first expression in an include!d file is included.

self and super behave inconsistently in use statements and as module names

Go over all libstd traits and see which of them !/TyNever should implement

Implementation of Index<Foo> prevents indexing arrays by other index types

incr. comp.: Increase partition granularity via special-casing non-inlined functions

Adding type annotation equivalent to existing type changes code semantics

cyclic type "of infinite size" may not be

Constant let binding slower than const

Rustdoc generates docs for hidden methods in impls

redundant E0210 (coherence) after E0120 (blanket Drop impl)

odd span with unused import generated by macro

"mod lib" in lib.rs produces incorrect error message

Confusing error message when traits from different modules have the same name

Mark dropck-related borrow errors explicitly

Performance left on the table?

Code only compiles with try!, not with question mark syntax

[rustbuild] cross-compiling to windows-gnu fails

Specialization influnces inference

Windows Defender goes nuts when running rustdoc on some projects

impl Trait fails to resolve when returning !

Unions interacting with Enum layout optimization

"lifetime parameter is not constrained..." when using lifetime param to derive assoc. type from reference type trait impl

Exposure of HashMap iteration order allows for O(n²) blowup.

In some cases, the compiler doesn't find a proper macro rule even when it exists

Closures should infer to capture by copy

Collision between extern-block fn and #[no_mangle] fn not detected

Rust has trouble seeing higher ranked lifetimes through generics

Add traits w/ auto-deriving for soundly serializing/inspecting/transforming rustc types.

Better SIMD shuffles

Inner function cannot be tested

LLVM assertions when using -C target-feature=+soft-float with a few targets

Trait object coercion has problems with contravariant structs and lifetime bounds

Channel should not default to dev when built from a tarball

Compilation of a crate using a large static map fails on latest i686-pc-windows-gnu Beta

item_like_imports: Can "ambiguity error" items be reexported?

parent() returns Some("") for single-component relative paths

Tracking issue for future-incompatibility lint invalid_type_param_default

travis-cargo currently cannot upload / generate code coverage information for documentation tests

Attribute for skipping field of struct in Debug derives?

Rust docs: Please add groupings of producers and consumers by type

Large array literal causes slow compilation

Should use super::{self, ...} work?

Inference fails because it doesn't consider deref coercions

MSVC profilers attribute most time to std::panicking::try::do_call<AssertUnwindSafe<closure>,()>

"cannot declare a new module at this location" should specify good locations

Inferring type succeeds with too little information

[testing infra] Pretty-printing tests fail when need to find an out-of-line module

Pretty-printer inserts an extra newline before the first match arm if it has a comment

--emit=obj for Windows msvc producing .o instead of .obj

Make std::io::Take<R> an instance of std::io::Seek when R:std::io::Seek

rust build on ARMv8 fails in test macro-stepping.rs, other debuginfo-gdb tests.

LLVM pointer range loop / autovectorization regression part two

Specify and possibly reconsider the precise semantics of #[no_mangle]

Poor error message related to higher rank lifetimes

Compiler switch to list bound checks

Generic Fn wrapper breaks without type annotations

debuginfo: How to (ideally) represent reference and pointer types in DWARF

Program cross compiled for mips-unknown-linux-musl crashes with SIGILL

Consider storing auto-generated error message strings in separate object file

Command::spawn has weird rules for finding binaries on Windows

Consider using incremental linking with msvc

Tracking issue for TrustedLen (trusted_len)

Inherent static methods on traits do not play well with associated types

Using pattern match directly on LockResult causes deadlock

misleading error message for trait usage from external scope

demangled characters like { make debugging annoying

support default impl for specialization

Overflow for trait implemented recursively on references

E0495 Does not mention the conflicting requirements

std::process::Command's current_dir behaves differently on Unix and Windows, with respect to relative exe paths

Using type with local type parameters has confusing error

Expand macro parameters in the comments.

Future::and_then and other adapters are not always zero cost

Rust distribution uses massive amount of storage space

Test cross compilation with proc-macro crates

index out of bound in slice not caught at compilation

Optimize iterator chains better

rustdoc: stabilize --playground-url and deprecate --markdown-playground-url

where clause shadows information about higher impls

Nested associated type projection is overly conservative

rustdoc: Don't distinguish structs and tuple structs with only private fields

Iterator adaptors should allow unsized function fields

rustc -v should print out linker output

Consider different way of inheriting handles in child processes on Windows

export_name with unusual utf8 breaks new version script based linker

Can't step into libstd with gdb on Windows

issues with ABIs and struct return types

llvm/msvc: IsStatement in codeview data is always false

Insufficient normalization

Overloaded call inferred to be through Fn when only FnOnce works

Tracking issue to stabilize --print target-spec-json

Identity Result match mapping should optimize to an identity function

method resolution problem related to Box<dyn Trait>

Repeated #[link] attributes for the same library cause it to be passed as many times to the linker.

Tracking issue for the msp430-interrupt calling convention/ABI

question mark and try! obscure type inference errors

Specialization does not find the default impl

test::black_box for big size T?

Allow access to location information from proc_macro TokenStreams

Randomize the ordering of struct fields when compiling in debug mode

memset not being optimized out when initializing array contents

Error about "does not live long enough" could be more helpful

rustc: assertion failiure in llvm when defining __CxxFrameHandler3

Unable to constrain associated types in trait inheritance

Cannot silence test runner

Type errors in macros have poor spans

LLVM error when emitting PTX code with debuginfo

Tracking issue for the "ptx-kernel" ABI

rustc generates a lot of llvm ir for small programs due to inline generated drops

add test: cross compiling core for no_std targets

Mut borrow lifetime expanded to the enclosing function

Reverse the stack traces

Deriving Debug on an enum with uninhabited type triggers warning

Missed optimization: references from pointers aren't treated as noalias

Add some mechanism for catching structured exceptions on Windows

rustc always links against non-debug Windows runtime

Impossible to pass diverging closures as an argument

Dead code lint emits unused code warning for code that is clearly used.

[config.toml] should allow specifying arbitrary flags to the cc command for a target

Guarantee that values in hash map are disjoint from each other and the HashMap struct.

missing_docs does not trigger for types only used in exported fields of enumerations

Type-inference breaks depending on the order of arguments in a function call

#![cfg] to disable a crate disables #![no_std]

Allow process::Child to be used with external calls to waitpid

[rustdoc] Placeholder for search field makes no sense

link-dead-code limitations (bad for code coverage)

Poor diagnostic: mutable diagnostic cannot be "immutablized"

Breakpoint set 2 locations when I set a breakpoint with LLDB

Unhelpful error when providing a borrowed closure to a function expecting a closure taking borrowed arguments

Extremely slow optimizer performance when including large array of strings

Make sure all file extensions for wasm are correct

Non-upper case constant warning misapplied in patterns

resolve: improve diagnostics for a single super at the crate root

Tracking issue: declarative macros 2.0

rustdoc: types used in exported type definitions are not documented.

Escaping char in libcore adds 2k of static data for no_std cases

Incorrect type mismatch resolving when using return in closure

Suggestion: make string/slice more efficient with match

dead_code warnings for functions/types used in a unused function

Document unwind-safety without referencing an RFC

Add option to define environment vars

Assertion failed in llvm/include/llvm/Support/Casting.h

Tracking issue for sanitizer support

Performance regression in nightly-2017-01-15

rustdoc splits test-args wrongly

Trait object coercion supercedes deref coercion

Warn about $x:expr in macro_rules expansion

Provide an easy way to use LLVM's Polly

Macros not included in back-traces when used in a crate

bootstrap overrides -O in CFLAGS for LLVM

Linking with LLD

#[deprecated] does nothing if placed on an impl item.

Enum associated functions can name-clash with variants, but cannot be called.

rustc --test should not check linking when using --emit=metadata or -Z no-trans

error[E0275]: overflow evaluating the requirement _: std::marker::Sized

making a temporary tuple for pattern matching tries to move borrowed content

Range* should overrride more methods of Iterator

A new compiler flag: "link everything statically or die, dammit!"

Need a way to close standard output

"Stability" of the -C passes and -C llvm-args flags

Error on bad pub(path) depends on module ordering

Braced macros are inconsistent with other braced items

Tracking issue for future-incompatibility lint missing_fragment_specifier

1.15.1 armhf run-make/relocation-model failed, "relocation [..] against `a local symbol' can not be used [..]; recompile with -fPIC"

Tracking issue for the x86-interrupt calling convention

consolidate recursion limit errors

Lifetime inference falls over with identical lifetimes across trait and implementing struct

1.15.1 (and earlier) armhf nondeterministically uses locking to implement atomic instructions when cross-compiling to x64 but not x86

Same for loop up to 38% slower depending on iterator used

vtable accesses optimization in a tight loop.

std::io functions should document which ErrorKinds they can return

type checker takes O(~1.5^recursion_limit) time to reject simple-ish code

Common well-known traits make "Trait Implementations" too verbose

duplicate definition error depends on macro declaration order

Misleading suggestion for missing trait bounds

std::process::Command no way to handle command-line length limits

Undetected unconditional recursion in Clone impl using to_owned()

Consider specific warning for trying to use an existing variable in a pattern

Derived traits in the standard library are missing stability information

rustc does not understand linker scripts with GROUP statements

rustbuild: if stage0 binaries can't be run, kindly inform user

Dyn compatibility error when using an associated type as a type parameter in the super-trait listing

Produce a warning when using const with interior mutability

Rust allows function argument names to shadow unit structs imported in function body

Specialization and lifetime dispatch

Overflow on requirement evaluation with associated types

UnwindSafe is unergonomic

E0122 says bounds aren't enforced, but they actually are?

refactor the AssociatedItem structures

Type inference incorrectly selects specialized instance of type parameter

No unused import for std::f64 if only f64 types used

To debug cargo project cause lots of 'symbol not found' problems on OSX

Weird error message for missing symbol if module name is the same as a macro

Mac lldb debuginfo behavior differs based on abs/rel input source path (?!)

Move libm bindings into separate crate

Indexing tuple warning misleading

Rustdoc incorrectly orders trait impls

Add explicit or zero constructor for std::time::Instant

support deeply nested coercions

LUB of a bivariant parameter is not fully general

Get rid of the "rust-call" hack

Rustdoc impl blocks refer to private names

Confusing type error due to strange inferred type for a closure argument

rustc fails to see a bound that is present, but also requires that the bound not be present

NVPTX: "LLVM ERROR: Cannot select" when translating num::from_str_radix

Error message when VS 2015 build tools exist but not the SDK needs to be better

! in Fn types

rustc: Disable color codes in non-tty terminal environments

lldb print error and crash

Inconsistency in trait item resolution between Box<Trait> and impl Trait

GDB hardcodes startswith(producer, "clang ") to cope with LLVM debug line info in prologues.

Unclear error with type inference failure

document what "thin pointers" are

Long trait bounds don't get broken up in rustdoc

Misleading error when a trait method implementation has explicit lifetime parameters but the trait signature does not.

Attribute macros invoked at crate root have issues

include!() in statement position expects an expression

Tracking issue for trait aliases

Specialization results in spurious mismatch type errors

Tracking issue for RFC 1824: Proposal for default crate recommendation ranking

Inference disrupted by trait bound that is redundant with a HRTB

Tracking issue for RFC 1868: A portability lint

Improve diagnostics for parse errors in proc macro output

confusing error message saying variable must be valid for anonymous lifetime that it appears to live long enough for

[RFC] figure out story around linear queries

Reordering where clauses can change program behavior

Missed bound check removal

“type must outlive the static lifetime” makes no sense

Non-optimal derived PartialEq for POD struct

Compiling to Webassembly quickly fills up available RAM and crashes computer

Collision of Borrow::borrow() and RefCell::borrow()

:vis matcher can't parse EOF

Incorrect suggestion in error when accessing field on raw pointer

"consider adding an explicit lifetime bound `R: 'static" suggestion is misleading

Lack of HRTB produces nonsense error message, correct syntax isn't even mentioned in The Book

Add (a lot of) tests to rustdoc

Result-based error handling optimizes very poorly for large payloads

rustdoc: disambiguate between types of the same name

Tracking issue for step_trait stabilization

Redundancy in trace_macro output

Make the ast representation of qualified self paths more syntactic

Provide a way to interpolate crate version in html_root_url

Link no-deps documentation with no html_root_url to docs.rs by default

In rustdoc, omit trait impls that a user cannot call

[RFC] Refactor types to be a (TypeCore, Substs) pair

introduce region-clauses into the ParamEnv, use to replace the body_id

Wishlist: compiler should give hint when trying to use Box<Trait> as Trait

Add span to E0271 errors pointing at the "found" associated type bound

Could we clarify type error messages that involve traits + closures?

Cannot infer type even if specified.

Strange lifetime error when using borrow_mut

1.17.0 powerpc64le: "LLVM ERROR: Undefined temporary symbol" after disabling optimisation

Suggest converting a type to trait object when it's possible and the method expects one

Include debuginfo in release builds of LLVM by default

region inference sometimes fails to recognize implied bound in closure

cfg_target_feature and target_feature don't interact properly

Slow "llvm module passes"

target_pointer_width in proc-macro crates provides build-time width, but some clients want runtime width

rustc: Uses 75G of RAM and takes 1h30 on attached

Enable some android host builder

Avoid shipping duplicate artifacts in the host and target sysroot

Output code bloat when programming with a functional style

Add Vec::contains_ref which is worse for inference but less restrictive than Vec::contains

rustdoc still doesn't handle renames in reexports correctly

Reconsider using SVH for loading transitive crate dependencies

Format self correctly

properly handle anonymous regions appearing in return type- named-anon conflicts

Need negative trait bound

Cannot call implementations of the Fn* traits on references

Altivec/VSX support

Error message when using non-derived constants from another crate in pattern matching is confusing

Confusing lifetime error with closure

Rust will memmov |self| when passed by value to inline function

debuginfo: Subroutine types are not ABI-adjusted

Doc block ignored for pub extern crate

macro_rules! macros do not backtrack

Peer credentials on Unix socket

*const T has quite a few methods that seem like they don't need to require T: Sized

Add drain_filter for BinaryHeap

Tracking issue for future-incompatibility lint late_bound_lifetime_arguments

std::fs::canonicalize returns UNC paths on Windows, and a lot of software doesn't support UNC paths

Field pattern shorthand can be interpreted as an item reference

Add lint for u8 as *mut cast

impl-trait return type is bounded by all input type parameters, even when unnecessary

Closure arguments are inferred monomorphically

Confusing error message: the trait std::ops::Fn<(char,)> is not implemented for T

rustdoc: it would be nice to have a way to extract the doctest source without building it

rustdoc: add the ability to build a doctest executable without running it

rustdoc: allow full set of compiler options to be specified

Possibly spurious overlapping impl (even with specialization)

Weird interaction with projections in trait bounds

Not all doc-comments on re-exports are displayed

incr. comp.: Access span information more carefully throughout the compiler.

Add as_str method for str::Split(Whitespace)

Unnecessary warning about panic at runtime

Tracking issue for RFC 2033: Experimentally add coroutines to Rust

cannot move out of borrowed content error is bad when self is borrowed

Add syntax highlighting for TOML to rustdoc

Improve error message on namespace collision

Unclear error note due to use of underscores when unifying paremeters to a single generic type

Extend stack probe support to non-tier-1 platforms, and clarify policy for mitigating LLVM-dependent unsafety

Coroutine tracing of borrows is quite conservative

rustbuild: rpath=false does not work, maybe because build-script-build bypasses rustc.rs wrapper

Exact same bound check happens twice in loops when processing slices known to be of the same size

GDB pretty printers incorrectly print Path slices

pthread_get_stacksize_np returns incorrect values for the main thread on OS X 10.9

Stabilize -Zunpretty=expanded

core::fmt fails to optimize on arm-none-eabi

Array lengths don't support generic parameters.

Improve error message for one named, one anonymous lifetime parameters

Tracking issue for RFC 2044: dual-MIT/Apache2 licensing

Tracking issue for RFC 1861: Extern types

reached the recursion limit while instantiating function_name::<[closure]>

No explanation for source of static lifetime requirement in E0597

Bors: 422 Update is not a fast forward

Xcode Instruments can not read Rust source code automatically.

rustc aborts when there is a compilation failure on FreeBSD and OpenBSD

"error: trait bound is not satisfied" when it is

Final link failed (with CARGO_INCREMENTAL)

Tracking issue for oom=panic (RFC 2116)

Confusing mismatched type error

"failed to run cargo build" on powerpc64 when installing rust 1.19.0

-Zdump-mir is incomplete for dead functions

Tuples of functions do not coerce to tuples of function pointers

Compiler unable to match types with trait implementation

Can show operands at runtime when 'attempt to multiply with overflow' panic ?

Static library linkage error

Tracking issue for #[doc(cfg(…))], #[doc(cfg_hide(…))] and doc_auto_cfg

x.py doc cannot work when a junction point / symbolic link cannot be created.

struct pass-by-value failing on SPARC

"The following implementations were found" should also mention the trait bounds.

Precision for debug formatting works with empty tuple, but not other things (odd inconsistency)

Is automatic insertion of type inference placeholders possible?

Type mismatch with generic parameter returns less than helpful errors

Warn when crate_type attribute is ignored because of --crate-type

"Use of undeclared type or module" doesn't detect accidental use of variable

Generated doc pages for types should include more info about the type's relationships

Tracking issue for #[doc(masked)]

Crate local state for procedural macros?

Expose target cpu to conditional compilation

LLVM's pass ordering chokes on zero-cost abstractions.

Check the well-formed-ness of type aliases.

Object safety "method references the Self type" check does not normalize.

Write on &mut [u8] and Cursor<&mut [u8]> doesn't optimize very well.

Document traits from #[derive(...)]

Re-enable detection of unused library #![feature] directives

Global allocator symbols aren't dllexport on MSVC

export_name works for msvc x86_64 toolchain, but not i686

Support coercing non-capturing closures to extern function pointers

Re-exported types have confusingly different documentation

Using LTO while building as static library causes conflicts

unused_assignments does not care about unused assignments to reference derefs

Use #[repr(C)] HList's to infer type-erased fmt fn pointers in format_args!'s static data.

Updating dependency caused type inference to fail on unrelated code

Expose min and max values in benchmarks

Meta issue for FIXMEs that reference closed issues

#[thread_local] from windows DLLs gets duplicated by inlining.

Consider making std::time::SystemTime platform-independent

rustc -C opt-level=3 generates bad assembly code for Vec by default

Poor error message with type alias and external crate

🔬 Tracking issue for RFC 2089: Extended Implied bounds

region errors: suggest new signature

128-bit integer division with remainder is not combined to a single operation

Alloc: Clarify supported Layouts

[idea] Allow .rmeta to be translated in .rlib files

Rustc failed to resolve trait bounds for trait implementation

Cast error doesn't suggest boxed traits but maybe it should.

Improve borrowck error message for nested flat_map

Overflow evaluating the requirement error could be better for trivially recursive impls

Tracking issue for RFC 1977: public & private dependencies

Cannot 'use' constant associated types.

Tracking Issue for RFC 1826: Change the default URL of doc.rust-lang.org

Weird error with inference when a function doesn’t compile

Missed code elimination with std::mem::replace/std::mem::swap

target_arch and target_os documentation for supported platforms

Consistent naming for Arm "thumb" targets?

In-band lifetimes: Lint against single-use lifetime names

Tracking issue: Allow autoderef and autoref in operators (experiment)

Initializing array of Option<T> using [None; n] syntax should not require std::marker::Copy for T