Commit Graph

6182 Commits

Author SHA1 Message Date
Niko Matsakis
d82d4b66f2 tolerate None return from get_line 2017-01-17 17:56:03 -05:00
Esteban Küber
fc774e629f Teach Diagnostics to highlight text 2017-01-17 14:28:53 -08:00
Jeffrey Seyfried
0b9e26f390 Fix fallout in rustdoc. 2017-01-17 21:06:45 +00:00
Jeffrey Seyfried
4c98e1bc59 Remove the lookahead buffer. 2017-01-17 21:06:44 +00:00
bors
a167c042ab Auto merge of #39110 - petrochenkov:sum, r=eddyb
Merge ObjectSum and PolyTraitRef in AST/HIR + some other refactoring

`ObjectSum` and `PolyTraitRef` are the same thing (list of bounds), they exist separately only due to parser quirks. The second commit merges them.

The first commit replaces `Path` with `Ty` in (not yet supported) equality predicates. They are parsed as types anyway and arbitrary types can always be disguised as paths using aliases, so this doesn't add any new functionality.

The third commit uses `Vec` instead of `P<[T]>` in AST. AST is not immutable like HIR and `Vec`s are more convenient for it, unnecessary conversions are also avoided.

The last commit renames `parse_ty_sum` (which is used for parsing types in general) into `parse_ty`, and renames `parse_ty` (which is used restricted contexts where `+` is not permitted due to operator priorities or other reasons) into `parse_ty_no_plus`.

This is the first part of https://github.com/rust-lang/rust/issues/39085#issuecomment-272743755 and https://github.com/rust-lang/rust/issues/39080 focused on data changes and mechanical renaming, I'll submit a PR with parser changes a bit later.

r? @eddyb
2017-01-17 12:31:15 +00:00
Jeffrey Seyfried
57c0ed097c Avoid interpolated token trees. 2017-01-17 08:17:28 +00:00
Jeffrey Seyfried
6a9248fc15 Clean up ext::tt::transcribe. 2017-01-17 08:17:28 +00:00
Jeffrey Seyfried
debcbf0b8e Refactor the parser to consume token trees. 2017-01-17 08:17:26 +00:00
Jeffrey Seyfried
de46b24758 Introduce string_reader.parse_all_token_trees(). 2017-01-17 08:16:49 +00:00
Jeffrey Seyfried
6466f55ebc Give the StringReader a sess: &ParseSess. 2017-01-17 08:16:47 +00:00
Vadim Petrochenkov
66ef5f2bb5 Rename ObjectSum into TraitObject in AST/HIR 2017-01-17 10:41:44 +03:00
Austin Bonander
68439614ba Fix feature_gate::find_lang_feature_issue() to not use unwrap() 2017-01-16 22:41:22 -08:00
Austin Bonander
375cbd20cf Implement #[proc_macro_attribute]
* Add support for `#[proc_macro]`

* Reactivate `proc_macro` feature and gate `#[proc_macro_attribute]` under it

* Have `#![feature(proc_macro)]` imply `#![feature(use_extern_macros)]`,
error on legacy import of proc macros via `#[macro_use]`
2017-01-16 22:41:22 -08:00
bors
31dee37a15 Auto merge of #39090 - solson:exprkind-array, r=eddyb
Rename ExprKind::Vec to Array in HIR and HAIR.

This is a clearer name since they represent `[a, b, c]` array literals.

r? @eddyb
2017-01-17 05:55:56 +00:00
Jeffrey Seyfried
f2d1407743 Remove field tokens_consumed of Parser. 2017-01-17 03:14:42 +00:00
Vadim Petrochenkov
869b81646d syntax: Rename parse_ty -> parse_ty_no_plus, parse_ty_sum -> parse_ty 2017-01-17 02:13:41 +03:00
Vadim Petrochenkov
03620dba25 Use resizable Vec instead of P<[T]> in AST 2017-01-17 01:54:59 +03:00
Vadim Petrochenkov
2efe865d22 AST/HIR: Merge ObjectSum and PolyTraitRef 2017-01-17 01:52:47 +03:00
Vadim Petrochenkov
828404684b AST/HIR: Replace Path with Type in WhereEqPredicate 2017-01-16 21:32:13 +03:00
Scott Olson
a9f8f98caa Rename ExprKind::Vec to Array in HIR and HAIR.
This is a clearer name since they represent [a, b, c] array literals.
2017-01-16 00:45:51 -08:00
est31
7821ea8391 Mark the pushpop_unsafe feature as "removed"
This marks the pushpop_unsafe feature as removed inside the feature_gate.
It was added in commit 1829fa5199 and then
removed again in commit d399098fd8 .
Seems that the second commit forgot to mark it as removed in feature_gate.rs.

This enables us to remove another element from the whitelist of non gate
tested unstable lang features (issue #39059).
2017-01-15 02:17:26 +01:00
est31
530b5c860b Remove the safe_suggestion feature
This removes the safe_suggestion feature from feature_gate.rs.
It was added in commit 164f0105bb
and then removed again in commit c11fe553df .

As the removal was in the same PR #38099 as the addition, we don't move it to
the "removed" section.

Removes an element from the whitelist of non gate tested unstable lang features (issue #39059).
2017-01-15 02:15:38 +01:00
bors
e357178146 Auto merge of #38814 - Ralith:cfg-fields, r=jseyfried
syntax: enable attributes and cfg on struct fields

This enables conditional compilation of field initializers in a struct literal, simplifying construction of structs whose fields are themselves conditionally present. For example, the intializer for the constant in the following becomes legal, and has the intuitive effect:

```rust
struct Foo {
    #[cfg(unix)]
    bar: (),
}

const FOO: Foo = Foo {
    #[cfg(unix)]
    bar: (),
};
```

It's not clear to me whether this calls for the full RFC process, but the implementation was simple enough that I figured I'd begin the conversation with code.
2017-01-12 20:44:02 +00:00
Benjamin Saunders
7972c1905b syntax: struct field attributes and cfg 2017-01-11 21:33:17 -08:00
Andrew Paseltiner
9940db63ef
Deprecate #[unsafe_destructor_blind_to_params]
CC #34761
2017-01-10 18:10:19 -05:00
bors
7ac9d337dc Auto merge of #38679 - alexcrichton:always-deny-warnings, r=nrc
Remove not(stage0) from deny(warnings)

Historically this was done to accommodate bugs in lints, but there hasn't been a
bug in a lint since this feature was added which the warnings affected. Let's
completely purge warnings from all our stages by denying warnings in all stages.
This will also assist in tracking down `stage0` code to be removed whenever
we're updating the bootstrap compiler.
2017-01-08 08:22:06 +00:00
bors
e447b73f39 Auto merge of #38792 - jseyfried:improve_macros_11_diagnostics, r=nikomatsakis
proc macros 1.1: improve diagnostics

Fixes #38586.
r? @nrc
2017-01-06 19:23:06 +00:00
Jeffrey Seyfried
a2fc566d41 Fold all spans in the AST. 2017-01-03 02:00:40 +00:00
Alex Crichton
045f8f6929 rustc: Stabilize the proc_macro feature
This commit stabilizes the `proc_macro` and `proc_macro_lib` features in the
compiler to stabilize the "Macros 1.1" feature of the language. Many more
details can be found on the tracking issue, #35900.

Closes #35900
2017-01-02 12:13:30 -08:00
bors
4947adaa8c Auto merge of #38692 - estebank:remove-try-from-pprust, r=petrochenkov
Use `?` instead of `try!` macro in `print::pprust`
2017-01-01 18:42:34 +00:00
Simonas Kazlauskas
86ce3a2f7c Further and hopefully final Windows fixes 2016-12-30 15:19:50 +01:00
est31
dd10c5a503 Feature gate: 1.16.0 instead of 1.15.0 2016-12-30 15:17:30 +01:00
Simonas Kazlauskas
64de4e2731 Fix LEB128 to work with the stage1
Stage 1 can’t really handle negative 128-bit literals, but an equivalent bit-not is fine
2016-12-30 15:17:25 +01:00
Simonas Kazlauskas
4e2b946e65 Cleanup FIXMEs 2016-12-30 15:17:25 +01:00
Simonas Kazlauskas
d4d5be18b7 Feature gate the 128 bit types
Dangling a carrot in front of a donkey.

This commit includes manual merge conflict resolution changes from a rebase by @est31.
2016-12-30 15:17:25 +01:00
Simonas Kazlauskas
b0e55a83a8 Such large. Very 128. Much bits.
This commit introduces 128-bit integers. Stage 2 builds and produces a working compiler which
understands and supports 128-bit integers throughout.

The general strategy used is to have rustc_i128 module which provides aliases for iu128, equal to
iu64 in stage9 and iu128 later. Since nowhere in rustc we rely on large numbers being supported,
this strategy is good enough to get past the first bootstrap stages to end up with a fully working
128-bit capable compiler.

In order for this strategy to work, number of locations had to be changed to use associated
max_value/min_value instead of MAX/MIN constants as well as the min_value (or was it max_value?)
had to be changed to use xor instead of shift so both 64-bit and 128-bit based consteval works
(former not necessarily producing the right results in stage1).

This commit includes manual merge conflict resolution changes from a rebase by @est31.
2016-12-30 15:15:44 +01:00
Alex Crichton
9b0b5b45db Remove not(stage0) from deny(warnings)
Historically this was done to accommodate bugs in lints, but there hasn't been a
bug in a lint since this feature was added which the warnings affected. Let's
completely purge warnings from all our stages by denying warnings in all stages.
This will also assist in tracking down `stage0` code to be removed whenever
we're updating the bootstrap compiler.
2016-12-29 21:07:20 -08:00
Alex Crichton
bcfd504744 Rollup merge of #38559 - japaric:ptx2, r=alexcrichton
PTX support, take 2

- You can generate PTX using `--emit=asm` and the right (custom) target. Which
  then you can run on a NVIDIA GPU.

- You can compile `core` to PTX. [Xargo] also works and it can compile some
  other crates like `collections` (but I doubt all of those make sense on a GPU)

[Xargo]: https://github.com/japaric/xargo

- You can create "global" functions, which can be "called" by the host, using
  the `"ptx-kernel"` ABI, e.g. `extern "ptx-kernel" fn kernel() { .. }`. Every
  other function is a "device" function and can only be called by the GPU.

- Intrinsics like `__syncthreads()` and `blockIdx.x` are available as
  `"platform-intrinsics"`. These intrinsics are *not* in the `core` crate but
  any Rust user can create "bindings" to them using an `extern
  "platform-intrinsics"` block. See example at the end.

- Trying to emit PTX with `-g` (debuginfo); you get an LLVM error. But I don't
  think PTX can contain debuginfo anyway so `-g` should be ignored and a warning
  should be printed ("`-g` doesn't work with this target" or something).

- "Single source" support. You *can't* write a single source file that contains
  both host and device code. I think that should be possible to implement that
  outside the compiler using compiler plugins / build scripts.

- The equivalent to CUDA `__shared__` which it's used to declare memory that's
  shared between the threads of the same block. This could be implemented using
  attributes: `#[shared] static mut SCRATCH_MEMORY: [f32; 64]` but hasn't been
  implemented yet.

- Built-in targets. This PR doesn't add targets to the compiler just yet but one
  can create custom targets to be able to emit PTX code (see the example at the
  end). The idea is to have people experiment with this feature before
  committing to it (built-in targets are "insta-stable")

- All functions must be "inlined". IOW, the `.rlib` must always contain the LLVM
  bitcode of all the functions of the crate it was produced from. Otherwise, you
  end with "undefined references" in the final PTX code but you won't get *any*
  linker error because no linker is involved. IOW, you'll hit a runtime error
  when loading the PTX into the GPU. The workaround is to use `#[inline]` on
  non-generic functions and to never use `#[inline(never)]` but this may not
  always be possible because e.g. you could be relying on third party code.

- Should `--emit=asm` generate a `.ptx` file instead of a `.s` file?

TL;DR Use Xargo to turn a crate into a PTX module (a `.s` file). Then pass that
PTX module, as a string, to the GPU and run it.

The full code is in [this repository]. This section gives an overview of how to
run Rust code on a NVIDIA GPU.

[this repository]: https://github.com/japaric/cuda

- Create a custom target. Here's the 64-bit NVPTX target (NOTE: the comments
  are not valid because this is supposed to be a JSON file; remove them before
  you use this file):

``` js
// nvptx64-nvidia-cuda.json
{
  "arch": "nvptx64",  // matches LLVM
  "cpu": "sm_20",  // "oldest" compute capability supported by LLVM
  "data-layout": "e-i64:64-v16:16-v32:32-n16:32:64",
  "llvm-target": "nvptx64-nvidia-cuda",
  "max-atomic-width": 0,  // LLVM errors with any other value :-(
  "os": "cuda",  // matches LLVM
  "panic-strategy": "abort",
  "target-endian": "little",
  "target-pointer-width": "64",
  "target-vendor": "nvidia",  // matches LLVM -- not required
}
```

(There's a 32-bit target specification in the linked repository)

- Write a kernel

``` rust

extern "platform-intrinsic" {
    fn nvptx_block_dim_x() -> i32;
    fn nvptx_block_idx_x() -> i32;
    fn nvptx_thread_idx_x() -> i32;
}

/// Copies an array of `n` floating point numbers from `src` to `dst`
pub unsafe extern "ptx-kernel" fn memcpy(dst: *mut f32,
                                         src: *const f32,
                                         n: usize) {
    let i = (nvptx_block_dim_x() as isize)
        .wrapping_mul(nvptx_block_idx_x() as isize)
        .wrapping_add(nvptx_thread_idx_x() as isize);

    if (i as usize) < n {
        *dst.offset(i) = *src.offset(i);
    }
}
```

- Emit PTX code

```
$ xargo rustc --target nvptx64-nvidia-cuda --release -- --emit=asm
   Compiling core v0.0.0 (file://..)
   (..)
   Compiling nvptx-builtins v0.1.0 (https://github.com/japaric/nvptx-builtins)
   Compiling kernel v0.1.0

$ cat target/nvptx64-nvidia-cuda/release/deps/kernel-*.s
//
// Generated by LLVM NVPTX Back-End
//

.version 3.2
.target sm_20
.address_size 64

        // .globl       memcpy

.visible .entry memcpy(
        .param .u64 memcpy_param_0,
        .param .u64 memcpy_param_1,
        .param .u64 memcpy_param_2
)
{
        .reg .pred      %p<2>;
        .reg .s32       %r<5>;
        .reg .s64       %rd<12>;

        ld.param.u64    %rd7, [memcpy_param_2];
        mov.u32 %r1, %ntid.x;
        mov.u32 %r2, %ctaid.x;
        mul.wide.s32    %rd8, %r2, %r1;
        mov.u32 %r3, %tid.x;
        cvt.s64.s32     %rd9, %r3;
        add.s64         %rd10, %rd9, %rd8;
        setp.ge.u64     %p1, %rd10, %rd7;
        @%p1 bra        LBB0_2;
        ld.param.u64    %rd3, [memcpy_param_0];
        ld.param.u64    %rd4, [memcpy_param_1];
        cvta.to.global.u64      %rd5, %rd4;
        cvta.to.global.u64      %rd6, %rd3;
        shl.b64         %rd11, %rd10, 2;
        add.s64         %rd1, %rd6, %rd11;
        add.s64         %rd2, %rd5, %rd11;
        ld.global.u32   %r4, [%rd2];
        st.global.u32   [%rd1], %r4;
LBB0_2:
        ret;
}
```

- Run it on the GPU

``` rust
// `kernel.ptx` is the `*.s` file we got in the previous step
const KERNEL: &'static str = include_str!("kernel.ptx");

driver::initialize()?;

let device = Device(0)?;
let ctx = device.create_context()?;
let module = ctx.load_module(KERNEL)?;
let kernel = module.function("memcpy")?;

let h_a: Vec<f32> = /* create some random data */;
let h_b = vec![0.; N];

let d_a = driver::allocate(bytes)?;
let d_b = driver::allocate(bytes)?;

// Copy from host to GPU
driver::copy(h_a, d_a)?;

// Run `memcpy` on the GPU
kernel.launch(d_b, d_a, N)?;

// Copy from GPU to host
driver::copy(d_b, h_b)?;

// Verify
assert_eq!(h_a, h_b);

// `d_a`, `d_b`, `h_a`, `h_b` are dropped/freed here
```

---

cc @alexcrichton @brson @rkruppe

> What has changed since #34195?

- `core` now can be compiled into PTX. Which makes it very easy to turn `no_std`
  crates into "kernels" with the help of Xargo.

- There's now a way, the `"ptx-kernel"` ABI, to generate "global" functions. The
  old PR required a manual step (it was hack) to "convert" "device" functions
  into "global" functions. (Only "global" functions can be launched by the host)

- Everything is unstable. There are not "insta stable" built-in targets this
  time (\*). The users have to use a custom target to experiment with this
  feature. Also, PTX instrinsics, like `__syncthreads` and `blockIdx.x`, are now
  implemented as `"platform-intrinsics"` so they no longer live in the `core`
  crate.

(\*) I'd actually like to have in-tree targets because that makes this target
more discoverable, removes the need to lug around .json files, etc.

However, bundling a target with the compiler immediately puts it in the path
towards stabilization. Which gives us just two cycles to find and fix any
problem with the target specification. Afterwards, it becomes hard to tweak
the specification because that could be a breaking change.

A possible solution could be "unstable built-in targets". Basically, to use an
unstable target, you'll have to also pass `-Z unstable-options` to the compiler.
And unstable targets, being unstable, wouldn't be available on stable.

> Why should this be merged?

- To let people experiment with the feature out of tree. Having easy access to
  the feature (in every nightly) allows this. I also think that, as it is, it
  should be possible to start prototyping type-safe single source support using
  build scripts, macros and/or plugins.

- It's a straightforward implementation. No different that adding support for
  any other architecture.
2016-12-29 17:26:15 -08:00
Esteban Küber
26f0181daa Use ? instead of try! macro in print::pprust 2016-12-29 13:57:01 -08:00
Eduard-Mihai Burtescu
6ebb6fdbee hir: lower ImplicitSelf to resolved Self TyQPath's. 2016-12-28 11:21:45 +02:00
Jorge Aparicio
18d49288d5 PTX support
- `--emit=asm --target=nvptx64-nvidia-cuda` can be used to turn a crate
  into a PTX module (a `.s` file).

- intrinsics like `__syncthreads` and `blockIdx.x` are exposed as
  `"platform-intrinsics"`.

- "cabi" has been implemented for the nvptx and nvptx64 architectures.
  i.e. `extern "C"` works.

- a new ABI, `"ptx-kernel"`. That can be used to generate "global"
  functions. Example: `extern "ptx-kernel" fn kernel() { .. }`. All
  other functions are "device" functions.
2016-12-26 21:06:23 -05:00
bors
c74ac6cb97 Auto merge of #38566 - jseyfried:fix_import_resolution_bug, r=eddyb
Fix bug in import resolution

Fixes #38535 and fixes #38556.
r? @nrc
2016-12-25 13:14:12 +00:00
bors
8d65c8d64e Auto merge of #38268 - withoutboats:parse_where_higher_rank_hack, r=eddyb
Prevent where < ident > from parsing.

In order to be forward compatible with `where<'a>` syntax for higher
rank parameters, prevent potential conflicts with UFCS from parsing
correctly for the near term.
2016-12-24 00:22:00 +00:00
bors
467a7f049b Auto merge of #38533 - jseyfried:legacy_custom_derive_deprecation, r=nrc
Allow legacy custom derive authors to disable warnings in downstream crates

This PR allows legacy custom derive authors to use a pre-deprecated method `registry.register_custom_derive()` instead of `registry.register_syntax_extension()` to avoid downstream deprecation warnings.

r? @nrc
2016-12-23 18:43:12 +00:00
bors
82611a0224 Auto merge of #38232 - jseyfried:refactor_global_paths, r=nrc
Refactor global paths

This PR removes the field `global: bool` from `ast::Path` and `hir::Path`, instead representing a global path `::foo::bar` as `{{root}}::foo::bar`, where `{{root}}` is a virtual keyword `keywords::CrateRoot`.

Also, fixes #38016.

r? @nrc
2016-12-23 06:22:45 +00:00
Jeffrey Seyfried
c12fc66a9d Allow legacy custom derive authors to disable warnings in downstream crates. 2016-12-23 05:49:34 +00:00
Jeffrey Seyfried
31d9cc3833 Fix import resolution bug and fold all idents in the AST. 2016-12-23 02:16:31 +00:00
Esteban Küber
39d6483bc1 Remove outdated FIXME comment
Removed FIXME comment referencing #3300.
2016-12-22 00:38:10 -08:00
Jeffrey Seyfried
8a1acb2c69 Pretty-print $crate::foo::bar as ::foo::bar. 2016-12-22 06:14:36 +00:00
Jeffrey Seyfried
f10f50b426 Refactor how global paths are represented (for both ast and hir). 2016-12-22 06:14:35 +00:00
bors
439c3128d7 Auto merge of #38099 - GuillaumeGomez:cast_suggestions, r=nikomatsakis
Cast suggestions

r? @nikomatsakis
2016-12-21 07:28:16 +00:00
Alex Crichton
551cb0646f Rollup merge of #38171 - jseyfried:cleanup, r=nrc
Miscellaneous cleanup/refactoring in `resolve` and `syntax::ext`

r? @nrc
2016-12-20 11:16:23 -08:00
Guillaume Gomez
c11fe553df Create check_ref method to allow to check coercion with & types 2016-12-20 11:37:15 +01:00
Guillaume Gomez
b2d0ec0eb4 Fix coercion ICE 2016-12-20 11:37:15 +01:00
Guillaume Gomez
164f0105bb Add safe_suggestion attribute 2016-12-20 11:37:15 +01:00
Jeffrey Seyfried
8e61ff25d8 Optimize ast::PathSegment. 2016-12-19 20:57:00 +00:00
bors
cc662efca1 Auto merge of #38194 - sgrif:sg-no-span-mangling, r=nrc
Don't perform span mangling when building field/tup access nodes

There are no guarantees that the two spans used to create the new one
come from the same place or are even valid.

Fixes #36081.
2016-12-19 04:39:18 +00:00
Jeffrey Seyfried
745ddf2aa7 Refactor out mark.as_placeholder_id(). 2016-12-18 23:26:31 +00:00
Jeffrey Seyfried
6f040b48ef Avoid including attributes in bang macro invocations. 2016-12-18 23:26:31 +00:00
Jeffrey Seyfried
421c5d11c1 Remove scope placeholders, remove method add_macro of ext::base::Resolver. 2016-12-18 23:26:30 +00:00
Jeffrey Seyfried
e80d1a8faf Remove MacroDef's fields imported_from and allow_internal_unstable,
remove `export` argument of `resolver.add_macro()`.
2016-12-18 23:26:29 +00:00
Jeffrey Seyfried
59de7f8f04 Add ident.unhygienize() and use Ident more instead of Name in resolve. 2016-12-18 23:26:22 +00:00
Jeffrey Seyfried
83ab9f7fac Remove some unused functions and fix formatting. 2016-12-18 23:25:30 +00:00
bors
ec8bb45624 Auto merge of #38279 - KalitaAlexey:issue-8521, r=jseyfried
macros: allow a `path` fragment to be parsed as a type parameter bound

Allow a `path` fragment to be parsed as a type parameter bound.
Fixes #8521.
2016-12-17 21:49:51 +00:00
bors
f99d4dfef2 Auto merge of #38205 - jseyfried:fix_module_directory_regression, r=eddyb
macros: fix the expected paths for a non-inline module matched by an `item` fragment

Fixes #38190.
r? @nrc
2016-12-17 06:43:16 +00:00
Kalita Alexey
12a6cf1123 Allow path fragments to be parsed as type parameter bounds in macro expansion 2016-12-16 14:16:46 +03:00
bors
b4b1e5ece2 Auto merge of #38049 - frewsxcv:libunicode, r=alexcrichton
Rename 'librustc_unicode' crate to 'libstd_unicode'.

Fixes https://github.com/rust-lang/rust/issues/26554.
2016-12-12 13:19:33 +00:00
Without Boats
14e4b00933 Fix mistake. 2016-12-09 21:17:58 -08:00
Without Boats
ddae271b78 Improve error message. 2016-12-09 20:39:42 -08:00
Without Boats
90f6219f49 Prevent where < ident > from parsing.
In order to be forward compatible with `where<'a>` syntax for higher
rank parameters, prevent potential conflicts with UFCS from parsing
correctly for the near term.
2016-12-09 10:54:05 -08:00
bors
7b06438d83 Auto merge of #38191 - oli-obk:clippy_is_sad, r=eddyb
annotate stricter lifetimes on LateLintPass methods to allow them to forward to a Visitor

this unblocks clippy (rustup blocked after #37918)

clippy has lots of lints that internally call an `intravisit::Visitor`, but the current lifetimes on `LateLintPass` methods conflicted with the required lifetimes (there was no connection between the HIR elements and the `TyCtxt`)

r? @Manishearth
2016-12-07 23:06:10 +00:00
Jeffrey Seyfried
fd98a8d795 macros: fix the expected paths for a non-inline module matched by an item fragment. 2016-12-07 10:56:55 +00:00
Sean Griffin
0ddf61890b Don't perform span mangling when building field/tup access nodes
There are no guarantees that the two spans used to create the new one
come from the same place or are even valid.

Fixes #36081.
2016-12-06 09:35:32 -05:00
bors
1692c0b587 Auto merge of #37973 - vadimcn:dllimport, r=alexcrichton
Implement RFC 1717

Implement the first two points from #37403.

r? @alexcrichton
2016-12-06 10:54:45 +00:00
Oliver Schneider
5e51edb0de
annotate stricter lifetimes on LateLintPass methods to allow them to forward to a Visitor 2016-12-06 11:28:51 +01:00
bors
341f084d8d Auto merge of #38087 - jooert:remove_unmarked, r=petrochenkov
Remove the `unmarked_api` feature

Closes #37981.
2016-12-04 19:47:18 +00:00
bors
b462e8fa61 Auto merge of #38082 - jseyfried:macro_invocation_paths, r=nrc
macros: support invocation paths (e.g. `foo::bar!()`) behind `#![feature(use_extern_macros)]`

r? @nrc
2016-12-04 12:51:38 +00:00
bors
2cdbd5eb42 Auto merge of #38079 - BurntSushi:attrtarget, r=alexcrichton
Add new #[target_feature = "..."] attribute.

This commit adds a new attribute that instructs the compiler to emit
target specific code for a single function. For example, the following
function is permitted to use instructions that are part of SSE 4.2:

    #[target_feature = "+sse4.2"]
    fn foo() { ... }

In particular, use of this attribute does not require setting the
-C target-feature or -C target-cpu options on rustc.

This attribute does not have any protections built into it. For example,
nothing stops one from calling the above `foo` function on hosts without
SSE 4.2 support. Doing so may result in a SIGILL.

I've also expanded the x86 target feature whitelist.
2016-12-03 17:41:14 +00:00
Vadim Chugunov
a9a6f8c8ed Remove the "linked_from" feature. 2016-12-01 16:56:49 -08:00
Ariel Ben-Yehuda
242cd7ebe2 limit the length of types in monomorphization
This adds the new insta-stable `#![type_size_limit]` crate attribute to control
the limit, and is obviously a [breaking-change] fixable by that.
2016-12-02 00:54:22 +02:00
Jeffrey Seyfried
ed9a09d40c Support paths in macro invocations. 2016-11-30 22:54:40 +00:00
Alex Crichton
2186660b51 Update the bootstrap compiler
Now that we've got a beta build, let's use it!
2016-11-30 10:38:08 -08:00
Johannes Oertel
7cbd18a690 Remove the unmarked_api feature
Closes #37981.
2016-11-30 15:51:04 +01:00
Corey Farwell
274777a158 Rename 'librustc_unicode' crate to 'libstd_unicode'.
Fixes #26554.
2016-11-30 01:24:01 -05:00
Andrew Gallant
80ef1dbf2d Add new #[target_feature = "..."] attribute.
This commit adds a new attribute that instructs the compiler to emit
target specific code for a single function. For example, the following
function is permitted to use instructions that are part of SSE 4.2:

    #[target_feature = "+sse4.2"]
    fn foo() { ... }

In particular, use of this attribute does not require setting the
-C target-feature or -C target-cpu options on rustc.

This attribute does not have any protections built into it. For example,
nothing stops one from calling the above `foo` function on hosts without
SSE 4.2 support. Doing so may result in a SIGILL.

This commit also expands the target feature whitelist to include lzcnt,
popcnt and sse4a. Namely, lzcnt and popcnt have their own CPUID bits,
but were introduced with SSE4.
2016-11-29 20:32:14 -05:00
bors
b30022a1d3 Auto merge of #37369 - estebank:multiline-span, r=nikomatsakis
Show multiline spans in full if short enough

When dealing with multiline spans that span few lines, show the complete span instead of restricting to the first character of the first line.

For example, instead of:

```
% ./rustc file2.rs
error[E0277]: the trait bound `{integer}: std::ops::Add<()>` is not satisfied
  --> file2.rs:13:9
   |
13 |    foo(1 + bar(x,
   |        ^ trait `{integer}: std::ops::Add<()>` not satisfied
   |
```

show

```
% ./rustc file2.rs
error[E0277]: the trait bound `{integer}: std::ops::Add<()>` is not satisfied
  --> file2.rs:13:9
   |
13 |      foo(1 + bar(x,
   |  ________^ starting here...
14 | |            y),
   | |_____________^ ...ending here: trait `{integer}: std::ops::Add<()>` not satisfied
   |
```

The [proposal in internals](https://internals.rust-lang.org/t/proposal-for-multiline-span-comments/4242/6) outlines the reasoning behind this.
2016-11-29 12:53:47 -06:00
bors
1c448574bc Auto merge of #37791 - petrochenkov:where, r=nikomatsakis
Support `?Sized` in where clauses

Implemented as described in https://github.com/rust-lang/rust/issues/20503#issuecomment-258677026 - `?Trait` bounds are moved on type parameter definitions when possible, reported as errors otherwise.
(It'd be nice to unify bounds and where clauses in HIR, but this is mostly blocked by rustdoc now - it needs to render bounds in pleasant way and the best way to do it so far is to mirror what was written in source code.)

Fixes https://github.com/rust-lang/rust/issues/20503
r? @nikomatsakis
2016-11-28 15:15:17 -06:00
Eduard Burtescu
9aaf26e7aa rustc: rework stability to be on-demand for type-directed lookup. 2016-11-28 04:18:11 +02:00
Eduard Burtescu
f97c132cac rustc: use Span's allow_internal_unstable instead of hir::BlockCheckMode. 2016-11-28 04:18:10 +02:00
Vadim Petrochenkov
7d15250b0e Support ?Sized in where clauses 2016-11-25 00:43:00 +03:00
Esteban Küber
b7982bbbe0 review comments 2016-11-23 23:44:17 -08:00
bors
1cabe21512 Auto merge of #37487 - goffrie:break, r=nikomatsakis
Implement the `loop_break_value` feature.

This implements RFC 1624, tracking issue #37339.
- `FnCtxt` (in typeck) gets a stack of `LoopCtxt`s, which store the
  currently deduced type of that loop, the desired type, and a list of
  break expressions currently seen. `loop` loops get a fresh type
  variable as their initial type (this logic is stolen from that for
  arrays). `while` loops get `()`.
- `break {expr}` looks up the broken loop, and unifies the type of
  `expr` with the type of the loop.
- `break` with no expr unifies the loop's type with `()`.
- When building MIR, loops no longer construct a `()` value at
  termination of the loop; rather, the `break` expression assigns the
  result of the loop.
- ~~I have also changed the loop scoping in MIR-building so that the test
  of a while loop is not considered to be part of that loop. This makes
  the rules consistent with #37360. The new loop scopes in typeck also
  follow this rule. That means that `loop { while (break) {} }` now
  terminates instead of looping forever. This is technically a breaking
  change.~~
- ~~On that note, expressions like `while break {}` and `if break {}` no
  longer parse because `{}` is interpreted as an expression argument to
  `break`. But no code except compiler test cases should do that anyway
  because it makes no sense.~~
- The RFC did not make it clear, but I chose to make `break ()` inside
  of a `while` loop illegal, just in case we wanted to do anything with
  that design space in the future.

This is my first time dealing with this part of rustc so I'm sure
there's plenty of problems to pick on here ^_^
2016-11-22 17:51:59 -06:00
Esteban Küber
eb53ca3aad Show multiline spans in full if short enough
When dealing with multiline spans that span few lines, show the complete
span instead of restricting to the first character of the first line.

For example, instead of:

```
% ./rustc foo.rs
error[E0277]: the trait bound `{integer}: std::ops::Add<()>` is not satisfied
  --> foo.rs:13:9
   |
13 |    foo(1 + bar(x,
   |        ^ trait `{integer}: std::ops::Add<()>` not satisfied
   |
```

show

```
% ./rustc foo.rs
error[E0277]: the trait bound `{integer}: std::ops::Add<()>` is not satisfied
  --> foo.rs:13:9
   |
13 |      foo(1 + bar(x,
   |  ________^ starting here...
14 | |            y),
   | |_____________^ ...ending here: trait `{integer}: std::ops::Add<()>` not satisfied
   |
```
2016-11-22 13:42:36 -08:00
Geoffry Song
9d42549df4
Implement the loop_break_value feature.
This implements RFC 1624, tracking issue #37339.

- `FnCtxt` (in typeck) gets a stack of `LoopCtxt`s, which store the
  currently deduced type of that loop, the desired type, and a list of
  break expressions currently seen. `loop` loops get a fresh type
  variable as their initial type (this logic is stolen from that for
  arrays). `while` loops get `()`.
- `break {expr}` looks up the broken loop, and unifies the type of
  `expr` with the type of the loop.
- `break` with no expr unifies the loop's type with `()`.
- When building MIR, `loop` loops no longer construct a `()` value at
  termination of the loop; rather, the `break` expression assigns the
  result of the loop. `while` loops are unchanged.
- `break` respects contexts in which expressions may not end with braced
  blocks. That is, `while break { break-value } { while-body }` is
  illegal; this preserves backwards compatibility.
- The RFC did not make it clear, but I chose to make `break ()` inside
  of a `while` loop illegal, just in case we wanted to do anything with
  that design space in the future.

This is my first time dealing with this part of rustc so I'm sure
there's plenty of problems to pick on here ^_^
2016-11-21 20:20:42 -08:00
Jeffrey Seyfried
fa8c53bae4 Start warning cycle. 2016-11-22 01:52:04 +00:00
Jeffrey Seyfried
5675d9d280 Clean up directory ownership semantics. 2016-11-22 01:48:10 +00:00
bors
ebec55406b Auto merge of #37824 - jseyfried:symbols, r=eddyb
Clean up `ast::Attribute`, `ast::CrateConfig`, and string interning

This PR
 - removes `ast::Attribute_` (changing `Attribute` from `Spanned<Attribute_>` to a struct),
 - moves a `MetaItem`'s name from the `MetaItemKind` variants to a field of `MetaItem`,
 - avoids needlessly wrapping `ast::MetaItem` with `P`,
 - moves string interning into `syntax::symbol` (`ast::Name` is a reexport of `symbol::Symbol` for now),
 - replaces `InternedString` with `Symbol` in the AST, HIR, and various other places, and
 - refactors `ast::CrateConfig` from a `Vec` to a `HashSet`.

r? @eddyb
2016-11-21 08:08:47 -06:00
Jeffrey Seyfried
a8e86f0f81 Fix fallout in rustdoc and tests. 2016-11-21 12:16:46 +00:00
Jeffrey Seyfried
b4d3df6592 Stabilize RFC 1560. 2016-11-21 09:10:16 +00:00
Jeffrey Seyfried
cc74068642 Remove Rc from the interner. 2016-11-21 09:00:56 +00:00
Jeffrey Seyfried
36c8f6b0d3 Cleanup InternedString. 2016-11-21 09:00:56 +00:00
Jeffrey Seyfried
e85a0d70b8 Use Symbol instead of InternedString in the AST, HIR, and various other places. 2016-11-21 09:00:55 +00:00
Jeffrey Seyfried
d2f8fb0a0a Move syntax::util::interner -> syntax::symbol, cleanup. 2016-11-20 23:40:20 +00:00
Jeffrey Seyfried
f177a00ac9 Refactor P<ast::MetaItem> -> ast::MetaItem. 2016-11-20 12:36:41 +00:00
Jeffrey Seyfried
e97686d048 Move MetaItemKind's Name to a field of MetaItem. 2016-11-20 12:36:30 +00:00
Jeffrey Seyfried
4b9b0d3474 Refactor CrateConfig. 2016-11-20 12:35:57 +00:00
Jeffrey Seyfried
a2626410d7 Refactor MetaItemKind to use Names instead of InternedStrings. 2016-11-20 11:46:06 +00:00
Jeffrey Seyfried
ff4994235a Avoid clearing the string interner. 2016-11-20 11:46:01 +00:00
Jeffrey Seyfried
3ea2bc4e93 Refactor away ast::Attribute_. 2016-11-20 11:46:00 +00:00
bors
195c42c426 Auto merge of #37749 - keeperofdakeys:should-panic, r=alexcrichton
Improvements to the #[should_panic] feature

Add more error checking for the `#[should_panic]` attribute, and print the expected panic string when it does not match.

Fixes https://github.com/rust-lang/rust/issues/29000

Eg:
```running 3 tests
test test2 ... ok
test test1 ... FAILED
: Panic did not include expected string 'foo'
test test3 ... FAILED

failures:

---- test1 stdout ----
	thread 'test1' panicked at 'bar', test.rs:7
note: Run with `RUST_BACKTRACE=1` for a backtrace.

---- test3 stdout ----
	thread 'test3' panicked at 'bar', test.rs:18

```
2016-11-18 08:24:00 -08:00
Jeffrey Seyfried
9c88650080 Add feature use_extern_macros. 2016-11-17 08:08:06 +00:00
Jeffrey Seyfried
641274f907 Resolve imports during expansion. 2016-11-17 08:07:44 +00:00
bors
9d4b6fa51d Auto merge of #37545 - alexcrichton:crt-static, r=brson
rustc: Implement #[link(cfg(..))] and crt-static

This commit is an implementation of [RFC 1721] which adds a new target feature
to the compiler, `crt-static`, which can be used to select how the C runtime for
a target is linked. Most targets dynamically linke the C runtime by default with
the notable exception of some of the musl targets.

[RFC 1721]: https://github.com/rust-lang/rfcs/blob/master/text/1721-crt-static.md

This commit first adds the new target-feature, `crt-static`. If enabled, then
the `cfg(target_feature = "crt-static")` will be available. Targets like musl
will have this enabled by default. This feature can be controlled through the
standard target-feature interface, `-C target-feature=+crt-static` or
`-C target-feature=-crt-static`.

Next this adds an gated and unstable `#[link(cfg(..))]` feature to enable the
`crt-static` semantics we want with libc. The exact behavior of this attribute
is a little squishy, but it's intended to be a forever-unstable
implementation detail of the liblibc crate.

Specifically the `#[link(cfg(..))]` annotation means that the `#[link]`
directive is only active in a compilation unit if that `cfg` value is satisfied.
For example when compiling an rlib, these directives are just encoded and
ignored for dylibs, and all staticlibs are continued to be put into the rlib as
usual. When placing that rlib into a staticlib, executable, or dylib, however,
the `cfg` is evaluated *as if it were defined in the final artifact* and the
library is decided to be linked or not.

Essentially, what'll happen is:

* On MSVC with `-C target-feature=-crt-static`, the `msvcrt.lib` library will be
  linked to.
* On MSVC with `-C target-feature=+crt-static`, the `libcmt.lib` library will be
  linked to.
* On musl with `-C target-feature=-crt-static`, the object files in liblibc.rlib
  are removed and `-lc` is passed instead.
* On musl with `-C target-feature=+crt-static`, the object files in liblibc.rlib
  are used and `-lc` is not passed.

This commit does **not** include an update to the liblibc module to implement
these changes. I plan to do that just after the 1.14.0 beta release is cut to
ensure we get ample time to test this feature.

cc #37406
2016-11-16 08:25:38 -08:00
Alex Crichton
06242ff15d rustc: Implement #[link(cfg(..))] and crt-static
This commit is an implementation of [RFC 1721] which adds a new target feature
to the compiler, `crt-static`, which can be used to select how the C runtime for
a target is linked. Most targets dynamically linke the C runtime by default with
the notable exception of some of the musl targets.

[RFC 1721]: https://github.com/rust-lang/rfcs/blob/master/text/1721-crt-static.md

This commit first adds the new target-feature, `crt-static`. If enabled, then
the `cfg(target_feature = "crt-static")` will be available. Targets like musl
will have this enabled by default. This feature can be controlled through the
standard target-feature interface, `-C target-feature=+crt-static` or
`-C target-feature=-crt-static`.

Next this adds an gated and unstable `#[link(cfg(..))]` feature to enable the
`crt-static` semantics we want with libc. The exact behavior of this attribute
is a little squishy, but it's intended to be a forever-unstable
implementation detail of the liblibc crate.

Specifically the `#[link(cfg(..))]` annotation means that the `#[link]`
directive is only active in a compilation unit if that `cfg` value is satisfied.
For example when compiling an rlib, these directives are just encoded and
ignored for dylibs, and all staticlibs are continued to be put into the rlib as
usual. When placing that rlib into a staticlib, executable, or dylib, however,
the `cfg` is evaluated *as if it were defined in the final artifact* and the
library is decided to be linked or not.

Essentially, what'll happen is:

* On MSVC with `-C target-feature=-crt-static`, the `msvcrt.lib` library will be
  linked to.
* On MSVC with `-C target-feature=+crt-static`, the `libcmt.lib` library will be
  linked to.
* On musl with `-C target-feature=-crt-static`, the object files in liblibc.rlib
  are removed and `-lc` is passed instead.
* On musl with `-C target-feature=+crt-static`, the object files in liblibc.rlib
  are used and `-lc` is not passed.

This commit does **not** include an update to the liblibc module to implement
these changes. I plan to do that just after the 1.14.0 beta release is cut to
ensure we get ample time to test this feature.

cc #37406
2016-11-16 07:00:09 -08:00
bors
c87bae6b65 Auto merge of #37758 - euclio:unstable, r=brson
do not use deprecated text for unstable docs

![2016-11-13-18 55 23](https://cloud.githubusercontent.com/assets/1372438/20249943/d7f684a2-a9d2-11e6-8c5a-a2bfe354b9aa.png)
![2016-11-13-18 55 12](https://cloud.githubusercontent.com/assets/1372438/20249942/d7f6595a-a9d2-11e6-9240-07f5a89367f4.png)

![2016-11-13-18 54 00](https://cloud.githubusercontent.com/assets/1372438/20249946/da176d46-a9d2-11e6-8f34-c09cff9bcc15.png)
![2016-11-13-18 54 45](https://cloud.githubusercontent.com/assets/1372438/20249941/d7d9837a-a9d2-11e6-99f4-e4bf8807b1c9.png)
2016-11-15 15:59:52 -08:00
Josh Driver
d6689fdc61 Add warnings when the #[should_panic] attribute is invalid 2016-11-14 22:22:17 +10:30
bors
8289a8916f Auto merge of #37278 - matklad:lone-lifetime, r=jseyfried
Fix syntax error in the compiler

Currently `rustc` accepts the following code: `fn f<'a>() where 'a {}`. This should be a syntax error, shouldn't it?

Not sure if my changes actually compile, waiting for the LLVM to build.
2016-11-14 02:46:12 -08:00
Aleksey Kladov
cf9ff2b59b Fix where clauses parsing
Don't allow lifetimes without any bounds at all
2016-11-14 10:23:20 +03:00
bors
87b76a521d Auto merge of #37701 - Mark-Simulacrum:macro-parser-impvement, r=jseyfried
Macro parser performance improvements and refactoring

This PR locally increased performance of https://github.com/rust-lang/rust/issues/37074 by ~6.6 minutes.

Follow up to https://github.com/rust-lang/rust/pull/37569, but doesn't focus explicitly on expansion performance.

History is relatively clean, but I can/will do some more polishing if this is deemed mergeable. Partially posting this now so I can get Travis to run tests for me.

r? @jseyfried
2016-11-13 16:23:57 -08:00
Andy Russell
30f75e396a
do not use deprecated text for unstable docs 2016-11-13 19:00:56 -05:00
bors
876b761010 Auto merge of #37753 - est31:master, r=petrochenkov
Fix empty lifetime list or one with trailing comma being rejected

Fixes #37733
2016-11-13 09:53:30 -08:00
est31
34f33ec789 Fix empty lifetime list or one with trailing comma being rejected
Fixes #37733
2016-11-13 17:55:17 +01:00
Mark-Simulacrum
2189f573ca Remove extra level of nesting. 2016-11-12 07:41:47 -07:00
Mark-Simulacrum
38912ee3d4 Move next_eis out of main loop to avoid re-allocating and dropping it. 2016-11-12 07:41:26 -07:00
Mark-Simulacrum
6046595e34 Use SmallVector for eof and bb eis. 2016-11-12 06:45:06 -07:00
Mark-Simulacrum
b8d6686ef3 Factor out inner current Earley item loop.
Change multiple functions to be non-public.
Change nameize to accept an iterator so as to avoid an allocation.
2016-11-12 06:42:40 -07:00
Mark-Simulacrum
27c09864bd Refactor parse_nt. 2016-11-12 06:42:40 -07:00
Mark-Simulacrum
68abb24e8d Factor out NamedParseResult. 2016-11-12 06:42:40 -07:00
Mark-Simulacrum
eef10d0b5b Clean up extraneous &mut. 2016-11-12 06:42:40 -07:00
Mark-Simulacrum
c9e6089d29 Refactor to extending from a drain instead of while looping. 2016-11-12 06:42:40 -07:00
Mark-Simulacrum
7221b07a07 Remove unused argument from nameize.
Also makes nameize non-public since it's only locally used.
2016-11-12 06:42:40 -07:00
Mark-Simulacrum
568874bc10 Cleanup macro_parser::parse, removing a few clones. 2016-11-12 06:42:40 -07:00
Mark-Simulacrum
7bbebb1f54 Change implementation of syntax::util::SmallVector to use data_structures::SmallVec. 2016-11-11 07:38:48 -07:00
bors
4da129d984 Auto merge of #37246 - goffrie:no-loop, r=jseyfried
Don't spin expanding stmt macros.

If we can't make progress when parsing a macro expansion as a statement then we should just bail.

This alleviates the symptoms shown in e.g. #37113 and #37234 but it doesn't fix the problem that parsing invalid enum bodies (and others) leaves the parser in a crappy state.

I'm not sold on this strategy (checking `tokens_consumed`), so if anyone has a better idea, I'm all ears!
2016-11-11 02:51:01 -08:00
Jeffrey Seyfried
11195676a0 Elimite $crate before invokng custom derives. 2016-11-10 10:23:35 +00:00
Eduard-Mihai Burtescu
8cc6be1bcb Rollup merge of #37661 - brson:qmarkstab, r=nikomatsakis
question_mark was stabilized in 1.13
2016-11-10 03:46:28 +02:00
Eduard Burtescu
49772fbf5d syntax: don't fake a block around closures' bodies during parsing. 2016-11-10 01:44:45 +02:00
Eduard-Mihai Burtescu
5ebd7c50a0 Rollup merge of #37614 - keeperofdakeys:proc_macro, r=jseyfried
macros 1.1: Allow proc_macro functions to declare attributes to be mark as used

This PR allows proc macro functions to declare attribute names that should be marked as used when attached to the deriving item. There are a few questions for this PR.

- Currently this uses a separate attribute named `#[proc_macro_attributes(..)]`, is this the best choice?
- In order to make this work, the `check_attribute` function had to be modified to not error on attributes marked as used. This is a pretty large change in semantics, is there a better way to do this?
- I've got a few clones where I don't know if I need them (like turning `item` into a `TokenStream`), can these be avoided?
- Is switching to `MultiItemDecorator` the right thing here?

Also fixes https://github.com/rust-lang/rust/issues/37563.
2016-11-09 20:51:18 +02:00
Eduard-Mihai Burtescu
bd9969fb11 Rollup merge of #37428 - estebank:generic-type-error-span, r=sanxiyn
Point to type argument span when used as trait

Given the following code:

``` rust
struct Foo<T: Clone>(T);

use std::ops::Add;

impl<T: Clone, Add> Add for Foo<T> {
  type Output = usize;

  fn add(self, rhs: Self) -> Self::Output {
    unimplemented!();
  }
}
```

present the following output:

``` nocode
error[E0404]: `Add` is not a trait
 --> file3.rs:5:21
  |
5 | impl<T: Clone, Add> Add for Okok<T> {
  |                ---  ^^^ expected trait, found type parameter
  |                |
  |                type parameter defined here
```

Fixes #35987.
2016-11-09 20:51:16 +02:00
Brian Anderson
ba92b01e9a question_mark was stabilized in 1.13 2016-11-09 02:35:36 +00:00
Esteban Küber
3edb4fc563 Point to type argument span when used as trait
Given the following code:

```rust
struct Foo<T: Clone>(T);

use std::ops::Add;

impl<T: Clone, Add> Add for Foo<T> {
    type Output = usize;

    fn add(self, rhs: Self) -> Self::Output {
      unimplemented!();
    }
}
```

present the following output:

```nocode
error[E0404]: `Add` is not a trait
 --> file3.rs:5:21
  |
5 | impl<T: Clone, Add> Add for Okok<T> {
  |                ---  ^^^ expected trait, found type parameter
  |                |
  |                type parameter defined here
```
2016-11-08 14:17:18 -08:00
Vadim Petrochenkov
ab5ba049bc Partially stabilize RFC 1506 "Clarify relationships between ADTs" 2016-11-08 22:34:05 +03:00
bors
38a959a543 Auto merge of #36843 - petrochenkov:dotstab, r=nikomatsakis
Stabilize `..` in tuple (struct) patterns

I'd like to nominate `..` in tuple and tuple struct patterns for stabilization.
This feature is a relatively small extension to existing stable functionality and doesn't have known blockers.
The feature first appeared in Rust 1.10 6 months ago.
An example of use: https://github.com/rust-lang/rust/pull/36203

Closes https://github.com/rust-lang/rust/issues/33627
r? @nikomatsakis
2016-11-08 02:06:45 -08:00
Josh Driver
d377cf5b3f Rename KNOWN_ATTRS to BUILT_ATTRS, and create KNOWN_ATTRS
KNOWN_ATTRIBUTES should really be named BUILT_ATTRIBUTES,
while KNOWN_ATTRIBUTES should be used to mark attributes
as known, similar to USED_ATTRIBUTES.
2016-11-08 08:30:26 +10:30
Alex Crichton
11251e59b9 Fix tests from the rollup 2016-11-05 10:51:04 -07:00
Alex Crichton
e126f3c6c6 Merge branch 'selfgate' of https://github.com/petrochenkov/rust into rollup 2016-11-05 10:50:47 -07:00
Alex Crichton
b9cbbe184a Rollup merge of #37569 - jseyfried:improve_expansion_perf, r=eddyb
macros: improve expansion performance

This PR fixes that regression, further improves performance on recursive, `tt`-heavy workloads, and makes a variety of other improvements to parsing and expansion performance.

Expansion performance improvements:

| Test case      | Run-time | Memory usage |
| -------------- | -------- | ------------ |
| libsyntax      | 8%       | 10%          |
| librustc       | 15%      | 6%           |
| librustc_trans | 30%      | 6%           |
| #37074         | 20%      | 15%          |
| #34630         | 40%      | 8%           |

r? @eddyb
2016-11-05 10:50:24 -07:00
Alex Crichton
8a38b24d95 Rollup merge of #37501 - alexcrichton:windows-subsystem, r=brson
rustc: Add knowledge of Windows subsystems.

This commit is an implementation of [RFC 1665] which adds support for the
`#![windows_subsystem]` attribute. This attribute allows specifying either the
"windows" or "console" subsystems on Windows to the linker.

[RFC 1665]: https://github.com/rust-lang/rfcs/blob/master/text/1665-windows-subsystem.md

Previously all Rust executables were compiled as the "console" subsystem which
meant that if you wanted a graphical application it would erroneously pop up a
console whenever opened. When compiling an application, however, this is
undesired behavior and the "windows" subsystem is used instead to have control
over user interactions.

This attribute is validated, but ignored on all non-Windows platforms.

cc #37499
2016-11-05 10:50:23 -07:00
Jeffrey Seyfried
b7eed53b55 Remove field TtReader::next_tok. 2016-11-04 02:39:20 +00:00
Jeffrey Seyfried
23ad6fdb66 Improve tt-heavy expansion performance. 2016-11-04 02:38:54 +00:00