Commit Graph

4286 Commits

Author SHA1 Message Date
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
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
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
Eduard Burtescu
b06212864f rustc: fix fallout from using ptr::P. 2014-09-14 04:20:34 +03: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
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
225353d8bb Add a Rust string ostream for LLVM 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
Luqman Aden
a152d5fced librustc: Enum nullable pointer opt should not apply to raw pointers. 2014-09-11 21:58:01 -04: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
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
f2c78dabf5 Use DWARF4 on Windows. 2014-09-10 16:52:23 -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
fb3c67a65c rollup merge of #17040 : kmcallister/borrow-extctxt 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
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
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
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
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
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
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
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
Nick Cameron
2df3a5b0d1 Check concrete type in impls with no trait
closes #16955
2014-09-05 14:38:37 +12: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
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
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
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
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
P1start
5bc27d5214 Change rustc to say array instead of vector 2014-08-31 19:55:32 +12: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
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