// rustfmt-normalize_comments: true
// rustfmt-wrap_comments: true
// rustfmt-format_strings: true
// Test of lots of random stuff.
// FIXME split this into multiple, self-contained tests.


#[attr1] extern crate foo;
#[attr2] #[attr3] extern crate foo;
#[attr1]extern crate foo;
#[attr2]#[attr3]extern crate foo;

use std::cell::*;
use std::{any, ascii, self, borrow, boxed, char, borrow, boxed, char, borrow, borrow, boxed, char, borrow, boxed, char, borrow, boxed, char, borrow, boxed, char, borrow, boxed, char, borrow, boxed, char, borrow, boxed, char, borrow, boxed, char};

mod doc;
mod other;


// sfdgfffffffffffffffffffffffffffffffffffffffffffffffffffffff ffffffffffffffffffffffffffffffffffffffffff

                                                         fn foo(a: isize,
     b: u32, /* blah blah */
         c: f64) {

}

fn foo()->Box<Write+'static> where 'a: 'b, for<'a> D<'b>: 'a {
    hello!()
}

fn baz<'a: 'b /* comment on 'a */, T: SomsssssssssssssssssssssssssssssssssssssssssssssssssssssseType /* comment on T */>(a: A, b: B /* comment on b */, c: C) -> Bob {
    #[attr1] extern crate foo;
    #[attr2] #[attr3] extern crate foo;
    #[attr1]extern crate foo;
    #[attr2]#[attr3]extern crate foo;
}

#[rustfmt::skip]
fn qux(a: dadsfa,   // Comment 1
       b: sdfasdfa, // Comment 2
       c: dsfdsafa) // Comment 3
{

}

/// Blah blah blah.
impl Bar {
    fn foo(&mut self, a: sdfsdfcccccccccccccccccccccccccccccccccccccccccccccccccc, // comment on a
           b: sdfasdfsdfasfs /*closing comment*/ ) -> isize {}

    /// Blah blah blah.
    pub fn f2(self) {
        (foo, bar)
    }

    #[an_attribute]
    fn f3(self) -> Dog {
    }
}

/// The `nodes` and `edges` method each return instantiations of
/// `Cow<[T]>` to leave implementers the freedom to create

/// entirely new vectors or to pass back slices into internally owned
/// vectors.
pub trait GraphWalk<'a, N, E> {
    /// Returns all the nodes in this graph.
    fn nodes(&'a self) -> Nodes<'a, N>;
    /// Returns all of the edges in this graph.
    fn edges(&'a self) -> Edges<'a, E>;
    /// The source node for `edge`.
    fn source(&'a self, edge: &E) -> N;
    /// The target node for `edge`.
    fn target(&'a self, edge: &E) -> N;
}

/// A Doc comment
#[AnAttribute]
pub struct Foo {
    #[rustfmt::skip]
    f :   SomeType, // Comment beside a field
    f :   SomeType, // Comment beside a field
    // Comment on a field
    g: SomeOtherType,
    /// A doc comment on a field
    h: AThirdType,}

struct Bar;

// With a where-clause and generics.
pub struct Foo<'a, Y: Baz>
    where X: Whatever
{
    f: SomeType, // Comment beside a field
}

fn foo(ann: &'a (PpAnn+'a)) {}

fn main() {
    for i in 0i32..4 {
        println!("{}", i);
    }


    while true {
        hello();
    }

        let rc = Cell::new(42usize,42usize, Cell::new(42usize, remaining_widthremaining_widthremaining_widthremaining_width), 42usize);
    let rc = RefCell::new(42usize,remaining_width,           remaining_width);  // a comment
      let x = "Hello!!!!!!!!! abcd  abcd abcd abcd abcd abcd\n abcd abcd abcd abcd abcd abcd abcd abcd abcd \
                   abcd  abcd abcd abcd abcd abcd abcd abcd abcd abcd \
                    abcd abcd abcd abcd abcd abcd abcd abcd abcd abcd abcd abcd abcd abcd abcd abcd abcd abcd abcd abcd abcd abcd abcd";
           let s = expand(a
    ,    
    b); }

fn deconstruct() -> (SocketAddr, Method, Headers,
                     RequestUri, HttpVersion,
                     AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA) {
}

fn deconstruct(foo: Bar) -> (SocketAddr, Method, Headers,
                     RequestUri, HttpVersion,
                     AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA) {
}

#[rustfmt::skip]
mod a{
fn foo(x:    T) {
    let x:    T = dfasdf;
}
}
