Now that features must be declared expanded source often does not compile.
This adds 'pretty-expanded' to a bunch of test cases that still work.
pub check_stdout: bool,
// Don't force a --crate-type=dylib flag on the command line
pub no_prefer_dynamic: bool,
- // Don't run --pretty expanded when running pretty printing tests
- pub no_pretty_expanded: bool,
+ // Run --pretty expanded when running pretty printing tests
+ pub pretty_expanded: bool,
// Which pretty mode are we testing with, default to 'normal'
pub pretty_mode: String,
// Only compare pretty output and don't try compiling
let mut force_host = false;
let mut check_stdout = false;
let mut no_prefer_dynamic = false;
- let mut no_pretty_expanded = false;
+ let mut pretty_expanded = false;
let mut pretty_mode = None;
let mut pretty_compare_only = false;
let mut forbid_output = Vec::new();
no_prefer_dynamic = parse_no_prefer_dynamic(ln);
}
- if !no_pretty_expanded {
- no_pretty_expanded = parse_no_pretty_expanded(ln);
+ if !pretty_expanded {
+ pretty_expanded = parse_pretty_expanded(ln);
}
if pretty_mode.is_none() {
force_host: force_host,
check_stdout: check_stdout,
no_prefer_dynamic: no_prefer_dynamic,
- no_pretty_expanded: no_pretty_expanded,
+ pretty_expanded: pretty_expanded,
pretty_mode: pretty_mode.unwrap_or("normal".to_string()),
pretty_compare_only: pretty_compare_only,
forbid_output: forbid_output,
parse_name_directive(line, "no-prefer-dynamic")
}
-fn parse_no_pretty_expanded(line: &str) -> bool {
- parse_name_directive(line, "no-pretty-expanded")
+fn parse_pretty_expanded(line: &str) -> bool {
+ parse_name_directive(line, "pretty-expanded")
}
fn parse_pretty_mode(line: &str) -> Option<String> {
}
fn parse_name_directive(line: &str, directive: &str) -> bool {
- line.contains(directive)
+ // This 'no-' rule is a quick hack to allow pretty-expanded and no-pretty-expanded to coexist
+ line.contains(directive) && !line.contains(&("no-".to_string() + directive))
}
pub fn parse_name_value_directive(line: &str, directive: &str)
if !proc_res.status.success() {
fatal_proc_rec("pretty-printed source does not typecheck", &proc_res);
}
- if props.no_pretty_expanded { return }
+ if !props.pretty_expanded { return }
// additionally, run `--pretty expanded` and try to build it.
let proc_res = print_source(config, props, testfile, srcs[round].clone(), "expanded");
// Regression test for issue #374
+// pretty-expanded FIXME #23616
+
enum sty { ty_nil, }
struct RawT {struct_: sty, cname: Option<String>, hash: uint}
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum option<T> { some(T), none, }
struct R<T> {v: Vec<option<T>> }
// except according to those terms.
// aux-build:anon-extern-mod-cross-crate-1.rs
+// pretty-expanded FIXME #23616
+
extern crate anonexternmod;
use anonexternmod::rust_get_test_int;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(libc)]
extern crate libc;
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct X {
x: int
}
+// pretty-expanded FIXME #23616
+
pub fn main() {
let i32_c: int = 0x10101010;
assert!(i32_c + i32_c * 2 / 3 * 2 + (i32_c - 7 % 3) ==
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(type_limits)]
// Unsigned integer operations
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn f() -> int { { return 3; } }
pub fn main() { assert!((f() == 3)); }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn main() {
assert_eq!(3 as uint * 3, 9);
assert_eq!(3 as (uint) * 3, 9);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(asm)]
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(asm)]
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(asm)]
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
// except according to those terms.
// Issue 483 - Assignment expressions result in nil
+// pretty-expanded FIXME #23616
+
fn test_assign() {
let mut x: int;
let y: () = x = 10;
// making method calls, but only if there aren't any matches without
// it.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures)]
trait iterable<A> {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
use std::marker::MarkerTrait;
// Test a case where the associated type binding (to `bool`, in this
// case) is derived from the trait definition. Issue #21636.
+// pretty-expanded FIXME #23616
+
use std::vec;
pub trait BitIter {
// Test equality constraints on associated types in a where clause.
+// pretty-expanded FIXME #23616
+
pub trait Foo {
type A;
fn boo(&self) -> <Self as Foo>::A;
// Test equality constrai32s on associated types in a where clause.
+// pretty-expanded FIXME #23616
+
pub trait ToI32 {
fn to_i32(&self) -> i32;
}
// `Target=[A]`, then the impl marked with `(*)` is seen to conflict
// with all the others.
+// pretty-expanded FIXME #23616
+
use std::marker::PhantomData;
use std::ops::Deref;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait SignedUnsigned {
type Opposite;
fn convert(self) -> Self::Opposite;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// (modulo bound lifetime names) appears in the environment
// twice. Issue #21965.
+// pretty-expanded FIXME #23616
+
fn foo<T>(t: T) -> i32
where T : for<'a> Fn(&'a u8) -> i32,
T : for<'b> Fn(&'b u8) -> i32,
// Check that we do not report ambiguities when the same predicate
// appears in the environment twice. Issue #21965.
+// pretty-expanded FIXME #23616
+
trait Foo {
type B;
// Test associated types appearing in struct-like enum variants.
+// pretty-expanded FIXME #23616
+
use self::VarValue::*;
pub trait UnifyKey {
// Test associated types appearing in tuple-like enum variants.
+// pretty-expanded FIXME #23616
+
use self::VarValue::*;
pub trait UnifyKey {
// Test equality constraints on associated types inside of an object type
+// pretty-expanded FIXME #23616
+
pub trait Foo {
type A;
fn boo(&self) -> <Self as Foo>::A;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Get {
type Value;
fn get(&self) -> &<Self as Get>::Value;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Get {
type Value;
fn get(&self) -> &<Self as Get>::Value;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Get {
type Value;
fn get(&self) -> &<Self as Get>::Value;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Get {
type Value;
fn get(&self) -> &<Self as Get>::Value;
// Test references to `Self::Item` in the trait. Issue #20220.
+// pretty-expanded FIXME #23616
+
use std::vec;
trait IntoIteratorX {
// Test that we are able to have an impl that defines an associated type
// before the actual trait.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
use std::marker::MarkerTrait;
// where clauses in the environment which in turn required normalizing
// `Self::Input`.
+// pretty-expanded FIXME #23616
+
pub trait Parser {
type Input;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn pairwise_sub<T:DoubleEndedIterator<Item=int>>(mut t: T) -> int {
let mut result = 0;
loop {
// Test that we can resolve nested projection types. Issue #20666.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
use std::marker::MarkerTrait;
// Test that we normalize associated types that appear in a bound that
// contains a binding. Issue #21664.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
#![allow(dead_code)]
// Test that we normalize associated types that appear in bounds; if
// we didn't, the call to `self.split2()` fails to type check.
+// pretty-expanded FIXME #23616
+
use std::marker::PhantomData;
struct Splits<'a, T:'a, P>(PhantomData<(&'a T, P)>);
// Test that we normalize associated types that appear in bounds; if
// we didn't, the call to `self.split2()` fails to type check.
+// pretty-expanded FIXME #23616
+
use std::marker::PhantomData;
struct Splits<'a, T, P>(PhantomData<(&'a(),T,P)>);
// various special paths in the `type_is_immediate` function.
+// pretty-expanded FIXME #23616
+
pub trait OffsetState: Sized {}
pub trait Offset {
type State: OffsetState;
// `Item` originates in a where-clause, not the declaration of
// `T`. Issue #20300.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
use std::marker::{MarkerTrait, PhantomData};
// Test where the impl self type uses a projection from a constant type.
+// pretty-expanded FIXME #23616
+
trait Int
{
type T;
// appear in associated type bindings in object types, which were not
// being properly flagged.
+// pretty-expanded FIXME #23616
+
use std::ops::{Shl, Shr};
use std::cell::RefCell;
// Test that we are handle to correctly handle a projection type
// that appears in a supertrait bound. Issue #20559.
+// pretty-expanded FIXME #23616
+
trait A
{
type TA;
// Test a where clause that uses a non-normalized projection type.
+// pretty-expanded FIXME #23616
+
trait Int
{
type T;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Foo<T> {
type Bar;
fn get_bar() -> <Self as Foo<T>>::Bar;
// Test associated type references in structure fields.
+// pretty-expanded FIXME #23616
+
trait Test {
type V;
// Test associated type references in a struct literal. Issue #20535.
+// pretty-expanded FIXME #23616
+
pub trait Foo {
type Bar;
// Regression test for #20582. This test caused an ICE related to
// inconsistent region erasure in trans.
+// pretty-expanded FIXME #23616
+
struct Foo<'a> {
buf: &'a[u8]
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Get<T> {
fn get(&self) -> T;
}
// Test equality constraints on associated types in a where clause.
+// pretty-expanded FIXME #23616
+
pub trait Foo {
type A;
fn boo(&self) -> <Self as Foo>::A;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Get {
type Value;
fn get(&self) -> &<Self as Get>::Value;
// Test references to the trait `Stream` in the bounds for associated
// types defined on `Stream`. Issue #20551.
+// pretty-expanded FIXME #23616
+
trait Stream {
type Car;
type Cdr: Stream;
// Test that we correctly normalize the type of a struct field
// which has an associated type.
+// pretty-expanded FIXME #23616
+
pub trait UnifyKey {
type Value;
// Test that we correctly normalize the type of a struct field
// which has an associated type.
+// pretty-expanded FIXME #23616
+
pub trait UnifyKey {
type Value;
// Test paths to associated types using the type-parameter-only sugar.
+// pretty-expanded FIXME #23616
+
pub trait Foo {
type A;
fn boo(&self) -> Self::A;
// carries a predicate that references the trait (`u32 : Trait1`,
// substituted).
+// pretty-expanded FIXME #23616
+
#![allow(dead_code)]
trait Trait1 : Trait2<SomeType<u32>> {
// error-pattern:expected item
+// pretty-expanded FIXME #23616
+
#![feature(custom_attribute, test)]
#[foo = "bar"]
// error-pattern:expected item
+// pretty-expanded FIXME #23616
+
#![feature(custom_attribute, test)]
mod m {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(main)]
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(main)]
#[main]
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unused_attribute)]
#![feature(custom_attribute)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(unsafe_destructor)]
#![feature(unsafe_no_drop_flag)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(start)]
#[start]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(main)]
#[main]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let mut sum = 0;
let xs = vec!(1, 2, 3, 4, 5);
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Pushable<T> {
fn push_val(&mut self, t: T);
}
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn f<T>(x: Vec<T>) -> T { return x.into_iter().next().unwrap(); }
fn g<F>(act: F) -> int where F: FnOnce(Vec<int>) -> int { return act(vec!(1, 2, 3)); }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct Foo {
x: int,
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
assert_eq!(0xffffffff, (-1 as u32));
assert_eq!(4294967295, (-1 as u32));
// Check that issue #954 stays fixed
+// pretty-expanded FIXME #23616
+
pub fn main() {
match -1 { -1 => {}, _ => panic!("wat") }
assert_eq!(1-1, 0);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::sync::Arc;
fn dispose(_x: Arc<bool>) { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
struct Foo { x: int, y: int }
let mut f = Foo { x: 10, y: 0 };
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax, collections)]
// aux-build:blind-item-mixed-crate-use-item-foo.rs
// aux-build:blind-item-mixed-crate-use-item-foo2.rs
+// pretty-expanded FIXME #23616
+
mod m {
pub fn f<T>(_: T, _: (), _: ()) { }
pub fn g<T>(_: T, _: (), _: ()) { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
mod m {
pub fn f<T>(_: T, _: ()) { }
pub fn g<T>(_: T, _: ()) { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn asBlock<F>(f: F) -> uint where F: FnOnce() -> uint {
return f();
}
// no-reformat
+// pretty-expanded FIXME #23616
+
/*
*
* When you write a block-expression thing followed by
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn force<F>(f: F) -> int where F: FnOnce() -> int { return f(); }
pub fn main() {
+// pretty-expanded FIXME #23616
+
pub fn main() {
if !false { assert!((true)); } else { assert!((false)); }
if !true { assert!((false)); } else { assert!((true)); }
// Basic boolean tests
+// pretty-expanded FIXME #23616
+
use std::cmp::Ordering::{Equal, Greater, Less};
use std::ops::{BitAnd, BitOr, BitXor};
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Foo {
fn foo(self);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct Foo(int, int);
fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
struct A {
a: int,
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct F { f: Vec<int> }
fn impure(_v: &[int]) {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
//
// Example from src/librustc_borrowck/borrowck/README.md
+// pretty-expanded FIXME #23616
+
fn foo<'a>(mut t0: &'a mut int,
mut t1: &'a mut int) {
let p: &int = &*t0; // Freezes `*t0`
// that the main function can read the variable too while
// the closures are in scope. Issue #6801.
+// pretty-expanded FIXME #23616
+
fn a() -> i32 {
let mut x = 3;
x += 1;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let x = [22];
let y = &x[0];
// Test that a `&mut` inside of an `&` is freezable.
+// pretty-expanded FIXME #23616
+
struct MutSlice<'a, T:'a> {
data: &'a mut [T]
}
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn borrow(_v: &int) {}
fn borrow_from_arg_imm_ref(v: Box<int>) {
// Check that we do not ICE when compiling this
// macro, which reuses the expression `$id`
+// pretty-expanded FIXME #23616
+
#![feature(box_patterns)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
#![feature(unboxed_closures)]
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn want_slice(v: &[int]) -> int {
let mut sum = 0;
for i in v { sum += *i; }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let mut x = None;
match x {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct Counter {
value: uint
}
// limited to the deref operation itself, and does not infect the
// block as a whole.
+// pretty-expanded FIXME #23616
+
struct Box {
x: uint
}
// Regression test for issue #7740
+// pretty-expanded FIXME #23616
+
pub fn main() {
static A: &'static char = &'A';
}
// This test verifies that casting from the same lifetime on a value
// to the same lifetime on a trait succeeds. See issue #10766.
+// pretty-expanded FIXME #23616
+
#![allow(dead_code)]
use std::marker;
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct Rec {
f: Box<int>,
}
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::cell::Cell;
#[derive(Copy)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn foo(s: &String) -> bool {
match &**s {
"kitty" => true,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn foo<'r>(s: &'r uint) -> bool {
match s {
&3 => true,
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let (&x, &y) = (&3, &'a');
assert_eq!(x, 3);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn select<'r>(x: &'r Option<int>, y: &'r Option<int>) -> &'r Option<int> {
match (x, y) {
(&None, &None) => x,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn foo<T:Clone>(x: &T) -> T{
match x {
&ref a => (*a).clone()
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn main() {
let _a = Box::new(1);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn int_id(x: int) -> int { return x; }
pub fn main() { loop { int_id(break); } }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let mut i = 0;
while i < 20 { i += 1; if i == 10 { break; } }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Speak : Sized {
fn say(&self, s:&str) -> String;
fn hi(&self) -> String { hello(self) }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub trait Foo<T> {
fn func1<U>(&self, t: U, w: T);
// a Send. Basically this just makes sure rustc is using
// each_bound_trait_and_supertraits in type_contents correctly.
+// pretty-expanded FIXME #23616
+
use std::sync::mpsc::{channel, Sender};
trait Bar : Send { }
// Tests "capabilities" granted by traits with super-builtin-kinds,
// even when using them cross-crate.
+// pretty-expanded FIXME #23616
+
extern crate trait_superkinds_in_metadata;
use std::sync::mpsc::{channel, Sender, Receiver};
// builtin-kinds, e.g., if a trait requires Send to implement, then
// at usage site of that trait, we know we have the Send capability.
+// pretty-expanded FIXME #23616
+
use std::sync::mpsc::{channel, Sender, Receiver};
trait Foo : Send { }
// Tests (correct) usage of trait super-builtin-kinds cross-crate.
+// pretty-expanded FIXME #23616
+
extern crate trait_superkinds_in_metadata;
use trait_superkinds_in_metadata::{RequiresRequiresShareAndSend, RequiresShare};
use trait_superkinds_in_metadata::{RequiresCopy};
// super-builtin-kind of a trait, if the type parameter is never used,
// the type can implement the trait anyway.
+// pretty-expanded FIXME #23616
+
use std::marker;
trait Foo : Send { }
// Tests the ability for the Self type in default methods to use
// capabilities granted by builtin kinds as supertraits.
+// pretty-expanded FIXME #23616
+
use std::sync::mpsc::{Sender, channel};
trait Foo : Send + Sized + 'static {
// Simple test case of implementing a trait with super-builtin-kinds.
+// pretty-expanded FIXME #23616
+
trait Foo : Send { }
impl Foo for int { }
// Tests correct implementation of traits with super-builtin-kinds
// using a bounded type parameter.
+// pretty-expanded FIXME #23616
+
trait Foo : Send { }
impl <T: Send> Foo for T { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct X {
a: int
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(libc)]
mod rustrt {
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(libc, std_misc)]
extern crate libc;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn foo() -> int { 22 }
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
/* Any copyright is dedicated to the Public Domain.
* http://creativecommons.org/publicdomain/zero/1.0/ */
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn each<T, F>(x: &[T], mut f: F) where F: FnMut(&T) {
for val in x {
f(val)
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures)]
fn each<'a,T,F:FnMut(&'a T)>(x: &'a [T], mut f: F) {
// exec-env:RUST_LOG=info
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax, old_io, rustc_private, std_misc)]
// issues #10618 and #16382
+// pretty-expanded FIXME #23616
+
const SIZE: int = 25;
fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let i: int = 'Q' as int;
assert_eq!(i, 0x51);
// This test makes sure we can do cross-crate inlining on functions
// that use capture clauses.
+// pretty-expanded FIXME #23616
+
extern crate cci_capture_clause;
pub fn main() {
// aux-build:cci_nested_lib.rs
+// pretty-expanded FIXME #23616
+
#![feature(globs)]
extern crate cci_nested_lib;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::cell::Cell;
#[derive(Copy)]
// main is conditionally compiled, but the conditional compilation
// is conditional too!
+// pretty-expanded FIXME #23616
+
#[cfg_attr(foo, cfg(bar))]
fn main() { }
// https://github.com/rust-lang/rust/issues/21833#issuecomment-72353044
+// pretty-expanded FIXME #23616
+
#![cfg_attr(not_used, no_std)]
fn main() { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#[cfg(windows)]
pub fn main() {
}
// check that cfg correctly chooses between the macro impls (see also
// cfg-macros-notfoo.rs)
+// pretty-expanded FIXME #23616
+
#[cfg(foo)]
#[macro_use]
mod foo {
// check that cfg correctly chooses between the macro impls (see also
// cfg-macros-foo.rs)
+// pretty-expanded FIXME #23616
+
#[cfg(foo)]
#[macro_use]
mod foo {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum Foo {
Bar,
Baz,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#[cfg(target_family = "windows")]
pub fn main() {
}
// aux-build:cfg_inner_static.rs
+// pretty-expanded FIXME #23616
+
extern crate cfg_inner_static;
pub fn main() {
// compile-flags: --cfg fooA --cfg fooB
// fooA AND !bar
+// pretty-expanded FIXME #23616
+
#[cfg(all(fooA, not(bar)))]
fn foo1() -> int { 1 }
+// pretty-expanded FIXME #23616
+
pub fn main() {
let c: char = 'x';
let d: char = 'x';
// Checks that mutable static items can have mutable slices
+// pretty-expanded FIXME #23616
+
static mut TEST: &'static mut [int] = &mut [1];
pub fn main() {
// aux-build:check_static_recursion_foreign_helper.rs
+// pretty-expanded FIXME #23616
+
#![feature(custom_attribute, libc)]
extern crate check_static_recursion_foreign_helper;
// Check that the various ways of getting to a reference to a vec (both sized
// and unsized) work properly.
+// pretty-expanded FIXME #23616
+
const aa: [int; 3] = [1, 2, 3];
const ab: &'static [int; 3] = &aa;
const ac: &'static [int] = ab;
// Reported as issue #126, child leaks the string.
+// pretty-expanded FIXME #23616
+
#![feature(std_misc)]
use std::thread::Thread;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct cat {
done : extern fn(uint),
meows : uint,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
/* Test that exporting a class also exports its
public fields and methods */
// except according to those terms.
// aux-build:cci_class_2.rs
+// pretty-expanded FIXME #23616
+
extern crate cci_class_2;
use cci_class_2::kitties::cat;
// except according to those terms.
// aux-build:cci_class_3.rs
+// pretty-expanded FIXME #23616
+
extern crate cci_class_3;
use cci_class_3::kitties::cat;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct cat {
meows : uint,
// except according to those terms.
// aux-build:cci_class_6.rs
+// pretty-expanded FIXME #23616
+
extern crate cci_class_6;
use cci_class_6::kitties::cat;
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct cat<U> {
info : Vec<U> ,
meows : uint,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct cat {
name : String,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::marker::PhantomData;
struct cat<U> {
// except according to those terms.
// aux-build:cci_class_4.rs
+// pretty-expanded FIXME #23616
+
extern crate cci_class_4;
use cci_class_4::kitties::cat;
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct kitten {
cat: Option<cat>,
}
// except according to those terms.
// aux-build:cci_class.rs
+// pretty-expanded FIXME #23616
+
extern crate cci_class;
use cci_class::kitties::cat;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct cat {
meows : uint,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct cat {
meows : uint,
// Test that cleanup scope for temporaries created in a match
// arm is confined to the match arm itself.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax, os)]
// This test verifies that temporaries created for `while`'s and `if`
// conditions are dropped after the condition is evaluated.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// It's unclear how likely such a bug is to recur, but it seems like a
// scenario worth testing.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// Test that cleanups for the RHS of shortcircuiting operators work.
+// pretty-expanded FIXME #23616
+
use std::env;
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax, std_misc)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures)]
use std::sync::mpsc::channel;
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn foo(i: isize) -> isize { i + 1 }
fn apply<A, F>(f: F, v: A) -> A where F: FnOnce(A) -> A { f(v) }
// Test a rather underspecified example:
+// pretty-expanded FIXME #23616
+
pub fn main() {
let f = {|i| i};
assert_eq!(f(2), 2);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::cmp::Ordering;
// Test default methods in PartialOrd and PartialEq
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// Check that coercions are propagated through match and if expressions.
+// pretty-expanded FIXME #23616
+
use std::boxed::Box;
pub fn main() {
// Check that coercions are propagated through match and if expressions.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::rc::Rc;
// Examples from the "deref coercions" RFC, at rust-lang/rfcs#241.
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn negate(x: &int) -> int {
-*x
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct SpeechMaker {
speeches: uint
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn sum(x: &[int]) -> int {
let mut sum = 0;
for y in x { sum += *y; }
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn bar(v: &mut [uint]) -> Vec<uint> {
v.to_vec()
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct SpeechMaker {
speeches: uint
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct SpeechMaker {
speeches: uint
}
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn reverse(v: &mut [uint]) {
v.reverse();
}
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn bar(v: &mut [uint]) {
v.reverse();
v.reverse();
// Check that coercions unify the expected return type of a polymorphic
// function call, instead of leaving the type variables as they were.
+// pretty-expanded FIXME #23616
+
struct Foo;
impl Foo {
fn foo<T>(self, x: T) -> Option<T> { Some(x) }
// aux-build:coherence-lib.rs
+// pretty-expanded FIXME #23616
+
extern crate "coherence-lib" as lib;
use lib::Remote1;
// aux-build:coherence-lib.rs
+// pretty-expanded FIXME #23616
+
extern crate "coherence-lib" as lib;
use lib::Remote1;
// aux-build:coherence-lib.rs
+// pretty-expanded FIXME #23616
+
extern crate "coherence-lib" as lib;
use lib::Remote1;
// aux-build:coherence-lib.rs
+// pretty-expanded FIXME #23616
+
extern crate "coherence-lib" as lib;
use lib::Remote;
// Test that it's ok for T to appear first in the self-type, as long
// as it's covered somewhere.
+// pretty-expanded FIXME #23616
+
extern crate "coherence-lib" as lib;
use lib::{Remote,Pair};
// Test that it's ok for T to appear second in the self-type, as long
// as it's covered somewhere.
+// pretty-expanded FIXME #23616
+
extern crate "coherence-lib" as lib;
use lib::{Remote,Pair};
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
#[derive(Copy)]
enum x { foo }
// aux-build:coherence-lib.rs
+// pretty-expanded FIXME #23616
+
extern crate "coherence-lib" as lib;
use lib::Remote1;
// aux-build:coherence-lib.rs
+// pretty-expanded FIXME #23616
+
extern crate "coherence-lib" as lib;
use lib::Remote1;
// aux-build:coherence-lib.rs
+// pretty-expanded FIXME #23616
+
extern crate "coherence-lib" as lib;
use lib::Remote;
// aux-build:coherence-lib.rs
+// pretty-expanded FIXME #23616
+
extern crate "coherence-lib" as lib;
use lib::Remote;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::fmt::Debug;
use std::default::Default;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(optin_builtin_traits)]
use std::marker::Send;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// no-pretty-expanded
-
use std::io::Write;
use std::fmt;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
type an_int = int;
fn cmp(x: Option<an_int>, y: Option<int>) -> bool {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
assert_eq!(format!(concat!("foo", "bar", "{}"), "baz"), "foobarbaz".to_string());
assert_eq!(format!(concat!()), "".to_string());
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#[cfg(target_arch = "x86")]
pub fn main() { }
// except according to those terms.
// Crate use statements
+// pretty-expanded FIXME #23616
+
#[cfg(bogus)]
use flippity;
// compile-flags: -C debug-assertions=no
// exec-env:RUST_LOG=conditional-debug-macro-off=4
+// pretty-expanded FIXME #23616
+
#![feature(rustc_private)]
#[macro_use]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
static A: [u8; 1] = ['h' as u8];
static B: u8 = (&A)[0];
static C: &'static &'static &'static &'static [u8; 1] = & & & &A;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum Foo {
Bar(u32),
Baz,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
macro_rules! assert_approx_eq {
($a:expr, $b:expr) => ({
use std::num::Float;
// aux-build:cci_const_block.rs
+// pretty-expanded FIXME #23616
+
extern crate cci_const_block;
pub fn main() {
// General test that function items in static blocks
// can be generated with a macro.
+// pretty-expanded FIXME #23616
+
struct MyType {
desc: &'static str,
data: uint,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
mod foo {
pub trait Value {
fn value(&self) -> uint;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(dead_code)]
#![allow(unused_unsafe)]
// Make sure const bounds work on things, and test that a few types
// are const.
+// pretty-expanded FIXME #23616
+
fn foo<T: Sync>(x: T) -> T { x }
struct F { field: int }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::ptr;
struct TestStruct {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(libc)]
extern crate libc;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
const a: int = 1;
const b: int = a + 2;
// Issue #570
+// pretty-expanded FIXME #23616
+
static lsl : int = 1 << 2;
static add : int = 1 + 2;
static addf : f64 = 1.0 + 2.0;
// aux-build:cci_const.rs
+// pretty-expanded FIXME #23616
+
extern crate cci_const;
static foo: &'static str = cci_const::foopy;
static a: uint = cci_const::uint_val;
// aux-build:cci_const.rs
+// pretty-expanded FIXME #23616
+
extern crate cci_const;
use cci_const::bar;
static foo: extern "C" fn() = bar;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
const C: &'static int = &1000;
static D: int = *C;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum E { V, VV(int) }
static C: E = E::V;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum E { V, VV(int) }
static C: E = E::V;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum A { A1, A2 }
enum B { B1=0, B2=2 }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum E { V0, V1(int) }
static C: &'static E = &E::V0;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum E { V16(u16), V32(u32) }
struct S { a: E, b: u16, c: u16 }
static C: S = S { a: E::V16(0xDEAD), b: 0x600D, c: 0xBAD };
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum E { V0, V16(u16) }
struct S { a: E, b: u16, c: u16 }
static C: S = S { a: E::V0, b: 0x600D, c: 0xBAD };
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum E {
S0 { s: String },
S1 { u: uint }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum E { V16(u16), V32(u32) }
static C: (E, u16, u16) = (E::V16(0xDEAD), 0x600D, 0xBAD);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum E { V0, V16(u16) }
static C: (E, u16, u16) = (E::V0, 0x600D, 0xBAD);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum E { V16(u16), V32(u32) }
struct S(E, u16, u16);
static C: S = S(E::V16(0xDEAD), 0x600D, 0xBAD);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum E { V0, V16(u16) }
struct S(E, u16, u16);
static C: S = S(E::V0, 0x600D, 0xBAD);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum E { V1(int), V0 }
const C: &'static [E] = &[E::V0, E::V1(0xDEADBEE)];
static C0: E = C[0];
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum E { V1(int), V0 }
static C: &'static [E] = &[E::V0, E::V1(0xDEADBEE), E::V0];
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum E { V1(int), V0 }
static C: [E; 3] = [E::V0, E::V1(0xDEADBEE), E::V0];
// Check that constant expressions can be used for declaring the
// type of a fixed length vector.
+// pretty-expanded FIXME #23616
+
pub fn main() {
const FOO: uint = 2;
// Check that constant expressions can be used in vec repeat syntax.
+// pretty-expanded FIXME #23616
+
pub fn main() {
const FOO: uint = 2;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
extern fn foopy() {}
static f: extern "C" fn() = foopy;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn foo() -> int {
return 0xca7f000d;
}
// Issue #358
+// pretty-expanded FIXME #23616
+
static toplevel_mod: int = -1;
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum Foo {
Bar,
Baz,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#[derive(Copy)]
enum Foo {
Bar = 0xDEADBEE
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
type Big = [u64; 8];
struct Pair<'a> { a: int, b: &'a Big }
const x: &'static Big = &([13, 14, 10, 13, 11, 14, 14, 15]);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::{str, string};
const A: [u8; 2] = ['h' as u8, 'i' as u8];
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum Foo {
IntVal(i32),
Int64Val(i64)
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct Bar(int, int);
static X: Bar = Bar(1, 2);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct Foo;
static X: Foo = Foo;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
/*!
* Try to double-check that static fns have the right size (with or
* without dummy env ptr, as appropriate) by iterating a size-2 array.
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn f(_: &[int]) {}
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
const FOO: int = 10;
const BAR: int = 3;
//
// (Compare with compile-fail/move-out-of-array-1.rs)
+// pretty-expanded FIXME #23616
+
struct C { _x: u8 }
impl Copy for C { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn main() {
use ::std::mem;
mem::drop(2_usize);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// compile-flags:--crate-name crate-name-attr-used -F unused-attributes
+// pretty-expanded FIXME #23616
+
#![crate_name = "crate-name-attr-used"]
fn main() {}
// aux-build:cci_const.rs
+// pretty-expanded FIXME #23616
+
extern crate cci_const;
pub fn main() {
// aux-build:newtype_struct_xc.rs
+// pretty-expanded FIXME #23616
+
extern crate newtype_struct_xc;
pub fn main() {
// Regression test for #15477. This test just needs to compile.
+// pretty-expanded FIXME #23616
+
use std::marker::PhantomFn;
trait Chromosome<X: Chromosome<i32>> : PhantomFn<(Self,X)> {
// Test a case where a supertrait references a type that references
// the original trait. This poses no problem at the moment.
+// pretty-expanded FIXME #23616
+
trait Chromosome: Get<Struct<i32>> {
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![deny(dead_code)]
static _X: uint = 0;
+// pretty-expanded FIXME #23616
+
fn f(x: int) -> int {
if x == 1 { return 1; } else { let y: int = 1 + f(x - 1); return y; }
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Foo {
fn m(&self, _:int) { }
}
// except according to those terms.
//~ WARNING no_split_stack is a deprecated synonym for no_stack_check
+// pretty-expanded FIXME #23616
+
#[no_split_stack]
fn main() {
}
// Test that `&mut T` implements `DerefMut<T>`
+// pretty-expanded FIXME #23616
+
use std::ops::{Deref, DerefMut};
fn inc<T: Deref<Target=int> + DerefMut>(mut t: T) {
// Test that `&T` and `&mut T` implement `Deref<T>`
+// pretty-expanded FIXME #23616
+
use std::ops::Deref;
fn deref<U:Copy,T:Deref<Target=U>>(t: T) -> U {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::rc::Rc;
fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#[derive(Copy)]
struct Test;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#[derive(Clone)]
enum E {
A,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#[derive(Clone)]
enum E<T,U> {
A(T),
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#[derive(Clone)]
struct S<T> {
foo: (),
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#[derive(Clone)]
struct S<T>(T, ());
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#[derive(Clone)]
struct S {
_int: int,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#[derive(Clone)]
struct S((), ());
// no-pretty-expanded FIXME #15189
+// pretty-expanded FIXME #23616
+
#[derive(PartialEq, Eq, PartialOrd, Ord)]
enum E<T> {
E0,
// no-pretty-expanded FIXME #15189
+// pretty-expanded FIXME #23616
+
#[derive(PartialEq, Eq, PartialOrd, Ord)]
enum ES<T> {
ES1 { x: T },
// no-pretty-expanded FIXME #15189
+// pretty-expanded FIXME #23616
+
#[derive(PartialEq, Eq, PartialOrd, Ord)]
struct S<T> {
x: T,
// no-pretty-expanded FIXME #15189
+// pretty-expanded FIXME #23616
+
#[derive(PartialEq, Eq, PartialOrd, Ord)]
struct TS<T>(T,T);
// where possible, by having a type that panics when compared as the
// second element, so this passes iff the instances shortcircuit.
+// pretty-expanded FIXME #23616
+
use std::cmp::Ordering;
pub struct FailCmp;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
#![feature(old_orphan_check, rustc_private)]
// This briefly tests the capability of `Cell` and `RefCell` to implement the
// `Encodable` and `Decodable` traits via `#[derive(Encodable, Decodable)]`
+// pretty-expanded FIXME #23616
+
#![feature(old_orphan_check, rustc_private)]
extern crate serialize;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub type task_id = int;
#[derive(PartialEq)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(hash)]
use std::hash::{Hash, SipHasher};
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
macro_rules! define_vec {
() => (
mod foo {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::hash::{Hash, SipHasher};
// testing multiple separate deriving attributes
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::hash::{Hash, SipHasher};
#[derive(PartialEq, Clone, Hash)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(rand)]
use std::rand;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#[derive(Hash)]
enum Foo {
Bar(int, char),
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#[derive(Hash)]
struct Foo {
x: int,
// Ensure that we can do a destructuring bind of a fixed-size array,
// even when the element type has a destructor.
+// pretty-expanded FIXME #23616
+
struct D { x: u8 }
impl Drop for D { fn drop(&mut self) { } }
// Just testing that panic!() type checks in statement or expr
+// pretty-expanded FIXME #23616
+
#![allow(unreachable_code)]
fn f() {
+// pretty-expanded FIXME #23616
+
pub fn main() {
let x: int = 15;
let y: int = 5;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn check_expr() {
let _: & uint = &1;
let _: & & uint = &&1;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
+// pretty-expanded FIXME #23616
+
fn f() -> int {
if true {
let _s: String = "should not leak".to_string();
// Test that destructor on a struct runs successfully after the struct
// is boxed and converted to an object.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum Foo { }
impl Drop for Foo {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(str_words)]
fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(collections)]
fn main() {
// shows a similar setup, but restricts `f` so that the struct `C<'a>`
// is force-fed a lifetime equal to that of the borrowed arena.
+// pretty-expanded FIXME #23616
+
#![allow(unstable)]
#![feature(unsafe_destructor, rustc_private)]
// Test coercions involving DST and/or raw pointers
+// pretty-expanded FIXME #23616
+
struct S;
trait T { fn dummy(&self) { } }
impl T for S {}
// Test that a custom deref with a fat pointer return type does not ICE
+// pretty-expanded FIXME #23616
+
use std::ops::{Deref, DerefMut};
pub struct Arr {
// Test that a custom deref with a fat pointer return type does not ICE
+// pretty-expanded FIXME #23616
+
use std::ops::Deref;
pub struct Arr {
// Test that overloaded index expressions with DST result types
// work and don't ICE.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
use std::ops::Index;
// Test DST raw pointers
+// pretty-expanded FIXME #23616
+
trait Trait {
fn foo(&self) -> int;
}
// As dst-struct.rs, but the unsized field is the only field in the struct.
+// pretty-expanded FIXME #23616
+
struct Fat<T: ?Sized> {
ptr: T
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// Regression test for a problem with the first mod attribute
// being applied to every mod
+// pretty-expanded FIXME #23616
+
#[cfg(target_os = "linux")]
mod hello;
// aux-build:anon-extern-mod-cross-crate-1.rs
// aux-build:anon-extern-mod-cross-crate-1.rs
+// pretty-expanded FIXME #23616
+
extern crate anonexternmod;
pub fn main() { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn wsucc(n: int) -> int { 0 + { return n + 1 } }
pub fn main() { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait thing<A> {
fn foo(&self) -> Option<A>;
}
+// pretty-expanded FIXME #23616
+
pub fn main() {
if 1 == 2 {
assert!((false));
// FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
+// pretty-expanded FIXME #23616
+
pub fn main() {
assert!(Some(Box::new(())).is_some());
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let x = *Box::new(());
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unused_mut)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::mem;
fn addr_of<T>(ptr: &T) -> uint {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
/*!
* C-like enums have to be represented as LLVM ints, not wrapped in a
* struct, because it's important for the FFI that they interoperate
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum Animal {
Cat = 0,
Dog = 1,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::mem::size_of;
enum Ei8 {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::mem::size_of;
#[repr(i8)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub enum E64 {
H64 = 0x7FFF_FFFF_FFFF_FFFF,
L64 = 0x8000_0000_0000_0000
// pp-exact
+// pretty-expanded FIXME #23616
+
enum color { red = 1, green, blue, imaginary = -1, }
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
mod a {
pub enum Foo {
Bar,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
extern crate core;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::result::Result;
use std::result::Result::Ok;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(dead_assignment)]
#![allow(unused_variable)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum Flopsy {
Bunny = 2
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(path)]
use std::env::*;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::env::*;
fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#[derive(PartialEq)]
struct Bar;
struct Baz;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(dead_assignment)]
pub fn main() {
// exec-env:TEST_EXEC_ENV=22
+// pretty-expanded FIXME #23616
+
use std::env;
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let x: int = 8;
let y = 9;
// Test to make sure that explicit self params work inside closures
+// pretty-expanded FIXME #23616
+
struct Box {
x: uint
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// aux-build:explicit_self_xcrate.rs
+// pretty-expanded FIXME #23616
+
extern crate explicit_self_xcrate;
use explicit_self_xcrate::{Foo, Bar};
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(std_misc)]
use std::num::strconv::ExponentFormat::{ExpBin, ExpDec};
// We can export tags without exporting the variants to create a simple
// sort of ADT.
+// pretty-expanded FIXME #23616
+
mod foo {
pub enum t { t1, }
// Modified to not use export since it's going away. --pcw
+// pretty-expanded FIXME #23616
+
mod foo {
use foo::bar::*;
pub mod bar {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use m::f;
use m::g;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
mod foo {
pub enum t { t1, }
}
+// pretty-expanded FIXME #23616
+
fn test_fn() {
fn ten() -> int { return 10; }
let rs = ten;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn test_generic<T: Clone, F>(expected: T, eq: F) where F: FnOnce(T, T) -> bool {
let actual: T = { expected.clone() };
assert!(eq(expected, actual));
// Regression test for issue #377
+// pretty-expanded FIXME #23616
+
struct A { a: int }
struct V { v: int }
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// Tests for standalone blocks as expressions
+// pretty-expanded FIXME #23616
+
fn test_basic() { let rs: bool = { true }; assert!((rs)); }
struct RS { v1: int, v2: int }
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn f(arg: &mut A) {
arg.a = 100;
}
// Issue #521
+// pretty-expanded FIXME #23616
+
fn f() {
let _x = match true {
true => { 10 }
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn test_int() {
fn f() -> int { 10 }
assert_eq!(f(), 10);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn test_generic<T, F>(expected: T, not_expected: T, eq: F) where
T: Clone,
F: FnOnce(T, T) -> bool,
// When all branches of an if expression result in panic, the entire if
// expression results in panic.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let _x = if true {
10
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn test_if_panic() {
let x = if false { panic!() } else { 10 };
assert!((x == 10));
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// Tests for if as expressions
+// pretty-expanded FIXME #23616
+
fn test_if() { let rs: bool = if true { true } else { false }; assert!((rs)); }
fn test_else() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// except according to those terms.
+// pretty-expanded FIXME #23616
+
type compare<T> = extern "Rust" fn(T, T) -> bool;
fn test_generic<T:Clone>(expected: T, eq: compare<T>) {
// When all branches of a match expression result in panic, the entire
// match expression results in panic.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let _x =
match true {
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn test_simple() {
let r = match true { true => { true } false => { panic!() } };
assert_eq!(r, true);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// Tests for using match as an expression
+// pretty-expanded FIXME #23616
+
fn test_basic() {
let mut rs: bool = match true { true => { true } false => { false } };
assert!((rs));
// Regression test for issue #762
+// pretty-expanded FIXME #23616
+
pub fn f() { }
pub fn main() { return ::f(); }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
static FOO : &'static str = concat!(concat!("hel", "lo"), "world");
pub fn main() {
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::cell::Cell;
#[derive(Copy)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
extern fn f() {
}
// Test direct calls to extern fns.
+// pretty-expanded FIXME #23616
+
extern fn f(x: uint) -> uint { x * 2 }
pub fn main() {
// aux-build:extern_calling_convention.rs
+// pretty-expanded FIXME #23616
+
extern crate extern_calling_convention;
use extern_calling_convention::foo;
// Tests that we can compare various kinds of extern fn signatures.
+// pretty-expanded FIXME #23616
+
extern fn voidret1() {}
extern fn voidret2() {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
extern crate "std" as mystd;
pub fn main() {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
use std::marker::MarkerTrait;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
extern "C" {
fn pow(x: f64, y: f64) -> f64;
}
// aux-build:extern_mod_ordering_lib.rs
+// pretty-expanded FIXME #23616
+
extern crate extern_mod_ordering_lib;
use extern_mod_ordering_lib::extern_mod_ordering_lib as the_lib;
// Test a function that takes/returns a u8.
+// pretty-expanded FIXME #23616
+
#[link(name = "rust_test_helpers")]
extern {
pub fn rust_dbg_extern_identity_u8(v: u8) -> u8;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#[link(name = "rust_test_helpers")]
extern {
pub fn rust_dbg_extern_identity_double(v: f64) -> f64;
// Test a foreign function that accepts empty struct.
+// pretty-expanded FIXME #23616
+
struct TwoU8s {
one: u8,
two: u8,
// Test a function that takes/returns a u32.
+// pretty-expanded FIXME #23616
+
#[link(name = "rust_test_helpers")]
extern {
pub fn rust_dbg_extern_identity_u32(v: u32) -> u32;
// Test a call to a function that takes/returns a u64.
+// pretty-expanded FIXME #23616
+
#[link(name = "rust_test_helpers")]
extern {
pub fn rust_dbg_extern_identity_u64(v: u64) -> u64;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
extern {
pub fn free(p: *const u8);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub struct TwoU16s {
one: u16, two: u16
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub struct TwoU32s {
one: u32, two: u32
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub struct TwoU64s {
one: u64, two: u64
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub struct TwoU8s {
one: u8, two: u8
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#[repr(C)]
pub struct Foo(u32);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
extern fn f() {
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
assert!(option_env!("__HOPEFULLY_DOESNT_EXIST__").is_none());
}
// declarations, but we currently run them top-to-bottom. I don't think the
// order really matters that much as long as we define what it is.
+// pretty-expanded FIXME #23616
+
struct A;
struct B;
struct C {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
// Make sure that this view item is filtered out because otherwise it would
// trigger a compilation error
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let arr = [1,2,3];
let arr2 = arr;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::ops::{Deref, DerefMut};
// Generic unique/owned smaht pointer.
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(std_misc)]
use std::num::Float;
+// pretty-expanded FIXME #23616
+
pub fn main() {
let a = 1.5e6f64;
let b = 1.5E6f64;
+// pretty-expanded FIXME #23616
+
pub fn main() {
let f = 4.999999999999f64;
assert!((f > 4.90f64));
// Ensure that declarations and types which use `extern fn` both have the same
// ABI (#9309).
+// pretty-expanded FIXME #23616
+
extern {
fn printf();
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn f(i: int, called: &mut bool) {
assert_eq!(i, 10);
*called = true;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn bare() {}
fn likes_block<F>(f: F) where F: FnOnce() { f() }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::mem;
pub fn main() {
// This is what the signature to spawn should look like with bare functions
+// pretty-expanded FIXME #23616
+
fn spawn<T:Send>(val: T, f: fn(T)) {
f(val);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct r<F> where F: FnOnce() {
field: F,
}
// Test explicit coercions from a fn item type to a fn pointer type.
+// pretty-expanded FIXME #23616
+
fn foo(x: int) -> int { x * 2 }
fn bar(x: int) -> int { x * 4 }
type IntMap = fn(int) -> int;
// Test implicit coercions from a fn item type to a fn pointer type.
+// pretty-expanded FIXME #23616
+
fn foo(x: int) -> int { x * 2 }
fn bar(x: int) -> int { x * 4 }
type IntMap = fn(int) -> int;
+// pretty-expanded FIXME #23616
+
fn foo(_f: fn(int) -> int) { }
fn id(x: int) -> int { return x; }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let f = |(x, y): (int, int)| {
assert_eq!(x, 1);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unused_variable)]
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct Pair { x: int, y: int }
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum BogusOption<T> {
None,
Some(T),
// Test that for loops can do what RFC #235 claims
+// pretty-expanded FIXME #23616
+
fn main() {
let mut v = vec![1];
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(lang_items, start, no_std, core, collections)]
#![no_std]
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() { let x: Vec<int> = Vec::new(); for _ in &x { panic!("moop"); } }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let x = [1; 100];
let mut y = 0;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(collections)]
extern crate collections;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(collections)]
extern crate collections;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let x = [1; 100];
let mut y = 0;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let x = [1; 100];
let y = [2; 100];
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let x = [1; 100];
let mut y = 0;
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn two<F>(mut it: F) where F: FnMut(int) { it(0); it(1); }
pub fn main() {
// calling pin_task and that's having weird side-effects.
+// pretty-expanded FIXME #23616
+
#![feature(libc)]
mod rustrt1 {
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(std_misc, libc)]
extern crate libc;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#[derive(Copy)]
pub struct S {
x: u64,
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(libc)]
extern crate libc;
// ABI is cdecl by default
+// pretty-expanded FIXME #23616
+
#![feature(libc)]
mod rustrt {
// Passing enums by value
+// pretty-expanded FIXME #23616
+
pub enum void { }
mod bindgen {
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(libc)]
extern crate libc;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
use std::f64;
let x = "NaN".to_string();
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(lang_items, start, no_std, core, collections)]
#![no_std]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::cell::RefCell;
pub fn main() {
// Issue 4691: Ensure that functional-struct-updates operates
// correctly and moves rather than copy when appropriate.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax, core)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn ho<F>(f: F) -> int where F: FnOnce(int) -> int { let n: int = f(3); return n; }
fn direct(x: int) -> int { return x + 1; }
+// pretty-expanded FIXME #23616
+
fn f() -> int { return 42; }
pub fn main() {
// Test that we do not leak when the arg pattern must drop part of the
// argument (in this case, the `y` field).
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// boxes. Make sure that we don't free the box as we match the
// pattern.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_patterns)]
#![feature(box_syntax)]
// Test that we can compile code that uses a `_` in function argument
// patterns.
+// pretty-expanded FIXME #23616
+
fn foo((x, _): (int, int)) -> int {
x
}
// aux-build:default_type_params_xc.rs
+// pretty-expanded FIXME #23616
+
extern crate default_type_params_xc;
struct Vec<T, A = default_type_params_xc::Heap>(Option<(T,A)>);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
use std::num::Int;
// Issue #45: infer type parameters in function applications
+// pretty-expanded FIXME #23616
+
fn id<T>(x: T) -> T { return x; }
pub fn main() { let x: int = 42; let y: int = id(x); assert!((x == y)); }
+// pretty-expanded FIXME #23616
+
mod foomod {
pub fn foo<T>() { }
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum wrapper<T> { wrapped(T), }
pub fn main() { let _w = wrapper::wrapped(vec!(1, 2, 3, 4, 5)); }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct S<T>(T);
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait vec_utils<T> {
fn map_<U, F>(x: &Self, f: F) -> Vec<U> where F: FnMut(&T) -> U;
}
// This used to cause memory corruption in stage 0.
+// pretty-expanded FIXME #23616
+
enum thing<K> { some(K), }
pub fn main() { let _x = thing::some("hi".to_string()); }
+// pretty-expanded FIXME #23616
+
enum clam<T> { a(T), }
pub fn main() { let _c = clam::a(3); }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(dead_assignment)]
#![allow(unused_variable)]
#![allow(unknown_features)]
+// pretty-expanded FIXME #23616
+
struct Foo<T> {
a: T
}
+// pretty-expanded FIXME #23616
+
struct Pair<T> {x: T, y: T}
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(rustc_private)]
extern crate getopts;
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn f() -> int { return 1; }
pub mod foo {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#[derive(Copy)]
enum Q { R(Option<uint>) }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#[derive(Copy)]
struct Pair { x: int, y: int }
// `&Typer<'tcx>` was getting an incorrect binder level, yielding
// weird compilation ICEs and so forth.
+// pretty-expanded FIXME #23616
+
trait Typer<'tcx> {
fn method(&self, data: &'tcx int) -> &'tcx int { data }
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Typer<'tcx> {
fn method(&self, data: &'tcx int) -> &'tcx int { data }
fn dummy(&self) { }
// A basic test of using a higher-ranked trait bound.
+// pretty-expanded FIXME #23616
+
trait FnLike<A,R> {
fn call(&self, arg: A) -> R;
}
// A basic test of using a higher-ranked trait bound.
+// pretty-expanded FIXME #23616
+
trait FnLike<A,R> {
fn call(&self, arg: A) -> R;
}
// did not consider that a match (something I would like to revise in
// a later PR).
+// pretty-expanded FIXME #23616
+
#![allow(dead_code)]
use std::marker::PhantomData;
// Test that we can parse all the various places that a `for` keyword
// can appear representing universal quantification.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures)]
#![allow(unused_variables)]
#![allow(dead_code)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures)]
// Test that `F : Fn(int) -> int + Send` is interpreted as two
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(unboxed_closures)]
// A basic test of using a higher-ranked trait bound.
+// pretty-expanded FIXME #23616
+
trait FnLike<A,R> {
fn call(&self, arg: A) -> R;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures)]
// A basic test of using a higher-ranked trait bound.
// PrinterSupport<'b>`, gets properly expanded when it appears in a
// closure type. This used to result in messed up De Bruijn indices.
+// pretty-expanded FIXME #23616
+
trait PrinterSupport<'ast> {
fn ast_map(&self) -> Option<&'ast uint> { None }
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::mem::size_of;
#[cfg(target_pointer_width = "32")]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
mod x {
pub fn g() -> uint {14}
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
macro_rules! loop_x {
($e: expr) => {
// $e shouldn't be able to interact with this 'x
+// pretty-expanded FIXME #23616
+
pub fn main() { let mut x: i32 = -400; x = 0 - x; assert!((x == 400)); }
+// pretty-expanded FIXME #23616
+
pub fn main() {
let mut x: i8 = -12;
let y: i8 = -12;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let x = Some(3);
if let Some(y) = x {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn foo() { if (return) { } }
pub fn main() { foo(); }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(advanced_slice_patterns)]
struct Foo(int, int, int, int);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum option_<T> {
none_,
some_(T),
// with the same name, which can be called on values that have a
// precise enough type to allow distinguishing between the methods.
+// pretty-expanded FIXME #23616
+
struct Foo<T>(T);
impl Foo<usize> {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct Foo;
trait Trait {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
mod foo {
pub struct Point {
pub x: i32,
// aux-build:impl_privacy_xc_1.rs
+// pretty-expanded FIXME #23616
+
extern crate impl_privacy_xc_1;
pub fn main() {
// aux-build:crate_with_invalid_spans.rs
+// pretty-expanded FIXME #23616
+
extern crate crate_with_invalid_spans;
fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use spam::{ham, eggs};
mod spam {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(dead_assignment)]
use std::mem::*;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
use std::mem::replace;
let mut x = 5;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use foo::bar::{baz, quux,};
mod foo {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn foo(_: &[&str]) {}
fn bad(a: &str, b: &str) {
// Given `<expr> as Box<Trait>`, we should be able to infer that a
// `Box<_>` is the expected type.
+// pretty-expanded FIXME #23616
+
trait Foo { fn foo(&self) -> u32; }
impl Foo for u32 { fn foo(&self) -> u32 { *self } }
// issue #680
+// pretty-expanded FIXME #23616
+
fn f() -> Vec<int> { Vec::new() }
pub fn main() { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let x = 2;
let x_message = match x {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct Foo;
impl Foo {
// Doing it incorrectly causes massive slowdown in LLVM during
// optimisation.
+// pretty-expanded FIXME #23616
+
#![feature(intrinsics, std_misc)]
use std::thread::Thread;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
#![feature(unsafe_destructor)]
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct Foo;
impl Foo {
// aux-build:inner_static.rs
+// pretty-expanded FIXME #23616
+
extern crate inner_static;
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::ptr;
// check that we do not report a type like this as uninstantiable,
+// pretty-expanded FIXME #23616
+
pub fn main() { let _x: int = 10; }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let a = 0xBEEF_isize;
let b = 0o755_isize;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn foo(_: *const ()) {}
fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
fn id_i8(n: i8) -> i8 { n }
fn id_i16(n: i16) -> i16 { n }
// propagation yet, and so we just saw a type variable, yielding an
// error.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
use std::u8;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(intrinsics, main)]
mod rusti {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
use std::intrinsics::assume;
// aux-build:cci_intrinsic.rs
+// pretty-expanded FIXME #23616
+
extern crate cci_intrinsic;
use cci_intrinsic::atomic_xchg;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
#![feature(intrinsics)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
#![feature(intrinsics)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(intrinsics)]
use std::ptr;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(intrinsics)]
mod rusti {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
use std::intrinsics;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(intrinsics)]
mod rusti {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(intrinsics, core)]
macro_rules! assert_approx_eq {
// successfully (and safely) invoke external, cdecl
// functions from outside the crate.
+// pretty-expanded FIXME #23616
+
extern crate foreign_lib;
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let ((),()) = ((),());
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
unsafe extern fn foo() {}
unsafe extern "C" fn bar() {}
// aux-build:issue-10028.rs
+// pretty-expanded FIXME #23616
+
extern crate "issue-10028" as issue10028;
use issue10028::ZeroLengthThingWithDestructor;
// except according to those terms.
// aux-build:issue_10031_aux.rs
+// pretty-expanded FIXME #23616
+
extern crate issue_10031_aux;
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum StdioContainer {
CreatePipe(bool)
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct A { foo: int }
struct B { a: int, b: int, c: int }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub struct Foo;
pub trait Bar {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
//// I am not a doc comment!
////////////////// still not a doc comment
// Regression test for issue #10682
// Nested `proc` usage can't use outer owned data
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::ascii::AsciiExt;
static NAME: &'static str = "hello world";
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum v {}
pub fn main() {
let y: v = unsafe { ::std::mem::uninitialized() };
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures)]
fn f<F:FnOnce()>(p: F) {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(unsafe_no_drop_flag)]
static mut drop_count: uint = 0;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
extern "Rust" fn foo() {}
fn main() {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
extern "Rust" fn main() {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn foo() -> int {
3
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![deny(missing_docs)]
#![doc="module"]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub mod two_tuple {
pub trait T { fn dummy(&self) { } }
pub struct P<'a>(&'a (T + 'a), &'a (T + 'a));
// compile-flags: --cfg foo
+// pretty-expanded FIXME #23616
+
struct Foo {
#[cfg(fail)]
bar: baz,
// Issue #1112
// Alignment of interior pointers to dynamic-size types
+// pretty-expanded FIXME #23616
+
struct X<T> {
a: T,
b: u8,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(dead_code)]
// FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
// aux-build:issue-11224.rs
+// pretty-expanded FIXME #23616
+
extern crate "issue-11224" as unused;
pub fn main() {}
// aux-build:issue-11225-1.rs
+// pretty-expanded FIXME #23616
+
extern crate "issue-11225-1" as foo;
pub fn main() {
// aux-build:issue-11225-2.rs
+// pretty-expanded FIXME #23616
+
extern crate "issue-11225-2" as foo;
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Common { fn dummy(&self) { } }
impl<'t, T> Common for (T, &'t T) {}
// aux-build:issue-11529.rs
+// pretty-expanded FIXME #23616
+
extern crate "issue-11529" as a;
fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_patterns)]
#![feature(box_syntax)]
+// pretty-expanded FIXME #23616
+
// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
// We weren't updating the auto adjustments with all the resolved
// type information after type check.
+// pretty-expanded FIXME #23616
+
trait A { fn dummy(&self) { } }
struct B<'a, T:'a> {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(dead_code)]
// this code used to cause an ICE
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(collections)]
extern crate collections;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct NoClone;
fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct A {
a: String
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(old_orphan_check, rustc_private, old_io)]
extern crate rbml;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
const TEST_STR: &'static str = "abcd";
fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![forbid(warnings)]
#![feature(std_misc)]
// aux-build:issue-12133-rlib.rs
// aux-build:issue-12133-dylib.rs
+// pretty-expanded FIXME #23616
+
extern crate "issue-12133-rlib" as a;
extern crate "issue-12133-dylib" as b;
// aux-build:issue-12133-dylib.rs
// no-prefer-dynamic
+// pretty-expanded FIXME #23616
+
extern crate "issue-12133-rlib" as a;
extern crate "issue-12133-dylib" as b;
// aux-build:issue-12133-dylib.rs
// aux-build:issue-12133-dylib2.rs
+// pretty-expanded FIXME #23616
+
extern crate "issue-12133-dylib2" as other;
fn main() {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct S;
fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(libc)]
#![crate_id="rust_get_test_int"]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main () {
let mut line = "".to_string();
let mut i = 0;
// aux-build:issue-12612-1.rs
// aux-build:issue-12612-2.rs
+// pretty-expanded FIXME #23616
+
extern crate "issue-12612-1" as foo;
extern crate "issue-12612-2" as bar;
// aux-build:issue-12660-aux.rs
+// pretty-expanded FIXME #23616
+
extern crate issue12660aux;
use issue12660aux::{my_fn, MyStruct};
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn main() {
let s = "Hello";
let first = s.bytes();
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(old_io, std_misc)]
use std::time::Duration;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(old_io, std_misc)]
use std::old_io::timer;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub struct Foo;
mod bar {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(collections)]
extern crate collections;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::collections::HashMap;
fn copy<T: Copy>(&x: &T) -> T {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
use std::marker::MarkerTrait;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::slice;
pub struct PhfMapEntries<'a, T: 'a> {
// Test that when instantiating trait default methods, typeck handles
// lifetime parameters defined on the method bound correctly.
+// pretty-expanded FIXME #23616
+
pub trait Foo {
fn bar<'a, I: Iterator<Item=&'a ()>>(&self, it: I) -> uint {
let mut xs = it.filter(|_| true);
// defining static with struct that contains enum
// with &'static str variant used to cause ICE
+// pretty-expanded FIXME #23616
+
pub enum Foo {
Bar,
Baz(&'static str),
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(libc)]
extern crate libc;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::ops::Deref;
struct Root {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(std_misc, libc)]
extern crate libc;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct Foo<'a> {
i: &'a bool,
j: Option<&'a int>,
// This test may not always fail, but it can be flaky if the race it used to
// expose is still present.
+// pretty-expanded FIXME #23616
+
#![feature(std_misc)]
use std::sync::mpsc::{channel, Sender, Receiver};
// aux-build:issue13507.rs
+// pretty-expanded FIXME #23616
+
#![feature(core)]
extern crate issue13507;
// aux-build:issue-13620-1.rs
// aux-build:issue-13620-2.rs
+// pretty-expanded FIXME #23616
+
extern crate "issue-13620-2" as crate2;
fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn foo<'r>() {
let maybe_value_ref: Option<&'r u8> = None;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub struct Foo<'a, 'b: 'a> { foo: &'a &'b int }
pub fn foo<'a, 'b>(x: Foo<'a, 'b>, _o: Option<& & ()>) { let _y = x.foo; }
fn main() {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
use std::u8;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Foo {
fn bar(&self, int) {}
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct Foo<'a> {
listener: Box<FnMut() + 'a>,
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct TestStruct {
x: *const [int; 2]
}
// Test that codegen works correctly when there are multiple refutable
// patterns in match expression.
+// pretty-expanded FIXME #23616
+
enum Foo {
FooUint(uint),
FooNullary,
// aux-build:issue-13872-2.rs
// aux-build:issue-13872-3.rs
+// pretty-expanded FIXME #23616
+
extern crate "issue-13872-3" as other;
fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unused_imports, dead_code)]
use foo::Foo;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Foo {
fn bar(&self);
fn baz(&self) { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct A(int);
struct B;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#[macro_use] extern crate "std" as std2;
fn main() {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn main() {
match ("", 1_usize) {
(_, 42_usize) => (),
// value was coerced to a trait object. (v.clone() returns Box<B1>
// which is coerced to Box<A>).
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// aux-build:issue-14421.rs
+// pretty-expanded FIXME #23616
+
extern crate "issue-14421" as bug_lib;
use bug_lib::B;
// aux-build:issue-14422.rs
+// pretty-expanded FIXME #23616
+
extern crate "issue-14422" as bug_lib;
use bug_lib::B;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(io, process_capture)]
use std::env;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unused_variable)]
struct T { f: extern "Rust" fn() }
// FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
+// pretty-expanded FIXME #23616
+
fn main() {
send::<Box<Foo>>(Box::new(Output(0)));
Test::<Box<Foo>>::foo(Box::new(Output(0)));
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
{|i| if 1 == i { }};
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#[deny(dead_code)]
pub enum Foo {
Bar {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum X {
Foo(uint),
Bar(bool)
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(old_io)]
use std::old_io::Reader;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Matcher {
fn next_match(&mut self) -> Option<(uint, uint)>;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub type BigRat<T = int> = T;
fn main() {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(asm)]
type History = Vec<&'static str>;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(old_io, io)]
use std::env;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures, core)]
trait Foo { fn dummy(&self) { }}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures, core)]
use std::ops::Fn;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(warnings)]
struct S<T>(T);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn main() {
let mut x: &[_] = &[1, 2, 3, 4];
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn main() {
assert_eq!(count_members(&[1, 2, 3, 4]), 4);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn main() {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub enum T {
T1(()),
T2(())
// no-prefer-dynamic
+// pretty-expanded FIXME #23616
+
#![feature(fs, process, env, path, rand)]
use std::env;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
macro_rules! inner {
($e:pat ) => ($e)
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
static mut n_mut: uint = 0;
static n: &'static uint = unsafe{ &n_mut };
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait MyTrait {
fn foo(&self);
}
// aux-build:issue-15562.rs
+// pretty-expanded FIXME #23616
+
extern crate "issue-15562" as i;
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
use std::iter::AdditiveIterator;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#[derive(PartialEq)]
enum Test<'a> {
Slice(&'a int)
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#[derive(Clone)]
enum Test<'a> {
Slice(&'a int)
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn main() {
let mut array = [1, 2, 3];
let pie_slice = &array[1..2];
// If `Index` used an associated type for its output, this test would
// work more smoothly.
+// pretty-expanded FIXME #23616
+
#![feature(old_orphan_check, core)]
use std::ops::Index;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![deny(warnings)]
#![allow(unused_imports)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum NestedEnum {
First,
Second,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(unsafe_destructor)]
static mut DROP_RAN: bool = false;
//
// regression test for the model lexer handling the DOTDOTDOT syntax (#15877)
+// pretty-expanded FIXME #23616
+
pub fn main() {
match 5_usize {
1_usize...5_usize => {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(unsafe_destructor, rustc_private)]
extern crate serialize;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::mem;
static mut DROP_COUNT: uint = 0;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn main() {
let mut buf = Vec::new();
|c: u8| buf.push(c);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct Empty;
// This used to cause an ICE
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn main() {
if true { return }
match () {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(hash)]
use std::hash::{SipHasher, hash};
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures)]
use std::thread;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait MatrixRow { fn dummy(&self) { }}
struct Mat;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
static _x: int = 1<<2;
}
// aux-build:issue-16643.rs
+// pretty-expanded FIXME #23616
+
extern crate "issue-16643" as i;
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn main() {
let x: (int, &[int]) = (2, &[1, 2]);
assert_eq!(match x {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
#![feature(unboxed_closures, core)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
#![feature(box_patterns)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let x = [1, 2, 3];
let y = x;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::any::Any;
fn foo(_: &u8) {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum pattern { tabby, tortoiseshell, calico }
enum breed { beagle, rottweiler, pug }
type name = String;
// Test that regionck creates the right region links in the pattern
// binding of a for loop
+// pretty-expanded FIXME #23616
+
fn foo<'a>(v: &'a [uint]) -> &'a uint {
for &ref x in v { return x; }
unreachable!()
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
static X2: u64 = -1 as u16 as u64;
static Y2: u64 = -1 as u32 as u64;
const X: u64 = -1 as u16 as u64;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::fs::File;
use std::io::{self, BufReader, Read};
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(unsafe_destructor)]
struct Leak<'a> {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
const X1: &'static [u8] = &[b'1'];
const X2: &'static [u8] = b"1";
const X3: &'static [u8; 1] = &[b'1'];
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
static mut DROPPED: [bool; 2] = [false, false];
struct A(uint);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax, io)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
fn main() {
// Test that astconv doesn't forget about mutability of &mut str
+// pretty-expanded FIXME #23616
+
fn main() {
fn foo<T: ?Sized>(_: &mut T) {}
let _f: fn(&mut str) = foo;
// aux-build:issue-17662.rs
+// pretty-expanded FIXME #23616
+
extern crate "issue-17662" as i;
use std::marker;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
const FOO: uint = 3;
fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
use std::marker;
// aux-build:issue-17718.rs
+// pretty-expanded FIXME #23616
+
#![feature(core)]
extern crate "issue-17718" as other;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Person {
type string;
fn dummy(&self) { }
// Test that generating drop glue for Box<str> doesn't ICE
+// pretty-expanded FIXME #23616
+
fn f(s: Box<str>) -> Box<str> {
s
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Aaa { fn dummy(&self) { } }
impl<'a> Aaa for &'a mut (Aaa + 'a) {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures)]
use std::marker::PhantomData;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn main() {
assert_eq!(match [0u8; 1024] {
_ => 42_usize,
// Test that we can parse where clauses on various forms of tuple
// structs.
+// pretty-expanded FIXME #23616
+
struct Bar<T>(T) where T: Copy;
struct Bleh<T, U>(T, U) where T: Copy, U: Sized;
struct Baz<T> where T: Copy {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn main() {
({return},);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures, std_misc)]
use std::thunk::Thunk;
// Issue #1821 - Don't recurse trying to typecheck this
+// pretty-expanded FIXME #23616
+
enum t {
foo(Vec<t>)
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct Cursor<'a>(::std::marker::PhantomData<&'a ()>);
trait CursorNavigator {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
const X: &'static str = "12345";
fn test(s: String) -> bool {
// Test that wrapping an unsized struct in an enum which gets optimised does
// not ICE.
+// pretty-expanded FIXME #23616
+
struct Str {
f: [u8]
}
// Test that non-static methods can be assigned to local variables as
// function pointers.
+// pretty-expanded FIXME #23616
+
trait Foo {
fn foo(&self) -> uint;
}
// Check that trans doesn't ICE when translating an array repeat
// expression with a count of 1 and a non-Copy element type.
+// pretty-expanded FIXME #23616
+
fn main() {
let _ = [Box::new(1_usize); 1];
}
// translating the def ID of the trait during AST decoding.
// aux-build:issue-18501.rs
+// pretty-expanded FIXME #23616
+
extern crate "issue-18501" as issue;
fn main() {
// impl.
// aux-build:issue-18514.rs
+// pretty-expanded FIXME #23616
+
extern crate "issue-18514" as ice;
use ice::{Tr, St};
// Test that coercing bare fn's that return a zero sized type to
// a closure doesn't cause an LLVM ERROR
+// pretty-expanded FIXME #23616
+
struct Foo;
fn uint_to_foo(_: uint) -> Foo {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(old_io)]
use std::old_io::FileType;
// once closure as an optimization by trans. This used to hit an
// incorrect assert.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures)]
fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
mod a {
pub type rust_task = uint;
pub mod rustrt {
// Test that param substitutions from the correct environment are
// used when translating unboxed closure calls.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures, core)]
pub fn inside<F: Fn()>(c: F) {
// Test that the self param space is not used in a conflicting
// manner by unboxed closures within a default method on a trait
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures)]
trait Tr {
// Test that we don't panic on a RefCell borrow conflict in certain
// code paths involving unboxed closures.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures)]
// aux-build:issue-18711.rs
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#[derive(Eq, PartialEq, PartialOrd, Ord)]
enum Test<'a> {
Int(&'a int),
// Test that regionck uses the right memcat for patterns in for loops
// and doesn't ICE.
+// pretty-expanded FIXME #23616
+
fn main() {
for &&x in Some(&0_usize).iter() {
assert_eq!(x, 0)
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
mod foo {
pub mod bar {
pub mod baz {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub trait Borrow<Borrowed: ?Sized> {
fn borrow(&self) -> &Borrowed;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct Str([u8]);
#[derive(Clone)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures, core)]
pub trait Handler {
// Test that a partially specified trait object with unspecified associated
// type does not ICE.
+// pretty-expanded FIXME #23616
+
trait Foo {
type A;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures)]
fn foo<T, F: FnOnce(T) -> T>(f: F) {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Trait<Input> {
type Output;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Trait<Input> {
type Output;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct MyStruct { field: usize }
struct Nested { nested: MyStruct }
struct Mix2 { nested: ((usize,),) }
// except according to those terms.
// aux-build:issue_19293.rs
+// pretty-expanded FIXME #23616
+
extern crate issue_19293;
use issue_19293::{Foo, MyEnum};
// aux-build:issue-19340-1.rs
+// pretty-expanded FIXME #23616
+
extern crate "issue-19340-1" as lib;
use lib::Homura;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum Homura {
Madoka {
name: String,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait T {
unsafe extern "Rust" fn foo(&self);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Base {
fn dummy(&self) { }
}
// reasonable examples) let to ambiguity errors about not being able
// to infer sufficient type information.
+// pretty-expanded FIXME #23616
+
fn main() {
let n = 0;
let it = Some(1_usize).into_iter().inspect(|_| {n;});
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait PoolManager {
type C;
fn dummy(&self) { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait PoolManager {
type C;
fn dummy(&self) { }
// Issue 1974
// Don't double free the condition allocation
+// pretty-expanded FIXME #23616
+
pub fn main() {
let s = "hej".to_string();
while s != "".to_string() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(collections)]
fn main() {
// Test that `<Type as Trait>::Output` and `Self::Output` are accepted as type annotations in let
// bindings
+// pretty-expanded FIXME #23616
+
trait Int {
fn one() -> Self;
fn leading_zeros(self) -> uint;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(core,unboxed_closures)]
#[allow(dead_code)]
// Check that associated types are `Sized`
+// pretty-expanded FIXME #23616
+
trait Trait {
type Output;
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(link_llvm_intrinsics)]
extern {
// Regression test for Issue #20343.
+// pretty-expanded FIXME #23616
+
#![deny(dead_code)]
struct B { b: u32 }
// aux-build:issue_20389.rs
+// pretty-expanded FIXME #23616
+
extern crate issue_20389;
struct Foo;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(dead_code)]
trait Foo<T> {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Trait {
fn method(self) -> int;
}
// Test that overloaded calls work with zero arity closures
+// pretty-expanded FIXME #23616
+
fn main() {
// FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
let functions: [Box<Fn() -> Option<()>>; 1] = [Box::new(|| None)];
// A reduced version of the rustbook ice. The problem this encountered
// had to do with trans ignoring binders.
+// pretty-expanded FIXME #23616
+
#![feature(os)]
use std::iter;
// UFCS-style calls to a method in `Trait` where `Self` was bound to a
// trait object of type `Trait`. See also `ufcs-trait-object.rs`.
+// pretty-expanded FIXME #23616
+
use std::fmt;
fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(non_camel_case_types)]
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait T0 {
type O;
fn dummy(&self) { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait T0 {
type O;
fn dummy(&self) { }
// Regression test for #20797.
+// pretty-expanded FIXME #23616
+
#![feature(old_io, old_path)]
use std::default::Default;
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(box_patterns)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
struct NT(str);
// insufficient type propagation caused the type of the iterator to be
// incorrectly unified with the `*const` type to which it is coerced.
+// pretty-expanded FIXME #23616
+
use std::ptr;
trait IntoIterator {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#[forbid(raw_pointer_derive)]
#[derive(Copy)]
struct Test(*const i32);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::sync::Arc;
fn main() {
// Make sure that "bare sequences" don't ICE in follow checking
+// pretty-expanded FIXME #23616
+
macro_rules! bare {
$($id:expr),+ => ( $($id)+ )
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn main() {
let v = vec![1, 2, 3];
let boxed: Box<Iterator<Item=i32>> = Box::new(v.into_iter());
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![no_implicit_prelude]
trait Iterator {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use ::std::ops::RangeFull;
fn test<T : Clone>(arg: T) -> T {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#[derive(Hash)]
struct Foo {
a: Vec<bool>,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use m::{START, END};
fn main() {
// Test that the requirement (in `Bar`) that `T::Bar : 'static` does
// not wind up propagating to `T`.
+// pretty-expanded FIXME #23616
+
pub trait Foo {
type Bar;
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn main() {
if let Ok(x) = "3.1415".parse() {
assert_eq!(false, x <= 0.0);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn test(it: &mut Iterator<Item=i32>) {
for x in it {
assert_eq!(x, 1)
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn main() {
static NONE: Option<((), &'static u8)> = None;
let ptr = unsafe {
// subtyping of projection types that resulted in an unconstrained
// region, yielding region inference failures.
+// pretty-expanded FIXME #23616
+
fn main() { }
fn foo<'a>(s: &'a str) {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
static foo: [uint; 3] = [1, 2, 3];
static slice_1: &'static [uint] = &foo;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(std_misc)]
use std::thread::Builder;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait A<X> {
fn dummy(&self, arg: X);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait DigitCollection: Sized {
type Iter: Iterator<Item = u8>;
fn digit_iter(self) -> Self::Iter;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(libc)]
extern crate libc;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::marker::{PhantomData, PhantomFn};
pub struct Handle<T, I>(T, I);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn main() {
match 42 {
x if x < 7 => (),
// Regression test for Issue #22536: If a type implements Copy, then
// moving it must not zero the original memory.
+// pretty-expanded FIXME #23616
+
trait Resources {
type Buffer: Copy;
fn foo(&self) {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(fs, net, fs_walk)]
use std::{fs, net};
// Test transitive analysis for associated types. Collected types
// should be normalized and new obligations generated.
+// pretty-expanded FIXME #23616
+
use std::borrow::{ToOwned, Cow};
fn assert_send<T: Send>(_: T) {}
// can successfully deal with a "deep" structure, which the drop-check
// was hitting a recursion limit on at one point.
+// pretty-expanded FIXME #23616
+
#![allow(non_camel_case_types)]
pub fn noop_fold_impl_item() -> SmallVector<ImplItem> {
// Test transitive analysis for associated types. Collected types
// should be normalized and new obligations generated.
+// pretty-expanded FIXME #23616
+
trait Foo {
type A;
fn foo(&self) {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Send {
fn f(&self);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait clam<A> {
fn get(self) -> A;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait clam<A> { fn get(self) -> A; }
trait foo<A> {
fn bar<B,C:clam<A>>(&self, c: C) -> B;
// Testing that the B's are resolved
+// pretty-expanded FIXME #23616
+
trait clam<A> { fn get(self) -> A; }
struct foo(int);
// aux-build:issue_2316_a.rs
// aux-build:issue_2316_b.rs
+// pretty-expanded FIXME #23616
+
extern crate issue_2316_b;
use issue_2316_b::cloth;
// instantiates all the methods, even those that could not otherwise
// be called.
+// pretty-expanded FIXME #23616
+
struct Foo {
x: i32
}
// aux-build:issue-2380.rs
+// pretty-expanded FIXME #23616
+
extern crate a;
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(collections)]
extern crate collections;
// aux-build:issue-2414-a.rs
// aux-build:issue-2414-b.rs
+// pretty-expanded FIXME #23616
+
extern crate b;
pub fn main() {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let _foo = 100;
const quux: int = 5;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct c1<T> {
x: T,
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct c1<T> {
x: T,
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct Pair { f: int, g: int }
pub fn main() {
// aux-build:issue_2472_b.rs
+// pretty-expanded FIXME #23616
+
extern crate issue_2472_b;
use issue_2472_b::{S, T};
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct socket {
sock: int,
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct font<'a> {
fontbuf: &'a Vec<u8> ,
}
// aux-build:issue-2526.rs
+// pretty-expanded FIXME #23616
+
#![allow(unused_imports)]
extern crate issue_2526;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct C {
x: uint,
}
// Tests that impls are allowed to have looser, more permissive bounds
// than the traits require.
+// pretty-expanded FIXME #23616
+
trait A {
fn b<C:Sync,D>(&self, x: C) -> C;
}
// aux-build:issue-2631-a.rs
+// pretty-expanded FIXME #23616
+
extern crate req;
use req::request;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn f() {
let _x: uint = loop { loop { break; } };
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// aux-build:issue_2723_a.rs
+// pretty-expanded FIXME #23616
+
extern crate issue_2723_a;
use issue_2723_a::f;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(unsafe_destructor)]
use std::cell::Cell;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(unsafe_destructor)]
use std::cell::Cell;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct CMap<'a> {
buf: &'a [u8],
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn thing<'r>(x: &'r [int]) -> &'r [int] { x }
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::mem;
struct Cat {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait bar<T> {
fn get_bar(&self) -> T;
}
// aux-build:issue-3012-1.rs
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax, libc)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax, collections)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum what { }
fn what_to_string(x: what) -> String
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
type Connection = Box<FnMut(Vec<u8>) + 'static>;
fn f() -> Option<Connection> {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let x = 1;
let y = 1;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn Matrix4<T>(m11: T, m12: T, m13: T, m14: T,
m21: T, m22: T, m23: T, m24: T,
m31: T, m32: T, m33: T, m34: T,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct thing { x: int, }
impl Drop for thing {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn quux<T>(x: T) -> T { let f = id::<T>; return f(x); }
fn id<T>(x: T) -> T { return x; }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let x = 1_usize;
let y = || x;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let x = &Some(1);
match x {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Canvas {
fn add_point(&self, point: &int);
fn add_points(&self, shapes: &[int]) {
// rustc --test match_borrowed_str.rs.rs && ./match_borrowed_str.rs
+// pretty-expanded FIXME #23616
+
fn compare(x: &str, y: &str) -> bool {
match x {
"foo" => y == "foo",
// Incorrect struct size computation in the FFI, because of not taking
// the alignment of elements into account.
+// pretty-expanded FIXME #23616
+
#![feature(libc)]
extern crate libc;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum PureCounter { PureCounterVariant(uint) }
fn each<F>(thing: PureCounter, blk: F) where F: FnOnce(&uint) {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(path_statement)]
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn vec_peek<'r, T>(v: &'r [T]) -> &'r [T] {
&v[1..5]
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
enum State { BadChar, BadSyntax }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#[derive(PartialEq)]
struct Bike {
name: String,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait A {
fn a_method(&self);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::ops::Add;
trait Positioned<S> {
// except according to those terms.
// aux-build:issue_3979_traits.rs
+// pretty-expanded FIXME #23616
+
extern crate issue_3979_traits;
use issue_3979_traits::{Positioned, Movable};
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Positioned {
fn SetX(&mut self, int);
fn X(&self) -> int;
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct HasNested {
nest: Vec<Vec<int> > ,
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(rustc_private)]
extern crate serialize;
// Issue #4036: Test for an issue that arose around fixing up type inference
// byproducts in vtable records.
+// pretty-expanded FIXME #23616
+
#![feature(rustc_private)]
extern crate serialize;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let _id: &Mat2<f64> = &Matrix::identity(1.0);
}
// aux-build:issue-4208-cc.rs
+// pretty-expanded FIXME #23616
+
extern crate numeric;
use numeric::{sin, Angle};
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct Foo;
impl Foo {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(io)]
use std::io;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let _foo = [0; 2*4];
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(old_io)]
use std::old_io::println;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::sync::mpsc::channel;
use std::thread;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn broken(v: &[u8], i: uint, j: uint) -> &[u8] { &v[i..j] }
pub fn main() {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::env;
pub fn main() {
// aux-build:issue-4545.rs
+// pretty-expanded FIXME #23616
+
extern crate "issue-4545" as somelib;
pub fn main() { somelib::mk::<int>(); }
// Ensures that destructors are run for expressions of the form "e;" where
// `e` is a type which requires a destructor.
+// pretty-expanded FIXME #23616
+
#![allow(path_statement)]
struct A { n: int }
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax, libc)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait U { fn f(self); }
impl U for isize { fn f(self) {} }
pub fn main() { 4.f(); }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub struct Scheduler {
/// The event loop used to drive the scheduler and perform I/O
event_loop: Box<int>
// regression test for issue 4875
+// pretty-expanded FIXME #23616
+
pub struct Foo<T> {
data: T,
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// Regression test for issue #5239
+// pretty-expanded FIXME #23616
+
pub fn main() {
let _f = |ref x: int| { *x };
let foo = 10;
// enough for trans to consider this as non-monomorphic,
// which led to various assertions and failures in turn.
+// pretty-expanded FIXME #23616
+
struct S<'a> {
v: &'a int
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct A(bool);
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
const INVALID_ENUM : u32 = 0;
const INVALID_VALUE : u32 = 1;
// aux-build:issue-5518.rs
+// pretty-expanded FIXME #23616
+
extern crate "issue-5518" as other;
fn main() {}
// aux-build:issue-5521.rs
+// pretty-expanded FIXME #23616
+
extern crate "issue-5521" as foo;
fn bar(a: foo::map) {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum Enum {
Foo { foo: uint },
Bar { bar: uint }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(dead_assignment)]
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::default::Default;
pub struct X<T> {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn foo<T: ::std::cmp::PartialEq>(_t: T) { }
pub fn main() { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unreachable_code)]
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct TwoDoubles {
r: f64,
i: f64
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(libc)]
extern crate libc;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub mod foo {
use super::Bar;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct T (&'static [int]);
static t : T = T (&[5, 4, 3]);
pub fn main () {
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub use local as local_alias;
pub mod local { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(old_io)]
use std::old_io;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn f<T>() -> bool {
enum E<T> { V(T) }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum Either<T, U> { Left(T), Right(U) }
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax, collections)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![deny(type_limits)]
pub fn main() {
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn swap<F>(f: F) -> Vec<int> where F: FnOnce(Vec<int>) -> Vec<int> {
let x = vec!(1, 2, 3);
f(x)
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub trait OpInt { fn call(&mut self, int, int) -> int; }
impl<F> OpInt for F where F: FnMut(int, int) -> int {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// Tests that everything still compiles and runs fine even when
// we reorder the bounds.
+// pretty-expanded FIXME #23616
+
trait A {
fn a(&self) -> uint;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#[derive(PartialEq)]
struct A { x: uint }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum Foo {
Bar(int),
Baz,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub mod Bar {
pub struct Foo {
v: int,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_patterns)]
#![feature(box_syntax)]
// Ensures that destructors are run for expressions of the form "let _ = e;"
// where `e` is a type which requires a destructor.
+// pretty-expanded FIXME #23616
+
struct Foo;
struct Bar { x: int }
struct Baz(int);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
use std::intrinsics;
// aux-build:iss.rs
+// pretty-expanded FIXME #23616
+
#![crate_id="issue-6919"]
extern crate issue6919_3;
// aux-build:issue-7178.rs
+// pretty-expanded FIXME #23616
+
extern crate "issue-7178" as cross_crate_self;
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
const FOO: f64 = 10.0;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn foo<T: 'static>(_: T) {}
fn bar<T>(x: &'static T) {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unreachable_code)]
fn foo() -> bool { false }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
/*
#7519 ICE pattern matching unit in function argument
*/
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Foo {
fn new() -> bool { false }
fn dummy(&self) { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub mod a {
pub struct Foo { a: usize }
}
// Regression test for issue 7660
// rvalue lifetime too short when equivalent `match` works
+// pretty-expanded FIXME #23616
+
#![feature(collections)]
extern crate collections;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unused_imports, dead_code)]
mod test1 {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
/*
#7673 Polymorphically creating traits barely works
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(advanced_slice_patterns)]
use std::ops::Add;
// aux-build:issue-7899.rs
+// pretty-expanded FIXME #23616
+
extern crate "issue-7899" as testcrate;
fn main() {
// aux-build:issue-8044.rs
+// pretty-expanded FIXME #23616
+
extern crate "issue-8044" as minimal;
use minimal::{BTree, leaf};
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
/*
#8171 Self is not recognised as implementing kinds in default method implementations
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait A {
fn dummy(&self) { }
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait A {
fn dummy(&self) { }
}
// aux-build:issue-8259.rs
+// pretty-expanded FIXME #23616
+
extern crate "issue-8259" as other;
static a: other::Foo<'static> = other::Foo::A;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum E {
Foo{f: int},
Bar,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum E {
Foo{f: int, b: bool},
Bar,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn main() {
let x = match Some(1) {
ref _y @ Some(_) => 1,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(old_io, io)]
use std::old_io;
// aux-build:issue_8401.rs
+// pretty-expanded FIXME #23616
+
extern crate issue_8401;
pub fn main() {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
use std::num::Int;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
match &[(Box::new(5),Box::new(7))] {
ps => {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(dead_code)]
enum Either {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub struct UninterpretedOption_NamePart {
name_part: Option<String>,
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn f<T, F>(g: F) -> T where F: FnOnce() -> T { g() }
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
macro_rules! sty {
($t:ty) => (stringify!($t))
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::default::Default;
struct X { pub x: uint }
// doesn't cause capture. Making this macro hygienic (as I've done)
// could very well make this test case completely pointless....
+// pretty-expanded FIXME #23616
+
enum T {
A(int),
B(uint)
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
static mut DROP: int = 0;
static mut DROP_S: int = 0;
static mut DROP_T: int = 0;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn assert_repr_eq<T: std::fmt::Debug>(obj : T, expected : String) {
assert_eq!(expected, format!("{:?}", obj));
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
macro_rules! silly_macro {
() => (
pub mod Qux {
// aux-build:issue_9123.rs
+// pretty-expanded FIXME #23616
+
extern crate issue_9123;
pub fn main() {}
// aux-build:issue_9188.rs
+// pretty-expanded FIXME #23616
+
extern crate issue_9188;
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
static DATA:&'static [&'static str] = &["my string"];
fn main() { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct A<'a> {
a: &'a [String],
b: Option<&'a [String]>,
+// pretty-expanded FIXME #23616
+
// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Base: Base2 + Base3{
fn foo(&self) -> String;
fn foo1(&self) -> String;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(old_io, std_misc)]
use std::sync::mpsc::{TryRecvError, channel};
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
mod a {
pub enum Enum<T> {
A(T),
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(unsafe_destructor)]
use std::cell::Cell;
// aux-build:issue-9906.rs
+// pretty-expanded FIXME #23616
+
extern crate "issue-9906" as testmod;
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
assert_eq!((0 + 0u8) as char, '\0');
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
const S: uint = 23 as uint; [0; S]; ()
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unused_variables)]
trait Bar {
// aux-build:issue-9968.rs
+// pretty-expanded FIXME #23616
+
extern crate "issue-9968" as lib;
use lib::{Trait, Struct};
// except according to those terms.
// aux-build:issue2170lib.rs
+// pretty-expanded FIXME #23616
+
extern crate issue2170lib;
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
// This used to cause an ICE because the retslot for the "return" had the wrong type
// aux-build:issue_3136_a.rc
+// pretty-expanded FIXME #23616
+
extern crate issue_3136_a;
pub fn main() {}
// aux-build:issue_9155.rs
+// pretty-expanded FIXME #23616
+
extern crate issue_9155;
struct Baz;
// for completeness since .rs files linked from .rc files support this
// notation to specify their module's attributes
+// pretty-expanded FIXME #23616
+
#![feature(custom_attribute, libc)]
#![allow(unused_attribute)]
#![attr1 = "val"]
+// pretty-expanded FIXME #23616
+
mod foo {
pub fn baz() { }
}
// Test to see that the element type of .cloned() can be inferred
// properly. Previously this would fail to deduce the type of `sum`.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
use std::iter::AdditiveIterator;
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn f(_a: Vec<int> ) { }
pub fn main() { f(vec!(1, 2, 3, 4, 5)); }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(std_misc)]
use std::thread::Thread;
// mod -> module
// match -> match
+// pretty-expanded FIXME #23616
+
pub fn main() {
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// aux-build:kinds_in_metadata.rs
+// pretty-expanded FIXME #23616
+
/* Any copyright is dedicated to the Public Domain.
* http://creativecommons.org/publicdomain/zero/1.0/ */
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
'foo: loop {
loop {
+// pretty-expanded FIXME #23616
+
struct Large {a: int,
b: int,
c: int,
// Issue #1818
+// pretty-expanded FIXME #23616
+
fn lp<T, F>(s: String, mut f: F) -> T where F: FnMut(String) -> T {
while false {
let r = f(s);
// Make sure #1399 stays fixed
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
#![feature(unboxed_closures, core)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let x = 3_usize;
let ref y = x;
// except according to those terms.
// shouldn't affect evaluation of $ex:
+// pretty-expanded FIXME #23616
+
macro_rules! bad_macro {
($ex:expr) => ({let _x = 9; $ex})
}
// This is ok because we often use the trailing underscore to mean 'prime'
+// pretty-expanded FIXME #23616
+
#[forbid(non_camel_case_types)]
type Foo_ = int;
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![forbid(non_camel_case_types)]
#![forbid(non_upper_case_globals)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(dead_assignment)]
#![allow(unreachable_code)]
#![allow(unused_variable)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unreachable_code)]
fn test() {
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn take(x: int) -> int {x}
fn the_loop() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(trace_macros, log_syntax)]
// make sure these macros can be used as in the various places that
// compile-flags:-C debug-assertions=no
// exec-env:RUST_LOG=logging-enabled-debug=debug
+// pretty-expanded FIXME #23616
+
#![feature(rustc_private)]
#[macro_use]
// exec-env:RUST_LOG=logging-enabled=info
+// pretty-expanded FIXME #23616
+
#![feature(rustc_private)]
#[macro_use]
// longer happens by enabling logging for *this* crate and then invoking a
// function in an external crate which will panic when logging is enabled.
+// pretty-expanded FIXME #23616
+
extern crate logging_right_crate;
pub fn main() {
// this test will trigger "output during runtime initialization" to make sure
// that the bug isn't re-introduced.
+// pretty-expanded FIXME #23616
+
pub fn main() {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unused_variable)]
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let _i = 0_usize;
loop {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
/* Make sure a loop{} can be the tailexpr in the body
of a diverging function */
// Issue #12512.
+// pretty-expanded FIXME #23616
+
fn main() {
let mut foo = Vec::new();
'foo: for i in &[1, 2, 3] {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn main() {
'outer: loop {
let _: i32 = loop { break 'outer };
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct S;
// Ensure S is moved, not copied, on assignment.
impl Drop for S { fn drop(&mut self) { } }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let x = vec!(10, 20, 30);
let mut sum = 0;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
macro_rules! do_block{
($val:block) => {$val}
}
// aux-build:macro_crate_def_only.rs
+// pretty-expanded FIXME #23616
+
#[macro_use] #[no_link]
extern crate macro_crate_def_only;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn increment(x: uint) -> uint {
x + 1
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
macro_rules! foo2 {
() => {
"foo"
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn main() {
vec![1_usize, 2, 3].len();
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
macro_rules! overly_complicated {
($fnname:ident, $arg:ident, $ty:ty, $body:block, $val:expr, $pat:pat, $res:path) =>
({
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
macro_rules! four {
() => (4)
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct A;
macro_rules! make_thirteen_method {() => (fn thirteen(&self)->int {13})}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
macro_rules! list {
( ($($id:ident),*) ) => (());
( [$($id:ident),*] ) => (());
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
macro_rules! higher_order {
(subst $lhs:tt => $rhs:tt) => ({
macro_rules! anon { $lhs => $rhs }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
macro_rules! mypat {
() => (
Some('y')
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
mod m {
pub type t = int;
}
// compile-flags: --cfg foo
+// pretty-expanded FIXME #23616
+
#[cfg(foo)]
macro_rules! foo { () => (1) }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#[cfg(foo)]
macro_rules! foo { () => (1) }
// aux-build:macro_with_super_1.rs
+// pretty-expanded FIXME #23616
+
#[macro_use]
extern crate macro_with_super_1;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct NewBool(bool);
enum Direction {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unnecessary_allocation)]
fn f1(ref_string: &str) -> String {
// except according to those terms.
// n.b. This was only ever failing with optimization disabled.
+// pretty-expanded FIXME #23616
+
fn a() -> int { match return 1 { 2 => 3, _ => panic!() } }
pub fn main() { a(); }
// regression test for issue #5625
+// pretty-expanded FIXME #23616
+
enum E {
Foo{f : int},
Bar
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum E {
Foo{f : int},
Bar
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum Foo {
B { b1: int, bb1: int},
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct X { x: int }
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct X { x: int }
pub fn main() {
+// pretty-expanded FIXME #23616
+
mod m1 {
pub enum foo { foo1, foo2, }
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn main() {
let value = Some(1);
assert_eq!(match value {
+// pretty-expanded FIXME #23616
+
fn altsimple(f: int) { match f { _x => () } }
pub fn main() { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(dead_assignment)]
#![allow(unused_variable)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn test1() {
// from issue 6338
match ((1, "a".to_string()), (2, "b".to_string())) {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
const s: int = 1;
const e: int = 42;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::sync::Mutex;
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let mut v = Some(22);
match v {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct Rec {
f: int
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn destructure(x: Option<int>) -> int {
match x {
None => 0,
// around this problem locally by renaming the constant in the `use`
// form to an uppercase identifier that placates the lint.
+// pretty-expanded FIXME #23616
+
#![deny(non_upper_case_globals)]
pub const A : int = 97;
// Issue #53
+// pretty-expanded FIXME #23616
+
pub fn main() {
match "test" { "not-test" => panic!(), "test" => (), _ => panic!() }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct Foo{
f : int,
}
+// pretty-expanded FIXME #23616
+
enum color {
rgb(int, int, int),
rgba(int, int, int, int),
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(advanced_slice_patterns)]
fn match_vecs<'a, T>(l1: &'a [T], l2: &'a [T]) -> &'static str {
// Tests that matching rvalues with drops does not crash.
+// pretty-expanded FIXME #23616
+
pub fn main() {
match vec!(1, 2, 3) {
x => {
// except according to those terms.
// pp-exact - Make sure we print all the attributes
+// pretty-expanded FIXME #23616
+
#![allow(unused_attribute)]
#![feature(custom_attribute)]
// Check that we successfully handle methods where the `self` type has
// an early-bound lifetime. Issue #18208.
+// pretty-expanded FIXME #23616
+
#![allow(dead_code)]
use std::marker;
// type is `&mut [u8]`, passes in a pointer to the lvalue and not a
// temporary. Issue #19147.
+// pretty-expanded FIXME #23616
+
#![feature(core, old_io)]
use std::mem;
// winnowing stage of method resolution failed to handle an associated
// type projection.
+// pretty-expanded FIXME #23616
+
#![feature(associated_types)]
trait Hasher {
///////////////////////////////////////////////////////////////////////////
+// pretty-expanded FIXME #23616
+
trait MakeString {
fn make_string(&self) -> String;
}
// know not to stop at the blanket, we have to recursively evaluate
// the `T:Foo` bound.
+// pretty-expanded FIXME #23616
+
use std::marker::Sized;
// Note: this must be generic for the problem to show up
// Test method calls with self as an argument (cross-crate)
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// Test method calls with self as an argument (cross-crate)
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// Test method calls with self as an argument
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// Test method calls with self as an argument
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// Test that we pick which version of `foo` to run based on the
// type that is (ultimately) inferred for `x`.
+// pretty-expanded FIXME #23616
+
trait foo {
fn foo(&self) -> i32;
}
// version will run (note that the `push` occurs after the call to
// `foo()`).
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// Test that we select between traits A and B. To do that, we must
// consider the `Sized` bound.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
trait A {
// Test that we can use method notation to call methods based on a
// where clause type, and not only type parameters.
+// pretty-expanded FIXME #23616
+
trait Foo {
fn foo(&self) -> i32;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct S<T> {
contents: T,
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn f() -> int {
mod m {
pub fn g() -> int { 720 }
// pretty-print such view items. If that happens again, this should
// begin failing.
+// pretty-expanded FIXME #23616
+
mod m {
pub fn f() -> Vec<int> { Vec::new() }
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
mod m {
pub struct S {
pub x: int,
+// pretty-expanded FIXME #23616
+
trait vec_monad<A> {
fn bind<B, F>(&self, f: F ) -> Vec<B> where F: FnMut(&A) -> Vec<B> ;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
use std::marker::MarkerTrait;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn test(foo: int) { assert!((foo == 10)); }
pub fn main() { let x = 10; test(x); }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(box_syntax)]
fn main() {
// except according to those terms.
// Issue #922
+// pretty-expanded FIXME #23616
+
fn f2<F>(_thing: F) where F: FnOnce() { }
fn f<F>(thing: F) where F: FnOnce() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::string::String;
struct StringBuffer {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let y: int = 42;
// aux-build:moves_based_on_type_lib.rs
+// pretty-expanded FIXME #23616
+
extern crate moves_based_on_type_lib;
use moves_based_on_type_lib::f;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let x = 10;
let y = x;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::fmt::Debug;
trait MyTrait<T> {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::fmt::Debug;
use std::default::Default;
// except according to those terms.
+// pretty-expanded FIXME #23616
+
/*
* This is a multi-line oldcomment.
*/
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn f<T:PartialEq + PartialOrd>(_: T) {
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Foo {
fn foo(&self, mut x: int) -> int {
let val = x;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let _x: &mut [int] = &mut [ 1, 2, 3 ];
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn test1() {
let mut ints = [0; 32];
ints[0] += 1;
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum colour { red, green, blue, }
enum tree { children(Box<list>), leaf(colour), }
// aux-build:namespaced_enum_emulate_flat.rs
+// pretty-expanded FIXME #23616
+
extern crate namespaced_enum_emulate_flat;
use namespaced_enum_emulate_flat::{Foo, A, B, C};
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub use Foo::*;
use nest::{Bar, D, E, F};
// aux-build:namespaced_enums.rs
+// pretty-expanded FIXME #23616
+
extern crate namespaced_enums;
fn _f(f: namespaced_enums::Foo) {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
mod m2 {
pub enum Foo {
A,
// aux-build:namespaced_enums.rs
+// pretty-expanded FIXME #23616
+
extern crate namespaced_enums;
use namespaced_enums::Foo;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum Foo {
A,
B(int),
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
match -5 {
-5 => {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
/* This test checks that nested comments are supported
/*
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
struct b {
i: int,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
/*
#7770 ICE with sibling methods containing same-name-enum containing
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct Foo { foo: bool, bar: Option<int>, baz: int }
pub fn main() {
//
// Issue #8587
+// pretty-expanded FIXME #23616
+
pub struct X;
impl X {
// aux-build:nested_item.rs
+// pretty-expanded FIXME #23616
+
extern crate nested_item;
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
/* Any copyright is dedicated to the Public Domain.
* http://creativecommons.org/publicdomain/zero/1.0/ */
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(collections)]
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn main() {
let _a: *const int = 3 as *const int;
let _a: *mut int = 3 as *mut int;
// expression
// FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
+// pretty-expanded FIXME #23616
+
fn unique() -> Box<FnMut()+'static> { return Box::new(|| ()); }
pub fn main() {
// expression
// FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
+// pretty-expanded FIXME #23616
+
fn unique() -> Box<FnMut()+'static> { Box::new(|| ()) }
pub fn main() {
// Tests for the new |args| expr lambda syntax
+// pretty-expanded FIXME #23616
+
fn f<F>(i: int, f: F) -> int where F: FnOnce(int) -> int { f(i) }
fn g<G>(_g: G) where G: FnOnce() { }
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#[derive(Clone)]
struct myvec<X>(Vec<X> );
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(unsafe_destructor)]
// Make sure the destructor is run for newtype structs.
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(libc)]
extern crate libc;
// aux-build:newtype_struct_xc.rs
+// pretty-expanded FIXME #23616
+
extern crate newtype_struct_xc;
use newtype_struct_xc::Au;
// aux-build:newtype_struct_xc.rs
+// pretty-expanded FIXME #23616
+
extern crate newtype_struct_xc;
pub fn main() {
// except according to those terms.
// Issue #901
+// pretty-expanded FIXME #23616
+
mod libc {
extern {
pub fn printf(x: ());
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() { let x = (); match x { () => { } } }
// compile-flags: -Z no-landing-pads
+// pretty-expanded FIXME #23616
+
use std::thread;
static mut HIT: bool = false;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
macro_rules! quote_tokens { () => (()) }
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct X {
repr: int
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::cell::Cell;
struct C<'a> {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main()
{
let all_nuls1 = "\0\x00\u{0}\u{0}";
// then we simply express the enum as just a pointer and not wrap it
// in a struct.
+// pretty-expanded FIXME #23616
+
use std::mem;
#[inline(never)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::mem;
enum E<T> { Thing(int, T), Nothing((), ((), ()), [i8; 0]) }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum blah { a, b, }
fn or_alt(q: blah) -> int {
// necessary. Testing the methods of the impls is done within the source
// file for each numeric type.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
use std::ops::Add;
// Test that `Box<Test>` is equivalent to `Box<Test+'static>`, both in
// fields and fn arguments.
+// pretty-expanded FIXME #23616
+
#![allow(dead_code)]
trait Test {
// Test that the lifetime of the enclosing `&` is used for the object
// lifetime bound.
+// pretty-expanded FIXME #23616
+
#![allow(dead_code)]
trait Test {
// Test that the lifetime from the enclosing `&` is "inherited"
// through the `Box` struct.
+// pretty-expanded FIXME #23616
+
#![allow(dead_code)]
trait Test {
// Test that the lifetime of the enclosing `&` is used for the object
// lifetime bound.
+// pretty-expanded FIXME #23616
+
#![allow(dead_code)]
trait Test {
// Test that the lifetime from the enclosing `&` is "inherited"
// through the `MyBox` struct.
+// pretty-expanded FIXME #23616
+
#![allow(dead_code)]
trait Test {
// Test that the lifetime of the enclosing `&` is used for the object
// lifetime bound.
+// pretty-expanded FIXME #23616
+
#![allow(dead_code)]
trait Test {
// Test for using an object with an associated type binding as the
// instantiation for a generic type with a bound.
+// pretty-expanded FIXME #23616
+
trait SomeTrait {
type SomeType;
// Check that a trait is still object-safe (and usable) if it has
// methods with by-value self so long as they require `Self : Sized`.
+// pretty-expanded FIXME #23616
+
trait Counter {
fn tick(&mut self) -> u32;
fn get(self) -> u32 where Self : Sized;
// Check that a trait is still object-safe (and usable) if it has
// generic methods so long as they require `Self : Sized`.
+// pretty-expanded FIXME #23616
+
trait Counter {
fn tick(&mut self) -> u32;
fn with<F:FnOnce(u32)>(&self, f: F) where Self : Sized;
// Check that a trait is still object-safe (and usable) if it has
// methods that return `Self` so long as they require `Self : Sized`.
+// pretty-expanded FIXME #23616
+
trait Counter {
fn new() -> Self where Self : Sized;
fn tick(&mut self) -> u32;
// Test that we can coerce an `@Object` to an `&Object`
+// pretty-expanded FIXME #23616
+
trait Foo {
fn foo(&self) -> uint;
fn bar(&mut self) -> uint;
// closed over do not contain managed values, and thus the boxes do
// not have headers.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// closed over contain managed values. This implies that the boxes
// will have headers that must be skipped over.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// Testing guarantees provided by once functions.
+// pretty-expanded FIXME #23616
+
use std::sync::Arc;
fn foo<F:FnOnce()>(blk: F) {
// Why one-tuples? Because macros.
+// pretty-expanded FIXME #23616
+
pub fn main() {
match ('c',) {
(x,) => {
// Testcase for issue #130, operator associativity.
+// pretty-expanded FIXME #23616
+
pub fn main() { assert!((3 * 5 / 2 == 7)); }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(unsafe_destructor)]
use std::cell::Cell;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum blah { a(int, int, uint), b(int, int), c, }
fn or_alt(q: blah) -> int {
// in ORDER matching up to when it ran.
// Correct order is: matched, inner, outer
+// pretty-expanded FIXME #23616
+
static mut ORDER: [uint; 3] = [0, 0, 0];
static mut INDEX: uint = 0;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(libc)]
extern crate libc;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#[derive(Copy)]
pub struct Foo {
f1: int,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(dead_assignment)]
#![allow(unused_variable)]
#![allow(unknown_features)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::ops::Deref;
struct DerefArray<'a, T:'a> {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::rc::Rc;
use std::ops::Deref;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::ops::Deref;
struct DerefWithHelper<H, T> {
// aux-build:overloaded_autoderef_xc.rs
+// pretty-expanded FIXME #23616
+
extern crate overloaded_autoderef_xc;
fn main() {
// Tests calls to closure arguments where the closure takes 1 argument.
// This is a bit tricky due to rust-call ABI.
+// pretty-expanded FIXME #23616
+
fn foo(f: &mut FnMut(int) -> int) -> int {
f(22)
}
// Tests calls to closure arguments where the closure takes 2 arguments.
// This is a bit tricky due to rust-call ABI.
+// pretty-expanded FIXME #23616
+
fn foo(f: &mut FnMut(int, int) -> int) -> int {
f(1, 2)
}
// Tests calls to closure arguments where the closure takes 0 arguments.
// This is a bit tricky due to rust-call ABI.
+// pretty-expanded FIXME #23616
+
fn foo(f: &mut FnMut() -> int) -> int {
f()
}
// Tests that nested vtables work with overloaded calls.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures, core)]
use std::marker::PhantomData;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(lang_items, unboxed_closures, core)]
use std::ops::{Fn, FnMut, FnOnce};
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures, core)]
use std::ops::{FnMut};
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::cell::Cell;
use std::ops::{Deref, DerefMut};
use std::vec::Vec;
// Test overloading of the `[]` operator. In particular test that it
// takes its argument *by reference*.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
use std::ops::Index;
// Test overloaded indexing combined with autoderef.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax, core)]
// Test using overloaded indexing when the "map" is stored in a
// field. This caused problems at some point.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
use std::ops::Index;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
use std::ops::{Index, IndexMut};
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn f<T: 'static>(_x: T) {}
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#[repr(packed)]
struct Foo {
bar: u8,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::mem;
#[repr(packed)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::mem;
#[repr(packed)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::mem;
#[repr(packed)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#[repr(packed)]
struct Foo {
bar: u8,
// aux-build:packed.rs
+// pretty-expanded FIXME #23616
+
extern crate packed;
use std::mem;
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::mem;
#[repr(packed)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::mem;
#[repr(packed)]
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::mem;
#[repr(packed)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::thread;
static mut dropped: bool = false;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(dead_code)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Foo {
type T;
fn foo() -> Box<<Self as Foo>::T>;
// Test parsing binary operators after macro invocations.
+// pretty-expanded FIXME #23616
+
#![feature(macro_rules)]
macro_rules! id {
+// pretty-expanded FIXME #23616
+
mod foo {
pub fn bar(_offset: uint) { }
}
// pattern-bound var is an upvar (when translating
// the for-each body)
+// pretty-expanded FIXME #23616
+
fn foo(src: uint) {
match Some(src) {
// this checks that a pred with a non-bool return
// type is rejected, even if the pred is never used
+// pretty-expanded FIXME #23616
+
fn bad(_a: int) -> int { return 37; } //~ ERROR Non-boolean return type
pub fn main() { }
// aux-build:priv-impl-prim-ty.rs
+// pretty-expanded FIXME #23616
+
extern crate "priv-impl-prim-ty" as bar;
pub fn main() {
// Check we do the correct privacy checks when we import a name and there is an
// item with that name in both the value and type namespaces.
+// pretty-expanded FIXME #23616
+
#![allow(dead_code)]
#![allow(unused_imports)]
// aux-build:privacy_reexport.rs
+// pretty-expanded FIXME #23616
+
extern crate privacy_reexport;
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub mod test2 {
// This used to generate an ICE (make sure that default functions are
// parented to their trait to find the first private thing as the trait).
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct cat {
meows : uint,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct cat {
meows : uint,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(old_io)]
use std::old_io::Command;
// Test coercions between pointers which don't do anything fancy like unsizing.
+// pretty-expanded FIXME #23616
+
pub fn main() {
// &mut -> &
let x: &mut int = &mut 42;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::mem::transmute;
mod a {
// Issue #14660
+// pretty-expanded FIXME #23616
+
mod bleh {
macro_rules! foo {
() => {
// Issue #17436
+// pretty-expanded FIXME #23616
+
mod bleh {
macro_rules! foo {
() => {
// aux-build:pub_use_xcrate1.rs
// aux-build:pub_use_xcrate2.rs
+// pretty-expanded FIXME #23616
+
extern crate pub_use_xcrate2;
use pub_use_xcrate2::Foo;
// aux-build:pub_use_mods_xcrate.rs
+// pretty-expanded FIXME #23616
+
#![allow(unused_imports)]
extern crate pub_use_mods_xcrate;
// Check that functions can modify local state.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// good as the old one. Check out issue #21672, #21595 and #21649 for
// more details.
+// pretty-expanded FIXME #23616
+
fn main() {
let xs = (0..8).map(|i| i == 1u64).collect::<Vec<_>>();
assert_eq!(xs[1], true);
// Test range syntax.
+// pretty-expanded FIXME #23616
+
fn foo() -> int { 42 }
// Test that range syntax works in return statements
// Test that the precedence of ranges is correct
+// pretty-expanded FIXME #23616
+
struct Foo {
foo: uint,
}
+// pretty-expanded FIXME #23616
+
struct Point {x: int, y: int, z: int}
fn f(p: Point) { assert!((p.z == 12)); }
+// pretty-expanded FIXME #23616
+
struct Point {x: int, y: int}
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#[derive(Copy)]
struct Point {x: int, y: int}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#[derive(Copy)]
struct Rect {x: int, y: int, w: int, h: int}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum t1 { a(int), b(uint), }
struct T2 {x: t1, y: int}
enum t3 { c(T2, uint), }
// aux-build:reexport-should-still-link.rs
+// pretty-expanded FIXME #23616
+
extern crate "reexport-should-still-link" as foo;
pub fn main() {
// except according to those terms.
+// pretty-expanded FIXME #23616
+
mod a {
pub fn f() {}
pub fn g() {}
// except according to those terms.
// aux-build:reexported_static_methods.rs
+// pretty-expanded FIXME #23616
+
extern crate reexported_static_methods;
use reexported_static_methods::Foo;
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct Point {
x: int,
y: int
// Test that the compiler considers the 'a bound declared in the
// trait. Issue #20890.
+// pretty-expanded FIXME #23616
+
trait Foo<'a> {
type Value: 'a;
// Test that the compiler considers the 'static bound declared in the
// trait. Issue #20890.
+// pretty-expanded FIXME #23616
+
trait Foo {
type Value: 'static;
fn dummy(&self) { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn foo(x: &[int]) -> int {
x[0]
}
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn foo(x: &[int]) -> int {
x[0]
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// A very limited test of the "bottom" region
+// pretty-expanded FIXME #23616
+
fn produce_static<T>() -> &'static T { panic!(); }
fn foo<T>(_x: &T) -> &uint { produce_static() }
// A test where we (successfully) close over a reference into
// an object.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(unboxed_closures, core)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum ast<'a> {
num(uint),
add(&'a ast<'a>, &'a ast<'a>)
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum ast<'a> {
num(uint),
add(&'a ast<'a>, &'a ast<'a>)
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct ctxt<'tcx> {
x: &'tcx i32
}
// Test lifetimes are linked properly when we create dependent region pointers.
// Issue #3148.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_patterns)]
#![feature(box_syntax)]
// Test lifetimes are linked properly when we autoslice a vector.
// Issue #3148.
+// pretty-expanded FIXME #23616
+
fn subslice<F>(v: F) -> F where F: FnOnce() { v }
fn both<F>(v: F) -> F where F: FnOnce() {
// Issue #3148.
+// pretty-expanded FIXME #23616
+
fn subslice1<'r>(v: &'r [uint]) -> &'r [uint] { v }
fn both<'r>(v: &'r [uint]) -> &'r [uint] {
// Test lifetimes are linked properly when we take reference
// to interior.
+// pretty-expanded FIXME #23616
+
struct Foo(int);
pub fn main() {
// Here the lifetime of the `&` should be at least the
// lifetime parameters must be early bound in the type of the
// associated item.
+// pretty-expanded FIXME #23616
+
use std::marker;
pub enum Value<'v> {
// Tests that you can use an early-bound lifetime parameter as
// on of the generic parameters in a trait.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// Tests that you can use a fn lifetime parameter as part of
// the value for a type parameter in a bound.
+// pretty-expanded FIXME #23616
+
trait GetRef<'a> {
fn get(&self) -> &'a int;
}
// Tests that you can use a fn lifetime parameter as part of
// the value for a type parameter in a bound.
+// pretty-expanded FIXME #23616
+
trait GetRef<'a, T> {
fn get(&self) -> &'a T;
}
// Tests that you can use a fn lifetime parameter as part of
// the value for a type parameter in a bound.
+// pretty-expanded FIXME #23616
+
trait Get<T> {
fn get(&self) -> T;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// Test that you can insert an explicit lifetime in explicit self.
+// pretty-expanded FIXME #23616
+
struct Foo {
f: uint
}
// Here, `f` is a function that takes a pointer `x` and a function
// `g`, where `g` requires its argument `y` to be in the same region
// that `x` is in.
+// pretty-expanded FIXME #23616
+
fn has_same_region(f: Box<for<'a> FnMut(&'a int, Box<FnMut(&'a int)>)>) {
// `f` should be the type that `wants_same_region` wants, but
// right now the compiler complains that it isn't.
// Issue #2263.
+// pretty-expanded FIXME #23616
+
#![allow(dead_assignment)]
#![allow(unused_variable)]
#![allow(unknown_features)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::mem::swap;
pub fn main() {
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn view<T>(x: &[T]) -> &[T] {x}
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn takes_two(x: &int, y: &int) -> int { *x + *y }
fn with<T, F>(f: F) -> T where F: FnOnce(&int) -> T {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn takes_two(x: &int, y: &int) -> int { *x + *y }
fn has_two<'a,'b>(x: &'a int, y: &'b int) -> int {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct boxed_int<'a> {
f: &'a int,
}
// Test an edge case in region inference: the lifetime of the borrow
// of `*x` must be extended to at least 'a.
+// pretty-expanded FIXME #23616
+
fn foo<'a,'b>(x: &'a &'b mut int) -> &'a int {
let y = &*x; // should be inferred to have type &'a &'b mut int...
// check that the &int here does not cause us to think that `foo`
// contains region pointers
+// pretty-expanded FIXME #23616
+
struct foo(Box<FnMut(&int)+'static>);
fn take_foo<T:'static>(x: T) {}
// region variables contained within (otherwise, region inference will
// give `x` a very short lifetime).
+// pretty-expanded FIXME #23616
+
static i: uint = 3;
fn foo<F:FnOnce()+'static>(_: F) {}
fn read(_: uint) { }
// add inference constraints that the operands of a binary operator
// should outlive the binary operation itself.
+// pretty-expanded FIXME #23616
+
pub struct P<'a> {
_ptr: *const &'a u8,
}
// Regression test for issue #22246 -- we should be able to deduce
// that `&'a B::Owned` implies that `B::Owned : 'a`.
+// pretty-expanded FIXME #23616
+
#![allow(dead_code)]
use std::ops::Deref;
// doing region-folding, when really all clients of the region-folding
// case only want to see FREE lifetime variables, not bound ones.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// This test verifies that temporary lifetime is correctly computed
// for static objects in enclosing scopes.
+// pretty-expanded FIXME #23616
+
use std::cmp::PartialEq;
fn f<T:PartialEq>(o: &mut Option<T>) {
// Test that region inference correctly links up the regions when a
// `ref` borrow occurs inside a fn argument.
+// pretty-expanded FIXME #23616
+
#![allow(dead_code)]
fn with<'a, F>(_: F) where F: FnOnce(&'a Vec<int>) -> &'a Vec<int> { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(libc)]
extern crate libc;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(unsafe_destructor)]
use std::marker;
// should not upset the variance inference for actual occurrences of
// that lifetime in type expressions.
+// pretty-expanded FIXME #23616
+
pub trait HasLife<'a> {
fn dummy(&'a self) { } // just to induce a variance on 'a
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum roption<'a> {
a, b(&'a uint)
}
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn region_identity(x: &uint) -> &uint { x }
fn apply<T, F>(t: T, f: F) -> T where F: FnOnce(T) -> T { f(t) }
// started out with a longer lifetime and was reassigned to a shorter
// one (it should infer to be the intersection).
+// pretty-expanded FIXME #23616
+
fn foo(x: &int) {
let a = 1;
let mut z = x;
// started out with a longer lifetime and was reassigned to a shorter
// one (it should infer to be the intersection).
+// pretty-expanded FIXME #23616
+
fn foo(x: &int) {
let a = 1;
match x {
// attempting to bootstrap librustc with new destructor lifetime
// semantics.
+// pretty-expanded FIXME #23616
+
use std::collections::HashMap;
use std::cell::RefCell;
// changes were caught. However, those uses in the compiler could
// easily get changed or refactored away in the future.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn get<T>(opt: &Option<T>) -> &T {
match *opt {
Some(ref v) => v,
// wrong path. The new algorithm avoids this problem and hence this
// example typechecks correctly.
+// pretty-expanded FIXME #23616
+
enum ScopeChain<'a> {
Link(Scope<'a>),
End
// attempting to bootstrap libsyntax; it is adapted from
// `syntax::ext::tt::generic_extension`.
+// pretty-expanded FIXME #23616
+
pub struct E<'a> {
pub f: &'a u8,
}
// Note: see compile-fail/variance-regions-*.rs for the tests that check that the
// variance inference works in the first place.
+// pretty-expanded FIXME #23616
+
struct Contravariant<'a> {
f: &'a int
}
// This is covariant with respect to 'a, meaning that
// Covariant<'foo> <: Covariant<'static> because
// 'foo <= 'static
+// pretty-expanded FIXME #23616
+
struct Covariant<'a> {
f: extern "Rust" fn(&'a int)
}
// This test can't be a unit test in std,
// because it needs TempDir, which is in extra
+// pretty-expanded FIXME #23616
+
#![feature(tempdir, path_ext)]
use std::ffi::CString;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
static FOO: [int; 4] = [32; 4];
static BAR: [int; 4] = [32, 32, 32, 32];
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
const foo: int = 4 >> 1;
enum bs { thing = foo }
pub fn main() { assert!((bs::thing as int == foo)); }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(unsafe_destructor)]
// Ensures that class dtors run if the object is inside an enum
+// pretty-expanded FIXME #23616
+
enum option<T> { none, some(T), }
fn f<T>() -> option<T> { return option::none; }
// just to make sure that `return` is only returning from the closure,
// not the surrounding function.
+// pretty-expanded FIXME #23616
+
static mut calls: uint = 0;
fn surrounding() {
+// pretty-expanded FIXME #23616
+
fn f() { let x: () = (); return x; }
pub fn main() { let _x = f(); }
// exec-env:RUST_LOG=rust-log-filter/foo
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax, std_misc, rustc_private)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(old_io)]
use std::old_io::process::Command;
// Test that we can use `Self` types in impls in the expected way.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// Assert that `mut self` on an immediate value doesn't
// allow mutating the original - issue #10615.
+// pretty-expanded FIXME #23616
+
#[derive(Copy)]
struct Value {
n: int
// Ensure assigning an owned or managed variable to itself works. In particular,
// that we do not glue_drop before we glue_take (#3290).
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
mod a {
pub mod b {
pub mod a {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait MyTrait {
fn f(&self) -> Self;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(core, std_misc)]
use std::thread::Thread;
use std::sync::Mutex;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(std_misc)]
use std::thread::Thread;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::sync::mpsc::{channel, Sender};
// tests that ctrl's type gets inferred properly
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(collections)]
extern crate collections;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(collections)]
extern crate collections;
// Test that a class with only sendable fields can be sent
+// pretty-expanded FIXME #23616
+
use std::sync::mpsc::channel;
struct foo {
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn test<F>(f: F) -> uint where F: FnOnce(uint) -> uint {
return f(22);
}
// Test accessing cross-crate inlined items from multiple compilation units.
+// pretty-expanded FIXME #23616
+
extern crate sepcomp_cci_lib;
use sepcomp_cci_lib::{cci_fn, CCI_STATIC};
// Test accessing external items from multiple compilation units.
+// pretty-expanded FIXME #23616
+
#[link(name = "sepcomp-extern-lib")]
extern {
#[allow(ctypes)]
// Generate some code in the first compilation unit before declaring any
// modules. This ensures that the first module doesn't go into the same
// compilation unit as the top-level module.
+// pretty-expanded FIXME #23616
+
fn pad() -> uint { 0 }
mod b {
// Generate some code in the first compilation unit before declaring any
// modules. This ensures that the first module doesn't go into the same
// compilation unit as the top-level module.
+// pretty-expanded FIXME #23616
+
fn one() -> uint { 1 }
mod a {
// Test linking against a library built with -C codegen-units > 1
+// pretty-expanded FIXME #23616
+
extern crate sepcomp_lib;
use sepcomp_lib::a::one;
use sepcomp_lib::b::two;
// Test references to static items across compilation units.
+// pretty-expanded FIXME #23616
+
fn pad() -> uint { 0 }
const ONE: uint = 1;
// In any case, this test should let us know if enabling parallel codegen ever
// breaks unwinding.
+// pretty-expanded FIXME #23616
+
use std::thread;
fn pad() -> uint { 0 }
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
assert!(("hello".to_string() < "hellr".to_string()));
assert!(("hello ".to_string() > "hello".to_string()));
// Test that we can do shifts by any integral type.
+// pretty-expanded FIXME #23616
+
struct Panolpy {
i8: i8,
i16: i16,
// Testing shifts for various combinations of integers
// Issue #1570
+// pretty-expanded FIXME #23616
+
pub fn main() {
test_misc();
test_expr();
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum test { thing = -5 >> 1_usize }
pub fn main() {
assert_eq!(test::thing as int, -3);
// Be sure that when a SIGPIPE would have been received that the entire process
// doesn't die in a ball of fire, but rather it's gracefully handled.
+// pretty-expanded FIXME #23616
+
use std::env;
use std::io::prelude::*;
use std::io;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
use std::simd::{i32x4, f32x4, u32x4};
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(simd)]
use std::ops;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
#![feature(simd)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(simd)]
#![allow(non_camel_case_types)]
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(simd)]
#[simd]
+// pretty-expanded FIXME #23616
+
enum clam<T> { a(T), }
pub fn main() { let c = clam::a(2); match c { clam::a::<int>(_) => { } } }
+// pretty-expanded FIXME #23616
+
enum clam<T> { a(T), }
pub fn main() { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(custom_derive)]
#[derive_Clone]
// Possibly-dynamic size of typaram should be cleared at pointer boundary.
+// pretty-expanded FIXME #23616
+
fn bar<T: Sized>() { }
fn foo<T>() { bar::<&T>() }
pub fn main() { }
// Possibly-dynamic size of typaram should be cleared at pointer boundary.
+// pretty-expanded FIXME #23616
+
fn bar<T: Sized>() { }
fn foo<T>() { bar::<Box<T>>() }
pub fn main() { }
// Test slicing expressions on slices and Vecs.
+// pretty-expanded FIXME #23616
+
fn main() {
let x: &[int] = &[1, 2, 3, 4, 5];
let cmp: &[int] = &[1, 2, 3, 4, 5];
// Test that if a slicing expr[..] fails, the correct cleanups happen.
+// pretty-expanded FIXME #23616
+
use std::thread;
struct Foo;
// Test that if a slicing expr[..] fails, the correct cleanups happen.
+// pretty-expanded FIXME #23616
+
use std::thread;
struct Foo;
// Test slicing sugar.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
extern crate core;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
/*!
* Tests the range assertion wraparound case in trans::middle::adt::load_discr.
*/
// Smallest "hello world" with a libc runtime
+// pretty-expanded FIXME #23616
+
#![feature(intrinsics, lang_items, start, no_std, libc)]
#![no_std]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(non_ascii_idents)]
#![deny(non_snake_case)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
/*
Make sure we can spawn tasks that take different types of
parameters. This is based on a test case for #520 provided by Rob
// Issue #2040
+// pretty-expanded FIXME #23616
+
pub fn main() {
let foo = 1;
assert_eq!(&foo as *const int, &foo as *const int);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(tempdir, path_ext)]
use std::fs::{File, TempDir};
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(static_assert)]
#[static_assert]
// aux-build:static_fn_inline_xc_aux.rs
+// pretty-expanded FIXME #23616
+
extern crate "static_fn_inline_xc_aux" as mycore;
use mycore::num;
// aux-build:static_fn_trait_xc_aux.rs
+// pretty-expanded FIXME #23616
+
extern crate "static_fn_trait_xc_aux" as mycore;
use mycore::num;
// except according to those terms.
// aux-build:static-function-pointer-aux.rs
+// pretty-expanded FIXME #23616
+
extern crate "static-function-pointer-aux" as aux;
fn f(x: int) -> int { x }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn f(x: int) -> int { x }
fn g(x: int) -> int { 2 * x }
+// pretty-expanded FIXME #23616
+
pub trait plus {
fn plus(&self) -> int;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Deserializer {
fn read_int(&self) -> int;
}
// aux-build:static-methods-crate.rs
+// pretty-expanded FIXME #23616
+
extern crate static_methods_crate;
use static_methods_crate::read;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
mod a {
pub trait Foo {
fn foo() -> Self;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub trait Number: NumConv {
fn from<T:Number>(n: T) -> Self;
}
// statics cannot. This ensures that there's some form of error if this is
// attempted.
+// pretty-expanded FIXME #23616
+
#![feature(libc)]
extern crate libc;
// aux-build:static_mut_xc.rs
+// pretty-expanded FIXME #23616
+
extern crate static_mut_xc;
unsafe fn static_bound(_: &'static int) {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(std_misc, alloc)]
use std::sync;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let a: String = "this \
is a test".to_string();
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn main() {
let x = "\\\\\
";
// except according to those terms.
// aux-build:xcrate_struct_aliases.rs
+// pretty-expanded FIXME #23616
+
extern crate xcrate_struct_aliases;
use xcrate_struct_aliases::{S, S2};
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct S {
x: int,
y: int,
// aux-build:struct_destructuring_cross_crate.rs
+// pretty-expanded FIXME #23616
+
extern crate struct_destructuring_cross_crate;
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum Foo {
Bar {
a: int,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum Foo {
Bar {
x: int,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct Foo {
new: int,
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct S { f0: String, f1: int }
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct S {
f0: String,
f1: String,
// Checks that functional-record-update order-of-eval is as expected
// even when no Drop-implementations are involved.
+// pretty-expanded FIXME #23616
+
use std::sync::atomic::{Ordering, AtomicUsize, ATOMIC_USIZE_INIT};
struct W { wrapped: u32 }
// Checks that struct-literal expression order-of-eval is as expected
// even when no Drop-implementations are involved.
+// pretty-expanded FIXME #23616
+
use std::sync::atomic::{Ordering, AtomicUsize, ATOMIC_USIZE_INIT};
struct W { wrapped: u32 }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
mod foo {
pub enum Foo {
Bar { a: int }
// except according to those terms.
// aux-build:struct_variant_xc_aux.rs
+// pretty-expanded FIXME #23616
+
extern crate struct_variant_xc_aux;
use struct_variant_xc_aux::Enum::StructVariant;
// except according to those terms.
// aux-build:struct_variant_xc_aux.rs
+// pretty-expanded FIXME #23616
+
extern crate struct_variant_xc_aux;
use struct_variant_xc_aux::Enum::{StructVariant, Variant};
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub mod a {
pub fn f() {}
pub mod b {
// There is some other borrowck bug, so we make the stuff not mut.
+// pretty-expanded FIXME #23616
+
use std::ops::Add;
trait Positioned<S> {
// aux-build:svh-b.rs
// aux-build:svh-a-comment.rs
+// pretty-expanded FIXME #23616
+
extern crate a;
extern crate b;
// aux-build:svh-b.rs
// aux-build:svh-a-doc.rs
+// pretty-expanded FIXME #23616
+
extern crate a;
extern crate b;
// aux-build:svh-b.rs
// aux-build:svh-a-macro.rs
+// pretty-expanded FIXME #23616
+
extern crate a;
extern crate b;
// aux-build:svh-b.rs
// aux-build:svh-a-no-change.rs
+// pretty-expanded FIXME #23616
+
extern crate a;
extern crate b;
// aux-build:svh-b.rs
// aux-build:svh-a-redundant-cfg.rs
+// pretty-expanded FIXME #23616
+
extern crate a;
extern crate b;
// aux-build:svh-b.rs
// aux-build:svh-a-whitespace.rs
+// pretty-expanded FIXME #23616
+
extern crate a;
extern crate b;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::mem::swap;
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::mem::swap;
pub fn main() {
// Issue #5041 - avoid overlapping memcpy when src and dest of a swap are the same
+// pretty-expanded FIXME #23616
+
use std::ptr;
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unused_mut)]
#![feature(collections)]
// compile-flags: --cfg foo --cfg qux="foo"
+// pretty-expanded FIXME #23616
+
pub fn main() {
// check
if ! cfg!(foo) { panic!() }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(optin_builtin_traits, core)]
use std::marker::{MarkerTrait, Send};
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::mem;
enum Tag<A> {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::mem;
enum Tag<A,B> {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::mem;
enum Tag {
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use alder::*;
mod alder {
+// pretty-expanded FIXME #23616
+
fn foo() {
fn zed(_z: bar) { }
enum bar { nil, }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum color {
red = 1,
blue = 2,
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use color::{red, green, blue, black, white, imaginary, purple, orange};
#[derive(Copy)]
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum colour { red(int, int), green, }
impl PartialEq for colour {
// use of tail calls causes arg slot leaks, issue #160.
+// pretty-expanded FIXME #23616
+
fn inner(dummy: String, b: bool) { if b { return inner(dummy, false); } }
pub fn main() {
+// pretty-expanded FIXME #23616
+
pub fn main() { assert!((even(42))); assert!((odd(45))); }
fn even(n: int) -> bool { if n == 0 { return true; } else { return odd(n - 1); } }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(std_misc)]
use std::sync::mpsc::{channel, Sender};
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(std_misc)]
use std::sync::mpsc::{channel, Sender};
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(std_misc)]
// Issue #922
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::sync::mpsc::channel;
pub fn main() { test00(); }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(dead_assignment)]
use std::sync::mpsc::channel;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(std_misc)]
#![allow(dead_assignment)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::sync::mpsc::channel;
// rustboot can't transmit nils across channels because they don't have
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(std_misc)]
use std::thread::Thread;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax, std_misc)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax, old_io, std_misc, io, set_panic, set_stdio)]
// Issue #787
// Don't try to clean up uninitialized locals
+// pretty-expanded FIXME #23616
+
use std::thread;
fn test_break() { loop { let _x: Box<int> = break; } }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(advanced_slice_patterns,)]
fn f<T,>(_: T,) {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
trait Foo : ::std::marker::MarkerTrait {
// trait exactly, as long as the implementation doesn't demand *more* bounds
// than the trait.
+// pretty-expanded FIXME #23616
+
trait A {
fn foo<T: Eq + Ord>(&self);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
trait U : ::std::marker::MarkerTrait {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
trait I { fn i(&self) -> Self; }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait connection {
fn read(&self) -> int;
}
//
// See issue #18209.
+// pretty-expanded FIXME #23616
+
pub trait Foo {
fn load_from() -> Box<Self>;
fn load() -> Box<Self> {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Foo {
fn foo(&self);
}
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait A<T> {
fn g<U>(&self, x: T, y: U) -> (T, U) { (x, y) }
}
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait A<T> {
fn g(&self, x: T) -> T { x }
}
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait A {
fn g<T>(&self, x: T, y: T) -> (T, T) { (x, y) }
}
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait A<T> {
fn g(&self, x: uint) -> uint { x }
fn h(&self, x: T) { }
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait A {
fn g(&self) -> int { 10 }
}
// aux-build:trait_default_method_xc_aux_2.rs
+// pretty-expanded FIXME #23616
+
extern crate "trait_default_method_xc_aux" as aux;
extern crate "trait_default_method_xc_aux_2" as aux2;
use aux::A;
// aux-build:trait_default_method_xc_aux.rs
+// pretty-expanded FIXME #23616
+
extern crate "trait_default_method_xc_aux" as aux;
use aux::{A, TestEquality, Something};
use aux::B;
// between the builtin rules for Sized and the where clause. Issue
// #20959.
+// pretty-expanded FIXME #23616
+
fn foo<K>(x: Option<K>)
where Option<K> : Sized
{
+// pretty-expanded FIXME #23616
+
trait to_str {
fn to_string_(&self) -> String;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub mod Foo {
pub trait Trait {
fn foo(&self);
// Test calling methods on an impl for a bare trait.
// aux-build:traitimpl.rs
+// pretty-expanded FIXME #23616
+
extern crate traitimpl;
use traitimpl::Bar;
// aux-build:trait_inheritance_auto_xc_2_aux.rs
+// pretty-expanded FIXME #23616
+
extern crate "trait_inheritance_auto_xc_2_aux" as aux;
// aux defines impls of Foo, Bar and Baz for A
// aux-build:trait_inheritance_auto_xc_aux.rs
+// pretty-expanded FIXME #23616
+
extern crate "trait_inheritance_auto_xc_aux" as aux;
use aux::{Foo, Bar, Baz, Quux};
// Testing that this impl turns A into a Quux, because
// A is already a Foo Bar Baz
+// pretty-expanded FIXME #23616
+
impl<T:Foo + Bar + Baz> Quux for T { }
trait Foo { fn f(&self) -> int; }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Foo { fn f(&self) -> int; }
trait Bar : Foo { fn g(&self) -> int; }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Foo { fn f(&self) -> int; }
trait Bar : Foo { fn g(&self) -> int; }
trait Baz : Bar { fn h(&self) -> int; }
// Testing that we can cast to a subtrait and call subtrait
// methods. Not testing supertrait methods
+// pretty-expanded FIXME #23616
+
trait Foo {
fn f(&self) -> int;
}
// Testing that supertrait methods can be called on subtrait object types
+// pretty-expanded FIXME #23616
+
trait Foo {
fn f(&self) -> int;
}
// aux-build:trait_inheritance_cross_trait_call_xc_aux.rs
+// pretty-expanded FIXME #23616
+
extern crate "trait_inheritance_cross_trait_call_xc_aux" as aux;
use aux::Foo;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Foo { fn f(&self) -> int; }
trait Bar : Foo { fn g(&self) -> int; }
// B and C both require A, so D does as well, twice, but that's just fine
+// pretty-expanded FIXME #23616
+
trait A { fn a(&self) -> int; }
trait B: A { fn b(&self) -> int; }
trait C: A { fn c(&self) -> int; }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait A { fn a(&self) -> int; }
trait B: A { fn b(&self) -> int; }
trait C: A { fn c(&self) -> int; }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait A { fn a(&self) -> int; }
trait B: A { fn b(&self) -> int; }
trait C: A { fn c(&self) -> int; }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
use std::cmp::{PartialEq, PartialOrd};
// Extending Num and using inherited static methods
+// pretty-expanded FIXME #23616
+
#![feature(core)]
use std::cmp::PartialOrd;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
use std::cmp::PartialOrd;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
use std::cmp::PartialEq;
// aux-build:trait_inheritance_overloading_xc.rs
+// pretty-expanded FIXME #23616
+
extern crate trait_inheritance_overloading_xc;
use trait_inheritance_overloading_xc::{MyNum, MyInt};
// Test for issue #4183: use of Self in supertraits.
+// pretty-expanded FIXME #23616
+
use std::num::Float as StdFloat;
pub static FUZZY_EPSILON: f64 = 0.1;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Foo { fn f(&self) -> int; }
trait Bar : Foo { fn g(&self) -> int; }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub trait MyNum {
fn from_int(int) -> Self;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
pub trait MyEq : ::std::marker::MarkerTrait { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub trait Add<RHS,Result> {
fn add(&self, rhs: &RHS) -> Result;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Panda<T> {
fn chomp(&self, bamboo: &T) -> T;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
mod traits {
pub trait Foo { fn f(&self) -> int; }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Foo { fn f(&self) -> int; }
trait Bar { fn g(&self) -> int; }
trait Baz { fn h(&self) -> int; }
// test for #8664
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// Uncovered during work on new scoping rules for safe destructors
// as an important use case to support properly.
+// pretty-expanded FIXME #23616
+
pub struct E<'a> {
pub f: &'a u8,
}
// Simple smoke test that unsafe traits can be compiled across crates.
+// pretty-expanded FIXME #23616
+
extern crate "trait-safety-lib" as lib;
use lib::Foo;
// Simple smoke test that unsafe traits can be compiled etc.
+// pretty-expanded FIXME #23616
+
unsafe trait Foo {
fn foo(&self) -> int;
}
//
// Issue #18453.
+// pretty-expanded FIXME #23616
+
use std::rc::Rc;
pub trait Foo<M> {
// Test case where an associated type is referenced from within the
// supertrait definition. Issue #20220.
+// pretty-expanded FIXME #23616
+
use std::vec::IntoIter;
pub trait Foo: Iterator<Item=<Self as Foo>::Key> {
// blanket impl for T:Copy coexists with an impl for Box<T>, because
// Box does not impl Copy.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// aux-build:go_trait.rs
+// pretty-expanded FIXME #23616
+
extern crate go_trait;
use go_trait::{Go, GoMut, GoOnce, go, go_mut, go_once};
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Foo {
fn bar(&self) -> String {
format!("test")
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(dead_assignment)]
#![allow(unused_variable)]
// distinct scopes to be compared (`'g` and `'h`). The only important
// thing is that compilation succeeds here.
+// pretty-expanded FIXME #23616
+
#![allow(missing_copy_implementations)]
#![allow(unused_variables)]
// and the blanket impl. The only important thing is that compilation
// succeeds here. Issue #22110.
+// pretty-expanded FIXME #23616
+
#![allow(dead_code)]
trait Foo<A> {
// Regression test for issue #22655: This test should not lead to
// infinite recursion.
+// pretty-expanded FIXME #23616
+
unsafe impl<T: Send + ?Sized> Send for Unique<T> { }
pub struct Unique<T:?Sized> {
// Async>::Cancel` be WF. This normalizes to `Receipt<Complete>`
// again, leading to an infinite cycle. Issue #23003.
+// pretty-expanded FIXME #23616
+
#![allow(dead_code)]
#![allow(unused_variables)]
// Test that we can infer the Target based on the Self or vice versa.
+// pretty-expanded FIXME #23616
+
use std::mem;
trait Convert<Target> {
// various methods in various ways successfully.
// See also `compile-fail/trait-repeated-supertrait-ambig.rs`.
+// pretty-expanded FIXME #23616
+
trait CompareTo<T> {
fn same_as(&self, t: T) -> bool;
}
// Last 7 bytes of Request struct are not occupied by any fields.
+// pretty-expanded FIXME #23616
+
enum TestOption<T> {
TestNone,
TestSome(T),
// Issue #7988
// Transmuting non-immediate type to immediate type
+// pretty-expanded FIXME #23616
+
pub fn main() {
unsafe {
::std::mem::transmute::<[int; 1],int>([1])
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
type point = (int, int);
fn f(p: point, x: int, y: int) {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct Foo<'a>(&'a [int]);
fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct Point(int, int);
fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct Foo(int, int, int);
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(core)]
use std::intrinsics::type_name;
// Test that type IDs correctly account for higher-rank lifetimes
// Also acts as a regression test for an ICE (issue #19791)
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures, core)]
use std::any::TypeId;
+// pretty-expanded FIXME #23616
+
mod a {
pub mod b {
pub type t = int;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct A { a: int }
fn a(a: A) -> int { return a.a; }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
+// pretty-expanded FIXME #23616
+
type lteq<T> = extern fn(T) -> bool;
pub fn main() { }
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct S<T> {
a: T,
b: uint,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn f(a: *const int) -> *const int { return a; }
fn g(a: *const int) -> *const int { let b = f(a); return b; }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::mem::size_of;
struct t {a: u8, b: i8}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::ptr;
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum T {
A(int),
B(f64)
// This test checks that the `_` type placeholder works
// correctly for enabling type inference.
+// pretty-expanded FIXME #23616
+
struct TestStruct {
x: *const int
}
// aux-build:typeid-intrinsic.rs
// aux-build:typeid-intrinsic2.rs
+// pretty-expanded FIXME #23616
+
#![feature(hash, core)]
extern crate "typeid-intrinsic" as other1;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(dead_assignment)]
#![allow(unused_variable)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let (x, y) = (10, 20);
let z = x + y;
+// pretty-expanded FIXME #23616
+
pub fn main() {
let mut word: u32 = 200000;
word = word - 1;
// These constants were chosen because they aren't used anywhere
// in the rest of the generated code so they're easily grep-able.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let mut x: u8 = 19; // 0x13
+// pretty-expanded FIXME #23616
+
pub fn main() {
let mut x: u8 = 12;
let y: u8 = 12;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(collections, rand)]
use std::borrow::{Cow, IntoCow};
// Test that when you use ufcs form to invoke a trait method (on a
// trait object) everything works fine.
+// pretty-expanded FIXME #23616
+
trait Foo {
fn test(&self) -> i32;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Foo<T> {
fn get(&self) -> T;
}
+// pretty-expanded FIXME #23616
+
pub fn main() { let _x: uint = 10 as uint; }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(lang_items, unboxed_closures)]
fn a<F:Fn(int, int) -> int>(f: F) -> int {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures)]
// Test by-ref capture of environment in unboxed closure types
// Test that the call operator autoderefs when calling a bounded type parameter.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures)]
use std::ops::FnMut;
// Test that the call operator autoderefs when calling a bounded type parameter.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures)]
use std::ops::FnMut;
// Test that we mutate a counter on the stack only when we expect to.
+// pretty-expanded FIXME #23616
+
fn call<F>(f: F) where F : FnOnce() {
f();
}
// Acts as a regression test for #16790, #18378 and #18543
// aux-build:unboxed-closures-cross-crate.rs
+// pretty-expanded FIXME #23616
+
extern crate "unboxed-closures-cross-crate" as ubcc;
fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures)]
fn main() {
// A battery of tests to ensure destructors of unboxed closure environments
// run at the right times.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures)]
static mut DROP_COUNT: uint = 0;
// Checks that higher-ranked extern fn pointers implement the full range of Fn traits.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures, core)]
use std::ops::{Fn,FnMut,FnOnce};
// Checks that extern fn pointers implement the full range of Fn traits.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures)]
#![feature(unboxed_closures)]
// Checks that the Fn trait hierarchy rules permit
// any Fn trait to be used where Fn is implemented.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures, core)]
use std::ops::{Fn,FnMut,FnOnce};
// Checks that the Fn trait hierarchy rules permit
// FnMut or FnOnce to be used where FnMut is implemented.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures, core)]
use std::ops::{FnMut,FnOnce};
// Test that we are able to infer that the type of `x` is `int` based
// on the expected type from the object.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures, core)]
use std::num::ToPrimitive;
// Test that we are able to infer that the type of `x` is `int` based
// on the expected type from the object.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures, core)]
use std::num::ToPrimitive;
// Test that we are able to infer that the type of `x` is `int` based
// on the expected type from the object.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures, core)]
use std::num::ToPrimitive;
// Test that we are able to infer a suitable kind for this closure
// that is just called (`FnMut`).
+// pretty-expanded FIXME #23616
+
fn main() {
let mut counter = 0;
// Test that we are able to infer a suitable kind for this `move`
// closure that is just called (`FnMut`).
+// pretty-expanded FIXME #23616
+
fn main() {
let mut counter = 0;
// Test that we are able to infer a suitable kind for this closure
// that is just called (`FnMut`).
+// pretty-expanded FIXME #23616
+
fn main() {
let mut counter = 0;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(unsafe_destructor)]
// Test that we are able to infer a suitable kind for this `move`
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(unsafe_destructor)]
// Test that we are able to infer a suitable kind for this closure
// Test that we can infer the "kind" of an unboxed closure based on
// the expected type.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures)]
// Test by-ref capture of environment in unboxed closure types
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(core,unboxed_closures)]
use std::marker::PhantomData;
// Test that the type variable in the type(`Vec<_>`) of a closed over
// variable does not interfere with type inference.
+// pretty-expanded FIXME #23616
+
fn f<F: FnMut()>(mut f: F) {
f();
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures, core)]
use std::ops::FnMut;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures)]
#![deny(unused_mut)]
// Test that in a by-ref once closure we move some variables even as
// we capture others by mutable reference.
+// pretty-expanded FIXME #23616
+
fn call<F>(f: F) where F : FnOnce() {
f();
}
// Tests that the reexports of `FnOnce` et al from the prelude work.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
#![feature(unboxed_closures, core)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures)]
use std::ops::FnMut;
// Ensures that single-word environments work right in unboxed closures.
// These take a different path in codegen.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures)]
fn a<F:Fn(int, int) -> int>(f: F) -> int {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures)]
fn main() {
// Test unboxed closure sugar used in object types.
+// pretty-expanded FIXME #23616
+
#![allow(dead_code)]
#![feature(unboxed_closures)]
//
// compile-flags: -g
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures)]
use std::ptr;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures)]
fn main() {
// no-pretty-expanded FIXME #15189
+// pretty-expanded FIXME #23616
+
#![feature(core)]
use std::iter::Unfold;
// unified with the type *T, and so the type variable
// in that type gets resolved.
+// pretty-expanded FIXME #23616
+
use std::mem;
fn null<T>() -> *const T {
// Test the uninit() construct returning various empty types.
+// pretty-expanded FIXME #23616
+
use std::mem;
#[derive(Clone)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(dead_assignment)]
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let _: Box<int>;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_patterns)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// Issue #976
+// pretty-expanded FIXME #23616
+
fn f<T>(x: Box<T>) {
let _x2 = x;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// Issue #961
+// pretty-expanded FIXME #23616
+
fn altsimple() {
match Box::new(true) {
_ => { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unused_variable)]
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// Issue #5192
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_patterns)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_patterns)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// Make sure the destructor is run for unit-like structs.
+// pretty-expanded FIXME #23616
+
#![feature(alloc)]
use std::boxed::BoxAny;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unused_variable)]
#![allow(dead_assignment)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn good(_a: &int) {
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unreachable_code)]
#![allow(unused_variable)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(path_statement)]
#![allow(unreachable_code)]
#![allow(unused_variable)]
// Check that safe fns are not a subtype of unsafe fns.
+// pretty-expanded FIXME #23616
+
fn foo(x: i32) -> i32 {
x * 22
}
//
// See also: compile-fail/unsafe-fn-called-from-safe.rs
+// pretty-expanded FIXME #23616
+
unsafe fn f() { return; }
fn g() {
//
// See also: compile-fail/unsafe-fn-called-from-safe.rs
+// pretty-expanded FIXME #23616
+
unsafe fn f() { return; }
unsafe fn g() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn f(x: *const int) {
unsafe {
assert_eq!(*x, 3);
// Test syntax checks for `?Sized` syntax.
+// pretty-expanded FIXME #23616
+
use std::marker::{PhantomData, PhantomFn};
trait T1 : PhantomFn<Self> { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// Test structs with always-unsized fields.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax, core)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// Issue Name: Unused move causes a crash
// Abstract: zero-fill to block after drop
+// pretty-expanded FIXME #23616
+
#![allow(path_statement)]
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// except according to those terms.
// Issue #1706
+// pretty-expanded FIXME #23616
+
extern crate "std" as stdlib;
pub fn main() {}
+// pretty-expanded FIXME #23616
+
mod foo {
pub fn x() -> int { return 1; }
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub use foo::bar::{self, First};
use self::bar::Second;
// Issue #1761
+// pretty-expanded FIXME #23616
+
impl foo for int { fn foo(&self) -> int { 10 } }
trait foo { fn foo(&self) -> int; }
pub fn main() {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unused_imports)]
#![feature(start, no_std)]
#![no_std]
// aux-build:inline_dtor.rs
+// pretty-expanded FIXME #23616
+
extern crate inline_dtor;
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(libc, std_misc)]
extern crate libc;
// us from approximating the lifetimes of `field1` and `field2` to a
// common intersection.
+// pretty-expanded FIXME #23616
+
#![allow(dead_code)]
#![feature(core)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(dead_code)]
// Get<T> is covariant in T
// Test that vec is now covariant in its argument type.
+// pretty-expanded FIXME #23616
+
#![allow(dead_code)]
#![feature(core)]
// except according to those terms.
// pp-exact - Make sure we actually print the attributes
+// pretty-expanded FIXME #23616
+
#![feature(custom_attribute)]
enum crew_of_enterprise_d {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
enum Foo {
Bar { x: int },
Baz { y: int }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::mem::size_of;
pub fn main() {
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let mut v = vec!(1);
v.push(2);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(lang_items, start, no_std, core, libc, collections)]
#![no_std]
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
assert_eq!(vec![1; 3], vec![1, 1, 1]);
assert_eq!(vec![1; 2], vec![1, 1]);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn one() -> i32 { 1 }
// Make sure the vec![...] macro doesn't introduce hidden rvalue
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
macro_rules! vec [
($($e:expr),*) => ({
let mut _temp = ::std::vec::Vec::new();
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
assert_eq!(vec!(1), vec!(1,));
assert_eq!(vec!(1, 2, 3), vec!(1, 2, 3,));
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let x = [1, 2, 3];
match x {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(advanced_slice_patterns)]
fn a() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(advanced_slice_patterns)]
fn foldl<T, U, F>(values: &[T],
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(advanced_slice_patterns)]
fn a() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() { let mut v = vec!(1, 2, 3); v.push(1); }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() { let _a = [0; 1 as uint]; }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(unsafe_destructor)]
use std::cell::Cell;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let v = vec![1,2,3,4,5];
let v2 = &v[1..3];
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct Foo {
string: String
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
assert_eq!(format!("{:?}", vec!(0, 1)), "[0, 1]".to_string());
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let v: Vec<int> = vec!(10, 20);
assert_eq!(v[0], 10);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![allow(unknown_features)]
#![feature(box_syntax)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(rand, core)]
use std::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT, Ordering};
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(visible_private_types)]
trait Foo { fn dummy(&self) { } }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(libc, old_io)]
extern crate libc;
// compile-flags:-D improper-ctypes
+// pretty-expanded FIXME #23616
+
#![allow(improper_ctypes)]
mod libc {
// aux-build:weak-lang-items.rs
+// pretty-expanded FIXME #23616
+
extern crate "weak-lang-items" as other;
use std::thread;
// Test that the `wf` checker properly handles bound regions in object
// types. Compiling this code used to trigger an ICE.
+// pretty-expanded FIXME #23616
+
pub struct Context<'tcx> {
vec: &'tcx Vec<int>
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Bound {
fn dummy(&self) { }
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait TheTrait { fn dummy(&self) { } }
impl TheTrait for &'static int { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
trait Foo<T> { fn dummy(&self, arg: T) { } }
trait Bar<A> {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
struct A<'a, 'b> where 'a : 'b { x: &'a int, y: &'b int }
fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn foo<'a, I>(mut it: I) where I: Iterator<Item=&'a int> {}
fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(unboxed_closures)]
struct Bencher;
// Test that we can quantify lifetimes outside a constraint (i.e., including
// the self type) in a where clause.
+// pretty-expanded FIXME #23616
+
use std::marker::PhantomFn;
static mut COUNT: u32 = 1;
+// pretty-expanded FIXME #23616
+
pub fn main() { let x: int = 10; while x == 10 && x == 11 { let _y = 0xf00_usize; } }
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub fn main() {
let mut i = 100;
'w: while 1 + 1 == 2 {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(collections)]
use std::collections::BinaryHeap;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(collections)]
use std::string::String;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
use std::sync::Mutex;
struct Point {x: int, y: int, z: int}
// GetLastError doesn't seem to work with stack switching
+// pretty-expanded FIXME #23616
+
#[cfg(windows)]
mod kernel32 {
extern "system" {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
pub type HANDLE = u32;
pub type DWORD = u32;
pub type SIZE_T = u32;
// aux-build:xcrate_address_insignificant.rs
+// pretty-expanded FIXME #23616
+
extern crate "xcrate_address_insignificant" as foo;
pub fn main() {
// aux-build:xcrate_static_addresses.rs
+// pretty-expanded FIXME #23616
+
extern crate xcrate_static_addresses;
use xcrate_static_addresses as other;
// aux-build:xcrate-trait-lifetime-param.rs
+// pretty-expanded FIXME #23616
+
extern crate "xcrate-trait-lifetime-param" as other;
struct Reader<'a> {
// except according to those terms.
// aux-build:xcrate_unit_struct.rs
+// pretty-expanded FIXME #23616
+
extern crate xcrate_unit_struct;
const s1: xcrate_unit_struct::Struct = xcrate_unit_struct::Struct;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
#![feature(unsafe_no_drop_flag)]
static mut destructions : int = 3;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// pretty-expanded FIXME #23616
+
fn main() {
let x = [(), ()];
projects / rust.git / commitdiff