Commit Graph

3634 Commits

Author SHA1 Message Date
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
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
Steven Fackler
92013a849d Turn on cfg format warnings 2014-09-30 12:52:00 -07: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
8a60952100 Move if let behind a feature gate 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
Kevin Ballard
5d8cfd53b5 Teach libsyntax about if let 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
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
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
bors
40b86baca0 auto merge of #17409 : farcaller/rust/patch-1, r=huonw
Parser.parse_method now has a second argument, I assume ast::Inherited is the correct visibility in this case.
2014-09-29 10:08:04 +00:00
Vladimir Pouzanov
75d49c8203 Fixed quote_method!() implementation
Parser.parse_method now has a second argument, I assume ast::Inherited is the correct visibility in this case.
2014-09-29 09:45:36 +01:00
Keegan McAllister
8826fdfe37 Keep ExpnId abstract by providing conversions 2014-09-28 09:25:48 -07: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
bors
43d7d7c15e auto merge of #17506 : sfackler/rust/cfg-attr, r=alexcrichton
cc #17490 

Reopening of #16230
2014-09-27 01:37:53 +00: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
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
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
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
Steven Fackler
dcdbdc1003 Fix rebase fallout 2014-09-24 00:35:42 -07:00
Steven Fackler
65cca7c8b1 Deprecate #[ignore(cfg(...))]
Replace `#[ignore(cfg(a, b))]` with `#[cfg_attr(all(a, b), ignore)]`
2014-09-23 23:49:20 -07:00
Steven Fackler
e520bb1b2f Add a cfg_attr syntax extension
This extends cfg-gating to attributes.

```rust
 #[cfg_attr(<cfg pattern>, <attr>)]
```
will expand to
```rust
 #[<attr>]
```
if the `<cfg pattern>` matches the current cfg environment, and nothing
if it does not. The grammar for the cfg pattern has a simple
recursive structure:

 * `value` and `key = "value"` are cfg patterns,
 * `not(<cfg pattern>)` is a cfg pattern and matches if `<cfg pattern>`
    does not.
 * `all(<cfg pattern>, ...)` is a cfg pattern and matches if all of the
    `<cfg pattern>`s do.
 * `any(<cfg pattern>, ...)` is a cfg pattern and matches if any of the
    `<cfg pattern>`s do.

Examples:

```rust
 // only derive Show for assert_eq! in tests
 #[cfg_attr(test, deriving(Show))]
 struct Foo { ... }

 // only derive Show for assert_eq! in tests and debug builds
 #[cfg_attr(any(test, not(ndebug)), deriving(Show))]
 struct Foo { ... }

 // ignore a test in certain cases
 #[test]
 #[cfg_attr(all(not(target_os = "linux"), target_endian = "big"), ignore)]
 fn test_broken_thing() { ... }

 // Avoid duplication when fixing staging issues in rustc
 #[cfg_attr(not(stage0), lang="iter")]
 pub trait Iterator<T> { ... }
```
2014-09-23 23:47:45 -07:00
bors
c669411afa auto merge of #17402 : steveklabnik/rust/update_manual, r=brson
Because I'm still 😷 😷 😷 , I figured some mindless tasks would be better than trying to finish the ownership guide. 

The manual has long been waiting for some ❤️ ❤️ ❤️ , and so I gave it a quick once-over. I made small commits in case any of the changes are a bit weird, I mostly did a few things:

1. changed 'manual' to 'reference.' I feel like this name is better. If it's not, It's not a huge deal. it shouldn't be `rust.md` though.
2. word wrapped everything appropriately. Changes 1&2 are in the first commit, so that its' easier to see the changes in the later ones.
3. fixed other small style issues
4. removed references to things that are in the standard library, and not the language itself

There's still lots of gross in here, but I didn't want to pile on too too many changes.

/cc @brson @nikomatsakis
2014-09-23 22:05:38 +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
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
Steve Klabnik
47682f96de manual -> reference & formatting
'reference' sounds better than 'manual' to me here, and rust.html is
certainly wrong.

I also wrapped everything to 80 cols.
2014-09-22 17:54:09 -04:00
bors
8a458181dd auto merge of #17339 : treeman/rust/doc-things, r=alexcrichton
Also some cleanup to conform to documentation style.
2014-09-22 09:05:29 +00:00
bors
d7e1bb5ff4 auto merge of #17415 : jakub-/rust/issue-17383, r=huonw
Fixes #17383.
2014-09-21 01:00:29 +00:00
Jakub Wieczorek
3514737b4c Fix the span for discriminators in non-C-like enums
Fixes #17383.
2014-09-21 01:33:57 +02:00
Mike Boutin
4a767007be libsyntax: Explicit error message for sugared doc comments.
Display an explicit message about items missing after sugared doc
comment attributes. References #2789.
2014-09-20 11:50:59 -04:00
bors
f7fb0f5a17 auto merge of #17319 : kmcallister/rust/method-macro-bt, r=pcwalton
We were leaving these on the stack, causing spurious backtraces.
2014-09-20 04:55:41 +00:00
Alex Crichton
ebe9ec8074 rollup merge of #17379 : pcwalton/keywords-followed-by-double-colon 2014-09-19 10:01:01 -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
1686353650 rollup merge of #17236 : fhahn/issue-16723-multiple-items 2014-09-19 10:00:06 -07:00
Florian Hahn
89b09440d8 Allow syntax extensions to return multiple items, closes #16723.
This patch replaces `MacItem` with `MacItems`.
2014-09-19 11:10:54 +02: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
Patrick Walton
5aa264a14f libsyntax: Disallow keywords followed by ::.
This breaks code that looked like:

    mymacro!(static::foo);

... where `mymacro!` expects a path or expression. Change such macros to
not accept keywords followed by `::`.

Closes #17298.

[breaking-change]
2014-09-18 16:26:47 -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
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
07f4fda598 syntax: use an index in CodeMap instead of Gc for ExpnInfo. 2014-09-18 14:36:18 +03: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
Keegan McAllister
5b42f79ff0 Pop the expansion context after expanding a method macro
We were leaving these on the stack, causing spurious backtraces.

I've confirmed that this test fails without the fix.
2014-09-17 11:18:53 -07:00
bors
4d2af38611 auto merge of #16836 : P1start/rust/closure_ret_bang, r=alexcrichton
Fixes #13490.
2014-09-17 15:51:11 +00:00
Alex Crichton
f4da040e62 rollup merge of #17290 : bkoropoff/issue-17283 2014-09-17 08:49:26 -07:00
Jonas Hietala
a0d502b0ed doc: Remove "see above". 2014-09-17 15:12:58 +02:00
Jonas Hietala
f38f0b2e1a doc: Backticks and spelling mistakes. 2014-09-17 15:02:26 +02:00
Jonas Hietala
9b49ad238d doc: Cleanup.
Remove ~~~ for code block specification. Use /// Over /** */ for doc
blocks.
2014-09-17 11:28:22 +02:00
Nick Cameron
3a01d0f1e3 rebasing fixes 2014-09-17 16:53:20 +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
Brian Koropoff
3863b68df4 Propagate restrictions against struct literals to the RHS of assignments
This prevents confusing errors when accidentally using an assignment
in an `if` expression.  For example:

```rust
fn main() {
    let x = 1u;
    if x = x {
        println!("{}", x);
    }
}
```

Previously, this yielded:

```
test.rs:4:16: 4:17 error: expected `:`, found `!`
test.rs:4         println!("{}", x);
                         ^
```

With this change, it now yields:

```
test.rs:3:8: 3:13 error: mismatched types: expected `bool`, found `()` (expected bool, found ())
test.rs:3     if x = x {
                 ^~~~~
```

Closes issue #17283
2014-09-16 19:21:42 -07:00
Brian Koropoff
99293b16e4 Convert restriction enum into bitflags
This makes having multiple restrictions at once cleaner.
Also drop NO_DOUBLEBAR restriction since it is never used.
2014-09-16 19:21:18 -07:00
bors
b75b0f7923 auto merge of #17223 : retep998/rust/into_string, r=huonw
Replaces some usage of `.to_string()` with `.into_string()`
2014-09-17 01:16:14 +00:00
Aaron Turon
fc525eeb4e Fallout from renaming 2014-09-16 14:37:48 -07:00
bors
3212d70302 auto merge of #17280 : thestinger/rust/heap, r=pcwalton 2014-09-16 04:56:01 +00:00
bors
63eaba24d6 auto merge of #17221 : bkoropoff/rust/strinterner-unsafe, r=sfackler
The `StrInterner::clear()` method takes self immutably but can invalidate references returned by `StrInterner::get_ref`. Since `get_ref` is unused, just remove it.

Closes #17181
2014-09-15 21:56:00 +00:00
Daniel Micay
84b37374bf heap: optimize EMPTY to avoid relocations
Sized deallocation makes it pointless to provide an address that never
overlaps with pointers returned by an allocator. Code can branch on the
capacity of the allocation instead of a comparison with this sentinel.

This improves the situation in #8859, and the remaining issues are only
from the logging API, which should be disabled by default in optimized
release builds anyway along with debug assertions. The remaining issues
are part of #17081.

Closes #8859
2014-09-15 16:48:20 -04: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
Eduard Burtescu
5b2837b918 syntax: document the ptr module. 2014-09-14 04:20:36 +03:00
Eduard Burtescu
f8df4fadc8 syntax: implement in-place folding of P<T> and Vec<T>. 2014-09-14 04:20:35 +03:00
Eduard Burtescu
d379ad111c syntax: tests: fix fallout from using ptr::P. 2014-09-14 03:39:36 +03:00
Eduard Burtescu
ccd8498afb syntax: fix fallout from using ptr::P. 2014-09-14 03:39:36 +03:00
Eduard Burtescu
d6fb338d01 syntax: ast_map: use borrowed references into the AST. 2014-09-14 03:39:36 +03:00
Eduard Burtescu
9259b022f8 syntax: fold: use move semantics for efficient folding. 2014-09-14 03:39:35 +03:00
Eduard Burtescu
cccb6f84a3 syntax: ast: replace Gc<T> (previously @T) with P<T>. 2014-09-14 03:39:35 +03:00
Eduard Burtescu
1872c4c6b5 syntax: add a custom owned smart pointer in ptr::P. 2014-09-14 03:39:35 +03: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
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
Peter Atashian
bcad3a5816 Improve memory usage of libsyntax
Replaces some usage of `.to_string()` with `.into_string()`

Signed-off-by: Peter Atashian <retep998@gmail.com>
2014-09-13 01:13:59 -04:00
Brian Koropoff
26d716a500 Remove unused, unsound method on StrInterner
The string slices returned by `get_ref` can actually be
invalidated by calling `clear`.  Since this method is unused,
it is easiest to simply remove it.

Closes #17181
2014-09-12 21:52:56 -07: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
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
8e61612889 Removing unused extern crates. 2014-09-12 11:24:31 +02: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
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
Steven Fackler
313cb8acae Change ItemModifier and ItemDecorator to traits
For convenience, the traits are implemented for the respective bare
functions. Change code from this:

```rust
ItemDecorator(some_function)
// or
ItemModifier(some_other_function)
```
to
```rust
ItemDecorator(box some_function)
// or
ItemModifier(box some_other_function)
```

[breaking-change]
2014-09-10 09:15: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
bors
a1f4973090 auto merge of #16662 : pczarn/rust/format-fmtstr-opt, r=brson
Based on an observation that strings and arguments are always interleaved, thanks to #15832. Additionally optimize invocations where formatting parameters are unspecified for all arguments, e.g. `"{} {:?} {:x}"`, by emptying the `__STATIC_FMTARGS` array. Next, `Arguments::new` replaces an empty slice with `None` so that passing empty `__STATIC_FMTARGS` generates slightly less machine code when `Arguments::new` is inlined. Furthermore, formatting itself treats these cases separately without making redundant copies of formatting parameters.

All in all, this adds a single mov instruction per `write!` in most cases. That's why code size has increased.
2014-09-09 23:55:43 +00: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
Piotr Czarnecki
5aaa606932 Optimize for the most common cases of format!
Format specs are ignored and not stored in case they're all default.
Restore default formatting parameters during iteration.
Pass `None` instead of empty slices of format specs to take advantage
of non-nullable pointer optimization.

Generate a call to one of two functions of `fmt::Argument`.
2014-09-09 20:34:41 +01:00
Piotr Czarnecki
696367fb8d Decouple string and argument pieces 2014-09-09 20:34:41 +01:00
Alex Crichton
8158463122 rollup merge of #17054 : pcwalton/subslice-syntax 2014-09-09 12:07:12 -07: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
Keegan McAllister
2b3619412f quote: Explicitly borrow the ExtCtxt
Fixes #16992.
2014-09-08 11:30:55 -07:00
Sebastien Martini
8baff54128 Fix deprecate warning "extern crate ... as ..."
Its arguments were inverted.
2014-09-07 17:58:33 +02:00
bors
ee72e46638 auto merge of #17032 : jamesluke/rust/master, r=alexcrichton
"extern create" -> "extern crate"
2014-09-07 09:26:27 +00:00
Daniel Micay
2fdad65a05 fix sized deallocation for OwnedSlice 2014-09-06 13:58:34 -04:00
jamesluke
4755441fd4 Fix documentation typo. 2014-09-05 16:03:58 -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
bors
5248b1187d auto merge of #16990 : DiamondLovesYou/rust/level-derive-clone, r=alexcrichton 2014-09-05 01:21:03 +00:00
Richard Diamond
0dadd3c3ad Auto-derive Clone for syntax::diagnostic::Level. 2014-09-04 13:31:00 -05: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
wickerwaka
2bc4a5e92a Center alignment for fmt
Use '^' to specify center alignment in format strings.

fmt!( "[{:^5s}]", "Hi" ) -> "[ Hi  ]"
fmt!( "[{:^5s}]", "H" )  -> "[  H  ]"
fmt!( "[{:^5d}]", 1i )   -> "[  1  ]"
fmt!( "[{:^5d}]", -1i )  -> "[ -1  ]"
fmt!( "[{:^6d}]", 1i )   -> "[  1   ]"
fmt!( "[{:^6d}]", -1i )  -> "[  -1  ]"

If the padding is odd then the padding on the right will be one
character longer than the padding on the left.

Tuples squashed
2014-09-04 07:38:53 -07: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
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
bors
3768ef477e auto merge of #16891 : eddyb/rust/patlit-from-expr-macros, r=kballard
Enables any macros using `MacExpr` to be treated as patterns when
they produce a literal in the form `ExprLit` (e.g. `stringify!` or `line!`).

Fixes #16876.
2014-09-01 16:45:59 +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
5dfb7a6ec1 auto merge of #16809 : nick29581/rust/dst-bug-3, r=alexcrichton
This corrects a rebasing error. Also adds a test so it won't happen again.

r?
2014-08-31 19:55:51 +00:00
bors
27e8d5bca7 auto merge of #16788 : Manishearth/rust/raw-ptr-syntax-ty, r=huonw
@huonw , r? :)

#16781
2014-08-31 12:50:55 +00:00
Alex Crichton
d1a5b277a1 rollup merge of #16839 : treeman/issue-15358 2014-08-30 23:47:23 -07:00
Eduard Burtescu
a9c3109a6a Allow ExprLit expression macros to be used in patterns. 2014-08-31 01:45:11 +03: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
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
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
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
Alex Crichton
d15d559739 Register new snapshots 2014-08-29 14:33:08 -07: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
Jonas Hietala
5bf1b03e5c Tweak error message for use of a keyword in ident position.
Closes #15358
2014-08-29 10:36:43 +02:00
P1start
b220db03bd Allow ! as the return type of proc/closure literals
Fixes #13490.
2014-08-29 17:24:55 +12:00
Nick Cameron
539237372a Forbid ~str and ~[]
This corrects a rebasing error. Also adds a test so it won't happen again.
2014-08-28 16:05:31 +12:00
Niko Matsakis
1b487a8906 Implement generalized object and type parameter bounds (Fixes #16462) 2014-08-27 21:46:52 -04:00
Manish Goregaokar
2b312eca89 Allow *-pointers in PtrTy (fixes #16781) 2014-08-27 18:49:17 +05:30
bors
5550edef46 auto merge of #16689 : wickerwaka/rust/crate-as, r=pcwalton
For review. Not sure about the link_attrs stuff. Will work on converting all the tests.

extern crate "foobar" as foo;
extern crate foobar as foo;

Implements remaining part of RFC #47.
Addresses issue #16461.

Removed link_attrs from rust.md, they don't appear to be supported by
the parser.
2014-08-27 06:01:18 +00: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
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
6d9b219e6f auto merge of #16646 : P1start/rust/trailing-commas, r=alexcrichton
This lets the parser understand trailing commas in method calls, method definitions, enum variants, and type parameters.

Closes #14240.
Closes #15887.
2014-08-24 22:16:00 +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
wickerwaka
c0e003d5ad extern crate foobar as foo;
Implements remaining part of RFC #47.
Addresses issue #16461.

Removed link_attrs from rust.md, they don't appear to be supported by
the parser.

Changed all the tests to use the new extern crate syntax

Change pretty printer to use 'as' syntax
2014-08-23 12:16:04 -07:00
P1start
fde41a3f70 Add support for trailing commas in more places
This lets the parser understand trailing commas in method calls, method
definitions, enum variants, and type parameters.

Closes #14240.
Closes #15887.
2014-08-23 07:23:51 +12:00
Brian Anderson
bc7a85de29 syntax: Fix complexity of string parsing. Closes #16624. 2014-08-21 15:47:39 -07:00
Corey Richardson
6e8ff99958 librustc: handle repr on structs, require it for ffi, unify with packed
As of RFC 18, struct layout is undefined. Opting into a C-compatible struct
layout is now down with #[repr(C)]. For consistency, specifying a packed
layout is now also down with #[repr(packed)]. Both can be specified.

To fix errors caused by this, just add #[repr(C)] to the structs, and change
 #[packed] to #[repr(packed)]

Closes #14309

[breaking-change]
2014-08-20 21:02:23 -04:00
Piotr Czarnecki
4155643428 Fix double evaluation of read+write operands
Stop read+write expressions from expanding into two occurences
in the AST. Add a bool to indicate whether an operand in output
position if read+write or not.

Fixes #14936
2014-08-19 20:39:26 +01:00
Patrick Walton
67deb2e65e libsyntax: Remove the use foo = bar syntax from the language in favor
of `use bar as foo`.

Change all uses of `use foo = bar` to `use bar as foo`.

Implements RFC #47.

Closes #16461.

[breaking-change]
2014-08-18 09:19:10 -07:00
Jakub Wieczorek
d283574558 Forbid extern statics from appearing in patterns
Fixes #16149.
2014-08-18 00:08:57 +02:00
Patrick Walton
7f928d150e librustc: Forbid external crates, imports, and/or items from being
declared with the same name in the same scope.

This breaks several common patterns. First are unused imports:

    use foo::bar;
    use baz::bar;

Change this code to the following:

    use baz::bar;

Second, this patch breaks globs that import names that are shadowed by
subsequent imports. For example:

    use foo::*; // including `bar`
    use baz::bar;

Change this code to remove the glob:

    use foo::{boo, quux};
    use baz::bar;

Or qualify all uses of `bar`:

    use foo::{boo, quux};
    use baz;

    ... baz::bar ...

Finally, this patch breaks code that, at top level, explicitly imports
`std` and doesn't disable the prelude.

    extern crate std;

Because the prelude imports `std` implicitly, there is no need to
explicitly import it; just remove such directives.

The old behavior can be opted into via the `import_shadowing` feature
gate. Use of this feature gate is discouraged.

This implements RFC #116.

Closes #16464.

[breaking-change]
2014-08-16 19:32:25 -07:00
bors
36db3866c0 auto merge of #16424 : pcwalton/rust/where-clauses, r=nikomatsakis
These `where` clauses are accepted everywhere generics are currently
accepted and desugar during type collection to the type parameter bounds
we have today.

A new keyword, `where`, has been added. Therefore, this is a breaking
change. Change uses of `where` to other identifiers.

[breaking-change]

r? @nikomatsakis (or whoever)
2014-08-15 06:26:23 +00:00
bors
6b5ec40d45 auto merge of #16435 : vadimcn/rust/windows, r=pcwalton
Using "win32" to mean "Windows" is confusing, especially now, that Rust supports win64 builds.
Let's call spade a spade.
2014-08-15 00:46:19 +00:00
Patrick Walton
604af3f6c0 librustc: Implement simple where clauses.
These `where` clauses are accepted everywhere generics are currently
accepted and desugar during type collection to the type parameter bounds
we have today.

A new keyword, `where`, has been added. Therefore, this is a breaking
change. Change uses of `where` to other identifiers.

[breaking-change]
2014-08-14 14:14:26 -07:00
bors
f8e0ede921 auto merge of #16468 : pcwalton/rust/as-renaming-import, r=alexcrichton
The old syntax will be removed after a snapshot.

RFC #47.

Issue #16461.

r? @brson
2014-08-14 21:01:19 +00:00
Patrick Walton
1c16accfc2 libsyntax: Accept use foo as bar; in lieu of use bar as foo;
The old syntax will be removed after a snapshot.

RFC #47.

Issue #16461.
2014-08-14 13:24:50 -07:00
Patrick Walton
9907fa4acc librustc: Stop assuming that implementations and traits only contain
methods.

This paves the way to associated items by introducing an extra level of
abstraction ("impl-or-trait item") between traits/implementations and
methods. This new abstraction is encoded in the metadata and used
throughout the compiler where appropriate.

There are no functional changes; this is purely a refactoring.
2014-08-14 11:40:22 -07:00
bors
404978ea72 auto merge of #16122 : pcwalton/rust/lifetimes-in-unboxed-closures, r=pnkfelix
This patch primarily does two things: (1) it prevents lifetimes from
leaking out of unboxed closures; (2) it allows unboxed closure type
notation, call notation, and construction notation to construct closures
matching any of the three traits.

This breaks code that looked like:

    let mut f;
    {
        let x = &5i;
        f = |&mut:| *x + 10;
    }

Change this code to avoid having a reference escape. For example:

    {
        let x = &5i;
        let mut f; // <-- move here to avoid dangling reference
        f = |&mut:| *x + 10;
    }

I believe this is enough to consider unboxed closures essentially
implemented. Further issues (for example, higher-rank lifetimes) should
be filed as followups.

Closes #14449.

[breaking-change]

r? @pnkfelix
2014-08-14 16:36:19 +00:00
Patrick Walton
8d27232141 librustc: Tie up loose ends in unboxed closures.
This patch primarily does two things: (1) it prevents lifetimes from
leaking out of unboxed closures; (2) it allows unboxed closure type
notation, call notation, and construction notation to construct closures
matching any of the three traits.

This breaks code that looked like:

    let mut f;
    {
        let x = &5i;
        f = |&mut:| *x + 10;
    }

Change this code to avoid having a reference escape. For example:

    {
        let x = &5i;
        let mut f; // <-- move here to avoid dangling reference
        f = |&mut:| *x + 10;
    }

I believe this is enough to consider unboxed closures essentially
implemented. Further issues (for example, higher-rank lifetimes) should
be filed as followups.

Closes #14449.

[breaking-change]
2014-08-14 08:53:25 -07:00
bors
385c39a77b auto merge of #16332 : brson/rust/slicestab, r=aturon
This implements some of the recommendations from https://github.com/rust-lang/meeting-minutes/blob/master/Meeting-API-review-2014-08-06.md.

Explanation in commits.
2014-08-14 05:36:25 +00:00
bors
9d45d63d0d auto merge of #15929 : pcwalton/rust/by-ref-closures, r=alexcrichton
by-reference upvars.

This partially implements RFC 38. A snapshot will be needed to turn this
on, because stage0 cannot yet parse the keyword.

Part of #12831.

r? @alexcrichton
2014-08-14 03:46:22 +00:00
Patrick Walton
a63003fe1a librustc: Parse, but do not fully turn on, the ref keyword for
by-reference upvars.

This partially implements RFC 38. A snapshot will be needed to turn this
on, because stage0 cannot yet parse the keyword.

Part of #12381.
2014-08-13 18:09:14 -07:00
Brian Anderson
bc450b17e3 core: Change the argument order on splitn and rsplitn for strs.
This makes it consistent with the same functions for slices,
and allows the search closure to be specified last.

[breaking-change]
2014-08-13 15:27:37 -07:00
Felix S. Klock II
c3ce245ba6 quote_expr macro: embed Ident using special encoding that preserves hygiene.
This adds support to `quote_expr!` and friends for round-trip hygienic
preservation of Ident.

Here are the pieces of the puzzle:

* adding a method for encoding Ident for re-reading into token tree.

* Support for reading such encoded Idents in the lexer.  Note that one
  must peek ahead for MOD_SEP after scan_embedded_hygienic_ident.

* To ensure that encoded Idents are only read when we are in the midst
  of expanding a `quote_expr` or similar, added a
  `read_embedded_ident` flag on `StringReader`.

* pprust support for encoding Ident's as (uint,uint) pairs (for hygiene).
2014-08-13 17:40:15 +02:00
Patrick Walton
857ba988f1 libsyntax: Don't strip types and lifetimes from single-segment paths in
patterns.

This breaks code like:

    fn main() {
        match Some("foo") {
            None::<int> => {}
            Some(_) => {}
        }
    }

Change this code to not contain a type error. For example:

    fn main() {
        match Some("foo") {
            None::<&str> => {}
            Some(_) => {}
        }
    }

Closes #16353.

[breaking-change]
2014-08-12 10:33:16 -07:00
Vadim Chugunov
3dfd12967a Replace #[cfg(target_os = "win32")] with #[cfg(target_os = "windows")] 2014-08-12 00:13:43 -07:00
Vadim Chugunov
98332b1a06 Replace all references to "Win32" with "Windows".
For historical reasons, "Win32" has been used in Rust codebase to mean "Windows OS in general".
This is confusing, especially now, that Rust supports Win64 builds.

[breaking-change]
2014-08-12 00:10:26 -07:00
Felix S. Klock II
8a80e0fdab Helper method for pprust::State for printing instances of ast_map::Node. 2014-08-09 10:17:40 +02:00
Felix S. Klock II
a9b1a3b40f refactored pprust::State constructor methods out from pprust::print_crate.
(Groundwork for pretty-printing only selected items in an input crate.)
2014-08-09 10:17:40 +02:00
Felix S. Klock II
4c2ff0ab17 ast_map: Added iterator over all node id's that match a path suffix.
This is useful e.g. for tools need a node-id, such as the flowgraph
pretty printer, since it can avoids the need to first pretty-print the
whole expanded,identified input in order to find out what the node-id
actually is.

It currently only supports path suffixes thst are made up of module
names (e.g. you cannot use the type instantiation form `a::<int>::b`
or `option::Option::unwrap_or` as a path suffix for this tool, though
the tool will produce paths that have non-modulues in the portion of
the path that is not included in the suffix).

(addressed review feedback too)
2014-08-09 10:17:31 +02:00
bors
aae7901a78 auto merge of #16285 : alexcrichton/rust/rename-share, r=huonw
This leaves the `Share` trait at `std::kinds` via a `#[deprecated]` `pub use`
statement, but the `NoShare` struct is no longer part of `std::kinds::marker`
due to #12660 (the build cannot bootstrap otherwise).

All code referencing the `Share` trait should now reference the `Sync` trait,
and all code referencing the `NoShare` type should now reference the `NoSync`
type. The functionality and meaning of this trait have not changed, only the
naming.

Closes #16281
[breaking-change]
2014-08-08 03:51:15 +00:00
Alex Crichton
1f760d5d1a Rename Share to Sync
This leaves the `Share` trait at `std::kinds` via a `#[deprecated]` `pub use`
statement, but the `NoShare` struct is no longer part of `std::kinds::marker`
due to #12660 (the build cannot bootstrap otherwise).

All code referencing the `Share` trait should now reference the `Sync` trait,
and all code referencing the `NoShare` type should now reference the `NoSync`
type. The functionality and meaning of this trait have not changed, only the
naming.

Closes #16281
[breaking-change]
2014-08-07 08:54:38 -07:00
Niko Matsakis
fcab98038c Temporary bootstrapping hack: introduce syntax for r egion bounds like 'b:'a,
meaning `'b outlives 'a`. Syntax currently does nothing but is needed for full
fix to #5763. To use this syntax, the issue_5763_bootstrap feature guard is
required.
2014-08-07 07:23:59 -04:00
bors
7be8f0af03 auto merge of #16306 : pnkfelix/rust/fsk-ast-refactor-PatWild, r=alexcrichton
AST refactoring: merge PatWild and PatWildMulti into one variant with a flag
2014-08-07 02:26:07 +00:00
bors
8fe73f1166 auto merge of #16291 : nham/rust/byte_literals, r=alexcrichton
This replaces many instances chars being casted to u8 with byte literals.
2014-08-06 23:41:05 +00:00
Felix S. Klock II
d3202354f5 AST refactoring: merge PatWild and PatWildMulti into one variant with a flag. 2014-08-06 17:04:44 +02:00
nham
dfdea3f116 Use byte literals in libsyntax 2014-08-06 01:31:48 -04:00
Alex Crichton
74ae05ad90 syntax: Handle \r\n in byte string literals
This ended up passing through the lexer but dying later on in parsing when it
wasn't handled. The strategy taken was to copy the `str_lit` funciton, but adapt
it for bytes.

Closes #16278
2014-08-05 17:02:55 -07:00
Falco Hirschenberger
0dc215741b Fixes missing overflow lint for i64 #14269
The `type_overflow` lint, doesn't catch the overflow for `i64` because
the overflow happens earlier in the parse phase when the `u64` as biggest
possible int gets casted to `i64` , without checking the for overflows.
We can't lint in the parse phase, so a refactoring of the `LitInt` type
was necessary.

The types `LitInt`, `LitUint` and `LitIntUnsuffixed` where merged to one
type `LitInt` which stores it's value as `u64`. An additional parameter was
added which indicate the signedness of the type and the sign of the value.
2014-08-05 09:59:03 +02:00
Joseph Crail
ad06dfe496 Fix misspelled comments. 2014-08-01 19:42:52 -04:00
bors
b495933a7f auto merge of #16141 : alexcrichton/rust/rollup, r=alexcrichton 2014-08-01 01:56:32 +00:00
bors
8c00357f9d auto merge of #15999 : Kimundi/rust/fix_folder, r=nikomatsakis
Note: This PR is motivated by an attempt to write an custom syntax extension that tried to use `syntax::fold`, and that could only do so by fixing bugs in it and copying out private functions.

---

Refactored `syntax::fold`

Prior to this, the code there had a few issues:

- Default implementations inconsistenly either had the prefix `noop_` or
  not.
- Some default methods where implemented in terms of a public noop function
  for user code to call, others where implemented directly on the trait
  and did not allow users of the trait to reuse the code.
- Some of the default implementations where private, and thus not reusable
  for other implementors.
- There where some bugs where default implemntations called other default
  implementations directly, rather than to the underlying Folder, with the
  result of some ast nodes never being visted even if the user implemented that
  method. (For example, the current Folder never folded struct fields)

This commit solves this situation somewhat radically by making __all__
`fold_...` functions in the module into Folder methods, and implementing
them all in terms of public `noop_...` functions for other implementors to
call out to.

Some public functions had to be renamed to fit the new system, so this is a
breaking change.

---

Also added a few trait implementations to `ast` types
2014-07-31 16:41:36 +00:00
bors
9826e801be auto merge of #16073 : mneumann/rust/dragonfly2, r=alexcrichton
Not included are two required patches:

* LLVM: segmented stack support for DragonFly [1]

* jemalloc: simple configure patches

[1]: http://reviews.llvm.org/D4705
2014-07-31 14:41:34 +00:00
Brian Anderson
134946d06e rustrt: Make begin_unwind take a single file/line pointer
Smaller text size.
2014-07-31 07:30:17 -07:00
Michael Neumann
e99fc20f95 Fix trailing whitespace 2014-07-31 02:01:16 +02:00
bors
f681420624 auto merge of #15915 : erickt/rust/master, r=alexcrichton
std: rename MemWriter to SeekableMemWriter, add seekless MemWriter

Not all users of MemWriter need to seek, but having MemWriter seekable adds between 3-29% in overhead in certain circumstances. This fixes that performance gap by making a non-seekable MemWriter, and creating a new SeekableMemWriter for those circumstances when that functionality is actually needed.

```
test io::mem::test::bench_buf_reader                        ... bench:       682 ns/iter (+/- 85)
test io::mem::test::bench_buf_writer                        ... bench:       580 ns/iter (+/- 57)
test io::mem::test::bench_mem_reader                        ... bench:       793 ns/iter (+/- 99)
test io::mem::test::bench_mem_writer_001_0000               ... bench:        48 ns/iter (+/- 27)
test io::mem::test::bench_mem_writer_001_0010               ... bench:        65 ns/iter (+/- 27) = 153 MB/s
test io::mem::test::bench_mem_writer_001_0100               ... bench:       132 ns/iter (+/- 12) = 757 MB/s
test io::mem::test::bench_mem_writer_001_1000               ... bench:       802 ns/iter (+/- 151) = 1246 MB/s
test io::mem::test::bench_mem_writer_100_0000               ... bench:       481 ns/iter (+/- 28)
test io::mem::test::bench_mem_writer_100_0010               ... bench:      1957 ns/iter (+/- 126) = 510 MB/s
test io::mem::test::bench_mem_writer_100_0100               ... bench:      8222 ns/iter (+/- 434) = 1216 MB/s
test io::mem::test::bench_mem_writer_100_1000               ... bench:     82496 ns/iter (+/- 11191) = 1212 MB/s
test io::mem::test::bench_seekable_mem_writer_001_0000      ... bench:        48 ns/iter (+/- 2)
test io::mem::test::bench_seekable_mem_writer_001_0010      ... bench:        64 ns/iter (+/- 2) = 156 MB/s
test io::mem::test::bench_seekable_mem_writer_001_0100      ... bench:       129 ns/iter (+/- 7) = 775 MB/s
test io::mem::test::bench_seekable_mem_writer_001_1000      ... bench:       801 ns/iter (+/- 159) = 1248 MB/s
test io::mem::test::bench_seekable_mem_writer_100_0000      ... bench:       711 ns/iter (+/- 51)
test io::mem::test::bench_seekable_mem_writer_100_0010      ... bench:      2532 ns/iter (+/- 227) = 394 MB/s
test io::mem::test::bench_seekable_mem_writer_100_0100      ... bench:      8962 ns/iter (+/- 947) = 1115 MB/s
test io::mem::test::bench_seekable_mem_writer_100_1000      ... bench:     85086 ns/iter (+/- 11555) = 1175 MB/s
```
2014-07-30 14:41:18 +00:00
bors
3ab170ffc5 auto merge of #16037 : erickt/rust/quote_arm, r=acrichto
This adds support for `quote_arm!(cx, $pat => $expr)`, and `macro_rules!(($a:arm) => (...))`. It also fixes a bug in pretty printing, where this would generate invalid code:

```
match { 5i } {
    1 => 2,
    _ => 3,
}
```

It would generate this code:

```
match { 5i } {
    1 => 2
    _ => 3
}
```

Finally, it adds a couple helper methods to `ExtCtxt`.
2014-07-30 13:01:10 +00:00
Erick Tryzelaar
e27b88d5bd remove seek from std::io::MemWriter, add SeekableMemWriter to librustc
Not all users of MemWriter need to seek, but having MemWriter
seekable adds between 3-29% in overhead in certain circumstances.
This fixes that performance gap by making a non-seekable MemWriter,
and creating a new SeekableMemWriter for those circumstances when
that functionality is actually needed.

```
test io::mem::test::bench_buf_reader                        ... bench:       682 ns/iter (+/- 85)
test io::mem::test::bench_buf_writer                        ... bench:       580 ns/iter (+/- 57)
test io::mem::test::bench_mem_reader                        ... bench:       793 ns/iter (+/- 99)
test io::mem::test::bench_mem_writer_001_0000               ... bench:        48 ns/iter (+/- 27)
test io::mem::test::bench_mem_writer_001_0010               ... bench:        65 ns/iter (+/- 27) = 153 MB/s
test io::mem::test::bench_mem_writer_001_0100               ... bench:       132 ns/iter (+/- 12) = 757 MB/s
test io::mem::test::bench_mem_writer_001_1000               ... bench:       802 ns/iter (+/- 151) = 1246 MB/s
test io::mem::test::bench_mem_writer_100_0000               ... bench:       481 ns/iter (+/- 28)
test io::mem::test::bench_mem_writer_100_0010               ... bench:      1957 ns/iter (+/- 126) = 510 MB/s
test io::mem::test::bench_mem_writer_100_0100               ... bench:      8222 ns/iter (+/- 434) = 1216 MB/s
test io::mem::test::bench_mem_writer_100_1000               ... bench:     82496 ns/iter (+/- 11191) = 1212 MB/s
test io::mem::test::bench_seekable_mem_writer_001_0000      ... bench:        48 ns/iter (+/- 2)
test io::mem::test::bench_seekable_mem_writer_001_0010      ... bench:        64 ns/iter (+/- 2) = 156 MB/s
test io::mem::test::bench_seekable_mem_writer_001_0100      ... bench:       129 ns/iter (+/- 7) = 775 MB/s
test io::mem::test::bench_seekable_mem_writer_001_1000      ... bench:       801 ns/iter (+/- 159) = 1248 MB/s
test io::mem::test::bench_seekable_mem_writer_100_0000      ... bench:       711 ns/iter (+/- 51)
test io::mem::test::bench_seekable_mem_writer_100_0010      ... bench:      2532 ns/iter (+/- 227) = 394 MB/s
test io::mem::test::bench_seekable_mem_writer_100_0100      ... bench:      8962 ns/iter (+/- 947) = 1115 MB/s
test io::mem::test::bench_seekable_mem_writer_100_1000      ... bench:     85086 ns/iter (+/- 11555) = 1175 MB/s
```

[breaking-change]
2014-07-29 16:31:39 -07:00
Erick Tryzelaar
e841a88b92 syntax: add support for quoting arms 2014-07-29 16:01:36 -07:00
Erick Tryzelaar
1200ad0f06 Fix a bug pretty printing match { 5i } { _ => { } }
This also always puts a trailing comma on the last non-block expr.
2014-07-29 15:51:03 -07:00
Erick Tryzelaar
a46463d179 syntax: promote a comment on PatEnum into a docstring 2014-07-29 15:51:03 -07:00
Erick Tryzelaar
4d472ff1be syntax: allow quasiquoter to inline Vec<Stmt>s 2014-07-29 15:51:03 -07:00
Erick Tryzelaar
3b7c25ce5b syntax: add some more extension helper methods 2014-07-29 15:51:03 -07:00
Luqman Aden
445340771d libsyntax: Don't ICE on macro invocation in count expr of fixed array type. 2014-07-29 15:43:12 -07:00
Michael Neumann
2e2f53fad2 Port Rust to DragonFlyBSD
Not included are two required patches:

* LLVM: segmented stack support for DragonFly [1]

* jemalloc: simple configure patches

[1]: http://reviews.llvm.org/D4705
2014-07-29 16:44:39 +02:00
Marvin Löbel
da6070dbef Add a few more derivings to AST types 2014-07-29 12:32:32 +02:00
Marvin Löbel
26a39f23ce Refactored syntax::fold.
Prior to this, the code there had a few issues:

- Default implementations inconsistently either had the prefix `noop_` or
  not.
- Some default methods where implemented in terms of a public noop function
  for user code to call, others where implemented directly on the trait
  and did not allow users of the trait to reuse the code.
- Some of the default implementations where private, and thus not reusable
  for other implementors.
- There where some bugs where default implementations called other default
  implementations directly, rather than to the underlying Folder, with the
  result of some AST nodes never being visited even if the user implemented that
  method. (For example, the current Folder never folded struct fields)

This commit solves this situation somewhat radically by making _all_
`fold_...` functions in the module into Folder methods, and implementing
them all in terms of public `noop_...` functions for other implementors to
call out to.

Some public functions had to be renamed to fit the new system, so this is a
breaking change.

[breaking-change]
2014-07-29 12:31:53 +02:00
Patrick Walton
b2eb88843d librustc: Disallow mutation and assignment in pattern guards, and modify
the CFG for match statements.

There were two bugs in issue #14684. One was simply that the borrow
check didn't know about the correct CFG for match statements: the
pattern must be a predecessor of the guard. This disallows the bad
behavior if there are bindings in the pattern. But it isn't enough to
prevent the memory safety problem, because of wildcards; thus, this
patch introduces a more restrictive rule, which disallows assignments
and mutable borrows inside guards outright.

I discussed this with Niko and we decided this was the best plan of
action.

This breaks code that performs mutable borrows in pattern guards. Most
commonly, the code looks like this:

    impl Foo {
        fn f(&mut self, ...) {}
        fn g(&mut self, ...) {
            match bar {
                Baz if self.f(...) => { ... }
                _ => { ... }
            }
        }
    }

Change this code to not use a guard. For example:

    impl Foo {
        fn f(&mut self, ...) {}
        fn g(&mut self, ...) {
            match bar {
                Baz => {
                    if self.f(...) {
                        ...
                    } else {
                        ...
                    }
                }
                _ => { ... }
            }
        }
    }

Sometimes this can result in code duplication, but often it illustrates
a hidden memory safety problem.

Closes #14684.

[breaking-change]
2014-07-25 15:26:21 -07:00
Patrick Walton
caa564bea3 librustc: Stop desugaring for expressions and translate them directly.
This makes edge cases in which the `Iterator` trait was not in scope
and/or `Option` or its variants were not in scope work properly.

This breaks code that looks like:

    struct MyStruct { ... }

    impl MyStruct {
        fn next(&mut self) -> Option<int> { ... }
    }

    for x in MyStruct { ... } { ... }

Change ad-hoc `next` methods like the above to implementations of the
`Iterator` trait. For example:

    impl Iterator<int> for MyStruct {
        fn next(&mut self) -> Option<int> { ... }
    }

Closes #15392.

[breaking-change]
2014-07-24 18:58:12 -07:00
Patrick Walton
3550068b53 librustc: Make bare functions implement the FnMut trait.
This is done entirely in the libraries for functions up to 16 arguments.
A macro is used so that more arguments can be easily added if we need.
Note that I had to adjust the overloaded call algorithm to not try
calling the overloaded call operator if the callee is a built-in
function type, to prevent loops.

Closes #15448.
2014-07-24 07:26:22 -07:00
Patrick Walton
bb165eb5c2 libsyntax: Remove ~self and mut ~self from the language.
This eliminates the last vestige of the `~` syntax.

Instead of `~self`, write `self: Box<TypeOfSelf>`; instead of `mut
~self`, write `mut self: Box<TypeOfSelf>`, replacing `TypeOfSelf` with
the self-type parameter as specified in the implementation.

Closes #13885.

[breaking-change]
2014-07-24 07:26:03 -07:00
Jakub Wieczorek
ad30579ef8 Parser: Global single-segment paths should be represented as PatEnum
Fixed #15774.
2014-07-23 22:15:11 +02:00
bors
62f1bb047b auto merge of #15871 : dotdash/rust/unnamed_fmtstr, r=pcwalton 2014-07-22 09:01:17 +00:00
bors
8d43e4474a auto merge of #15867 : cmr/rust/rewrite-lexer4, r=alexcrichton 2014-07-22 07:16:17 +00:00
Corey Richardson
35c0bf3292 Add a ton of ignore-lexer-test 2014-07-21 18:38:40 -07:00
Marvin Löbel
cef4378269 Refactoring: Only use MacroExpander for expanding outside of
`syntax::ext::expand`
2014-07-22 01:00:03 +02:00
Marvin Löbel
94d92e6830 Moved syntax::ext::base::SyntaxEnv into syntax::ext::base::ExtCtx 2014-07-21 23:45:23 +02:00
Björn Steinbrink
1654f08e03 Allow merging of statics generated by format!() 2014-07-21 21:52:37 +02:00
Corey Richardson
188d889aaf ignore-lexer-test to broken files and remove some tray hyphens
I blame @ChrisMorgan for the hyphens.
2014-07-21 10:59:58 -07:00
root
0e1880d8fe syntax: Join consecutive string literals in format strings together
Emit a single rt::Piece per consecutive string literals. String literals
are split on {{ or }} escapes.

Saves a small amount of static storage and emitted code size.
2014-07-21 09:54:35 -07:00
John Clements
1607064cfe repair macro docs
In f1ad425199, I changed the handling
of macros, to prevent macro invocations from occurring in fully expanded
source. Instead, I added a side table. It contained only the
spans of the macros, because this was the only information required
in order to make macro export work.

However, librustdoc was also affected by this change, since it
extracts macro information in a similar way. As a result of the earlier
change, exported macros were no longer documented.

In order to repair this, I've adjusted the side table to contain whole
items, rather than just the spans.
2014-07-21 09:54:07 -07:00
bors
8748a69e6c auto merge of #15808 : jakub-/rust/use-mod, r=alexcrichton
Implements RFC #168.
2014-07-20 21:06:32 +00:00
bors
c4dd47df34 auto merge of #15805 : Sawyer47/rust/issue-8709, r=alexcrichton
Closes #8709
2014-07-20 19:26:31 +00:00
bors
df997e53af auto merge of #15814 : kvark/rust/ast, r=huonw
Makes working with syntax deriving a bit more pleasuring. For instance, once can use local (non-static) strings anywhere inside `TraitDef` now.
2014-07-20 16:01:32 +00:00
Jakub Wieczorek
4b9bc2e8f2 Implement new mod import sugar
Implements RFC #168.
2014-07-20 12:40:08 +02:00
bors
4f55b52b1a auto merge of #15785 : treeman/rust/fix-15780, r=alexcrichton
Fix for #15780.
2014-07-20 09:31:29 +00:00
Piotr Jawniak
20df4ccafe Correctly stringify! types and paths inside macros
Closes #8709
2014-07-20 08:47:14 +02:00
Alex Crichton
707cf47ac8 Register new snapshots 2014-07-19 20:38:00 -07:00
Dzmitry Malyshau
a2467b945c Fixed lifetimes on syntax deriving structs, implemented Clone 2014-07-19 17:33:17 -04:00
bors
f05a2c97b8 auto merge of #15754 : jakub-/rust/diagnostics, r=alexcrichton 2014-07-19 08:51:34 +00:00
Jonas Hietala
820a55857a Special case for 0 arguments given in format! 2014-07-18 20:39:38 +02:00
Jakub Wieczorek
5274e997ab Assign more diagnostic codes 2014-07-18 20:13:19 +02:00
Jonas Hietala
18717fcf68 Correct plural of arguments in format_args! 2014-07-18 19:25:46 +02:00
Patrick Walton
02adaca4dc librustc: Implement unboxed closures with mutable receivers 2014-07-18 09:01:37 -07:00
bors
d9f1d6b7f6 auto merge of #15732 : bgamari/rust/to-tokens, r=alexcrichton
Here I add a `ToTokens` impl for `Attribute_` and `Option<T>`, as well as generalize the impl for `Vec<T>`
2014-07-18 09:31:22 +00:00
bors
8a308b167f auto merge of #15725 : aochagavia/rust/vec, r=alexcrichton
* Deprecated `to_owned` in favor of `to_vec`
* Deprecated `into_owned` in favor of `into_vec`

[breaking-change]
2014-07-18 03:46:23 +00:00
Patrick Walton
de70d76373 librustc: Remove cross-borrowing of Box<T> to &T from the language,
except where trait objects are involved.

Part of issue #15349, though I'm leaving it open for trait objects.
Cross borrowing for trait objects remains because it is needed until we
have DST.

This will break code like:

    fn foo(x: &int) { ... }

    let a = box 3i;
    foo(a);

Change this code to:

    fn foo(x: &int) { ... }

    let a = box 3i;
    foo(&*a);

[breaking-change]
2014-07-17 14:05:36 -07:00
bors
c4b1077dfb auto merge of #15706 : phi-gamma/rust/master, r=huonw
I kept changes to each file in a separate commit. Please let me know if you prefer them
squashed!
2014-07-17 17:16:23 +00:00
Adolfo Ochagavía
8107ef77f0 Rename functions in the CloneableVector trait
* Deprecated `to_owned` in favor of `to_vec`
* Deprecated `into_owned` in favor of `into_vec`

[breaking-change]
2014-07-17 16:35:48 +02:00
Ben Gamari
e4f8cec416 syntax: Add ToTokens impl for Method 2014-07-17 08:54:43 -04:00
Ben Gamari
a807aa1fca syntax: Add quote_method! 2014-07-17 01:02:27 -04:00
Patrick Walton
fe49cbeb82 libsyntax: Remove Send from PtrTy in deriving.
It'll be complex to port to the new explicit-self regime and it seems to
be unused.
2014-07-16 20:01:53 -07:00
Patrick Walton
357d5cd96c librustc: Implement the fully-expanded, UFCS form of explicit self.
This makes two changes to region inference: (1) it allows region
inference to relate early-bound regions; and (2) it allows regions to be
related before variance runs. The former is needed because there is no
relation between the two regions before region substitution happens,
while the latter is needed because type collection has to run before
variance. We assume that, before variance is inferred, that lifetimes
are invariant. This is a conservative overapproximation.

This relates to #13885. This does not remove `~self` from the language
yet, however.

[breaking-change]
2014-07-16 20:01:52 -07:00
Ben Gamari
96072d6efc syntax: Generalize ToTokens impl for Vec<T>
It will now `flat_map` over the elements of a `Vec<T>` if
`T: ToTokens`
2014-07-16 22:24:42 -04:00
Ben Gamari
8659889ed9 syntax: Add ToTokens for Attribute_ 2014-07-16 22:17:16 -04:00
Ben Gamari
eddc3ccce8 syntax: Add ToTokens for Option<T> 2014-07-16 22:16:55 -04:00
bors
efbbb51ec0 auto merge of #15691 : jbclements/rust/method-field-cleanup, r=alexcrichton
This patch applies the excellent suggestion of @pnkfelix to group the helper methods for method field access into a Trait, making the code much more readable, and much more similar to the way it was before.
2014-07-16 10:26:16 +00:00
Philipp Gesang
778529b13e
obsolete.rs: fix typo in message 2014-07-16 08:01:54 +02:00
Ben Gamari
69ffcdcccf libsyntax::ast: Derive Show impls 2014-07-15 18:54:47 -04:00
John Clements
ca05828cb7 change to new trait style for method field refs
Per @pnkfelix 's suggestion, using a trait to make these
field accesses more readable (and vastly more similar
to the original code.

oops fix new ast_map fix
2014-07-15 14:46:32 -07:00
John Clements
154ca08388 use trait rather than fns
please note the snapshot-waiting unpleasantness. I'm
unable to use the traditional #[cfg(stage0)] mechanism
to swap the new style in for later compiler stages,
because macros invocations in method positions cause
the parser to choke before cfg can strip it out.

Parenthetical note: this problem wouldn't arise with
an interleaved parsing/expansion....
2014-07-15 14:33:14 -07:00
bors
de111e69a8 auto merge of #15615 : jakub-/rust/diagnostics, r=brson 2014-07-15 21:06:12 +00:00
Adolfo Ochagavía
584fbde5d1 Fix errors 2014-07-15 20:34:16 +02:00
Adolfo Ochagavía
211f1caa29 Deprecate str::from_utf8_owned
Use `String::from_utf8` instead

[breaking-change]
2014-07-15 19:55:17 +02:00
Felix S. Klock II
e64f594f10 Extend --pretty flowgraph=ID to include dataflow results in output.
Use one or more of the following `-Z` flag options to tell the
graphviz renderer to include the corresponding dataflow sets (after
the iterative constraint propagation reaches a fixed-point solution):

  * `-Z flowgraph-print-loans` : loans computed via middle::borrowck
  * `-Z flowgraph-print-moves` : moves computed via middle::borrowck::move_data
  * `-Z flowgraph-print-assigns` : assignments, via middle::borrowck::move_data
  * `-Z flowgraph-print-all` : all of the available sets are included.

Fix #15016.

----

This also adds a module, `syntax::ast_map::blocks`, that captures a
common abstraction shared amongst code blocks and procedure-like
things.  As part of this, moved `ast_map.rs` to subdir
`ast_map/mod.rs`, to follow our directory layout conventions.

(incorporated review feedback from huon, acrichto.)
2014-07-15 12:26:56 +02:00
bors
7a6208f2cc auto merge of #15646 : jbclements/rust/method-macros, r=cmr
This patch adds support for macros in method position. It follows roughly the template for Item macros, where an outer `Method` wrapper contains a `Method_` enum which can either be a macro invocation or a standard macro definition. 

One note; adding support for macros that expand into multiple methods is not included here, but should be a simple parser change, since this patch updates the type of fold_macro to return a smallvector of methods.

For reviewers, please pay special attention to the parser changes; these are the ones I'm most concerned about.

Because of the small change to the interface of fold_method, this is a ...

[breaking change]
2014-07-13 19:16:28 +00:00
John Clements
aee5917556 macro expansion for methods
Closes #4621
2014-07-13 10:22:43 -07:00
John Clements
bb333ca392 expansion abstraction 2014-07-13 10:10:38 -07:00
John Clements
2c4b6d6f7d add make_method method to MacResult trait
this allows macro results to be parsed as methods
2014-07-13 10:10:38 -07:00
John Clements
6c8bb5a68a macro in method position parsing 2014-07-13 10:10:38 -07:00
John Clements
6ee2155fe0 remove no-stmt check
nothing wrong with a statement expanding into 0 stmts, that I can see.
2014-07-13 10:10:38 -07:00
John Clements
c4cc3ba130 update fold_method to return a smallvector
This is nice for macros, to allow them to expand into multiple methods
2014-07-13 10:10:38 -07:00
John Clements
b293a6604b macro method unit test case fix 2014-07-13 10:10:27 -07:00
John Clements
b0b4b3122a refactor Method definition to make space for macros
This change propagates to many locations, but because of the
Macro Exterminator (or, more properly, the invariant that it
protects), macro invocations can't occur downstream of expansion.
This means that in librustc and librustdoc, extracting the
desired field can simply assume that it can't be a macro
invocation. Functions in ast_util abstract over this check.
2014-07-13 10:08:27 -07:00
bors
13dc0d7938 auto merge of #15584 : alexcrichton/rust/warn-annoyances, r=cmr
* Don't warn about `#[crate_name]` if `--crate-name` is specified
* Don't warn about non camel case identifiers on `#[repr(C)]` structs
* Switch `mode` to `mode_t` in libc.
2014-07-13 04:46:31 +00:00
Corey Richardson
2dfbe7f989 Use a nicer Show impl for Name 2014-07-12 20:31:55 -07:00
bors
ad7ef8c27c auto merge of #15621 : sfackler/rust/attr-span, r=cmr
They used to be one token too long, so you'd see things like
```
rust/rust/test.rs:1:1: 2:2 warning: unused attribute,
rust/rust/test.rs:1 #![foo]
rust/rust/test.rs:2 #![bar]
```
instead of
```
test.rs:1:1: 1:8 warning: unused attribute, #[warn(unused_attribute)] on
by default
test.rs:1 #![foo]
          ^~~~~~~
```
2014-07-13 03:01:32 +00:00
Jakub Wieczorek
a5fe176e97 Convert a first batch of diagnostics to have error codes 2014-07-12 21:53:34 +02:00
bors
f2d251d12e auto merge of #15610 : brson/rust/0.12.0, r=alexcrichton 2014-07-12 18:06:36 +00:00
bors
cdd6346f45 auto merge of #15601 : jbclements/rust/disable-default-macro-behavior, r=alexcrichton
Our AST definition can include macro invocations, which can expand into all kinds of things. Macro invocations are expanded away during expansion time, and the rest of the compiler doesn't have to deal with them. However, we have no way of enforcing this.

This patch adds two protective mechanisms.

First, it adds a (quick) explicit check that ensures there are no macro invocations remaining in the AST after expansion. Second, it updates the visit and fold mechanisms so that by default, they will not traverse macro invocations. It's easy enough to add this, if desired (it's documented in the source, and examples appear, e.g. in the IdentFinder.

Along the way, I also consulted with @sfackler to refactor the macro export mechanism so that it stores macro text spans in a side table, rather than leaving them in the AST.
2014-07-12 11:06:39 +00:00
Steven Fackler
52ccab1405 Fix spans for attributes
They used to be one token too long, so you'd see things like
```
rust/rust/test.rs:1:1: 2:2 warning: unused attribute,
rust/rust/test.rs:1 #![foo]
rust/rust/test.rs:2 #![bar]
```
instead of
```
test.rs:1:1: 1:8 warning: unused attribute, #[warn(unused_attribute)] on
by default
test.rs:1 #![foo]
          ^~~~~~~
```
2014-07-11 15:26:26 -07:00
Brian Anderson
fa2d220567 Update doc URLs for version bump 2014-07-11 11:21:57 -07:00
John Clements
c253b3675a add Macro Exterminator
the Macro Exterminator ensures that there are no macro invocations in
an AST. This should help make later passes confident that there aren't
hidden items, methods, expressions, etc.
2014-07-11 10:32:42 -07:00
John Clements
53642eed80 make walk/visit_mac opt-in only
macros can expand into arbitrary items, exprs, etc. This
means that using a default walker or folder on an AST before
macro expansion is complete will miss things (the things that
the macros expand into). As a partial fence against this, this
commit moves the default traversal of macros into a separate
procedure, and makes the default trait implementation signal
an error. This means that Folders and Visitors can traverse
macros if they want to, but they need to explicitly add an
impl that calls the walk_mac or fold_mac procedure

This should prevent problems down the road.
2014-07-11 10:32:41 -07:00
John Clements
f1ad425199 use side table to store exported macros
Per discussion with @sfackler, refactored the expander to
change the way that exported macros are collected. Specifically,
a crate now contains a side table of spans that exported macros
go into.

This has two benefits. First, the encoder doesn't need to scan through
the expanded crate in order to discover exported macros. Second, the
expander can drop all expanded macros from the crate, with the pleasant
result that a fully expanded crate contains no macro invocations (which
include macro definitions).
2014-07-11 10:32:41 -07:00
John Clements
50d9965c25 rename one of the two confusing MacroExpanders
There were two things named MacroExpander, which was confusing. I renamed
one of them TTMacroExpander.

[breaking change]
2014-07-11 10:32:30 -07:00
Felix S. Klock II
5cee57869c Removed dead structures after changes to PartialOrd/Ord derivings.
Remove the `NonMatchesExplode` variant now that no deriving impl uses it.
Removed `EnumNonMatching` entirely.
Remove now irrelevant `on_matching` field and `HandleNonMatchingEnums` type.
Removed unused `EnumNonMatchFunc` type def.

Drive-by: revise `EnumNonMatchCollapsedFunc` doc.

Made all calls to `expand_enum_method_body` go directly to
`build_enum_match_tuple`.

Alpha-rename `enum_nonmatch_g` back to `enum_nonmatch_f` to reduce overall diff noise.
Inline sole call of `some_ordering_const`.
Inline sole call of `ordering_const`.

Removed a bunch of code that became dead after the above changes.
2014-07-11 17:32:23 +02:00
Felix S. Klock II
c8ae44682d O(n*k) code-size deriving on enums (better than previous O(n^k)).
In the above formulas, `n` is the number of variants, and `k` is the
number of self-args fed into deriving.  In the particular case of
interest (namely `PartialOrd` and `Ord`), `k` is always 2, so we are
basically comparing `O(n)` versus `O(n^2)`.

Also, the stage is set for having *all* enum deriving codes go through
`build_enum_match_tuple` and getting rid of `build_enum_match`.

Also, seriously attempted to clean up the code itself.  Added a bunch
of comments attempting to document what I learned as I worked through
the original code and adapted it to this new strategy.
2014-07-11 17:32:18 +02:00
Felix S. Klock II
5d1bdc320b Revise the const_nonmatching flag with more info about author's intent.
In particular, I want authors of deriving modes to understand what
they are opting into (namely quadratic code size or worse) when they
select NonMatchesExplode.
2014-07-11 17:01:01 +02:00
Jakub Wieczorek
9b9cce2316 Add scaffolding for assigning alpha-numeric codes to rustc diagnostics 2014-07-11 00:32:00 +02:00
bors
898701cb35 auto merge of #15556 : alexcrichton/rust/snapshots, r=brson
Closes #15544
2014-07-10 03:21:30 +00:00
bors
1b8e671d74 auto merge of #15514 : luqmana/rust/die-advance-die, r=cmr
Closes #15492.
2014-07-09 23:51:27 +00:00
Luqman Aden
9e123c4056 libsyntax: Remove uses of advance. 2014-07-09 15:51:58 -07:00
Alex Crichton
6f8b6c8c36 syntax: De-doc comment to fix nightlies
This reverts the promotion from line-comment to doc-comment in 4989a56 to fix
the compiler-docs target.

Closes #15553
2014-07-09 14:44:40 -07:00
Alex Crichton
0c71e0c596 Register new snapshots
Closes #15544
2014-07-09 10:57:58 -07:00
Corey Richardson
69a0cdf491 Fix all the test fallout 2014-07-09 00:49:54 -07:00
Corey Richardson
092c5078be ast: make Name its own type 2014-07-09 00:49:54 -07:00
Corey Richardson
f512779554 lexer: lex WS/COMMENT/SHEBANG rather than skipping
Now, the lexer will categorize every byte in its input according to the
grammar. The parser skips over these while parsing, thus avoiding their
presence in the input to syntax extensions.
2014-07-09 00:06:29 -07:00
Corey Richardson
cc4213418e syntax: don't parse numeric literals in the lexer
This removes a bunch of token types. Tokens now store the original, unaltered
numeric literal (that is still checked for correctness), which is parsed into
an actual number later, as needed, when creating the AST.

This can change how syntax extensions work, but otherwise poses no visible
changes.

[breaking-change]
2014-07-09 00:06:29 -07:00
Corey Richardson
9f5e21da4e syntax: don't process string/char/byte/binary lits
This shuffles things around a bit so that LIT_CHAR and co store an Ident
which is the original, unaltered literal in the source. When creating the AST,
unescape and postprocess them.

This changes how syntax extensions can work, slightly, but otherwise poses no
visible changes. To get a useful value out of one of these tokens, call
`parse::{char_lit, byte_lit, bin_lit, str_lit}`

[breaking-change]
2014-07-09 00:06:29 -07:00
Corey Richardson
bf04a7ccb1 ast: add an as_str method to Ident
This is technically unsafe but interned strings are considered immortal.
2014-07-09 00:06:29 -07:00
Corey Richardson
c8a02527ae lexer: add ident_from and ident_from_to methods 2014-07-09 00:06:29 -07:00
Corey Richardson
47fe8aa6bf lexer: shuffle around some functions 2014-07-09 00:06:29 -07:00
Corey Richardson
5f970e690f codemap: be less annoying in debug logging 2014-07-09 00:06:29 -07:00
Corey Richardson
ae9a92bd4e syntax: use a better Show impl for Ident
Rather than just dumping the id in the interner, which is useless, actually
print the interned string. Adjust the lexer logging to use Show instead of
Poly.
2014-07-09 00:06:29 -07:00
Corey Richardson
91357a9c4e token: replace ast::Ident with just Ident 2014-07-09 00:06:28 -07:00
Corey Richardson
4989a56448 syntax: doc comments all the things 2014-07-09 00:06:27 -07:00
John Clements
19e718b34d carry self ident forward through re-parsing
formerly, the self identifier was being discarded during parsing, which
stymies hygiene. The best fix here seems to be to attach a self identifier
to ExplicitSelf_, a change that rippled through the rest of the compiler,
but without any obvious damage.
2014-07-08 16:28:21 -07:00
John Clements
69c27546ee macro literals should be compared by name only 2014-07-08 16:27:38 -07:00
John Clements
48c3e5f740 comments 2014-07-08 16:27:38 -07:00
John Clements
7f575186f9 remove outdated comment
I believe this comment is now irrelevant, as a result of
commit 6757053cff
2014-07-08 16:27:37 -07:00
John Clements
e59dd484c2 implement hygiene for method args 2014-07-08 16:27:37 -07:00
John Clements
8f34b21375 test case for expansion of method macro 2014-07-08 16:27:34 -07:00
John Clements
9ee9c49cb4 introducing let-syntax
The let-syntax expander is different in that it doesn't apply
a mark to its token trees before expansion. This is used
for macro_rules, and it's because macro_rules is essentially
MTWT's let-syntax. You don't want to mark before expand sees
let-syntax, because there's no "after" syntax to mark again.

In some sense, the cleaner approach might be to introduce a new
AST node that macro_rules expands into; this would make it clearer
that the expansion of a macro is distinct from the addition of a
new macro binding.

This should work for now, though...
2014-07-08 16:26:43 -07:00
John Clements
92c2ff6d69 self arg macro test case 2014-07-08 15:15:46 -07:00
John Clements
6007797ed6 replace idents with names 2014-07-08 15:15:46 -07:00
John Clements
c1b8b3c35c get rid of keyword idents, replace with names
should prevent future bugs
2014-07-08 15:15:46 -07:00
John Clements
06b64345d6 preserve context in parsing of self varref 2014-07-08 15:14:46 -07:00
John Clements
728b269199 remove unused fn, make SELF_KEYWORD_NAME public 2014-07-08 15:14:46 -07:00
John Clements
29b3f29820 test harness cleanup 2014-07-08 15:14:46 -07:00
John Clements
9f94f823b0 change if/else to match 2014-07-08 15:14:45 -07:00
John Clements
f3fa836939 added test for method arg hygiene 2014-07-08 15:14:45 -07:00
bors
8bb34a3146 auto merge of #15493 : brson/rust/tostr, r=pcwalton
This updates https://github.com/rust-lang/rust/pull/15075.

Rename `ToStr::to_str` to `ToString::to_string`. The naive renaming ends up with two `to_string` functions defined on strings in the prelude (the other defined via `collections::str::StrAllocating`). To remedy this I removed `StrAllocating::to_string`, making all conversions from `&str` to `String` go through `Show`. This has a measurable impact on the speed of this conversion, but the sense I get from others is that it's best to go ahead and unify `to_string` and address performance for all `to_string` conversions in `core::fmt`. `String::from_str(...)` still works as a manual fast-path.

Note that the patch was done with a script, and ended up renaming a number of other `*_to_str` functions, particularly inside of rustc. All the ones I saw looked correct, and I didn't notice any additional API breakage.

Closes #15046.
2014-07-08 20:06:40 +00:00
Richo Healey
12c334a77b std: Rename the ToStr trait to ToString, and to_str to to_string.
[breaking-change]
2014-07-08 13:01:43 -07:00
Nick Cameron
a0cfda53c4 Change DST syntax: type -> Sized?
closes #13367

[breaking-change] Use `Sized?` to indicate a dynamically sized type parameter or trait (used to be `type`). E.g.,

```
trait Tr for Sized? {}

fn foo<Sized? X: Share>(x: X) {}
```
2014-07-08 22:44:31 +12:00
Jakub Wieczorek
947942e42c Improve non-exhaustive pattern witnesses for structs with multiple fields 2014-07-07 22:00:34 +02:00
Alex Crichton
e44c2b9bbc Add #[crate_name] attributes as necessary 2014-07-05 12:45:42 -07:00
Alex Crichton
50ee1ec1b4 rustc: Remove CrateId and all related support
This commit removes all support in the compiler for the #[crate_id] attribute
and all of its derivative infrastructure. A list of the functionality removed is:

* The #[crate_id] attribute no longer exists
* There is no longer the concept of a version of a crate
* Version numbers are no longer appended to symbol names
* The --crate-id command line option has been removed

To migrate forward, rename #[crate_id] to #[crate_name] and only the name of the
crate itself should be mentioned. The version/path of the old crate id should be
removed.

For a transitionary state, the #[crate_id] attribute is still accepted if
the #[crate_name] is not present, but it is warned about if it is the only
identifier present.

RFC: 0035-remove-crate-id
[breaking-change]
2014-07-05 12:38:42 -07:00
bors
98eb5f7498 auto merge of #15428 : phildawes/rust/master, r=huonw
Fix small bug introduced in e38cb972dc: PatIdent span was incorrect
because self.last_span was being used before the ident token was
parsed.
2014-07-05 14:41:44 +00:00
bors
c8bbba9a4b auto merge of #15427 : aochagavia/rust/parse, r=pcwalton 2014-07-05 12:56:44 +00:00
bors
29d6a8ecc6 auto merge of #15425 : jbclements/rust/hygiene-for-3-kinds-of-args, r=cmr
This pull request adds hygiene for 3 kinds of argument bindings:
- arguments to item fns,
- arguments to `ExprFnBlock`s, and
- arguments to `ExprProc`s

It also adds a bunch of unit tests, fixes a few macro uses to be non-capturing, and has a few cleanup items.

local `make check` succeeds.
2014-07-05 03:16:50 +00:00
Phil Dawes
9deeaefdbb Parser: fix PatIdent span bug
Fix small bug introduced in e38cb972dc: PatIdent span was incorrect
because self.last_span was being used before the ident token was
parsed.
2014-07-04 21:54:42 +01:00
Adolfo Ochagavía
45e52a13e8 Removed unnecessary method in test 2014-07-04 22:39:50 +02:00
John Clements
cc13f9bae8 implement hygiene for ExprFnBlock and ExprProc 2014-07-04 13:20:14 -07:00
John Clements
ff9995e089 added test cases for closure arg hygiene 2014-07-04 13:20:14 -07:00
John Clements
63fb7c6f40 comments only 2014-07-04 13:20:14 -07:00
John Clements
0ba15c99f3 hygiene for item fn args
also, introduce fn_decl_arg_bindings and expand_and_rename abstractions
2014-07-04 13:20:14 -07:00
John Clements
92708322fd comments & test cases for IdentRenamers 2014-07-04 13:20:14 -07:00
John Clements
6bee3c87c9 use PatIdentRenamer for match bindings 2014-07-04 13:20:13 -07:00
John Clements
35175f015f comments only 2014-07-04 13:20:13 -07:00
John Clements
aa91ef0cf8 new_mark -> apply_mark, new_rename -> apply_rename 2014-07-04 13:20:06 -07:00
John Clements
b8cd7f7c6d add PatIdentRenamer 2014-07-04 12:08:04 -07:00
John Clements
9fdaa948c0 move RenameList to mtwt, add new_renames abstraction 2014-07-04 12:07:51 -07:00
John Clements
f126eacd11 comments, whitespace, rename NameFinderContext to PatIdentFinder 2014-07-04 12:05:43 -07:00
Patrick Walton
29ec2506ab librustc: Remove the &LIFETIME EXPR production from the language.
This was parsed by the parser but completely ignored; not even stored in
the AST!

This breaks code that looks like:

    static X: &'static [u8] = &'static [1, 2, 3];

Change this code to the shorter:

    static X: &'static [u8] = &[1, 2, 3];

Closes #15312.

[breaking-change]
2014-07-04 00:56:57 -07:00
bors
5b11610ced auto merge of #15343 : alexcrichton/rust/0.11.0-release, r=brson 2014-07-04 01:21:19 +00:00
John Clements
4358bf8bfa simplify and uncomment item-fn-arg hygiene unit test 2014-07-03 17:32:35 -07:00
Piotr Jawniak
2f355b79dd Simplify creating a parser from a token tree
Closes #15306
2014-07-03 12:54:52 -07:00
Joseph Crail
e3fa23bcb6 Fix spelling errors. 2014-07-03 12:54:51 -07:00
Kevin Ballard
b81905eedb Fix ICE with nested macro_rules!-style macros
Fixes #10536.
2014-07-03 12:54:51 -07:00
John Clements
e38cb972dc Simplify PatIdent to contain an Ident rather than a Path
Rationale: for what appear to be historical reasons only, the PatIdent contains
a Path rather than an Ident.  This means that there are many places in the code
where an ident is artificially promoted to a path, and---much more problematically---
a bunch of elements from a path are simply thrown away, which seems like an invitation
to some really nasty bugs.

This commit replaces the Path in a PatIdent with a SpannedIdent, which just contains an ident
and a span.
2014-07-03 12:54:51 -07:00
Alex Crichton
ff1dd44b40 Merge remote-tracking branch 'origin/master' into 0.11.0-release
Conflicts:
	src/libstd/lib.rs
2014-07-02 11:08:21 -07:00
Brian Anderson
d21336ee0a rustc: Remove &str indexing from the language.
Being able to index into the bytes of a string encourages
poor UTF-8 hygiene. To get a view of `&[u8]` from either
a `String` or `&str` slice, use the `as_bytes()` method.

Closes #12710.

[breaking-change]
2014-07-01 19:12:29 -07:00
Steven Fackler
55cae0a094 Implement RFC#28: Add PartialOrd::partial_cmp
I ended up altering the semantics of Json's PartialOrd implementation.
It used to be the case that Null < Null, but I can't think of any reason
for an ordering other than the default one so I just switched it over to
using the derived implementation.

This also fixes broken `PartialOrd` implementations for `Vec` and
`TreeMap`.

RFC: 0028-partial-cmp
2014-06-29 21:42:09 -07:00
Patrick Walton
a5bb0a3a45 librustc: Remove the fallback to int for integers and f64 for
floating point numbers for real.

This will break code that looks like:

    let mut x = 0;
    while ... {
        x += 1;
    }
    println!("{}", x);

Change that code to:

    let mut x = 0i;
    while ... {
        x += 1;
    }
    println!("{}", x);

Closes #15201.

[breaking-change]
2014-06-29 11:47:58 -07:00
bors
fe8bc17801 auto merge of #15208 : alexcrichton/rust/snapshots, r=pcwalton
This change registers new snapshots, allowing `*T` to be removed from the language. This is a large breaking change, and it is recommended that if compiler errors are seen that any FFI calls are audited to determine whether they should be actually taking `*mut T`.
2014-06-28 20:11:34 +00:00
Alex Crichton
0dfc90ab15 Rename all raw pointers as necessary 2014-06-28 11:53:58 -07:00
bors
de337f3ddf auto merge of #15191 : pcwalton/rust/variance-in-trait-matching, r=huonw
I believe that #5781 got fixed by the DST work. It duplicated the
variance inference work in #12828. Therefore, all that is left in #5781
is adding a test.

Closes #5781.

r? @huonw
2014-06-28 18:21:34 +00:00
Patrick Walton
05e3248a79 librustc: Match trait self types exactly.
This can break code that looked like:

    impl Foo for Box<Any> {
        fn f(&self) { ... }
    }

    let x: Box<Any + Send> = ...;
    x.f();

Change such code to:

    impl Foo for Box<Any> {
        fn f(&self) { ... }
    }

    let x: Box<Any> = ...;
    x.f();

That is, upcast before calling methods.

This is a conservative solution to #5781. A more proper treatment (see
the xfail'd `trait-contravariant-self.rs`) would take variance into
account. This change fixes the soundness hole.

Some library changes had to be made to make this work. In particular,
`Box<Any>` is no longer showable, and only `Box<Any+Send>` is showable.
Eventually, this restriction can be lifted; for now, it does not prove
too onerous, because `Any` is only used for propagating the result of
task failure.

This patch also adds a test for the variance inference work in #12828,
which accidentally landed as part of DST.

Closes #5781.

[breaking-change]
2014-06-28 11:18:37 -07:00
bors
0ddf6f4b7c auto merge of #15233 : jbclements/rust/match-var-hygiene-etc, r=cmr
This PR includes two big things and a bunch of little ones.

1) It enables hygiene for variables bound by 'match' expressions.
2) It fixes a bug discovered indirectly (#15221), wherein fold traversal failed to visit nonterminal nodes.
3) It fixes a small bug in the macro tutorial.

It also adds tests for the first two, and makes a bunch of small comment improvements and cleanup.
2014-06-28 05:21:34 +00:00
John Clements
04ced031ad comments only 2014-06-27 22:14:22 -07:00
John Clements
e3361bcbc2 adjust fold to fold over interpolated items/exprs/etc.
Closes #15221
2014-06-27 22:14:13 -07:00
John Clements
268f6c56c2 removed incomplete comment
as written, I don't believe this comment was helpful; I think it's
better just to steer the reader toward a general understanding of
hygiene.
2014-06-27 22:11:11 -07:00
John Clements
351a5fd2b4 added unit and standalone test for 15221, extra debugging output 2014-06-27 22:10:43 -07:00
John Clements
e100d26d1d undo helpful attempt to spell-check
Yes, that word is spelled \'memoization\'
2014-06-27 22:08:58 -07:00
John Clements
235ca1801e remove trailing whitespace 2014-06-27 22:08:57 -07:00
John Clements
4b46c700f4 hygiene for match-bound vars now implemented
Closes #9384
2014-06-27 22:08:57 -07:00
John Clements
7bad96e742 improve match test case to include guard 2014-06-27 22:08:51 -07:00
John Clements
47eec97cda remove unnecessary abstraction 2014-06-27 21:41:17 -07:00
John Clements
977b380cd2 cleanup and shiny new more-functional interface 2014-06-27 21:41:17 -07:00
John Clements
a18a63185c WIP match hygiene, compiles 2014-06-27 21:41:17 -07:00