test.rs

    // Comment NOTE
    /* Comment FIXME ALERT
    	*/

    // Identifiers
    hellóñαωΑΩµo!();
    HellóñαωΑΩµ::Hello;
    'hellóñαωΑΩµo

    pub use self::PathParameters::*;
    pub use symbol::{Ident, Symbol as Name};
    use serialize::{self, Encoder, Decoder};
    use std::u32;
    use std::str::{Bytes, CharIndices};
    use std::str::Lines;
    use std::str;

    #[derive(Clone, PartialEq, Eq, Hash, Copy)]

    pub struct Lifetime {
    	pub id: NodeId,
    	pub span: Span,
    	pub bounds: Vec<PathSegment>
    }

    impl fmt::Debug for Lifetime {
    	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    		write!(f, "lifetime({}: {})", self.id, pprust::lifetime_to_string(self))
    	}
    }
    impl<'a> PartialEq<&'a str> for Path {
    	fn eq(&self, string: &&'a str) -> bool {
    		self.segments.len() == 1 && self.segments[0].identifier.name == *string
    	}
    }

    enum TraitBoundModifier {
    	None,
    	Maybe,
    }

    union tests {
    	a: i128,
    	b: isize,
    }

    // Self vs self
    trait T {
        type Item;
        // `Self` will be whatever type that implements `T`.
        fn new() -> Self;
        // `Self::Item` will be the type alias in the implementation.
        fn f(&self) -> Self::Item;
    }

    // Raw identifiers
    extern crate foo;
    fn main() {
        foo::r#try();
    }

    // str
    fn str_user() {
    	let the_line: &str = "this is &str";
    	let char_iter = str::chars(&the_line);
    }

    #[valid types]
    fn types() {
    	let num = 333_3_;
    	let num_u8: u8 = 333u8;
    	let num_u16: u16 = 333u16;
    	let num_u32: u32 = 333u32;
    	let num_u64: u64 = 333u64;
    	let num_u128: u128 = 333u128;
    	let num_usize: usize = 333usize;
    	let num_float: f32 = 333.45f32;

    	let binary = 0b1_010;
    	let octal = 0o21535;
    	let hexadecimal = 0x73A2_F;

    	let char1: char = 'a';
    	let char2: char = '\n';
    	let char3: char = '\u{123_AF}';

    	let byte1: u8 = b'a';
    	let byte2: u8 = b'\x13';

    	let string: str = "hello \n \r \u{123_________fd_} \
    						bye";
    	let byte_string: str = b"hello \t \0 \u{123} \b bye";
    	let raw_string1: str = r"hello \t \b";
    	let raw_string2: str = r####"hello \n "### bye"########;
    	let raw_string3: str = br####"hello \n"####;

        // Invalid

    	let invalid_binary= 0b1_015;
    	let invalid_octal = 0o64_92;
    	let invalid_hexadecimal = 0x7_3AY;

        let invalid_char1: char = '\y';
    	let invalid_char2: char = '\324';
    	let invalid_char3: char = '%%';
    	let invalid_char4: char = '\n\dfd';
    	let invalid_char5: char = 'aaaaa';
    	let open_char: char = '&&&;

    	let invalid_byte1: u8 = b'ab';
    	let invalid_byte2: u8 = b'\b';
    	let invalid_byte2: u8 = b'\u{123}';

    	let invalid_string: str = "hello \b \u{_123} \u{1234567} \  bye";
    }

    //ControlFlow-specific keywords
    fn controlflow(y: Vec<usize>) -> usize {
        let mut x = 0;
        while x < 10 {
            if x > 5 {
                x = 1;
            }
            else {
                return 5
            }
        }
        loop {
            x+= 1;
            break;
        }
        for z in y {
            match z {
                1 => continue,
                _ => x = 2,
            }
        }
        x
    }