Commit Graph

6091 Commits

Author SHA1 Message Date
bors
d670919aa4 auto merge of #18105 : nikomatsakis/rust/issue-18055, r=pcwalton
Check object lifetime bounds in coercions, not just trait bounds.  Fixes #18055.

r? @pcwalton 

This is a [breaking change]. Change code like this:

    fn foo(v: &[u8]) -> Box<Clone+'static> { ... }

to make the lifetimes agree:

    // either...
    fn foo(v: &'static[u8]) -> Box<Clone+'static> { box v }

    // or ...
    fn foo<'a>(v: &'a [u8]) -> Box<Clone+'a> { box v }
2014-10-18 15:12:11 +00:00
bors
2c0f87610d auto merge of #18022 : nikomatsakis/rust/issue-18019, r=pcwalton
Only consider impliciy unboxed closure impl if the obligation is actually for `Fn`, `FnMut`, or `FnOnce`.

Fixes #18019

r? @pcwalton
2014-10-18 04:32:16 +00:00
bors
222ae8b9bb auto merge of #17815 : typelist/rust/recursive-structs, r=brson
The representability-checking routine ```is_type_representable``` failed to detect structural recursion in some cases, leading to stack overflow later on.

The first problem was in the loop in the ```find_nonrepresentable``` function. We were improperly terminating the iteration if we saw a ```ContainsRecursive``` condition. We should have kept going in case a later member of the struct (or enum, etc) being examined was ```SelfRecursive```. The example from #17431 triggered this issue:

```rust
use std::sync::Mutex;
struct Foo { foo: Mutex<Option<Foo>> }
impl Foo { fn bar(self) {} }
fn main() {}
```

I'm not 100% sure, but I think the ```ty_enum``` case of ```fn type_structurally_recursive``` had a similar problem, since it could ```break``` on ```ContainsRecursive``` before looking at all variants. I've replaced this with a ```flat_map``` call.

The second problem was that we were failing to identify code like ```struct Foo { foo: Option<Option<Foo>> }``` as SelfRecursive, even though we correctly identified ```struct Foo { foo: Option<Foo> }```. This was caused by using DefId's for the ```ContainsRecursive``` check, which meant the nested ```Option```s were identified as illegally recursive (because ```ContainsRecursive``` is not an error, we would then keep compiling and eventually hit a stack overflow).

In order to make sure that we can recurse through the different ```Option``` invocations, I've changed the type of ```seen``` from ```Vec<DefId>``` to ```Vec<t>``` and added a separate ```same_type``` function to check whether two types are the same when generics are taken into account. Now we only return ```ContainsRecursive``` when this stricter check is satisfied. (There's probably a better way to do this, and I'm not sure my code is entirely correct--but my knowledge of rustc internals is pretty limited, so any help here would be appreciated!)

Note that the ```SelfRecursive``` check is still comparing ```DefId```s--this is necessary to prevent code like this from being allowed:

```rust
struct Foo { x: Bar<Foo> }
struct Bar<T> { x: Bar<Foo> }
```

All four of the new ```issue-17431``` tests cause infinite recursion on master, and errors with this pull request. I wrote the extra ```issue-3008-4.rs``` test to make sure I wasn't introducing a regression.

Fixes #17431.
2014-10-18 00:47:22 +00:00
bors
4694b99102 auto merge of #16855 : P1start/rust/help-messages, r=brson
This adds ‘help’ diagnostic messages to rustc. This is used for anything that provides help to the user, particularly the `--explain` messages that were previously integrated into the relevant error message.

They look like this:

```
match.rs:10:13: 10:14 error: unreachable pattern [E0001]
match.rs:10             1 => {},
                        ^
match.rs:3:1: 3:38 note: in expansion of foo!
match.rs:7:5: 20:2 note: expansion site
match.rs:10:13: 10:14 help: pass `--explain E0001` to see a detailed explanation
```

(`help` is coloured cyan.) Adding these errors on a separate line stops the lines from being too long, as discussed in #16619.
2014-10-17 20:32:22 +00:00
Felix S. Klock II
88de96178f Check for borrow of local variable introduced within static block.
(Rather than ICE on it.)

Fix #18118.
2014-10-17 18:15:57 +02:00
Brian Koropoff
4a4a4347cb Fix translation of unboxing shim for rust-call ABI methods
When translating the unboxing shim, account for the fact that the shim
translation has already performed the necessary unboxing of input
types and values when forwarding to the shimmed function.  This
prevents ICEing or generating incorrect code.

Closes #16739
2014-10-16 21:57:08 -07:00
Brian Koropoff
90bf7cdd79 Fix ICE in overloaded call with incorrect arity
When an overloaded call expression has parameters but the function
object takes none, construct an array of formal argument types with
the arity of the call expression so that we don't fail by indexing out
of bounds later.

Closes #16939
2014-10-16 19:03:29 -07:00
Brian Koropoff
9094aabb12 Fix soundness bug in treatment of closure upvars by regionck
- Unify the representations of `cat_upvar` and `cat_copied_upvar`
- In `link_reborrowed_region`, account for the ability of upvars to
  change their mutability due to later processing.  A map of recursive
  region links we may want to establish in the future is maintained,
  with the links being established when the kind of the borrow is
  adjusted.
- When categorizing upvars, add an explicit deref that represents the
  closure environment pointer for closures that do not take the
  environment by value.  The region for the implicit pointer is an
  anonymous free region type introduced for this purpose.  This
  creates the necessary constraint to prevent unsound reborrows from
  the environment.
- Add a note to categorizations to make it easier to tell when extra
  dereferences have been inserted by an upvar without having to
  perform deep pattern matching.
- Adjust borrowck to deal with the changes.  Where `cat_upvar` and
  `cat_copied_upvar` were previously treated differently, they are
  now both treated roughly like local variables within the closure
  body, as the explicit derefs now ensure proper behavior.  However,
  error diagnostics had to be changed to explicitly look through the
  extra dereferences to avoid producing confusing messages about
  references not present in the source code.

Closes issue #17403.  Remaining work:

- The error diagnostics that result from failed region inference are
  pretty inscrutible and should be improved.

Code like the following is now rejected:

    let mut x = 0u;
    let f = || &mut x;
    let y = f();
    let z = f(); // multiple mutable references to the same location

This also breaks code that uses a similar construction even if it does
not go on to violate aliasability semantics.  Such code will need to
be reworked in some way, such as by using a capture-by-value closure
type.

[breaking-change]
2014-10-16 17:29:44 -07:00
Niko Matsakis
7876cf9ca9 Check object lifetime bounds in coercions, not just trait bounds. Fixes #18055. 2014-10-16 18:58:42 -04:00
Luqman Aden
7899248504 librustc: Remove special case for old reflection visitor. 2014-10-16 11:15:36 -04:00
Luqman Aden
3410c52eec librustc: Remove trans::reflect and the opaque and ty_visitor lang items. 2014-10-16 11:15:36 -04:00
Luqman Aden
7210a5af87 librustc: Stop generating visit glue and remove from TyDesc. 2014-10-16 11:15:36 -04:00
Luqman Aden
7a4122ac67 librustc: Remove visit_tydesc intrinsic. 2014-10-16 11:15:35 -04:00
Luqman Aden
814586be57 librustc: Remove all uses of {:?}. 2014-10-16 11:15:34 -04:00
Luqman Aden
38aca17c47 Remove libdebug and update tests. 2014-10-16 11:15:34 -04:00
bors
126f224d9a auto merge of #18015 : jakub-/rust/issue-4201, r=pcwalton
Closes #4201.
2014-10-16 01:22:19 +00:00
Viktor Dahl
0525bb7669 Add assume intrinsic
Adds an `assume` intrinsic that gets translated to llvm.assume. It is
used on a boolean expression and allows the optimizer to assume that
the expression is true.

This implements #18051.
2014-10-16 01:44:44 +02:00
bors
8096fee18c auto merge of #17934 : pcwalton/rust/better-autoderef-fixup, r=pnkfelix
librustc: Improve method autoderef/deref/index behavior more, and enable IndexMut on mutable vectors.

This fixes a bug whereby the mutability fixups for method behavior were
not kicking in after autoderef failed to happen at any level. It also
adds support for `Index` to the fixer-upper.

Closes #12825.

r? @pnkfelix
2014-10-15 21:17:22 +00:00
bors
7134fc8de6 auto merge of #17983 : jakub-/rust/memoize-things, r=pcwalton 2014-10-15 19:22:21 +00:00
Ariel Ben-Yehuda
cedfde9769 fix stupid error 2014-10-15 21:12:30 +03:00
Ariel Ben-Yehuda
e74e059bd4 improve the comments on integer overflow safety 2014-10-15 20:39:12 +03:00
Ariel Ben-Yehuda
5bcd0a0b50 prevent the creation of integers too big for the target architecture 2014-10-15 20:26:43 +03:00
Ariel Ben-Yehuda
61ab2ea08a response for review comments 2014-10-15 20:09:09 +03:00
Ariel Ben-Yehuda
e053dfad23 Add a compile-time error when oversized types are used
LLVM generates wrong code (which may be an instance of compile-time UB) when
faced with types that take lots of memory - bigger than the address space.
Make using such types a trans error. While trans errors are bad, overbig
types are expected to be very rare.
2014-10-15 14:17:34 +03:00
Ariel Ben-Yehuda
01d693b1cd Use the correct LLVM integer sizes
Use the integer sizes LLVM uses, rather than having random projections
laying around. Sizes are u64, Alignments are u32, C_*int is target-dependent
but 64-bit is fine (the int -> C_int conversion is non-precision-losing,
but it can be preceded by `as int` conversions which are, so it is
somewhat ugly. However, being able to suffix a `u` to properly infer
integer types is nice).
2014-10-15 14:17:34 +03:00
Jakub Wieczorek
dbc4a4b53b Make memoize!() a function instead 2014-10-15 11:02:50 +02:00
Jakub Wieczorek
c2e8f3b481 Add a memoize! macro and use it throughout rustc 2014-10-15 10:47:09 +02:00
bors
71dfa5befe auto merge of #18053 : nick29581/rust/ufcs1, r=pcwalton
With the 'receiver' as an argument and static dispatch. Part of UFCS implementation (#16293).

r?
2014-10-15 08:02:21 +00:00
Nick Cameron
eb598e5344 Allow self as an arg in extension methods 2014-10-15 17:50:41 +13:00
Nick Cameron
d3f51dcab8 Allow passing self as an argument to methods
Part of UFCS (#16293)
2014-10-15 17:38:31 +13:00
Aaron Turon
31b7d64fdc rustc: Add deprecation/renaming support for lints
Since a large number of lints are being renamed for RFC 344, this commit
adds some basic deprecation/renaming functionality to the pluggable lint
system. It allows a simple mapping of old to new names, and can warn
when old names are being used.

This change needs to be rolled out in stages. In this commit, the
deprecation warning is commented out, but the old name is forwarded to
the new one.

Once the commit lands and we have generated a new snapshot of the
compiler, we can add the deprecation warning and rename all uses of the
lints in the rust codebase.
2014-10-14 16:04:06 -07:00
Aaron Turon
3c0d2a7c90 rustc: Improve lint descriptions
Improves the description of `dead_code` and `unreachable_code` to
clarify the difference between them.
2014-10-14 15:23:09 -07:00
Aaron Turon
d6eb719729 rustc: Add missing lint registration
The pluggable lint changes apparently dropped the fat pointer transmute
lint by accident.

This commit registers the lint.
2014-10-14 15:23:09 -07:00
Aaron Turon
aabb6e72c1 rustc: Rename lints per RFC 344
RFC 344 proposes a set of naming conventions for lints. This commit
renames existing lints to follow the conventions.

Use the following sed script to bring your code up to date:

```
s/unnecessary_typecast/unused_typecasts/g
s/unsigned_negate/unsigned_negation/g
s/type_limits/unused_comparisons/g
s/type_overflow/overflowing_literals/g
s/ctypes/improper_ctypes/g
s/owned_heap_memory/box_pointers/g
s/unused_attribute/unused_attributes/g
s/path_statement/path_statements/g
s/unused_must_use/unused_must_use/g
s/unused_result/unused_results/g
s/non_uppercase_statics/non_upper_case_globals/g
s/unnecessary_parens/unused_parens/g
s/unnecessary_import_braces/unused_import_braces/g
s/unused_unsafe/unused_unsafe/g
s/unsafe_block/unsafe_blocks/g
s/unused_mut/unused_mut/g
s/unnecessary_allocation/unused_allocation/g
s/missing_doc/missing_docs/g
s/unused_imports/unused_imports/g
s/unused_extern_crate/unused_extern_crates/g
s/unnecessary_qualification/unused_qualifications/g
s/unrecognized_lint/unknown_lints/g
s/unused_variable/unused_variables/g
s/dead_assignment/unused_assignments/g
s/unknown_crate_type/unknown_crate_types/g
s/variant_size_difference/variant_size_differences/g
s/transmute_fat_ptr/fat_ptr_transmutes/g
```

Closes #16545
Closes #17932

Due to deprecation, this is a:

[breaking-change]
2014-10-14 15:22:52 -07:00
Patrick Walton
f7fb38729e librustc: Improve method autoderef/deref/index behavior more, and enable
`IndexMut` on mutable vectors.

This fixes a bug whereby the mutability fixups for method behavior were
not kicking in after autoderef failed to happen at any level. It also
adds support for `Index` to the fixer-upper.

Closes #12825.
2014-10-14 14:44:17 -07:00
bors
1fd8e4cae0 auto merge of #18014 : hirschenberger/rust/issue-17999, r=alexcrichton
Fix issue #17999 (Unused variables inside `for` are not detected)
2014-10-14 15:22:28 +00:00
Niko Matsakis
590a61f788 Only consider impliciy unboxed closure impl if the obligation is
actually for `Fn`, `FnMut`, or `FnOnce`.

Fixes #18019
2014-10-13 19:55:42 -04:00
Alex Crichton
1b19296567 rollup merge of #18007 : dotdash/arg_lifetime_end 2014-10-13 15:10:21 -07:00
Alex Crichton
030c79c91a rollup merge of #17991 : sfackler/extern-error 2014-10-13 15:10:05 -07:00
Alex Crichton
02350ac20b rollup merge of #17984 : bkoropoff/issue-17651 2014-10-13 15:09:56 -07:00
Alex Crichton
412f4d1fc7 rollup merge of #17927 : alexcrichton/more-const 2014-10-13 15:09:25 -07:00
Falco Hirschenberger
af2f538390 Fix issue #17999 (Unused variables inside for are not detected) 2014-10-13 23:15:07 +02:00
Jakub Wieczorek
43e5d10428 Improve the error message for missing else clauses in if expressions 2014-10-13 22:48:29 +02:00
bors
c7e0724274 auto merge of #17733 : jgallagher/rust/while-let, r=alexcrichton
This is *heavily* based on `if let` (#17634) by @jakub- and @kballard

This should close #17687
2014-10-13 19:37:40 +00:00
Alex Crichton
c56c9fcf08 rustc: Remove the dummy hack from check_match
Turns out you can create &'static T quite easily in a constant, I just forgot
about this!
2014-10-13 11:50:47 -07:00
Steven Fackler
84d1cbfd25 Don't ICE on bad extern paths
Closes #17990
2014-10-13 09:25:08 -07:00
Björn Steinbrink
fafe136c2d Emit lifetime end markers for function arguments
Function arguments are (hopefully!) the last places where allocas don't
get proper markers for the end of their lifetimes. This means that this
code using 64 bytes of stack for the function arguments:

````rust
std::io::println("1");
std::io::println("2");
std::io::println("3");
std::io::println("4");
````

But with the proper lifetime markers, the slots can be reused, and
the arguments only need 16 bytes of stack.
2014-10-13 16:16:16 +02:00
bors
7dbd4349c4 auto merge of #17975 : thestinger/rust/fPIE, r=eddyb
Position independent code has fewer requirements in executables, so pass
the appropriate flag to LLVM in order to allow more optimization. At the
moment this means faster thread-local storage.
2014-10-13 10:32:43 +00:00
bors
70d8b8ddc5 auto merge of #17948 : jakub-/rust/issue-17933, r=alexcrichton
Fixes #17933.
2014-10-13 06:42:43 +00:00
bors
ff0abf05c9 auto merge of #17944 : jakub-/rust/issue-17877, r=alexcrichton
Fixes #17877.
2014-10-12 21:47:34 +00:00
Brian Koropoff
04608413ba Properly visit nested functions and closures in check_rvalues
This correctly catches moves of unsized values in nested
functions and closures.

Closes issue #17651
2014-10-12 14:43:32 -07:00
Alex Crichton
18e41299f9 rustc: Warn about dead constants
A few catch-all blocks ended up not having this case for constants.

Closes #17925
2014-10-12 12:15:22 -07:00
Jakub Wieczorek
0c48c5712d Never expand specialized columns that only contain wild patterns in them
Doing so would incur deeply nested expansion of the tree with no useful
side effects. This is problematic for "wide" data types such as structs
with dozens of fields but where only a few are actually being matched or bound.
Most notably, matching a fixed slice would use a number of stack frames that
grows with the number of elements in the slice.

Fixes #17877.
2014-10-12 20:36:48 +02:00
Daniel Micay
4deb4bcba5 optimize position independent code in executables
Position independent code has fewer requirements in executables, so pass
the appropriate flag to LLVM in order to allow more optimization. At the
moment this means faster thread-local storage.
2014-10-12 09:18:14 -04:00
Jakub Wieczorek
fdc1eeac62 Make the diagnostic for static variables in patterns better
Fixes #17933.
2014-10-12 11:11:50 +02:00
bors
38517d0eba auto merge of #17952 : jakub-/rust/remove-virtual-structs, r=eddyb
Closes #17861.
2014-10-12 06:17:17 +00:00
bors
adb44f53d8 auto merge of #17942 : JIghtuse/rust/master, r=alexcrichton
[breaking-change]
Closes #17916
2014-10-12 00:07:15 +00:00
Jakub Wieczorek
403cd40e6a Remove virtual structs from the language 2014-10-11 19:42:26 +02:00
John Gallagher
16ccdba851 Use explicit case rather than catch-all 2014-10-11 12:03:15 -04:00
Boris Egorov
6e29f86bc8 Remove into_vec method from &[T]
[breaking-change]
Closes #17916
2014-10-11 16:22:43 +07:00
Alex Crichton
dae48a07f3 Register new snapshots
Also convert a number of `static mut` to just a plain old `static` and remove
some unsafe blocks.
2014-10-10 22:09:49 -07:00
John Gallagher
45fd623762 Handle while let desugaring 2014-10-10 20:30:32 -04:00
bors
45797a0765 auto merge of #17037 : kmcallister/rust/no-stack-check, r=thestinger
r? @brson 

Fixes #16980.
2014-10-10 07:52:00 +00:00
bors
b74208bc12 auto merge of #17669 : nikomatsakis/rust/multidispatch, r=pcwalton
Implement multidispatch and conditional dispatch. Because we do not attempt to preserve crate concatenation, this is a backwards compatible change. This is not yet fully integrated into method dispatch, so "UFCS"-style wrappers must be used to take advantage of the new features (see the run-pass tests).

cc #17307 (multidispatch)
cc #5527 (trait reform -- conditional dispatch)

Because we no longer preserve crate concatenability, this deviates slightly from what was specified in the RFC. The motivation for this change is described in [this blog post](http://smallcultfollowing.com/babysteps/blog/2014/09/30/multi-and-conditional-dispatch-in-traits/). I will post an amendment to the RFC in due course but do not anticipate great controversy on this point -- particularly as the RFCs more important features (e.g., conditional dispatch) just don't work without the change.
2014-10-10 03:02:02 +00:00
bors
f9fc49c06e auto merge of #17853 : alexcrichton/rust/issue-17718, r=pcwalton
This change is an implementation of [RFC 69][rfc] which adds a third kind of
global to the language, `const`. This global is most similar to what the old
`static` was, and if you're unsure about what to use then you should use a
`const`.

The semantics of these three kinds of globals are:

* A `const` does not represent a memory location, but only a value. Constants
  are translated as rvalues, which means that their values are directly inlined
  at usage location (similar to a #define in C/C++). Constant values are, well,
  constant, and can not be modified. Any "modification" is actually a
  modification to a local value on the stack rather than the actual constant
  itself.

  Almost all values are allowed inside constants, whether they have interior
  mutability or not. There are a few minor restrictions listed in the RFC, but
  they should in general not come up too often.

* A `static` now always represents a memory location (unconditionally). Any
  references to the same `static` are actually a reference to the same memory
  location. Only values whose types ascribe to `Sync` are allowed in a `static`.
  This restriction is in place because many threads may access a `static`
  concurrently. Lifting this restriction (and allowing unsafe access) is a
  future extension not implemented at this time.

* A `static mut` continues to always represent a memory location. All references
  to a `static mut` continue to be `unsafe`.

This is a large breaking change, and many programs will need to be updated
accordingly. A summary of the breaking changes is:

* Statics may no longer be used in patterns. Statics now always represent a
  memory location, which can sometimes be modified. To fix code, repurpose the
  matched-on-`static` to a `const`.

      static FOO: uint = 4;
      match n {
          FOO => { /* ... */ }
          _ => { /* ... */ }
      }

  change this code to:

      const FOO: uint = 4;
      match n {
          FOO => { /* ... */ }
          _ => { /* ... */ }
      }

* Statics may no longer refer to other statics by value. Due to statics being
  able to change at runtime, allowing them to reference one another could
  possibly lead to confusing semantics. If you are in this situation, use a
  constant initializer instead. Note, however, that statics may reference other
  statics by address, however.

* Statics may no longer be used in constant expressions, such as array lengths.
  This is due to the same restrictions as listed above. Use a `const` instead.

[breaking-change]
Closes #17718 

[rfc]: https://github.com/rust-lang/rfcs/pull/246
2014-10-10 00:07:08 +00:00
Keegan McAllister
d7fff9f15b Add -C no-stack-check
Fixes #16980.
2014-10-09 14:32:23 -07:00
Keegan McAllister
db3bd23467 Rename the no_split_stack attribute to no_stack_check
The old name is misleading as we haven't had segmented stacks in quite some
time. But we still recognize it, with a deprecation warning.
2014-10-09 14:24:36 -07:00
Niko Matsakis
7a07f2a780 Add a few more debug statements 2014-10-09 17:19:53 -04:00
Niko Matsakis
2bb0796ae2 Convert tests to cross-crate, fix a RefCell bug I found in the process. 2014-10-09 17:19:53 -04:00
Niko Matsakis
389ef6601d Implement multidispatch and conditional dispatch. Because we do not
attempt to preserve crate concatenation, this is a backwards compatible
change.

Conflicts:
	src/librustc/middle/traits/select.rs
2014-10-09 17:19:50 -04:00
bors
8b12fb326b auto merge of #17891 : brson/rust/verbump, r=alexcrichton 2014-10-09 21:12:03 +00:00
Brian Anderson
5c92a8e054 Use the same html_root_url for all docs 2014-10-09 10:50:13 -07:00
Brian Anderson
6beddcfd83 Revert "Update html_root_url for 0.12.0 release"
This reverts commit 2288f33230.
2014-10-09 10:34:34 -07:00
bors
eb04229f7a auto merge of #17880 : pcwalton/rust/duplicate-bindings-in-parameter-list, r=alexcrichton
parameter list.

This breaks code like:

    fn f(a: int, a: int) { ... }
    fn g<T,T>(a: T) { ... }

Change this code to not use the same name for a parameter. For example:

    fn f(a: int, b: int) { ... }
    fn g<T,U>(a: T) { ... }

Code like this is *not* affected, since `_` is not an identifier:

    fn f(_: int, _: int) { ... } // OK

Closes #17568.

r? @alexcrichton 
[breaking-change]
2014-10-09 16:57:03 +00:00
Alex Crichton
831f909484 rustc: Convert statics to constants 2014-10-09 09:44:51 -07:00
Alex Crichton
90d03d7926 rustc: Add const globals to the language
This change is an implementation of [RFC 69][rfc] which adds a third kind of
global to the language, `const`. This global is most similar to what the old
`static` was, and if you're unsure about what to use then you should use a
`const`.

The semantics of these three kinds of globals are:

* A `const` does not represent a memory location, but only a value. Constants
  are translated as rvalues, which means that their values are directly inlined
  at usage location (similar to a #define in C/C++). Constant values are, well,
  constant, and can not be modified. Any "modification" is actually a
  modification to a local value on the stack rather than the actual constant
  itself.

  Almost all values are allowed inside constants, whether they have interior
  mutability or not. There are a few minor restrictions listed in the RFC, but
  they should in general not come up too often.

* A `static` now always represents a memory location (unconditionally). Any
  references to the same `static` are actually a reference to the same memory
  location. Only values whose types ascribe to `Sync` are allowed in a `static`.
  This restriction is in place because many threads may access a `static`
  concurrently. Lifting this restriction (and allowing unsafe access) is a
  future extension not implemented at this time.

* A `static mut` continues to always represent a memory location. All references
  to a `static mut` continue to be `unsafe`.

This is a large breaking change, and many programs will need to be updated
accordingly. A summary of the breaking changes is:

* Statics may no longer be used in patterns. Statics now always represent a
  memory location, which can sometimes be modified. To fix code, repurpose the
  matched-on-`static` to a `const`.

      static FOO: uint = 4;
      match n {
          FOO => { /* ... */ }
          _ => { /* ... */ }
      }

  change this code to:

      const FOO: uint = 4;
      match n {
          FOO => { /* ... */ }
          _ => { /* ... */ }
      }

* Statics may no longer refer to other statics by value. Due to statics being
  able to change at runtime, allowing them to reference one another could
  possibly lead to confusing semantics. If you are in this situation, use a
  constant initializer instead. Note, however, that statics may reference other
  statics by address, however.

* Statics may no longer be used in constant expressions, such as array lengths.
  This is due to the same restrictions as listed above. Use a `const` instead.

[breaking-change]

[rfc]: https://github.com/rust-lang/rfcs/pull/246
2014-10-09 09:44:50 -07:00
Alex Crichton
a89ad58710 rustc: Reformat check_const with modern style
Remove a bunch of two-space tabs
2014-10-09 09:44:01 -07:00
Brian Anderson
158eaa643b 0.12.0 release
-----BEGIN PGP SIGNATURE-----
 Version: GnuPG v1
 
 iQIcBAABAgAGBQJUNrj+AAoJEIWrlub6G+X+4TMQAIlyIoTpbZfA7MgaqHmrqp/O
 DkWH4sjoiTL3pdqHitbaJWFzStLjmM+hzOKYVYxXJGqpHuZv7pbnN2sQCKvJ6m9E
 htojoy9ZVeOUjkqz3+PYc6mh+SuQq4bpAhnnt60tLSxZCda7uTpdTcsOgDlwhu8P
 /YIbnBHo6brcQi6kEK27uN7U2MsluRR/ZhAmZH1mvrTtjKrGsKTEdta2NW1tUzNT
 sDluM9D0/WFjwSA9OohjtpUI7KYudqChOCRaqREgNq6xc/9at/TQHULsjzxLFIiC
 tAttF7ZZ2s1TmS4qzmx3AAWl8n8xYrDo+CpfPqKvSGwDegfHN9Epa+24Cdf2Q5GO
 9RSup89NlNNo3tjmK+G1cUqi/K9RseiZNPSJSoLlR2L9QFg/VFEVbcaZX+oX+CQF
 pfWkKqsfLqj50EimO+vuXRZhShHlu/McOdN0cd+S0KEGdd7ngqU3d7YJf9Ppm1mV
 d1VUqnPxvDrGQTGqk4cpGMIv+LmT6vY2iix3ha583zMYcU9VWrC9VEmR3I4XZefE
 UgsbAx2jIgagWa6ylDpes7X8dn/7qj3BA6l3Bt9aGrs9KnyQ+a3xOyz8dFvRJwks
 T8izOhfJXpxW4CLFZjDIQ9RD/joJuvuqTSIqf7zGIxIbMUQFB9EC/Rn7a3ftidds
 aZVZSl2li1vOa3DucW64
 =4lHl
 -----END PGP SIGNATURE-----

Merge tag '0.12.0'

0.12.0 release
2014-10-09 09:36:30 -07:00
bors
dfd52817ee auto merge of #17875 : dotdash/rust/static_bool, r=alexcrichton
While booleans are represented as i1 in SSA values, LLVM expects them
to be stored/loaded as i8 values. Using i1 as we do now works, but
kills some optimizations, so we should switch to i8, just like we do
everywhere else.

Fixes #16959.
2014-10-09 12:47:01 +00:00
Björn Steinbrink
6fa5a2f66f Properly translate boolean statics to be stored as i8
While booleans are represented as i1 in SSA values, LLVM expects them
to be stored/loaded as i8 values. Using i1 as we do now works, but
kills some optimizations, so we should switch to i8, just like we do
everywhere else.

Fixes #16959.
2014-10-09 11:09:17 +02:00
bors
1b46b007d7 auto merge of #17784 : bkoropoff/rust/issue-17780, r=pcwalton
This fixes a soundness problem where `Fn` unboxed closures can mutate free variables in the environment.
The following presently builds:

```rust
#![feature(unboxed_closures, overloaded_calls)]

fn main() {
    let mut x = 0u;
    let _f = |&:| x = 42;
}
```

However, this is equivalent to writing the following, which borrowck rightly rejects:

```rust
struct F<'a> {
    x: &'a mut uint
}

impl<'a> Fn<(),()> for F<'a> {
    #[rust_call_abi_hack]
    fn call(&self, _: ()) {
        *self.x = 42; // error: cannot assign to data in a `&` reference
    }
}

fn main() {
    let mut x = 0u;
    let _f = F { x: &mut x };
}
```

This problem is unique to unboxed closures; boxed closures cannot be invoked through an immutable reference and are not subject to it.

This change marks upvars of `Fn` unboxed closures as freely aliasable in mem_categorization, which causes borrowck to reject attempts to mutate or mutably borrow them.

@zwarich pointed out that even with this change, there are remaining soundness issues related to regionck (issue #17403).  This region issue affects boxed closures as well.

Closes issue #17780
2014-10-09 07:12:30 +00:00
Patrick Walton
1498814195 librustc: Forbid duplicate name bindings in the same parameter or type
parameter list.

This breaks code like:

    fn f(a: int, a: int) { ... }
    fn g<T,T>(a: T) { ... }

Change this code to not use the same name for a parameter. For example:

    fn f(a: int, b: int) { ... }
    fn g<T,U>(a: T) { ... }

Code like this is *not* affected, since `_` is not an identifier:

    fn f(_: int, _: int) { ... } // OK

Closes #17568.

[breaking-change]
2014-10-08 22:41:23 -07:00
bors
d569dfe37e auto merge of #17871 : michaelwoerister/rust/lldb-versioning, r=alexcrichton
Apart from making the build system determine the LLDB version, this PR also fixes an issue with enums in LLDB pretty printers. In order for GDB's pretty printers to know for sure if a field of some value is an enum discriminant, I had rustc mark discriminant fields with the `artificial` DWARF tag. This worked out nicely for GDB but it turns out that one can't access artificial fields from LLDB. So I changed the debuginfo representation so that enum discriminants are marked by the special field name `RUST$ENUM$DISR` instead, which works in both cases.

The PR does not activate the LLDB test suite yet.
2014-10-09 03:07:27 +00:00
Johannes Muenzel
53ddf2e57d Fix several issues with the struct and enum representability-checking logic. 2014-10-08 22:39:57 -04:00
Michael Woerister
98a0f9166c debuginfo: Don't mark struct fields as artificial.
LLDB doesn't allow for reading 'artifical' fields (fields that are generated by the compiler). So do not mark, slice fields, enum discriminants, and GcBox value fields as artificial.
2014-10-08 11:52:06 +02:00
John Gallagher
7091fe3972 Remove use of final and override (now reserved) 2014-10-07 22:18:12 -04:00
bors
8881c3524b auto merge of #17834 : sfackler/rust/rustdoc-cfgs, r=alexcrichton,alexcrichton
Rustdoc would previously improperly handle key="value" style cfgs, which
are notably used for Cargo features.
2014-10-07 21:12:10 +00:00
Brian Anderson
2288f33230 Update html_root_url for 0.12.0 release 2014-10-07 11:18:50 -07:00
Nick Cameron
3b0550c3a9 Rename slicing methods 2014-10-07 15:49:53 +13:00
Nick Cameron
2d3823441f Put slicing syntax behind a feature gate.
[breaking-change]

If you are using slicing syntax you will need to add #![feature(slicing_syntax)] to your crate.
2014-10-07 15:49:53 +13:00
Nick Cameron
59976942ea Use slice syntax instead of slice_to, etc. 2014-10-07 15:49:53 +13:00
Steven Fackler
a585b4e8a0 Properly handle cfgs in rustdoc
Rustdoc would previously improperly handle key="value" style cfgs, which
are notably used for Cargo features.
2014-10-06 19:39:23 -07:00
bors
7c8fc95aca auto merge of #17803 : bkoropoff/rust/issue-17021, r=alexcrichton
This closes issue #17021.
2014-10-06 09:27:19 +00:00
bors
0e2f0acf22 auto merge of #17781 : P1start/rust/bitflags-lints, r=alexcrichton
Closes #17773.
2014-10-06 07:37:19 +00:00
P1start
e3ca987f74 Rename the file permission statics in std::io to be uppercase
For example, this renames `GroupRWX` to `GROUP_RWX`, and deprecates the old
name. Code using these statics should be updated accordingly.
2014-10-06 16:43:34 +13:00
bors
f50b56c62b auto merge of #17414 : jakub-/rust/issue-17405, r=alexcrichton
Fixes #17405.
Fixes #17518.
Fixes #17800.
2014-10-06 02:52:22 +00:00
Daniel Micay
6bb648fadc work around yet another MinGW-w64 ASLR bug 2014-10-05 19:02:36 -04:00
Jakub Wieczorek
b9896cbf6e Fix handling of struct variants in a couple of places
Fixes #17405.
Fixes #17518.
Fixes #17800.
2014-10-05 22:32:47 +02:00
Brian Koropoff
24d7669099 Handle emitting debug info for unboxed closures
This fixes an ICE.  Closes issue #17021
2014-10-05 12:19:22 -07:00
bors
f56c1c91f3 auto merge of #17762 : bkoropoff/rust/issue-17734, r=alexcrichton
Closes issue #17734

r? @nick29581
2014-10-05 19:17:07 +00:00
bors
c586490715 auto merge of #17785 : P1start/rust/diagnostics, r=alexcrichton
Closes #17765.
Closes #15524.
Closes #14772.
2014-10-05 10:57:04 +00:00
Brian Koropoff
f74b1c4ee2 Categorize upvars in Fn unboxed closures as freely aliasable
This causes borrowck to correctly reject mutation or mutable borrows
of upvars in `Fn` unboxed closures since the closure environment is
aliasable.

This also tracks the responsible closure in the aliasability
information returned and uses it to give a helpful diagnostic.

Closes issue #17780
2014-10-05 00:24:10 -07:00
Brian Koropoff
ea3ab731a3 Track kind of closure in upvar categorization
Keep track of the kind of closure responsible for an upvar
2014-10-05 00:23:33 -07:00
bors
5660db2508 auto merge of #16970 : kmcallister/rust/llvm-unreachable, r=thestinger
I'm not sure how to add an automated test for this.
2014-10-05 07:17:09 +00:00
bors
3b8c528d08 auto merge of #17776 : luqmana/rust/ul, r=alexcrichton
Update our LLVM snapshot to master (as of ~ Wed Oct 1 18:49:58 2014 +0000). 

Since my patches have landed upstream this fixes #13429 and #7298.
2014-10-05 04:57:11 +00:00
Keegan McAllister
401aeaf6d3 Add intrinsics::unreachable 2014-10-04 20:09:09 -07:00
P1start
a29df44f51 Tweak ‘discriminant value already exists’ error message
Closes #15524.
2014-10-05 14:16:32 +13:00
P1start
88baca7486 Rename vector patterns to array patterns
Closes #17765.
2014-10-05 12:08:37 +13:00
bors
07aeac8ac8 auto merge of #17761 : bkoropoff/rust/issue-17758, r=alexcrichton
This fixes an ICE and closes issue #17758
2014-10-04 21:57:08 +00:00
bors
e434aa1cf7 auto merge of #17760 : bkoropoff/rust/issue-17737, r=eddyb
This is a quick fix.  In the long term, the `TyVisitor` interface should be expanded to better represent closure types.

Closes issue #17737
2014-10-04 17:47:06 +00:00
Luqman Aden
4b22178d32 Update LLVM. 2014-10-04 13:28:57 -04:00
Björn Steinbrink
2d93a0406b Register new snapshots 2014-10-04 15:44:50 +02:00
Brian Koropoff
1f7a8bcb4b Correctly generate drop glue for Box<str>
This fixes an ICE.  Closes issue #17734
2014-10-03 23:00:20 -07:00
Brian Koropoff
4c166abbbb Handle provided trait methods when giving inference error suggestions
This fixes an ICE.  Closes issue #17758
2014-10-03 22:36:54 -07:00
Brian Koropoff
8e455ea07c Fix type visitor glue for unboxed closures
This is a quick fix that prevents an ICE by mimicing the visitor
glue for boxed closures and bare functions.  Ideally, the `TyVisitor`
interface will be improved in the future to allow representing
more information about unboxed closures such as Fn/FnMut/FnOnce
status, capture mode, and captured free variable types and offsets.

Closes issue #17737
2014-10-03 19:40:19 -07:00
bors
136ab3c6b1 auto merge of #17731 : bkoropoff/rust/unboxed-by-ref, r=pcwalton
This began as an attempt to fix an ICE in borrowck (issue #17655), but the rabbit hole went pretty deep.  I ended up plumbing support for capture-by-reference unboxed closures all the way into trans.

Closes issue #17655.
2014-10-04 00:17:04 +00:00
Alex Crichton
2a11f2b544 rollup merge of #17215 : P1start/lints 2014-10-03 07:38:12 -07:00
P1start
a667a6917b Move the lint for the stability lints to the method name only
Closes #17337.
2014-10-03 20:39:57 +13:00
P1start
f56c67ba86 Change rustc pretty-printing to print [T, ..n] instead of [T, .. n] 2014-10-03 20:39:56 +13:00
P1start
073a1abff2 Report trait/impl sig inconsistency before method/body inconsistency
Closes #15657.
2014-10-03 20:39:56 +13:00
P1start
45044124e4 Improve the non_snake_case lint to give better suggestions 2014-10-03 20:39:56 +13:00
P1start
333592edde Update the unused lint group to include more lints 2014-10-03 20:39:56 +13:00
P1start
94bcd3539c Set the non_uppercase_statics lint to warn by default 2014-10-03 20:39:56 +13:00
bors
9a2286d3a1 auto merge of #16995 : kmcallister/rust/plugin-tutorial, r=alexcrichton
@steveklabnik, are you interested in looking this over?
2014-10-03 07:33:26 +00:00
Brian Koropoff
c4c19fe960 Correctly trans capture-by-ref unboxed closures
Store references to the freevars instead of copies when constructing
the environment and insert an additional load when reading them from
the environment.
2014-10-02 21:08:45 -07:00
Brian Koropoff
72dc0f5f82 Return correct types for capture-by-ref unboxed closure upvars
Treat upvars of capture-by-reference unboxed closures as references
with appropriate regions and mutability.
2014-10-02 21:08:45 -07:00
Brian Koropoff
931f59f214 Fix categorization of upvars of capture-by-reference unboxed closures
In particular, this causes mutation of an upvar to correctly mark
it as mutable during adjustment.  This makes borrowck correctly
flag conflicting borrows, etc.

We still seem to generate incorrect code in trans which copies the upvar
by value into the closure.  This remains to be fixed.
2014-10-02 21:08:45 -07:00
Brian Koropoff
4e5666eace Fix missing entries in upvar borrows map for capture-by-ref unboxed closures
This prevents a later ICE in borrowck.

Closes issue #17655
2014-10-02 21:08:08 -07:00
Alex Crichton
7ae802f57b rollup merge of #17666 : eddyb/take-garbage-out
Conflicts:
	src/libcollections/lib.rs
	src/libcore/lib.rs
	src/librustdoc/lib.rs
	src/librustrt/lib.rs
	src/libserialize/lib.rs
	src/libstd/lib.rs
	src/test/run-pass/issue-8898.rs
2014-10-02 14:53:18 -07:00
Alex Crichton
9998052e21 rollup merge of #17722 : jakub-/issue-17169 2014-10-02 14:51:10 -07:00
Alex Crichton
dd0c786d33 rollup merge of #17682 : nodakai/librustc-handy-version 2014-10-02 14:50:18 -07:00
Alex Crichton
51820b610e rollup merge of #17646 : bkoropoff/cast-ice 2014-10-02 14:50:08 -07:00
Jakub Wieczorek
f2973f63a3 Fix cross-crate tuple structs in statics
Fixes #17169.
Fixes #17649.
2014-10-02 21:31:06 +02:00
Aaron Turon
d2ea0315e0 Revert "Use slice syntax instead of slice_to, etc."
This reverts commit 40b9f5ded5.
2014-10-02 11:48:07 -07:00
Aaron Turon
c0c6c89589 Revert "Remove the _ suffix from slice methods."
This reverts commit df2f1fa768.
2014-10-02 11:47:58 -07:00
Aaron Turon
7bf56df4c8 Revert "Put slicing syntax behind a feature gate."
This reverts commit 95cfc35607.
2014-10-02 11:47:51 -07:00
bors
b2d4eb186e auto merge of #17590 : bjadamson/rust/rustc-improvements, r=alexcrichton
Removes an unnecessary allocation when passing the command line arguments to the librustc driver.
2014-10-02 15:57:19 +00:00
Eduard Burtescu
aa0b350c97 docs: remove mentions of Gc. 2014-10-02 16:59:31 +03:00
Eduard Burtescu
8a91d33ee7 rustc: remove support for Gc. 2014-10-02 16:59:31 +03:00
Eduard Burtescu
d1a57e479c syntax: ast: remove TyBox and UnBox. 2014-10-02 16:36:01 +03:00
bors
b419e9e739 auto merge of #17663 : eddyb/rust/method-origin-subst, r=nikomatsakis
Fixes #17662.
2014-10-02 13:22:21 +00:00
bors
84a4a07bbd auto merge of #17434 : P1start/rust/borrowck-messages, r=nikomatsakis
This was originally part of #17215.

Closes #15506.
Closes #15630.
Closes #17263.

This also partially implements #15838.
2014-10-02 11:32:25 +00:00
bors
dd7f00de80 auto merge of #17681 : jgallagher/rust/dep-info-escape-spaces, r=alexcrichton
cc #17627
2014-10-02 08:12:19 +00:00
P1start
02c6ebde7e Change the use of moved value error to be more accurate
Previously it output `partially moved` to eagerly. This updates it to be more
accurate and output `collaterally moved` for use of values that were invalidated
by moves out of different fields in the same struct.

Closes #15630.
2014-10-02 15:51:05 +13:00
Nick Cameron
95cfc35607 Put slicing syntax behind a feature gate.
[breaking-change]

If you are using slicing syntax you will need to add #![feature(slicing_syntax)] to your crate.
2014-10-02 13:23:36 +13:00
Nick Cameron
df2f1fa768 Remove the _ suffix from slice methods.
Deprecates slicing methods from ImmutableSlice/MutableSlice in favour of slicing syntax or the methods in Slice/SliceMut.

Closes #17273.
2014-10-02 13:19:45 +13:00
Nick Cameron
40b9f5ded5 Use slice syntax instead of slice_to, etc. 2014-10-02 13:19:45 +13:00
P1start
35ff2def5d Clarify some borrowck errors
Closes #17263.
2014-10-02 11:21:59 +13:00
P1start
36b85025df Add an explanatory note when calling a closure via &
Closes #15506.
2014-10-02 11:09:29 +13:00
P1start
a8577be6f4 Output a note when lifetimes cannot be elided from functions 2014-10-02 11:09:29 +13:00
Keegan McAllister
61bf75bb5e Add a guide to compiler plugins
Fixes #16983.
2014-10-01 13:21:52 -07:00
bors
b224dfe1a6 auto merge of #17678 : fhahn/rust/issue-17628-infinite-recursion, r=alexcrichton
This is a patch for #17628, thanks to @kmcallister for your helpful hints!
2014-10-01 19:37:18 +00:00
NODA, Kai
1dfb23f4cf librustc/driver: expose build information of rustc.
CFG_RELEASE, CFG_VER_HASH and CFG_VER_DATE were only available as an output
to stdout from the driver::version() function that had an inconvenient
signature.
2014-10-02 02:02:43 +08:00
John Gallagher
2883b7682a Make --dep-info escape spaces in filenames
Closes #17627
2014-10-01 11:40:00 -04:00
bors
00ebebb258 auto merge of #17654 : gereeter/rust/no-unnecessary-cell, r=alexcrichton
There is more that could be done, but this was the low hanging fruit.
2014-10-01 13:27:24 +00:00
bors
8ab6fce95e auto merge of #17653 : kaini/rust/master, r=alexcrichton
Fixes that unit-like structs cannot be used if they are re-exported and used in another crate. (ICE)
The relevant changes are in `rustc::metadata::{decoder, encoder}` and `rustc::middle::ty`.

A test case is included.

The problem is that the expressoin `UnitStruct` is an `ExprPath` to an `DefFn`, which is of expr kind `RvalueDatumExpr`, but for unit-struct ctors the expr kind should be `RvalueDpsExpr`. I fixed this (in a I guess clean way) by introducing `CtorFn` in the metadata and including a `is_ctor` flag in `DefFn`.
2014-10-01 11:27:23 +00:00
Florian Hahn
49e976d771 Limit recursion depth for macro expansions, closes #17628 2014-10-01 11:46:04 +02:00
bors
ff2616e847 auto merge of #17630 : sfackler/rust/cfg-warnings, r=brson
Closes #17490
2014-10-01 09:22:15 +00:00
bors
60e7317345 auto merge of #17501 : pcwalton/rust/improve-method-lookup-autoderef, r=nikomatsakis
prefer `Deref` over `DerefMut` in all other circumstances.

Because the compiler now prefers `Deref`, this can break code that
looked like:

    let mut foo = bar.borrow_mut();
    (*foo).call_something_that_requires_mutable_self();

Replace this code with:

    let mut foo = bar.baz();
    (&mut *foo).call_something_that_requires_mutable_self();

Closes #12825.

[breaking-change]

r? @nikomatsakis
2014-10-01 07:22:18 +00:00
bors
2f15dcd4d3 auto merge of #17584 : pcwalton/rust/range-patterns-dotdotdot, r=nick29581
This breaks code that looks like:

    match foo {
        1..3 => { ... }
    }

Instead, write:

    match foo {
        1...3 => { ... }
    }

Closes #17295.

r? @nick29581
2014-10-01 03:17:24 +00:00
Brian Koropoff
7c9db32f82 Disallow casting directly between C-like enums and unsafe pointers
This closes issue #17444
2014-09-30 20:07:09 -07:00
Brian Koropoff
293b57701b Add missing case for pointer -> int when translating constant cast expressions
Closes issue #17458
2014-09-30 20:07:09 -07:00
bors
57a05cf49b auto merge of #17634 : jakub-/rust/if_let, r=kballard
Continuation of https://github.com/rust-lang/rust/pull/16741.
2014-09-30 23:17:20 +00:00
Patrick Walton
496cc4c0d4 librustc: Fix up mutability in method autoderefs if incorrect, and
prefer `Deref` over `DerefMut` in all other circumstances.

Closes #12825.
2014-09-30 14:38:04 -07:00
Benjamin Adamson
d96faf7e71 Remove unnecessary allocation, update API name for starting the rustc driver. 2014-09-30 13:54:45 -07:00
Eduard Burtescu
79d4540ea8 Fold MethodOrigins to resolve inference variables they may contain.
Fixes #17662.
2014-09-30 23:53:15 +03:00
Steven Fackler
99e2bb79b6 Fix librustc 2014-09-30 12:52:47 -07:00
Jakub Wieczorek
e723051a2e Temporarily remove the description for the diagnostic E0162
It turns out that adding new diagnostics is causing link failures
in runpass-full-deps tests. Further investigation pending.
2014-09-30 18:54:03 +02:00
Jakub Wieczorek
5254ccc7c1 Update after the fall out from the syntax::ptr changes 2014-09-30 18:54:03 +02:00
Kevin Ballard
13e00e4a3d Update based on PR feedback 2014-09-30 18:54:03 +02:00
Kevin Ballard
976438f78f Produce a better error for irrefutable if let patterns
Modify ast::ExprMatch to include a new value of type ast::MatchSource,
making it easy to tell whether the match was written literally or
produced via desugaring. This allows us to customize error messages
appropriately.
2014-09-30 18:54:02 +02:00
Kevin Ballard
0e6ff432dc Desugar 'if let' into the appropriate 'match' 2014-09-30 18:54:02 +02:00
Patrick Walton
416144b827 librustc: Forbid .. in range patterns.
This breaks code that looks like:

    match foo {
        1..3 => { ... }
    }

Instead, write:

    match foo {
        1...3 => { ... }
    }

Closes #17295.

[breaking-change]
2014-09-30 09:11:26 -07:00
Michael Kainer
065a5b0424 Fixes ICE when using reexported unit-like structs
Fixes that unit-like structs cannot be used if they are reexported and
used in another crate. The compiler fails with an ICE, because unit-like
structs are exported as DefFn and the expression `UnitStruct` is
interpreted as function pointer instead of a call to the constructor.

To resolve this ambiguity tuple-like struct constructors are now exported
as CtorFn. When `rustc::metadata::decoder` finds a CtorFn it sets a new
flag `is_ctor` in DefFn to true.

Relevant changes are in `rustc::metadata::{encoder, decoder}` and in
`rustc::middle::ty`.

Closes #12660 and #16973.
2014-09-30 16:22:55 +02:00
Patrick Walton
78e2503db3 librustc: Stop looking in metadata in type contents.
4x improvement in pre-trans compile time for rustc.
2014-09-30 05:52:08 -07:00
Jonathan S
25b40841a5 Removed some unnecessary RefCells from resolve 2014-09-30 05:12:34 -05:00
bors
d2f8d4c505 auto merge of #17563 : brson/rust/wintcbfix, r=thestinger
This is the bare minimum to stop using split stacks on Windows, fixing https://github.com/rust-lang/rust/issues/13259 and #14742, by turning on stack probes for all functions and disabling compiler and runtime support for split stacks on Windows.

It does not restore the out-of-stack error message, which requires more runtime work.

This includes a test that the Windows TCB is no longer being clobbered, but the out-of-stack test itself is pretty weak, only testing that the program exits abnormally, not that it isn't writing to bogus memory, so I haven't truly verified that this is providing the safety we claim.

A more complete solution is in https://github.com/rust-lang/rust/pull/16388, which has some unresolved issues yet.

cc @Zoxc @klutzy @vadimcn
2014-09-30 06:47:25 +00:00
Nick Cameron
1c36d1c71d Emit an error rather than ICEing for a missing built-in bound lang item.
closes #17392
2014-09-30 11:30:08 +13:00
Alex Crichton
1ae44c2059 rollup merge of #17621 : sfackler/new-snap 2014-09-29 08:17:18 -07:00
Alex Crichton
1a18258d86 rollup merge of #17619 : wizeman/fix-perm 2014-09-29 08:14:50 -07:00
Alex Crichton
29216b5e5c rollup merge of #17613 : bkoropoff/issue-17593 2014-09-29 08:14:36 -07:00
Alex Crichton
0358f31127 rollup merge of #17598 : bkoropoff/issue-17441 2014-09-29 08:14:27 -07:00
Alex Crichton
7784a8d397 rollup merge of #17592 : kmcallister/inline-asm-loc 2014-09-29 08:14:23 -07:00
Alex Crichton
792e32bcfc rollup merge of #17576 : kmcallister/hide-quotes 2014-09-29 08:12:51 -07:00
Alex Crichton
655b7269c8 rollup merge of #17519 : pcwalton/unboxed-closure-move-syntax 2014-09-29 08:10:44 -07:00
Ricardo M. Correia
991f506248 rustc: Fix permission denied error in 'ar' when lto is enabled
The reason that 'ar' can fail with permission denied is that when
link-time optimizations are enabled, rustc copies libraries into a
temporary directory, preserving file permissions, and subsequently
modifies them using 'ar'.

The modification can fail because some package managers may install
libraries in system directories as read-only files, which means the
temporary file also becomes read-only when it is copied.

I have fixed this by giving the temporary file's owner read+write
permissions after the copy.

I have also added a regression test for this issue.
2014-09-29 15:07:14 +02:00
bors
b9478ee251 auto merge of #17321 : apoelstra/rust/error-on-unknown-impl, r=alexcrichton
Followup to RFC 57.

Fixes #7607
Fixes #8767
Fixes #12729
Fixes #15060
2014-09-29 05:13:08 +00:00
Steven Fackler
fa419d3d21 Register new snapshots 2014-09-28 19:28:48 -07:00
bors
496b68d485 auto merge of #17533 : michaelwoerister/rust/function-call-locs, r=luqmana
This PR makes rustc emit debug locations for *all* call and invoke statements in LLVM IR, if they are contained within a function that debuginfo is enabled for. This is important because LLVM does not handle the case where a function body containing debuginfo is inlined into another function with debuginfo, but the inlined call statement does not have a debug location. In this case, LLVM will not know where (in terms of source code coordinates) the function was inlined to and we end up with some statements still linked to the source locations in there original, non-inlined function without any indication that they are indeed an inline-copy. Later, when generating DWARF from the IR, LLVM will interpret this as corrupt IR and abort.

Unfortunately, the undesirable case described above can still occur when using LTO. If there is a crate compiled without debuginfo calling into a crate compiled with debuginfo, we again end up with the conditions triggering the error. This is why some LTO tests still fail with the dreaded assertion, if the standard library was built with debuginfo enabled. That is, `RUSTFLAGS_STAGE2=-g make rustc-stage2` will succeed but `RUSTFLAGS_STAGE2=-g make check` will still fail after this PR has been merged. I will open a separate issue for this problem.
2014-09-29 01:03:06 +00:00
Brian Koropoff
ca15637b7c Reject casts to unsized types and suggest use of reference or box
This prevents ICEs or less helpful diagnostics if typeck proceeds
further.  Closes issue #17441
2014-09-28 17:57:34 -07:00
Brian Koropoff
cab84be812 Correctly populate trait impl map when checking for impl overlaps
Also fix an existing compile-fail test which was intended to cover
this case.

This closes issue #17593
2014-09-28 14:28:48 -07:00
Andrew Poelstra
bb5807919a Cleanup error messages for anonymous impl for types not declared in the current module
Followup to RFC 57.

Fixes #7607
Fixes #8767
Fixes #12729
Fixes #15060
2014-09-28 12:58:10 -05:00
Keegan McAllister
8826fdfe37 Keep ExpnId abstract by providing conversions 2014-09-28 09:25:48 -07:00
bors
b7aa03a3ca auto merge of #17532 : ahmedcharles/rust/typo, r=alexcrichton 2014-09-28 11:38:01 +00:00
bors
7eb9337dac auto merge of #17527 : sfackler/rust/cfg-syntax, r=alexcrichton
We'll need a snapshot before we can convert the codebase over and turn on the deprecation warnings.

cc #17490

This is sitting on top of #17506
2014-09-28 08:57:57 +00:00
Steven Fackler
9519abecfb Convert cfg syntax to new system
This removes the ability to use `foo(bar)` style cfgs. Switch them to
`foo_bar` or `foo="bar"` instead.

[breaking-change]
2014-09-27 22:59:26 -07:00
Keegan McAllister
9d60de93e2 Translate inline assembly errors back to source locations
Fixes #17552.
2014-09-27 11:10:37 -07:00
Keegan McAllister
fc1b908322 Hide the quote_*! macros when the feature gate is off
This makes it easier to experiment with improved quasiquoting as an ordinary
plugin library.

The list of quote macros in feature_gate.rs was already out of sync;
this commit also prevents that problem in the future.
2014-09-26 17:17:14 -07:00
Patrick Walton
21df9c805f librustc: Give trait methods accessible via fewer autoderefs priority
over inherent methods accessible via more autoderefs.

This simplifies the trait matching algorithm. It breaks code like:

    impl Foo {
        fn foo(self) {
            // before this change, this will be called
        }
    }

    impl<'a,'b,'c> Trait for &'a &'b &'c Foo {
        fn foo(self) {
            // after this change, this will be called
        }
    }

    fn main() {
        let x = &(&(&Foo));
        x.foo();
    }

To explicitly indicate that you wish to call the inherent method, perform
explicit dereferences. For example:

    fn main() {
        let x = &(&(&Foo));
        (***x).foo();
    }

Part of #17282.

[breaking-change]
2014-09-26 13:02:47 -07:00
Brian Anderson
91e30ecf67 rustc: Turn off split stacks on Windows 2014-09-26 10:16:56 -07:00
Patrick Walton
2257e231a7 librustc: Eliminate the ref syntax for unboxed closure capture clauses
in favor of `move`.

This breaks code that used `move` as an identifier, because it is now a
keyword. Change such identifiers to not use the keyword `move`.
Additionally, this breaks code that was counting on by-value or
by-reference capture semantics for unboxed closures (behind the feature
gate). Change `ref |:|` to `|:|` and `|:|` to `move |:|`.

Part of RFC #63; part of issue #12831.

[breaking-change]
2014-09-26 09:03:19 -07:00
Michael Woerister
302486e49b debuginfo: Make sure that all calls to drop glue are associated with debug locations.
This commit makes rustc emit debug locations for all call
and invoke statements in LLVM IR, if they are contained
within a function that debuginfo is enabled for. This is
important because LLVM does not handle the case where a
function body containing debuginfo is inlined into another
function with debuginfo, but the inlined call statement
does not have a debug location. In this case, LLVM will
not know where (in terms of source code coordinates) the
function was inlined to and we end up with some statements
still linked to the source locations in there original,
non-inlined function without any indication that they are
indeed an inline-copy. Later, when generating DWARF from
the IR, LLVM will interpret this as corrupt IR and abort.

Unfortunately, the undesirable case described above can
still occur when using LTO. If there is a crate compiled
without debuginfo calling into a crate compiled with
debuginfo, we again end up with the conditions triggering
the error. This is why some LTO tests still fail with the
dreaded assertion, if the standard library was built with
debuginfo enabled.
That is, `RUSTFLAGS_STAGE2=-g make rustc-stage2` will
succeed but `RUSTFLAGS_STAGE2=-g make check` will still
fail after this commit has been merged. This is a problem
that has to be dealt with separately.

Fixes #17201
Fixes #15816
Fixes #15156
2014-09-25 14:17:14 +02:00
Ahmed Charles
37b8837407 Fix typo, structs => fields. 2014-09-25 04:51:18 -07:00
Niko Matsakis
ca8e563bb7 Remove as much of TypeContents as I can -- unfortunately, it is still
used by EUV to compute whether a given type moves-by-default.
2014-09-25 07:09:13 -04:00
Niko Matsakis
3694f42b8c Move checking of whether fields are Sized or not into wf / trait code. 2014-09-25 07:09:13 -04:00
Niko Matsakis
e924357554 Remove the last redundant check from kindck, and then remove the pass as well. 2014-09-25 07:09:13 -04:00
Niko Matsakis
2ec305d1bc Move checks for closure bounds out of kind.rs 2014-09-25 07:09:08 -04:00
Niko Matsakis
034f69ec4b Remove redundant local variable checks. 2014-09-25 07:08:36 -04:00
Niko Matsakis
62e5dc929c Remove checks that are already being done during typeck 2014-09-25 07:07:51 -04:00
Niko Matsakis
7119974f82 Move unsafe destructor check from kind.rs into wf.rs 2014-09-25 07:06:28 -04:00
Niko Matsakis
c31623b0e4 Integrate caching of results. Measurements show approx 90% hit rate. 2014-09-25 07:06:27 -04:00
Niko Matsakis
effb3636cc Integrate builtin bounds fully into the trait checker 2014-09-25 07:06:27 -04:00
bors
9ff308137a auto merge of #17428 : fhahn/rust/issue-16114-rename-begin-unwind-2, r=alexcrichton
This is a PR for #16114 and includes to following things:

* Rename `begin_unwind` lang item to `fail_fmt`
*  Rename `core::failure::begin_unwind` to `fail_impl`
* Rename `fail_` lang item to `fail`
2014-09-25 05:17:31 +00:00
bors
5e13d3aa00 auto merge of #17378 : Gankro/rust/hashmap-entry, r=aturon
Deprecates the `find_or_*` family of "internal mutation" methods on `HashMap` in
favour of the "external mutation" Entry API as part of RFC 60. Part of #17320,
but this still needs to be done on the rest of the maps. However they don't have
any internal mutation methods defined, so they can be done without deprecating
or breaking anything. Work on `BTree` is part of the complete rewrite in #17334.

The implemented API deviates from the API described in the RFC in two key places:

* `VacantEntry.set` yields a mutable reference to the inserted element to avoid code
duplication where complex logic needs to be done *regardless* of whether the entry
was vacant or not.
* `OccupiedEntry.into_mut` was added so that it is possible to return a reference
into the map beyond the lifetime of the Entry itself, providing functional parity
to `VacantEntry.set`.

This allows the full find_or_insert functionality to be implemented using this API.
A PR will be submitted to the RFC to amend this.

[breaking-change]
2014-09-25 03:32:36 +00:00
Alexis Beingessner
fe8a413fc0 handling fallout from entry api 2014-09-24 21:53:58 -04:00
Florian Hahn
1c7d253ca3 Rename fail_ lang item to fail, closes #16114 2014-09-25 01:09:09 +02:00
Florian Hahn
9a01da9460 Rename begin_unwind lang item to fail_fmt, refs #16114 2014-09-24 23:44:00 +02:00
Jakub Wieczorek
fd52224e78 Remove dead code from librustc 2014-09-24 21:03:55 +02:00
Jakub Wieczorek
5bcc154dff Remove unused enum variants 2014-09-24 21:03:55 +02:00
Jakub Wieczorek
3530e4a647 Use more descriptive names in dead code messages 2014-09-24 21:03:55 +02:00
Jakub Wieczorek
2ec795b4f0 Add detection of unused enum variants 2014-09-24 21:03:55 +02:00
bors
9e3bf02c38 auto merge of #17472 : kaseyc/rust/ICE_fix, r=aturon
Add checks for null bytes in the value strings for the export_name and link_section attributes, reporting an error if any are found, before calling with_c_str on them.

Fixes #16478
2014-09-24 15:45:48 +00:00
bors
8cad720879 auto merge of #17471 : vadimcn/rust/link-libgcc, r=alexcrichton
Closes #17271
Closes #15420
2014-09-24 11:25:48 +00:00
Kasey Carrothers
3e8ad53939 Cleanup the check_null function. 2014-09-23 12:54:16 -07:00
bors
321785927c auto merge of #17413 : jakub-/rust/issue-17385, r=pcwalton
This is to make sure it hadn't been moved if there are no bindings
in any of the arms.

Fixes #17385.
2014-09-23 17:05:39 +00:00
bors
d80cd3d9bc auto merge of #17028 : pcwalton/rust/higher-rank-trait-lifetimes, r=pnkfelix
They will ICE during typechecking if used, because they depend on trait
reform.

This is part of unboxed closures.

r? @nikomatsakis
2014-09-23 14:30:40 +00:00
Kasey Carrothers
80014b2856 Check for null bytes before calling with_c_str on link_section and export_name value strings. 2014-09-23 00:54:10 -07:00
bors
f351e676cb auto merge of #17443 : alexcrichton/rust/issue-17442, r=brson
...des a full path via -Clinker=..."

This reverts commit 94f05324fe.
2014-09-23 07:15:40 +00:00
Patrick Walton
5376b1c798 librustc: Parse and resolve higher-rank lifetimes in traits.
They will ICE during typechecking if used, because they depend on trait
reform.

This is part of unboxed closures.
2014-09-22 21:14:58 -07:00
Patrick Walton
e9ad12c0ca librustc: Forbid private types in public APIs.
This breaks code like:

    struct Foo {
        ...
    }

    pub fn make_foo() -> Foo {
        ...
    }

Change this code to:

    pub struct Foo {    // note `pub`
        ...
    }

    pub fn make_foo() -> Foo {
        ...
    }

The `visible_private_types` lint has been removed, since it is now an
error to attempt to expose a private type in a public API. In its place
a `#[feature(visible_private_types)]` gate has been added.

Closes #16463.

RFC #48.

[breaking-change]
2014-09-22 20:05:45 -07:00
bors
43fd619819 auto merge of #17286 : vberger/rust/deprecated_in_macros, r=aturon
Closes #17185.

The stability lint will now check code generated by macro expansion. It will allow to detect :
- arguments passed to macros using deprecated (and others) items
- macro expansion generating code using deprecated items due to its arguments (hence the second commit, fixing such issue found in libcollections)

Checking is still done at expansion, but it will also detect a macro explicitly using a deprecated item in its definition.
2014-09-22 23:50:30 +00:00
Vadim Chugunov
a46865981e Link libgcc statically on Win64.
Allow linking it statically on Win32 with an override.
2014-09-22 16:33:18 -07:00
bors
4b5f4563bf auto merge of #17408 : bkoropoff/rust/bot-ice, r=alexcrichton
- Don't attempt to autoderef `!`.  The `Deref`/`DerefMut` trait lookup would generate a bunch of unhelpful error spew.
- Don't allow explicit deref of `!`, since later passes just ICE.  This closes issue #17373 
- Don't allow explicit index of `!`, since later passes just ICE.  There does not seem to be an issue associated with this
2014-09-22 22:05:33 +00:00
Victor Berger
eb58ac126e Lint stability now checks macro arguments.
Closes #17185.
2014-09-22 19:28:07 +02:00
Alex Crichton
92cc12b01c Revert "Prefer bundled gcc. External gcc can still be used if one provides a full path via -Clinker=..."
This reverts commit 94f05324fe.
2014-09-22 10:14:05 -07:00
bors
4e5b62618c auto merge of #17419 : anchovieshat/rust/remove_no_opt, r=cmr
Closes #13649
2014-09-21 21:45:28 +00:00
bors
8d3728fae0 auto merge of #17412 : vadimcn/rust/gccpref, r=alexcrichton
Fixes #17251
2014-09-21 16:30:28 +00:00
bors
b8599ecdb3 auto merge of #17421 : anchovieshat/rust/move_lto, r=thestinger
Closes #12443
2014-09-21 07:50:31 +00:00
Colin Davidson
a7a1bf81d7 Move -Z lto to -C lto.
Closes #12443
2014-09-21 02:17:31 -04:00
Colin Davidson
88b98a0603 Minor grammar fixes. 2014-09-21 01:19:49 -04:00
Colin Davidson
b2b0737fbe Remove -Z no-opt flag.
Closes #13649
2014-09-21 00:52:04 -04:00
Jakub Wieczorek
7b08827f2d Induce an empty loan for the value being matched in match expressions
This is to make sure it hadn't been moved if there are no bindings
in any of the arms.

Fixes #17385.
2014-09-20 21:01:29 +02:00
Vadim Chugunov
94f05324fe Prefer bundled gcc. External gcc can still be used if one provides a full path via -Clinker=... 2014-09-20 11:44:01 -07:00
Vadim Chugunov
04c41eb372 Move bundled gcc and its libs out into $rust/rustlib/<triple>/gcc/(bin|lib). This way the libs won't be on the -L library search path, and won't confuse external gcc, if one is used. The bundled gcc itself will still be able to find them, because it searches for libs relative to own install location. 2014-09-20 11:42:26 -07:00
Brian Koropoff
a92c3fb3ed Disallow index of !
This avoids ICEs in later passes that cannot cope with this construct
2014-09-20 00:18:54 -07:00
Brian Koropoff
c48faaff64 Disallow dereference of !
Later compiler passes are not prepared to deal with deref of
`ty_bot` and will generate various ICEs, so disallow it outright for now.

Closes issue #17373
2014-09-20 00:18:54 -07:00
Brian Koropoff
31f6d45a18 Do not attempt to autoderef !
This prevents error spam when attempting to look up overload traits.
2014-09-20 00:18:08 -07:00
Alex Crichton
f082416bec Test fixes from the rollup 2014-09-19 19:58:14 -07:00
Alex Crichton
859407e1ef rollup merge of #17363 : thestinger/aslr 2014-09-19 10:00:41 -07:00
Alex Crichton
6fe4467188 rollup merge of #17358 : epdtry/pcg-lto 2014-09-19 10:00:38 -07:00
Alex Crichton
04f5fe5a08 rollup merge of #17338 : nick29581/variants-namespace 2014-09-19 10:00:29 -07:00
Alex Crichton
81ee3586b5 rollup merge of #17318 : nick29581/slice 2014-09-19 10:00:24 -07:00
Alex Crichton
b94075c9ce rollup merge of #17314 : eddyb/span-no-gc 2014-09-19 10:00:21 -07:00
Alex Crichton
64b27e995e rollup merge of #17259 : eddyb/def-no-gc 2014-09-19 10:00:12 -07:00
Alex Crichton
0e5cb75766 rollup merge of #17250 : ahmedcharles/bitflags 2014-09-19 10:00:10 -07:00
Ahmed Charles
0f6cbcaa88 Move uses of enum to bitflags!.
There are still others, but this is the first batch.
2014-09-18 20:35:24 -07:00
Nick Cameron
ce0907e46e Add enum variants to the type namespace
Change to resolve and update compiler and libs for uses.

[breaking-change]

Enum variants are now in both the value and type namespaces. This means that
if you have a variant with the same name as a type in scope in a module, you
will get a name clash and thus an error. The solution is to either rename the
type or the variant.
2014-09-19 15:11:00 +12:00
Patrick Walton
7c00d77e8b librustc: Implement the syntax in the RFC for unboxed closure sugar.
Part of issue #16640. I am leaving this issue open to handle parsing of
higher-rank lifetimes in traits.

This change breaks code that used unboxed closures:

* Instead of `F:|&: int| -> int`, write `F:Fn(int) -> int`.

* Instead of `F:|&mut: int| -> int`, write `F:FnMut(int) -> int`.

* Instead of `F:|: int| -> int`, write `F:FnOnce(int) -> int`.

[breaking-change]
2014-09-18 16:31:58 -07:00
Nick Cameron
31a7e38759 Implement slicing syntax.
`expr[]`, `expr[expr..]`, `expr[..expr]`,`expr[expr..expr]`

Uses the Slice and SliceMut traits.

Allows ... as well as .. in range patterns.
2014-09-19 11:15:49 +12:00
Daniel Micay
360a29d9c9 stop disabling ASLR in normal Windows builds
Closes #16514
2014-09-18 12:58:48 -04:00
Eduard Burtescu
74b8868b5f rustc: remove Gc<Def> and depth from DefUpvar. 2014-09-18 14:36:36 +03:00
Eduard Burtescu
7c5df404b0 rustc: move freevar finding to resolve. 2014-09-18 14:36:36 +03:00
Eduard Burtescu
5c192ae123 rustc: move type definitions from middle::freevars to middle::ty. 2014-09-18 14:36:36 +03:00
Eduard Burtescu
6536a0c0d6 rustc: add a closure depth to DefUpvar. 2014-09-18 14:36:36 +03:00
Eduard Burtescu
6543c5b9a4 rustc: remove BindingMode from DefLocal. 2014-09-18 14:36:35 +03:00
Eduard Burtescu
1813b8cf55 rustc: remove DefArg and DefBinding in favor of DefLocal. 2014-09-18 14:36:35 +03:00
Eduard Burtescu
f1a8f53cf1 Fix fallout in tests from removing the use of Gc in ExpnInfo. 2014-09-18 14:36:18 +03:00
Eduard Burtescu
e35e47f5c1 rustc: fix fallout from removing the use of Gc for ExpnInfo. 2014-09-18 14:36:18 +03:00
Daniel Micay
98fff20a7c stop clamping the DWARF version to 3 on Linux
Closes #13611
2014-09-18 01:10:12 -04:00
Stuart Pernsteiner
ed476b02a6 support LTO against libraries built with codegen-units > 1 2014-09-17 16:58:20 -07:00
Patrick Walton
78a841810e librustc: Implement associated types behind a feature gate.
The implementation essentially desugars during type collection and AST
type conversion time into the parameter scheme we have now. Only fully
qualified names--e.g. `<T as Foo>::Bar`--are supported.
2014-09-17 16:38:57 -07:00
bors
b88d1030e1 auto merge of #17343 : alexcrichton/rust/rollup, r=alexcrichton 2014-09-17 18:26:14 +00:00
Alex Crichton
3a54a4ee6b Test fixes from the rollup 2014-09-17 09:37:39 -07:00
Alex Crichton
665e759d5a rollup merge of #17333 : mo/drop_unused_diagnostic_codes 2014-09-17 08:50:16 -07:00
Alex Crichton
4a7665c808 rollup merge of #17312 : Manishearth/builtin-shrink 2014-09-17 08:49:46 -07:00
Alex Crichton
498e35aa87 rollup merge of #17311 : jakub-/issue-17302 2014-09-17 08:49:41 -07:00
Alex Crichton
2278f9575d rollup merge of #17310 : nikomatsakis/type-bounds-generalize-to-multiple-object-bounds 2014-09-17 08:49:39 -07:00
Alex Crichton
e65f6714b0 rollup merge of #17279 : jakub-/for-loop-unused-variable 2014-09-17 08:49:10 -07:00
Alex Crichton
27af691017 rollup merge of #17226 : P1start/rustdoc-colour 2014-09-17 08:48:53 -07:00
Alex Crichton
e68c95329e rollup merge of #16931 : omasanori/unnecessary-path-brackets 2014-09-17 08:48:31 -07:00
Alex Crichton
fc6eb9a911 rollup merge of #16889 : P1start/array-not-vector 2014-09-17 08:48:27 -07:00
bors
ad9ed40e7f auto merge of #17264 : bkoropoff/rust/issue-17252, r=nick29581
Recursive items are currently detected in the `check_const` pass which runs after type checking.  This means a recursive static item used as an array length will cause type checking to blow the stack.  This PR separates the recursion check out into a separate pass which is run before type checking.

Closes issue #17252

r? @nick29581
2014-09-17 14:06:19 +00:00
bors
12b757b370 auto merge of #17246 : bkoropoff/rust/issue-17216, r=pnkfelix
Trans the cleanup scope of for loop bindings so we don't leak resources.  Regression test included.

Closes #17216
2014-09-17 08:31:18 +00:00
P1start
8b88811419 rustdoc: Correctly distinguish enums and types
This is done by adding a new field to the `DefTy` variant of `middle::def::Def`,
which also clarifies an error message in the process.

Closes #16712.
2014-09-17 18:53:54 +12:00
Nick Cameron
74db87b99d move feature_gate to libsyntax 2014-09-17 16:53:20 +12:00
Nick Cameron
375c95b7ad move std_inject to libsyntax 2014-09-17 16:53:20 +12:00
Nick Cameron
520671f150 move most of front to libsyntax 2014-09-17 16:53:20 +12:00
Martin Olsson
573aa3549a Drop a few unused diagnostic codes
Avoids warnings during bootstrap, similar to:

  src/librustc/lib.rs:149:1: 149:39 warning: diagnostic code E0099 never used
  src/librustc/lib.rs:149 __build_diagnostic_array!(DIAGNOSTICS)

All of these codes stopped being used in this commit:
688ddf7 ("typeck/kind -- stop using old trait framework.")

See also similar fix: https://github.com/rust-lang/rust/issues/16449
2014-09-17 06:32:56 +02:00
bors
0e784e1684 auto merge of #17268 : aturon/rust/mut-conventions, r=alexcrichton
As per [RFC 52](https://github.com/rust-lang/rfcs/blob/master/active/0052-ownership-variants.md), use `_mut` suffixes to mark mutable variants, and `into_iter` for moving iterators. Additional details and motivation in the RFC.

Note that the iterator *type* names are not changed by this RFC; those are awaiting a separate RFC for standardization.

Closes #13660
Closes #16810

[breaking-change]
2014-09-16 23:26:11 +00:00
Aaron Turon
fc525eeb4e Fallout from renaming 2014-09-16 14:37:48 -07:00
bors
ceb9bbfbf5 auto merge of #17213 : mo/rust/fix_typos, r=aturon 2014-09-16 21:36:08 +00:00
Aaron Turon
d8dfe1957b Align with _mut conventions
As per [RFC
52](https://github.com/rust-lang/rfcs/blob/master/active/0052-ownership-variants.md),
use `_mut` suffixes to mark mutable variants, and `into_iter` for moving
iterators.

[breaking-change]
2014-09-16 11:46:52 -07:00
Jakub Wieczorek
bdd9ee3cc7 Run cleanup for base struct in functional struct update expressions
Fixes #17302.
2014-09-16 20:34:16 +02:00
Niko Matsakis
e86c87a81e Generalize lifetime bounds on type parameters to support multiple
lifetime bounds. This doesn't really cause any difficulties, because
we already had to accommodate the fact that multiple implicit bounds
could accumulate. Object types still require precisely one lifetime
bound. This is a pre-step towards generalized where clauses (once you
have lifetime bounds in where clauses, it is harder to restrict them
to exactly one).
2014-09-16 14:18:06 -04:00
Manish Goregaokar
9c3a08551a Clean up code for unused_must_use lint 2014-09-16 22:53:19 +05:30
bors
946654a721 auto merge of #17197 : nikomatsakis/rust/issue-5527-trait-reform-revisited, r=pcwalton
This patch does not make many functional changes, but does a lot of restructuring towards the goals of #5527. This is the biggest patch, basically, that should enable most of the other patches in a relatively straightforward way.

Major changes:

- Do not track impls through trans, instead recompute as needed.
- Isolate trait matching code into its own module, carefully structure to distinguish various phases (selection vs confirmation vs fulfillment)
- Consider where clauses in their more general form
- Integrate checking of builtin bounds into the  trait matching process, rather than doing it separately in kind.rs (important for opt-in builtin bounds)

What is not included:

- Where clauses are still not generalized. This should be a straightforward follow-up patch.
- Caching. I did not include much caching. I have plans for various kinds of caching we can do. Should be straightforward. Preliminary perf measurements suggested that this branch keeps compilation times roughly what they are.
- Method resolution. The initial algorithm I proposed for #5527 does not work as well as I hoped. I have a revised plan which is much more similar to what we do today.
- Deref vs deref-mut. The initial fix I had worked great for autoderef, but not for explicit deref. 
- Permitting blanket impls to overlap with specific impls. Initial plan to consider all nested obligations before considering an impl to match caused many compilation errors. We have a revised plan but it is not implemented here, should be a relatively straightforward extension.
2014-09-16 15:25:59 +00:00
bors
3212d70302 auto merge of #17280 : thestinger/rust/heap, r=pcwalton 2014-09-16 04:56:01 +00:00
Daniel Micay
d206f05132 remove the closure_exchange_malloc lang item 2014-09-15 18:16:33 -04:00
Martin Olsson
7caf2ab802 Fix two typos 2014-09-15 23:04:08 +02:00
Jakub Wieczorek
c2a25a4a83 Add missing unused variable warnings for for loop bindings 2014-09-15 22:24:14 +02:00
Niko Matsakis
5ba0196cb8 misc ppaux changes 2014-09-15 15:28:12 -04:00
Niko Matsakis
688ddf7915 typeck/kind -- stop using old trait framework.
- Unify the "well-formedness" checking that typeck was already doing with what
  was taking place in kind.
- Move requirements that things be sized into typeck.
- I left the checking on upvars in kind, though I think it should eventually be
  refactored into regionck (which would perhaps be renamed).

This reflects a general plan to convert typeck so that it registers
obligations or other pending things for conditions it cannot check
eventually. This makes it easier to identify all the conditions that
apply to an AST expression, but can also influence inference in somec
cases (e.g., `Send` implies `'static`, so I already had to promote a lot
of the checking that `kind.rs` was doing into typeck, this branch just
continues the process).
2014-09-15 15:28:12 -04:00
Niko Matsakis
088c94ae96 trans -- stop tracking vtables precisely, instead recompute as needed. 2014-09-15 15:28:12 -04:00
Niko Matsakis
6349a61231 Port coherence to use the new trait matching code 2014-09-15 15:28:12 -04:00
Niko Matsakis
c5754f3971 Guts of the new trait matching algorithm, not yet in use 2014-09-15 14:58:49 -04:00
bors
a8d478db51 auto merge of #17208 : kmcallister/rust/llvm-diagnostics, r=thestinger
I would like to map this information back to AST nodes, so that we can print remarks with spans, and so that remarks can be enabled on a per-function basis.  Unfortunately, doing this would require a lot more code restructuring — for example, we currently throw away the AST map and lots of other information before LLVM optimizations run.  So for the time being, we print the remarks with debug location strings from LLVM.  There's a warning if you use `-C remark` without `--debuginfo`.

Fixes #17116.
2014-09-15 16:56:03 +00:00
Florian Gilcher
e9c4efb1bf Only pass -fno-use-linker-plugin on Windows
Only pass -fno-use-linker-plugin on Windows where it avoids pulling in
dependencies. Passing it to clang on OS X and Linux would make it fail
though.
2014-09-15 07:12:52 +02:00
Brian Koropoff
83b7cb7ceb Separate static item recursion check into its own pass
This new pass is run before type checking so that recursive items
are detected beforehand.  This prevents going into an infinite
recursion during type checking when a recursive item is used in
an array type.

As a bonus, use `span_err` instead of `span_fatal` so multiple
errors can be reported.

Closes issue #17252
2014-09-14 20:56:07 -07:00
bors
13037a3727 auto merge of #17163 : pcwalton/rust/impls-next-to-struct, r=alexcrichton
type they provide an implementation for.

This breaks code like:

    mod foo {
        struct Foo { ... }
    }

    impl foo::Foo {
        ...
    }

Change this code to:

    mod foo {
        struct Foo { ... }

        impl Foo {
            ...
        }
    }

Closes #17059.

RFC #155.

[breaking-change]

r? @brson
2014-09-14 08:11:04 +00:00
P1start
06d9cc1d7a Add help diagnostic messages
This adds ‘help’ diagnostic messages to rustc. This is used for anything that
provides help to the user, particularly the `--explain` messages that were
previously integrated into the relevant error message.
2014-09-14 17:48:47 +12:00
bors
0f99abae9c auto merge of #17130 : jakub-/rust/issue-17033, r=pcwalton
Fixes #17033.
Fixes #15965.

cc @nikomatsakis
2014-09-14 05:46:05 +00:00
bors
19311b6103 auto merge of #13316 : eddyb/rust/ast-ptr, r=brson
Replaces Gc<T> in the AST with a custom owned smart pointer, P<T>. Fixes #7929.

## Benefits
* **Identity** (affinity?): sharing AST nodes is bad for the various analysis passes (e.g. one could bypass borrowck with a shared `ExprAddrOf` node taking a mutable borrow), the only reason we haven't hit any serious issues with it is because of inefficient folding passes which will always deduplicate any such shared nodes. Even if we were to switch to an arena, this would still hold, i.e. we wouldn't just use `&'a T` in the AST, but rather an wrapper (`P<'a, T>`?).

* **Immutability**: `P<T>` disallows mutating its inner `T` (unless that contains an `Unsafe` interior, which won't happen in the AST), unlike `~T`.

* **Efficiency**: folding can reuse allocation space for `P<T>` and `Vec<T>`, the latter even when the input and output types differ (as it would be the case with arenas or an AST with type parameters to toggle macro support). Also, various algorithms have been changed from copying `Gc<T>` to using `&T` and iterators.

* **Maintainability**: there is another reason I didn't just replace `Gc<T>` with `~T`: `P<T>` provides a fixed interface (`Deref`, `and_then` and `map`) which can remain fully functional even if the implementation changes (using a special thread-local heap, for example). Moreover, switching to, e.g. `P<'a, T>` (for a contextual arena) is easy and mostly automated.
2014-09-14 03:21:07 +00:00
Eduard Burtescu
b06212864f rustc: fix fallout from using ptr::P. 2014-09-14 04:20:34 +03:00
bors
931b11549f auto merge of #17189 : bkoropoff/rust/extern-existing-crate, r=alexcrichton
When checking for an existing crate, compare against the `crate_metadata::name` field, which is the crate name which was requested during resolution, rather than the result of the `crate_metadata::name()` method, which is the crate name within the crate metadata, as these may not match when using the --extern option to `rustc`.

This fixes spurious "multiple crate version" warnings under the following scenario:

- The crate `foo`, is referenced multiple times
- `--extern foo=./path/to/libbar.rlib` is specified to rustc
- The internal crate name of `libbar.rlib` is not `foo`

The behavior surrounding `Context::should_match_name` and the comments in `loader.rs` both lead me to believe that this scenario is intended to work.

Fixes #17186
2014-09-14 00:51:05 +00:00
Brian Koropoff
5857ec6d78 Fix issue #17216
The cleanup scope of for loop bindings should translated when
popped to ensure resources are not leaked.
2014-09-13 15:35:21 -07:00
bors
79a5448f41 auto merge of #17188 : thestinger/rust/tvec, r=pcwalton
`Box<[T]>` is created by allocating `Box<[T, ..n]>` and coercing it so
this code path is never used. It's also broken because it clamps the
capacity of the memory allocations to 4 elements and that's incompatible
with sized deallocation. This dates back to when `~[T]` was a growable
vector type implemented as:

*{ { tydesc, ref_count, prev, next }, { length, capacity, data[] } }

Since even empty vectors had to allocate, it started off the capacity of
all vectors at 4 as a heuristic. It's not possible to grow `Box<[T]>`
and there is no need for a memory allocation when it's empty, so it
would be a terrible heuristic today even if it worked.
2014-09-13 20:36:02 +00:00
bors
7277fe9ee7 auto merge of #17161 : vadimcn/rust/fix-debuginfo, r=alexcrichton
This PR fixes debuginfo tests on Windows.
2014-09-13 17:25:54 +00:00
bors
13475a0851 auto merge of #17182 : luqmana/rust/rnp, r=alexcrichton
Fixes #17120.
2014-09-13 11:25:59 +00:00
Patrick Walton
467bea04fa librustc: Forbid inherent implementations that aren't adjacent to the
type they provide an implementation for.

This breaks code like:

    mod foo {
        struct Foo { ... }
    }

    impl foo::Foo {
        ...
    }

Change this code to:

    mod foo {
        struct Foo { ... }

        impl Foo {
            ...
        }
    }

Additionally, if you used the I/O path extension methods `stat`,
`lstat`, `exists`, `is_file`, or `is_dir`, note that these methods have
been moved to the the `std::io::fs::PathExtensions` trait. This breaks
code like:

    fn is_it_there() -> bool {
        Path::new("/foo/bar/baz").exists()
    }

Change this code to:

    use std::io::fs::PathExtensions;

    fn is_it_there() -> bool {
        Path::new("/foo/bar/baz").exists()
    }

Closes #17059.

RFC #155.

[breaking-change]
2014-09-13 02:07:39 -07:00
bors
90304ed266 auto merge of #17175 : pcwalton/rust/region-bounds-on-closures, r=huonw
This can break code like:

    fn call_rec(f: |uint| -> uint) -> uint {
        (|x| f(x))(call_rec(f))
    }

Change this code to use a temporary instead of violating the borrow
rules:

    fn call_rec(f: |uint| -> uint) -> uint {
        let tmp = call_rec(|x| f(x)); f(tmp)
    }

Closes #17144.

[breaking-change]

r? @huonw
2014-09-13 08:06:00 +00:00
bors
a9cf19889a auto merge of #17162 : sfackler/rust/decorator-traits, r=huonw
The other extension types already worked this way and it can be useful to track some state along with the extension.

I also removed the `BasicMacroExpander` and `BasicIdentMacroExpander` since the span inside of them was never used. The expander function types now directly implement the relevant trait.
2014-09-13 05:25:57 +00:00
bors
8780d9c6b5 auto merge of #17134 : vberger/rust/lint_unused_extern_crate, r=alexcrichton
This PR creates a new lint : ``unused_extern_crate``, which do pretty much the same thing as ``unused_import``, but for ``extern crate`` statements. It is related to feature request #10385.

I adapted the code tracking used imports so that it tracks extern crates usage as well. This was mainly trial and error and while I believe all cases are covered, there might be some code I added that is useless (long compile times didn't give me the opportunity to check this in detail).

Also, I removed some unused ``extern crate`` statements from the libs, that where spotted by this new lint.
2014-09-12 19:05:53 +00:00
Keegan McAllister
ad9a1daa81 Add -C remark for LLVM optimization remarks
Fixes #17116.
2014-09-12 11:46:38 -07:00
Keegan McAllister
225353d8bb Add a Rust string ostream for LLVM 2014-09-12 11:46:38 -07:00
Keegan McAllister
77b3a7ba8b Fix bad error message copypasta 2014-09-12 11:46:38 -07:00
Eduard Burtescu
7ef6ff0669 Track the visited AST's lifetime throughout Visitor. 2014-09-12 14:24:45 +03:00
Eduard Burtescu
a09dbf28e6 Remove largely unused context from Visitor. 2014-09-12 14:24:45 +03:00
Victor Berger
9f8ec427e5 New lint : unused_extern_crate. #10385 2014-09-12 11:24:31 +02:00
Daniel Micay
0fc06b14c5 remove dead and broken tvec ~[T] code path
`Box<[T]>` is created by allocating `Box<[T, ..n]>` and coercing it so
this code path is never used. It's also broken because it clamps the
capacity of the memory allocations to 4 elements and that's incompatible
with sized deallocation. This dates back to when `~[T]` was a growable
vector type implemented as:

*{ { tydesc, ref_count, prev, next }, { length, capacity, data[] } }

Since even empty vectors had to allocate, it started off the capacity of
all vectors at 4 as a heuristic. It's not possible to grow `Box<[T]>`
and there is no need for a memory allocation when it's empty, so it
would be a terrible heuristic today even if it worked.
2014-09-12 03:37:20 -04:00
Brian Koropoff
957229c215 Fix check for existing crate when using --extern
When checking for an existing crate, compare against the
`crate_metadata::name` field, which is the crate name which
was requested during resolution, rather than the result of the
`crate_metadata::name()` method, which is the crate name within
the crate metadata, as these may not match when using the --extern
option to `rustc`.

This fixes spurious "multiple crate version" warnings under the
following scenario:

- The crate `foo`, is referenced multiple times
- `--extern foo=./path/to/libbar.rlib` is specified to rustc
- The internal crate name of `libbar.rlib` is not `foo`

The behavior surrounding `Context::should_match_name` and the
comments in `loader.rs` both lead me to believe that this scenario
is intended to work.

Fixes #17186
2014-09-11 23:10:44 -07:00
Brian Koropoff
f9888ac339 Make debug message about resolving extern crate statements more helpful 2014-09-11 22:49:41 -07:00
bors
805cf81b77 auto merge of #17112 : nick29581/rust/unsized-fields, r=nikomatsakis
closes #16977 

r? @nikomatsakis
2014-09-12 03:35:38 +00:00
Luqman Aden
a152d5fced librustc: Enum nullable pointer opt should not apply to raw pointers. 2014-09-11 21:58:01 -04:00
bors
06c0b1d28a auto merge of #16957 : vadimcn/rust/package-gcc, r=brson
Package rustc's mingw dependencies into Windows installer to avoid requiring a separate mingw install.

Closes #11782
2014-09-11 21:55:42 +00:00
Nick Cameron
4028ebc603 Handle always-unsized structs
closes #16977
2014-09-12 09:16:05 +12:00
Patrick Walton
a9b929dbb6 librustc: Make sure region bounds on closures outlive calls to them.
This can break code like:

    fn call_rec(f: |uint| -> uint) -> uint {
        (|x| f(x))(call_rec(f))
    }

Change this code to use a temporary instead of violating the borrow
rules:

    fn call_rec(f: |uint| -> uint) -> uint {
        let tmp = call_rec(|x| f(x)); f(tmp)
    }

Closes #17144.

[breaking-change]
2014-09-11 12:00:56 -07:00
Vadim Chugunov
c05ba8a298 Append target-specific tools directory ($(RUST)/bin/rustlib/<triple>/bin/) to PATH during linking,
so that rustc can invoke them.
2014-09-11 09:40:20 -07:00
bors
c8b0d667c3 auto merge of #17157 : nikomatsakis/rust/occurs-check, r=pcwalton
Avoid ever constructing cyclic types in the first place, rather than detecting them in resolve. This simplifies logic elsewhere in the compiler, in particular on the trait reform branch.

r? @pnkfelix or @pcwalton 

cc #5527
2014-09-11 12:20:43 +00:00
bors
1f4117f518 auto merge of #17110 : thestinger/rust/dst, r=cmr
The pointer in the slice must not be null, because enum representations
make that assumption. The `exchange_malloc` function returns a non-null
sentinel for the zero size case, and it must not be passed to the
`exchange_free` lang item.

Since the length is always equal to the true capacity, a branch on the
length is enough for most types. Slices of zero size types are
statically special cased to never attempt deallocation. This is the same
implementation as `Vec<T>`.

Closes #14395
2014-09-11 04:55:41 +00:00
Vadim Chugunov
76c02af434 Remove dependency on GCC's LTO linker plugin, since Rust does its' own LTO. 2014-09-10 21:20:59 -07:00
Steven Fackler
200a08fc21 Remove BasicMacroExpander and BasicIdentMacroExpander
The spans inside of these types were always None and never used. Pass
the expander function directly instead of wrapping it in one of these
types.

[breaking-change]
2014-09-10 21:02:39 -07:00
bors
7ea660e678 auto merge of #17142 : sfackler/rust/issue-17115, r=alexcrichton
Closes #17115
2014-09-11 02:35:38 +00:00
bors
09abbbdafc auto merge of #16866 : P1start/rust/tuple-indexing, r=brson
This allows code to access the fields of tuples and tuple structs behind the feature gate `tuple_indexing`:

```rust
#![feature(tuple_indexing)]

let x = (1i, 2i);
assert_eq!(x.1, 2);

struct Point(int, int);
let origin = Point(0, 0);
assert_eq!(origin.0, 0);
assert_eq!(origin.1, 0);
```

Implements [RFC 53](https://github.com/rust-lang/rfcs/blob/master/active/0053-tuple-accessors.md). Closes #16950.
2014-09-11 00:05:41 +00:00
Vadim Chugunov
f2c78dabf5 Use DWARF4 on Windows. 2014-09-10 16:52:23 -07:00
Vadim Chugunov
792a2eac93 Disable ASLR on Windows, for now. 2014-09-10 16:52:21 -07:00
OGINO Masanori
61135205e1 Add unnecessary_import_braces lint.
The lint checks any unnecessary braces around one imported item like
`use std::num::{abs};`.

Signed-off-by: OGINO Masanori <masanori.ogino@gmail.com>
2014-09-10 17:27:36 +09:00
Steven Fackler
b865c1f28c Don't ICE on macros with -Z show-span
Closes #17115
2014-09-09 22:39:13 -07:00
Patrick Walton
1bce8698cd librustc: Obsolete the old external crate renaming syntax.
Instead of `extern crate foo = bar`, write `extern crate bar as foo`.
Instead of `extern crate baz = "quux"`, write `extern crate "quux" as
baz`.

Closes #16461.

[breaking-change]
2014-09-09 19:24:06 -07:00
Niko Matsakis
c4d56b7ee7 Avoid ever constructing cyclic types in the first place, rather than detecting them in resolve. This simplifies logic elsewhere in the compiler. cc #5527 2014-09-09 18:33:07 -04:00
P1start
bf274bc18b Implement tuple and tuple struct indexing
This allows code to access the fields of tuples and tuple structs:

    let x = (1i, 2i);
    assert_eq!(x.1, 2);

    struct Point(int, int);
    let origin = Point(0, 0);
    assert_eq!(origin.0, 0);
    assert_eq!(origin.1, 0);
2014-09-10 10:25:12 +12:00
Daniel Micay
9639cafd36 fixes for Box<[T]>
The pointer in the slice must not be null, because enum representations
make that assumption. The `exchange_malloc` function returns a non-null
sentinel for the zero size case, and it must not be passed to the
`exchange_free` lang item.

Since the length is always equal to the true capacity, a branch on the
length is enough for most types. Slices of zero size types are
statically special cased to never attempt deallocation. This is the same
implementation as `Vec<T>`.

Closes #14395
2014-09-09 15:14:36 -04:00
Alex Crichton
25e08fb4fe rollup merge of #17114 : nick29581/dst-type 2014-09-09 12:07:14 -07:00
Alex Crichton
a9d8f295e0 rollup merge of #17101 : pcwalton/for-loop-borrowck 2014-09-09 12:07:13 -07:00
Alex Crichton
e6b0784903 rollup merge of #17085 : jakub-/issue-17074 2014-09-09 12:07:13 -07:00
Alex Crichton
8158463122 rollup merge of #17054 : pcwalton/subslice-syntax 2014-09-09 12:07:12 -07:00
Alex Crichton
2c66c296db rollup merge of #17052 : pcwalton/feature-gate-subslices 2014-09-09 12:07:11 -07:00
Alex Crichton
fb3c67a65c rollup merge of #17040 : kmcallister/borrow-extctxt 2014-09-09 12:07:11 -07:00
Alex Crichton
a0b3701a21 rollup merge of #17013 : rgawdzik/literal_int 2014-09-09 12:07:11 -07:00
Jakub Wieczorek
28bc56828f Change method lookup to require invariance for mutable references
Fixes #17033.
Fixes #15965.
2014-09-09 20:25:31 +02:00
Nick Cameron
b1916288bf Handle Sized? in type items.
Resolves bounds for `type` and adds the warning for 'unbounds' (? bounds) that we have for bounds.

Closes #16888
2014-09-09 18:22:20 +12:00
Patrick Walton
eb678ff87f librustc: Change the syntax of subslice matching to use postfix ..
instead of prefix `..`.

This breaks code that looked like:

    match foo {
        [ first, ..middle, last ] => { ... }
    }

Change this code to:

    match foo {
        [ first, middle.., last ] => { ... }
    }

RFC #55.

Closes #16967.

[breaking-change]
2014-09-08 16:12:13 -07:00
Nick Cameron
c2fcd4ca72 Check traits for built-in bounds in impls 2014-09-09 10:41:27 +12:00
Keegan McAllister
2b3619412f quote: Explicitly borrow the ExtCtxt
Fixes #16992.
2014-09-08 11:30:55 -07:00
Patrick Walton
22179f49e5 librustc: Feature gate subslice matching in non-tail positions.
This breaks code that uses the `..xs` form anywhere but at the end of a
slice. For example:

    match foo {
        [ 1, ..xs, 2 ]
        [ ..xs, 1, 2 ]
    }

Add the `#![feature(advanced_slice_patterns)]` gate to reenable the
syntax.

RFC #54.

Closes #16951.

[breaking-change]
2014-09-08 11:04:14 -07:00
Patrick Walton
3ca53d3a10 librustc: Make sure lifetimes in for loop heads outlive the for loop
itself.

This breaks code like:

    for &x in my_vector.iter() {
        my_vector[2] = "wibble";
        ...
    }

Change this code to not invalidate iterators. For example:

    for i in range(0, my_vector.len()) {
        my_vector[2] = "wibble";
        ...
    }

The `for-loop-does-not-borrow-iterators` test for #8372 was incorrect
and has been removed.

Closes #16820.

[breaking-change]
2014-09-08 10:50:34 -07:00
bors
0c73e5fc5f auto merge of #12809 : eddyb/rust/ty-arena, r=cmr
This was inspired by seeing a LLVM flatline of **~600MB** when running rustc with jemalloc (each type's `t_box_` is allocated on the heap, creating a lot of fragmentation, which jemalloc can deal with, unlike glibc).
2014-09-08 15:36:13 +00:00
Eduard Burtescu
f7a997be05 rustc: fix fallout from the addition of a 'tcx lifetime on trans::Block. 2014-09-08 15:28:24 +03:00
Eduard Burtescu
28be695b2c rustc: fix fallout from the addition of a 'tcx lifetime on tcx. 2014-09-08 15:28:23 +03:00
Eduard Burtescu
22f8b8462e rustc: use a TypedArena to allocate types in the type context. 2014-09-08 15:14:10 +03:00
bors
5c3987985e auto merge of #17053 : thestinger/rust/large_address_aware, r=sfackler,cmr
By default, 32-bit Windows executables are restricted to 2GiB of address
space even when running on 64-bit Windows when 4GiB is available.

Closes #17043
2014-09-08 11:56:12 +00:00
bors
a39f69f91d auto merge of #17036 : pczarn/rust/issue-15913-ICE-with-call-trans, r=alexcrichton
A match in callee.rs was recognizing some foreign fns as named tuple constructors. A reproducible test case for this is nearly impossible since it depends on the way NodeIds happen to be assigned in different crates.

Fixes #15913
2014-09-08 08:06:18 +00:00
bors
dd626b48c4 auto merge of #16933 : nick29581/rust/dst-rvalue, r=nikomatsakis
Closes #16813 

r? @nikomatsakis I feel like I should be checking more things in check_rvalues, but not sure what - I don't properly understand expr_use_visitor
2014-09-08 02:36:15 +00:00
Nick Cameron
742f49c961 Forbid unsized rvalues
Closes #16813
2014-09-08 09:32:52 +12:00
Jakub Wieczorek
c98a80e472 Fix casts in constant expressions
Fixes #17074.
2014-09-07 21:24:18 +02:00
inrustwetrust
61414a9850 Changed addl_lib_search_paths from HashSet to Vec
This makes the extra library paths given to the gcc linker come in
the same order as the -L options on the rustc command line.
2014-09-07 11:42:02 +02:00
bors
d52d0c8364 auto merge of #17016 : steveklabnik/rust/fix_diagnostic_codes, r=huonw
Fixes #16449.
2014-09-07 03:36:27 +00:00
Daniel Micay
c6633fde53 mark win32 binaries as large address aware
By default, 32-bit Windows executables are restricted to 2GiB of address
space even when running on 64-bit Windows when 4GiB is available.

Closes #17043
2014-09-06 17:54:52 -04:00
Daniel Micay
d1bd139251 fix sized deallocation for Box<[T]> 2014-09-06 13:58:30 -04:00
Daniel Micay
5aa2da0133 fix sized deallocation for proc 2014-09-06 13:50:58 -04:00
Daniel Micay
395e453c06 fix a sized deallocation issue in the glue code 2014-09-06 13:50:58 -04:00
bors
6eabd85265 auto merge of #17003 : nick29581/rust/impl, r=pcwalton
closes #16955 

r? @pcwalton
2014-09-06 14:51:26 +00:00
Piotr Czarnecki
808e039d40 Fix ICE with trans of calls to foreign fns
It was failing occasionally.
2014-09-06 12:31:05 +01:00
Piotr Czarnecki
10935de0cd rustc: Refactor middle::trans::inline 2014-09-06 12:31:05 +01:00
bors
a356e98803 auto merge of #16997 : gamazeps/rust/master, r=huonw
Changed the names according to the issue #16988
2014-09-06 10:31:29 +00:00
bors
20c0ba1279 auto merge of #16907 : SimonSapin/rust/tempdir-result, r=huonw
This allows using `try!()`

[breaking-change]

Fixes #16875
2014-09-06 08:01:33 +00:00
bors
4bea7b3ed0 auto merge of #16367 : epdtry/rust/parallel-codegen, r=alexcrichton
This branch adds support for running LLVM optimization and codegen on different parts of a crate in parallel.  Instead of translating the crate into a single LLVM compilation unit, `rustc` now distributes items in the crate among several compilation units, and spawns worker threads to optimize and codegen each compilation unit independently.  This improves compile times on multicore machines, at the cost of worse performance in the compiled code.  The intent is to speed up build times during development without sacrificing too much optimization.

On the machine I tested this on, `librustc` build time with `-O` went from 265 seconds (master branch, single-threaded) to 115s (this branch, with 4 threads), a speedup of 2.3x.  For comparison, the build time without `-O` was 90s (single-threaded).  Bootstrapping `rustc` using 4 threads gets a 1.6x speedup over the default settings (870s vs. 1380s), and building `librustc` with the resulting stage2 compiler takes 1.3x as long as the master branch (44s vs.  55s, single threaded, ignoring time spent in LLVM codegen).

The user-visible changes from this branch are two new codegen flags:

 * `-C codegen-units=N`: Distribute items across `N` compilation units.
 * `-C codegen-threads=N`: Spawn `N` worker threads for running optimization and codegen.  (It is possible to set `codegen-threads` larger than `codegen-units`, but this is not very useful.)

Internal changes to the compiler are described in detail on the individual commit messages.

Note: The first commit on this branch is copied from #16359, which this branch depends on.

r? @nick29581
2014-09-06 06:06:35 +00:00
Stuart Pernsteiner
6d2d47b2fc don't use ld -r with -C codegen-units=1 2014-09-05 14:30:36 -07:00
Robert Gawdzik ☢
5eea93af39 Fixes type range issue during linting (#16684)
- Ensures the propagated negation sign is properly utilized during type
   checking.
 - Removed redundant type checking, specifically regarding the out of bounds checking
   on a bounded type.
 - Closes #16684
2014-09-05 14:59:39 -04:00
bors
82c052794d auto merge of #16628 : pczarn/rust/hashmap-opt, r=nikomatsakis
This is #15720, rebased and reopened.

cc @nikomatsakis
2014-09-05 17:36:25 +00:00
Stuart Pernsteiner
4d9a478616 add workaround for mingw ld --force-exe-suffix behavior 2014-09-05 09:18:57 -07:00
Stuart Pernsteiner
1b676fb760 don't leave unwanted temporary files with --emit=ir/asm 2014-09-05 09:18:57 -07:00
Stuart Pernsteiner
b5a0b700c6 use target-specific linker args when combining compilation units 2014-09-05 09:18:57 -07:00
Stuart Pernsteiner
73f8adcbc8 make separate compilation respect #[inline] attributes
Adjust the handling of `#[inline]` items so that they get translated into every
compilation unit that uses them.  This is necessary to preserve the semantics
of `#[inline(always)]`.

Crate-local `#[inline]` functions and statics are blindly translated into every
compilation unit.  Cross-crate inlined items and monomorphizations of
`#[inline]` functions are translated the first time a reference is seen in each
compilation unit.  When using multiple compilation units, inlined items are
given `available_externally` linkage whenever possible to avoid duplicating
object code.
2014-09-05 09:18:57 -07:00
Stuart Pernsteiner
edc5cdcba2 make symbols internal when possible
Add a post-processing pass to `trans` that converts symbols from external to
internal when possible.  Translation with multiple compilation units initially
makes most symbols external, since it is not clear when translating a
definition whether that symbol will need to be accessed from another
compilation unit.  This final pass internalizes symbols that are not reachable
from other crates and not referenced from other compilation units, so that LLVM
can perform more aggressive optimizations on those symbols.
2014-09-05 09:18:57 -07:00
Stuart Pernsteiner
e09bef810a avoid duplicate translation of monomorphizations, drop glue, and visit glue
Use a shared lookup table of previously-translated monomorphizations/glue
functions to avoid translating those functions in every compilation unit where
they're used.  Instead, the function will be translated in whichever
compilation unit uses it first, and the remaining compilation units will link
against that original definition.
2014-09-05 09:18:57 -07:00
Stuart Pernsteiner
da9606247d translate into multiple llvm contexts
Rotate between compilation units while translating.  The "worker threads"
commit added support for multiple compilation units, but only translated into
one, leaving the rest empty.  With this commit, `trans` rotates between various
compilation units while translating, using a simple stragtegy: upon entering a
module, switch to translating into whichever compilation unit currently
contains the fewest LLVM instructions.

Most of the actual changes here involve getting symbol linkage right, so that
items translated into different compilation units will link together properly
at the end.
2014-09-05 09:18:57 -07:00
Stuart Pernsteiner
2e7bc0f808 reuse original symbols for inlined items
When inlining an item from another crate, use the original symbol from that
crate's metadata instead of generating a new symbol using the `ast::NodeId` of
the inlined copy.  This requires exporting symbols in the crate metadata in a
few additional cases.  Having predictable symbols for inlined items will be
useful later to avoid generating duplicate object code for inlined items.
2014-09-05 09:18:57 -07:00
Stuart Pernsteiner
cf672850df run optimization and codegen on worker threads
Refactor the code in `llvm::back` that invokes LLVM optimization and codegen
passes so that it can be called from worker threads.  (Previously, it used
`&Session` extensively, and `Session` is not `Share`.)  The new code can handle
multiple compilation units, by compiling each unit to `crate.0.o`, `crate.1.o`,
etc., and linking together all the `crate.N.o` files into a single `crate.o`
using `ld -r`.  The later linking steps can then be run unchanged.

The new code preserves the behavior of `--emit`/`-o` when building a single
compilation unit.  With multiple compilation units, the `--emit=asm/ir/bc`
options produce multiple files, so combinations like `--emit=ir -o foo.ll` will
not actually produce `foo.ll` (they instead produce several `foo.N.ll` files).

The new code supports `-Z lto` only when using a single compilation unit.
Compiling with multiple compilation units and `-Z lto` will produce an error.
(I can't think of any good reason to do such a thing.)  Linking with `-Z lto`
against a library that was built as multiple compilation units will also fail,
because the rlib does not contain a `crate.bytecode.deflate` file.  This could
be supported in the future by linking together the `crate.N.bc` files produced
when compiling the library into a single `crate.bc`, or by making the LTO code
support multiple `crate.N.bytecode.deflate` files.
2014-09-05 09:18:55 -07:00
Stuart Pernsteiner
e29aa1430b move back:🔗:write into a separate file 2014-09-05 09:18:55 -07:00
Stuart Pernsteiner
0ab27b1d5b split CrateContext into shared and local pieces
Break up `CrateContext` into `SharedCrateContext` and `LocalCrateContext`.  The
local piece corresponds to a single compilation unit, and contains all
LLVM-related components.  (LLVM data structures are tied to a specific
`LLVMContext`, and we will need separate `LLVMContext`s to safely run
multithreaded optimization.)  The shared piece contains data structures that
need to be shared across all compilation units, such as the `ty::ctxt` and some
tables related to crate metadata.
2014-09-05 09:18:55 -07:00
Stuart Pernsteiner
cf35cb365a make CrateContext fields private 2014-09-05 09:18:53 -07:00
Steve Klabnik
1b9c5e69ba Remove unused diagnostic codes.
Fixes #16449.
2014-09-05 06:08:19 -04:00
Nick Cameron
2df3a5b0d1 Check concrete type in impls with no trait
closes #16955
2014-09-05 14:38:37 +12:00
Piotr Czarnecki
0ad4644ae1 Work around inability to link lifetime of ref bindings (#16994) 2014-09-05 01:24:04 +01:00
Felix Raimundo
d0f1c7dfb0 Update language item from 'share' to 'sync' #16988 2014-09-05 02:03:26 +02:00
bors
d3e7922ddd auto merge of #16982 : jbcrail/rust/comment-and-string-corrections, r=alexcrichton
I corrected spelling and capitalization errors in comments and strings.
2014-09-04 18:30:59 +00:00
bors
bef51ba234 auto merge of #16923 : wickerwaka/rust/crate-as-fixup, r=alexcrichton
Changed occurances of:
extern crate foo = "bar";
to:
extern crate "bar" as foo;

Added warning for old deprecated syntax
2014-09-04 16:40:59 +00:00
bors
8d5e64f3bc auto merge of #16981 : kmcallister/rust/ctypes-warning, r=alexcrichton 2014-09-04 13:01:00 +00:00
bors
5924937a5a auto merge of #16883 : jakub-/rust/issue-16648, r=pcwalton
They were only correct in the simplest case. Some of the optimisations
are certainly possible but should be introduced carefully and only
when the whole pattern codegen infrastructure is in a better shape.

Fixes #16648.
2014-09-04 06:41:04 +00:00
Joseph Crail
b7bfe04b2d Fix spelling errors and capitalization. 2014-09-03 23:10:38 -04:00
Keegan McAllister
f422de1e85 Use a visitor to look for non-FFI-safe types
Fixes #16250.
2014-09-03 19:28:37 -07:00
bors
a4d257b150 auto merge of #16954 : nick29581/rust/dst-bug-deref, r=nikomatsakis
Closes #16930 

r?
2014-09-03 23:21:05 +00:00
bors
3b5d92c923 auto merge of #16953 : nick29581/rust/dst-bug-7, r=pcwalton
Closes #16947 

r?
2014-09-03 21:31:07 +00:00
bors
9b81a4eef8 auto merge of #16811 : nick29581/rust/dst-bug-2, r=nikomatsakis
closes #16800 
r? @nikomatsakis - I'm not 100% sure this is the right approach, it is kind of ad-hoc. The trouble is we don't have any intrinsic notion of which types are sized and which are not, we only have the Sized bound, so I have nothing to validate the Sized bound against.
2014-09-03 17:51:05 +00:00
bors
b7d456dfea auto merge of #16934 : nick29581/rust/dst-bug-6, r=pcwalton
Closes #16911 

r?
2014-09-03 06:26:02 +00:00
Nick Cameron
ab3999f615 Handle custom deref returning fat pointers
Closes #16930
2014-09-03 15:31:36 +12:00
Nick Cameron
7d72bdb226 Fix ICE when casting &[T] to *const [T]
Closes #16947
2014-09-03 15:22:32 +12:00
bors
f7ec95efbb auto merge of #16917 : nick29581/rust/cross-trait, r=pcwalton
Closes #15349

r? @pcwalton (or anyone else)
2014-09-03 02:40:59 +00:00
bors
2e38581792 auto merge of #16892 : andrew-d/rust/andrew-fix-test-reexports, r=sfackler
Fixes #16597

I'm not 100% sure this is the correct way to handle this - but I wasn't able to find a better way without doing way more refactoring of the code that I was comfortable with.  Comments and criticism are appreciated 😄
2014-09-03 00:51:00 +00:00
Nick Cameron
7f72884f13 Remove cross-borrowing for traits.
Closes #15349

[breaking-change]

Trait objects are no longer implicitly coerced from Box<T> to &T. You must make an explicit coercion using `&*`.
2014-09-03 08:32:35 +12:00
Nick Cameron
e9bd650cad Schedule cleanup for &* on fat owned pointers
For example `let _x: &Trait = &*(box Foo as Box<Trait>);`. There was a bug where no cleanup would be scheduled by the deref.

No test because cleanup-auto-borrow-obj.rs is a test for this once we remove trait cross-borrowing (done on another branch).
2014-09-03 08:29:33 +12:00
Nick Cameron
5520ea81a1 Reviewer changes 2014-09-02 19:47:39 +12:00
Nick Cameron
3c610af670 Fix ICE with static DST coercion
Closes #16911
2014-09-02 15:54:22 +12:00
Nick Cameron
52d6d3be48 DST raw pointers - *-pointers are fat pointers 2014-09-02 10:05:00 +12:00
bors
01364c44a4 auto merge of #16867 : wickerwaka/rust/ice-16750, r=alexcrichton
Not sure if this is addressing the root cause or just patching up a symptom. Also not sure if I should be adding a diagnostic code for this.

Fixes #16750
Fixes #15812
2014-09-01 19:41:02 +00:00
wickerwaka
2cb210d2c6 Updated to new extern crate syntax.
Added warning for old deprecated syntax
2014-09-01 09:02:00 -07:00
bors
12b438c31b auto merge of #16802 : nick29581/rust/dst-bug-1, r=luqmana
Closes #16783 

r? @nikomatsakis
2014-09-01 07:51:02 +00:00
Nick Cameron
cc598e6f8e Second approach - using type contents 2014-09-01 09:48:19 +12:00
Simon Sapin
a049fb98cd Have std::io::TempDir::new and new_in return IoResult
This allows using `try!()`

[breaking-change]

Fixes #16875
2014-08-31 22:06:11 +02:00
P1start
5bc27d5214 Change rustc to say array instead of vector 2014-08-31 19:55:32 +12:00
Andrew Dunham
5bb6196378 Address review comments, add tests 2014-08-30 23:48:31 -07:00
Alex Crichton
1bd0df3fbb rollup merge of #16840 : huonw/feature-has-added 2014-08-30 23:47:33 -07:00
Andrew Dunham
1c49eaaa55 gensym each test re-export module individually
Fixes #16597
2014-08-30 20:36:16 -07:00
bors
f297366593 auto merge of #16859 : alexcrichton/rust/snapshots, r=huonw 2014-08-30 19:51:25 +00:00
Jakub Wieczorek
6f35ede5a4 Remove the branch merging optimisations for slice patterns
They were only correct in the simplest case. Some of the optimisations
are certainly possible but should be introduced carefully and only
when the whole pattern codegen infrastructure is in a better shape.

Fixes #16648.
2014-08-30 19:50:46 +02:00
Huon Wilson
b79930eeb9 Fix grammar of the accepted feature warning. 2014-08-31 02:25:19 +10:00
bors
cbacdbc5f3 auto merge of #16598 : bkoropoff/rust/import-shadow-name, r=alexcrichton
This partially alleviates the confusing behavior in issue #16597
2014-08-30 12:41:22 +00:00
bors
d398eb76ae auto merge of #16419 : huonw/rust/pretty-expanded-hygiene, r=pnkfelix
Different Identifiers and Names can have identical textual representations, but different internal representations, due to the macro hygiene machinery (syntax contexts and gensyms). This provides a way to see these internals by compiling with `--pretty expanded,hygiene`.

This is useful for debugging & hacking on macros (e.g. diagnosing https://github.com/rust-lang/rust/issues/15750/https://github.com/rust-lang/rust/issues/15962 likely would've been faster with this functionality).

E.g. 

```rust
#![feature(macro_rules)]
// minimal junk
#![no_std]

macro_rules! foo {
    ($x: ident) => { y + $x }
}

fn bar() {
    foo!(x)
}
```
```rust
#![feature(macro_rules)]
// minimal junk
#![no_std]


fn bar /* 61#0 */() { y /* 60#2 */ + x /* 58#3 */ }
```
2014-08-30 10:51:26 +00:00
bors
43c26e6041 auto merge of #16190 : Pythoner6/rust/labeled-while-loop, r=alexcrichton
Fixes #12643

> Say!
> I like labelled breaks/continues!

I will use them with a `for` loop.
And I will use with a `loop` loop.
Say! I will use them ANYWHERE!
… _even_ in a `while` loop.

Because they're now supported there.
2014-08-30 09:01:20 +00:00
Huon Wilson
32e437161d rustc: implement a pretty mode to print ident/name's ctxt & gensyms.
`--pretty expanded,hygiene` is helpful with debugging macro issues,
since two identifiers/names can be textually the same, but different
internally (resulting in weird "undefined variable" errors).
2014-08-30 16:50:38 +10:00
wickerwaka
d3d14d6a41 Added cfail test
Changed error to 'use of trait `{}` as a struct constructor'
2014-08-29 21:11:34 -07:00
bors
c8e86e977f auto merge of #16322 : michaelwoerister/rust/gdb-pretty, r=alexcrichton
Also extends the autotest framework to let a test case choose if pretty printing should be enabled.
2014-08-30 04:01:24 +00:00
Joseph Martin
e76db8ebc2 Fixed missing use statement 2014-08-29 23:44:21 -04:00
Pythoner6
aec34d8f26 Fix formatting, update copyright dates 2014-08-29 23:44:08 -04:00
Pythoner6
373b9d6243 Add support for labeled while loops. 2014-08-29 23:43:55 -04:00
wickerwaka
f5776f81fd Detect a traits being used as structs in check_expr_with_unifier
Fixes #16750
Fixes #15812
2014-08-29 19:27:27 -07:00
Alex Crichton
d15d559739 Register new snapshots 2014-08-29 14:33:08 -07:00
P1start
ed2aad8b43 Add lint groups; define built-in lint groups bad_style and unused
This adds support for lint groups to the compiler. Lint groups are a way of
grouping a number of lints together under one name. For example, this also
defines a default lint for naming conventions, named `bad_style`. Writing
`#[allow(bad_style)]` is equivalent to writing
`#[allow(non_camel_case_types, non_snake_case, non_uppercase_statics)]`. These
lint groups can also be defined as a compiler plugin using the new
`Registry::register_lint_group` method.

This also adds two built-in lint groups, `bad_style` and `unused`. The contents
of these groups can be seen by running `rustc -W help`.
2014-08-30 09:12:04 +12:00
P1start
de7abd8824 Unify non-snake-case lints and non-uppercase statics lints
This unifies the `non_snake_case_functions` and `uppercase_variables` lints
into one lint, `non_snake_case`. It also now checks for non-snake-case modules.
This also extends the non-camel-case types lint to check type parameters, and
merges the `non_uppercase_pattern_statics` lint into the
`non_uppercase_statics` lint.

Because the `uppercase_variables` lint is now part of the `non_snake_case`
lint, all non-snake-case variables that start with lowercase characters (such
as `fooBar`) will now trigger the `non_snake_case` lint.

New code should be updated to use the new `non_snake_case` lint instead of the
previous `non_snake_case_functions` and `uppercase_variables` lints. All use of
the `non_uppercase_pattern_statics` should be replaced with the
`non_uppercase_statics` lint. Any code that previously contained non-snake-case
module or variable names should be updated to use snake case names or disable
the `non_snake_case` lint. Any code with non-camel-case type parameters should
be changed to use camel case or disable the `non_camel_case_types` lint.

[breaking-change]
2014-08-30 09:10:05 +12:00
bors
bd159d3867 auto merge of #15955 : nikomatsakis/rust/issue-5527-new-inference-scheme, r=pcwalton
The inference scheme proposed in <http://smallcultfollowing.com/babysteps/blog/2014/07/09/an-experimental-new-type-inference-scheme-for-rust/>.

This is theoretically a [breaking-change]. It is possible that you may encounter type checking errors, particularly related to closures or functions with higher-ranked lifetimes or object types. Adding more explicit type annotations should help the problem. However, I have not been able to make an example that *actually* successfully compiles with the older scheme and fails with the newer scheme.

f? @pcwalton, @pnkfelix
2014-08-29 19:21:12 +00:00
Niko Matsakis
6e27c2fd58 Label FIXMEs with a bug number 2014-08-29 10:21:54 -04:00
Niko Matsakis
4c01251416 Introduce new inference scheme: variables are now instantiated with at most one type, and region variables are introduced as needed 2014-08-29 10:21:54 -04:00
bors
602592675c auto merge of #16838 : nick29581/rust/dst-bug-4, r=pnkfelix,nikomatsakis
Don't double free embedded, unsized slices.

Merge/rebase error from DST. Thanks to @eddyb for finding.

Closes #16826 (I hope)

r?
2014-08-29 13:56:29 +00:00
Huon Wilson
ddc8cc92c9 rustc: remove a trait that is unnecessary after pretty move.
The type in the `impl` is now in the module with the trait.
2014-08-29 18:05:26 +10:00
Huon Wilson
149032aff3 rustc: move pretty printing into its own module.
There's a lot of it, and it's a fairly well-defined/separate chunk of
code, so it might as well be separate.
2014-08-29 18:05:26 +10:00
Nick Cameron
415d7e8ae9 Don't double free embedded, unsized slices
Thanks to @eddyb for finding the bug.

Closes #16826 (I hope)
2014-08-29 19:49:01 +12:00
Huon Wilson
fd278a892a Avoid flow-on Iterator error for for ... in [ty err] {}.
This squashes the

> `for` loop expression has type `[type error]` which does not implement
> the `Iterator` trait

message that one received when writing `for ... in x` where was
previously found to have a type error.

Fixes #16042.
2014-08-29 17:43:46 +10:00
Huon Wilson
2e4a21c2c2 Mention type of for exprs that don't implement Iterator.
This improves the error message by telling the user the exact type of
`x` if it doesn't implement `Iterator` in `for ... in x {}`.

Closes #16043.
2014-08-29 17:39:09 +10:00
bors
e3549ee202 auto merge of #16770 : cburgdorf/rust/patch_overloaded_calls_hint, r=alexcrichton 2014-08-29 04:56:18 +00:00
Niko Matsakis
d6e5797e41 Introduce snapshot_vec abstraction 2014-08-28 21:15:23 -04:00
bors
2e92c67dc0 auto merge of #16664 : aturon/rust/stabilize-option-result, r=alexcrichton
Per API meeting

  https://github.com/rust-lang/meeting-minutes/blob/master/Meeting-API-review-2014-08-13.md

# Changes to `core::option`

Most of the module is marked as stable or unstable; most of the unstable items are awaiting resolution of conventions issues.

However, a few methods have been deprecated, either due to lack of use or redundancy:

* `take_unwrap`, `get_ref` and `get_mut_ref` (redundant, and we prefer for this functionality to go through an explicit .unwrap)
* `filtered` and `while`
* `mutate` and `mutate_or_set`
* `collect`: this functionality is being moved to a new `FromIterator` impl.

# Changes to `core::result`

Most of the module is marked as stable or unstable; most of the unstable items are awaiting resolution of conventions issues.

* `collect`: this functionality is being moved to a new `FromIterator` impl.
* `fold_` is deprecated due to lack of use
* Several methods found in `core::option` are added here, including `iter`, `as_slice`, and variants.

Due to deprecations, this is a:

[breaking-change]
2014-08-28 23:56:20 +00:00
Niko Matsakis
790d9c4708 Refactor and cleanup inference code: s/get_ref()/fields/, use try! macro rather than if_ok! 2014-08-28 14:37:35 -04:00
Niko Matsakis
1c15e9efeb Fix regionck to account for the uniqueness requirements on ref mut reborrows 2014-08-28 14:15:34 -04:00
Niko Matsakis
f60a7c4798 Fix regionck to consider bounds on a proc when capturing variables 2014-08-28 14:15:32 -04:00
Aaron Turon
276b8b125d Fallout from stabilizing core::option 2014-08-28 09:12:54 -07:00
Nick Cameron
bdfeb65585 Forbid the Sized bound on unsized types
closes #16800
2014-08-28 18:50:00 +12:00
Niko Matsakis
1b487a8906 Implement generalized object and type parameter bounds (Fixes #16462) 2014-08-27 21:46:52 -04:00
Nick Cameron
d13fe1c528 Fix an ICE with error types in a vec
Closes #16783
2014-08-28 10:30:30 +12:00
Michael Woerister
6974b4f1b5 debuginfo: Add GDB pretty printers for structs and enums. 2014-08-27 15:19:14 +02:00
bors
c73ab0c10b auto merge of #16751 : luqmana/rust/tr, r=alexcrichton
Fixes #15562.
2014-08-27 09:31:14 +00:00
bors
e61ec99af2 auto merge of #16704 : flugsio/rust/fix-rustc-ice-lint-underscores-only, r=brson
Fix for type identifiers with only underscores (two or more), I assume they doesn't count as camel case.

```rust
type __ = int;

fn main() {
}
```

```
error: internal compiler error: unexpected failure
note: the compiler hit an unexpected failure path. this is a bug.
note: we would appreciate a bug report: http://doc.rust-lang.org/complement-bugreport.html
note: run with `RUST_BACKTRACE=1` for a backtrace
task 'rustc' failed at 'index out of bounds: the len is 0 but the index is 0', /home/rustbuild/src/rust-buildbot/slave/nightly-linux/build/src/librustc/lib.rs:1

stack backtrace:
   1: 0xb603f5d0 - rt::backtrace:👿:write::ha55f265f6626471dmxr
   2: 0xb6042620 - failure::on_fail::h4d2c6d42b67e94803Sr
   3: 0xb640a180 - unwind::begin_unwind_inner::h484879fa7cc3611fZhe
   4: 0xb6409e50 - unwind::begin_unwind_fmt::hd14e5c64bc9006capfe
   5: 0xb6409df0 - rust_begin_unwind
   6: 0xb6454580 - failure::begin_unwind::h9ab1fc5753bd08f3YDk
   7: 0xb6458cb0 - failure::fail_bounds_check::h88167bad36865909aCk
   8: 0xb6f685d0 - lint::builtin::NonCamelCaseTypes.LintPass::check_item::check_case::he854eeffd105cb0f40E
   9: 0xb6f68050 - lint::builtin::NonCamelCaseTypes.LintPass::check_item::hc35b45d248e41cd43XE
  10: 0xb6f7b760 - lint::context::Context<'a>.Visitor<(*>::visit_item::closure.139262
  11: 0xb6f79510 - lint::context::Context<'a>::with_lint_attrs::hb9efe321fa321ce6spG
  12: 0xb6f81d30 - lint::context::Context<'a>.Visitor<(*>::visit_mod::he4593c831936b308ZMG
  13: 0xb6f8f2f0 - lint::context::check_crate::closure.139319
  14: 0xb6f79510 - lint::context::Context<'a>::with_lint_attrs::hb9efe321fa321ce6spG
  15: 0xb6efda70 - lint::context::check_crate::ha9e64328726b9579q1G
  16: 0xb6efda20 - driver::driver::phase_3_run_analysis_passes::closure.136263
  17: 0xb659d640 - util::common::time::h2837683151147173214
  18: 0xb6e7d130 - driver::driver::phase_3_run_analysis_passes::h7079eff53afc4de3Jfz
  19: 0xb6e783f0 - driver::driver::compile_input::h0ec84a550e24779cP1y
  20: 0xb6f26250 - driver::run_compiler::h7e7c01ecbfd0ad87JzC
  21: 0xb6f26150 - driver::main_args::closure.137215
  22: 0xb6f380d0 - task::TaskBuilder<S>::try_future::closure.138376
  23: 0xb6f37ec0 - task::TaskBuilder<S>::spawn_internal::closure.138353
  24: 0xb774bdd0 - task::spawn_opts::closure.8325
  25: 0xb6409c10 - unwind::try::try_fn::h91f00772748cf73eD8d
  26: 0xb6468ae0 - rust_try_inner
  27: 0xb6468aa0 - rust_try
  28: 0xb6407880 - unwind::try::h78a4fc0e85c326aef6d
  29: 0xb6407640 - task::Task::run::hb6f2d9484116e3d8xcd
  30: 0xb774bba0 - task::spawn_opts::closure.8271
  31: 0xb6409350 - thread::thread_start::h8c02fef9f651da5cjBd
  32: 0xb5ed3fc0 - start_thread
  33: 0xb62e8a32 - __clone
  34:        0x0 - <unknown>
```
2014-08-27 00:31:25 +00:00
Christoph Burgdorf
7fb3aa5eea add missing ! char to feature gate hint 2014-08-26 22:44:53 +02:00
bors
7932b719ec auto merge of #14397 : nick29581/rust/coerce, r=pnkfelix
DST coercions and DST fields in structs

The commits are not quite stand alone, I should probably squash them together before landing. In particular if you review the individual commits, then you'll see some scrappy stuff that gets fixed in later commits. But reading the commits in order might be easier to get an overall idea of what is going on.

The first commit includes putting back time zone into our time library - @pcwalton removed that as part of his de-~str'ing, but I had already converted it to use StrBuf, so we may as well leave it in. Update: no longer, this is removed in a later commit.
2014-08-26 10:31:06 +00:00
Nick Cameron
08364a4cac Optimise a particularly clown shoes example of DST codegen 2014-08-26 16:07:33 +12:00
Nick Cameron
52ef46251e Rebasing changes 2014-08-26 16:07:32 +12:00
Nick Cameron
3e626375d8 DST coercions and DST structs
[breaking-change]

1. The internal layout for traits has changed from (vtable, data) to (data, vtable). If you were relying on this in unsafe transmutes, you might get some very weird and apparently unrelated errors. You should not be doing this! Prefer not to do this at all, but if you must, you should use raw::TraitObject rather than hardcoding rustc's internal representation into your code.

2. The minimal type of reference-to-vec-literals (e.g., `&[1, 2, 3]`) is now a fixed size vec (e.g., `&[int, ..3]`) where it used to be an unsized vec (e.g., `&[int]`). If you want the unszied type, you must explicitly give the type (e.g., `let x: &[_] = &[1, 2, 3]`). Note in particular where multiple blocks must have the same type (e.g., if and else clauses, vec elements), the compiler will not coerce to the unsized type without a hint. E.g., `[&[1], &[1, 2]]` used to be a valid expression of type '[&[int]]'. It no longer type checks since the first element now has type `&[int, ..1]` and the second has type &[int, ..2]` which are incompatible.

3. The type of blocks (including functions) must be coercible to the expected type (used to be a subtype). Mostly this makes things more flexible and not less (in particular, in the case of coercing function bodies to the return type). However, in some rare cases, this is less flexible. TBH, I'm not exactly sure of the exact effects. I think the change causes us to resolve inferred type variables slightly earlier which might make us slightly more restrictive. Possibly it only affects blocks with unreachable code. E.g., `if ... { fail!(); "Hello" }` used to type check, it no longer does. The fix is to add a semicolon after the string.
2014-08-26 12:38:51 +12:00
Nick Cameron
34d607f9c9 Use the slice repr for ~[T] 2014-08-26 12:37:45 +12:00
Luqman Aden
1660c3be93 librustc: Use Typer's node_ty method instead of free function in ExprUseVisitor. 2014-08-25 13:30:49 -07:00
Luqman Aden
6ad0346f0b librustc: Restrict transmute intrinsicck to just rust-intrinsic fn's. 2014-08-25 12:48:35 -07:00
bors
5fb2dfaa20 auto merge of #16740 : alexcrichton/rust/issue-16725, r=pcwalton
Closes #16725
2014-08-25 12:10:56 +00:00
Alex Crichton
1c76d559c3 rustc: Encode the visibility of foreign items
The privacy pass of the compiler was previously not taking into account the
privacy of foreign items, or bindings to external functions. This commit fixes
this oversight by encoding the visibility of foreign items into the metadata for
each crate.

Any code relying on this will start to fail to  compile and the bindings must be
marked with `pub` to indicate that they can be used externally.

Closes #16725
[breaking-change]
2014-08-25 05:01:51 -07:00
bors
0b3e43d2a4 auto merge of #16699 : treeman/rust/issue-8492, r=alexcrichton
Closes #8492.

I did not find this suggestion in the [guidelines][] but it's mentioned in the [old style guide][].

[guidelines]: https://github.com/rust-lang/rust-guidelines
[old style guide]: 73c864a10a
2014-08-25 03:30:54 +00:00
bors
833277e2d2 auto merge of #16694 : vadimcn/rust/debug-linker, r=alexcrichton
Shows linker spew even when linking succeeds.  This is occasionally useful in order to see verbose linker output.
2014-08-25 00:00:59 +00:00
bors
9e8c30c553 auto merge of #16718 : Sawyer47/rust/bool-cast, r=pcwalton
Current version of rust fails when casting from bool, e.g.
```rust
fn main() {
    let _a = false as uint;
    let _b = true as uint;
    let _c: [bool, ..false as uint];
    let _d: [bool, ..true as uint];
    // _a and _b work, but _c and _d result in an error
    // error: expected constant expr for vector length: can't cast str to uint
}
```
This commit makes it work as expected.
2014-08-24 20:30:59 +00:00
Jonas Hietala
9968ae2554 Adjust the error messages to match the pattern "expected foo, found bar"
Closes #8492
2014-08-24 09:53:01 +02:00
Piotr Jawniak
46cf384ba9 Fix const evaluation of cast expression from bool 2014-08-24 09:14:41 +02:00
Jimmie Elvenmark
9eb9fcd719 lint: Improve camel case suggestion when empty. 2014-08-24 09:07:19 +02:00
Björn Steinbrink
bbc66332fe Enable the MergeFunc pass
Fixes #9536
2014-08-24 01:08:58 +02:00
Vadim Chugunov
77e39b0560 Log linker stderr and stdout. 2014-08-23 14:38:41 -07:00
bors
6843d8ccd5 auto merge of #16693 : vadimcn/rust/rename--win32, r=pcwalton 2014-08-23 14:30:57 +00:00
Jimmie Elvenmark
673c555443 librustc: Don't ICE with type when name only contain underscores. 2014-08-23 16:03:28 +02:00
Vadim Chugunov
68811817f7 Complete renaming of win32 to windows 2014-08-23 02:11:28 -07:00
Luqman Aden
30ab05aeb5 librustc: Properly tag upvars in proc's to stop misleading unused_mut warnings. 2014-08-22 10:18:22 -07:00
bors
36789fbbc5 auto merge of #16656 : luqmana/rust/ucmla, r=pcwalton
Gets rid of a FIXME in `base::get_fn_llvm_attributes`.

r? @pcwalton
2014-08-22 15:20:48 +00:00
bors
c9cf3b3cc4 auto merge of #16655 : pcwalton/rust/unboxed-closures-unboxing-shims, r=luqmana
Closes #16591.

r? @luqmana
2014-08-22 13:35:51 +00:00
bors
5fe5e3947b auto merge of #16639 : pcwalton/rust/unboxed-closures-param-resolution, r=nick29581
Closes #16508.

r? @nick29581
2014-08-22 06:50:56 +00:00
Patrick Walton
24a2137269 librustc: Consider where clauses when traversing free regions in
signatures.

Closes #16549.
Closes #16564.
2014-08-21 19:33:29 -07:00
bors
b43596b43e auto merge of #16637 : pcwalton/rust/unboxed-closures-expected-tuple, r=pnkfelix
code wasn't considering the zero-argument case.

Closes #16168.

r? @pnkfelix
2014-08-21 23:10:59 +00:00
Luqman Aden
171c542965 librustc: Mark unboxed closure calls and definitions with appropriate llvm return/argument attributes. 2014-08-21 11:25:47 -07:00
bors
f92015f71b auto merge of #16499 : cmr/rust/struct-undef-repr, r=pcwalton
r? @pcwalton
2014-08-21 17:30:57 +00:00