//! arguments:
//!
//! - `Struct`, when `Self` is a struct (including tuple structs, e.g
-//! `struct T(int, char)`).
+//! `struct T(i32, char)`).
//! - `EnumMatching`, when `Self` is an enum and all the arguments are the
//! same variant of the enum (e.g. `Some(1)`, `Some(3)` and `Some(4)`)
//! - `EnumNonMatchingCollapsed` when `Self` is an enum and the arguments
//! following snippet
//!
//! ```rust
-//! struct A { x : int }
+//! struct A { x : i32 }
//!
-//! struct B(int);
+//! struct B(i32);
//!
//! enum C {
-//! C0(int),
-//! C1 { x: int }
+//! C0(i32),
+//! C1 { x: i32 }
//! }
//! ```
//!
-//! The `int`s in `B` and `C0` don't have an identifier, so the
+//! The `i32`s in `B` and `C0` don't have an identifier, so the
//! `Option<ident>`s would be `None` for them.
//!
//! In the static cases, the structure is summarised, either into the just
//! trait PartialEq {
//! fn eq(&self, other: &Self);
//! }
-//! impl PartialEq for int {
-//! fn eq(&self, other: &int) -> bool {
+//! impl PartialEq for i32 {
+//! fn eq(&self, other: &i32) -> bool {
//! *self == *other
//! }
//! }
//!
//! ```{.text}
//! Struct(vec![FieldInfo {
-//! span: <span of `int`>,
+//! span: <span of `i32`>,
//! name: None,
//! self_: <expr for &a>
//! other: vec![<expr for &b>]
//! ```{.text}
//! EnumMatching(0, <ast::Variant for C0>,
//! vec![FieldInfo {
-//! span: <span of int>
+//! span: <span of i32>
//! name: None,
//! self_: <expr for &a>,
//! other: vec![<expr for &b>]
//! StaticStruct(<ast::StructDef of B>, Unnamed(vec![<span of x>]))
//!
//! StaticEnum(<ast::EnumDef of C>,
-//! vec![(<ident of C0>, <span of C0>, Unnamed(vec![<span of int>])),
+//! vec![(<ident of C0>, <span of C0>, Unnamed(vec![<span of i32>])),
//! (<ident of C1>, <span of C1>, Named(vec![(<ident of x>, <span of x>)]))])
//! ```
/// ```
/// #[derive(PartialEq)]
- /// struct A { x: int, y: int }
+ /// struct A { x: i32, y: i32 }
///
/// // equivalent to:
/// impl PartialEq for A {
/// #[derive(PartialEq)]
/// enum A {
/// A1,
- /// A2(int)
+ /// A2(i32)
/// }
///
/// // is equivalent to
#[should_fail]
#[test] fn macros_cant_escape_fns_test () {
let src = "fn bogus() {macro_rules! z (() => (3+4));}\
- fn inty() -> int { z!() }".to_string();
+ fn inty() -> i32 { z!() }".to_string();
let sess = parse::new_parse_sess();
let crate_ast = parse::parse_crate_from_source_str(
"<test>".to_string(),
#[should_fail]
#[test] fn macros_cant_escape_mods_test () {
let src = "mod foo {macro_rules! z (() => (3+4));}\
- fn inty() -> int { z!() }".to_string();
+ fn inty() -> i32 { z!() }".to_string();
let sess = parse::new_parse_sess();
let crate_ast = parse::parse_crate_from_source_str(
"<test>".to_string(),
// macro_use modules should allow macros to escape
#[test] fn macros_can_escape_flattened_mods_test () {
let src = "#[macro_use] mod foo {macro_rules! z (() => (3+4));}\
- fn inty() -> int { z!() }".to_string();
+ fn inty() -> i32 { z!() }".to_string();
let sess = parse::new_parse_sess();
let crate_ast = parse::parse_crate_from_source_str(
"<test>".to_string(),
// should be able to use a bound identifier as a literal in a macro definition:
#[test] fn self_macro_parsing(){
expand_crate_str(
- "macro_rules! foo ((zz) => (287u;));
- fn f(zz : int) {foo!(zz);}".to_string()
+ "macro_rules! foo ((zz) => (287;));
+ fn f(zz: i32) {foo!(zz);}".to_string()
);
}
fn automatic_renaming () {
let tests: Vec<RenamingTest> =
vec!(// b & c should get new names throughout, in the expr too:
- ("fn a() -> int { let b = 13; let c = b; b+c }",
+ ("fn a() -> i32 { let b = 13; let c = b; b+c }",
vec!(vec!(0,1),vec!(2)), false),
// both x's should be renamed (how is this causing a bug?)
- ("fn main () {let x: int = 13;x;}",
+ ("fn main () {let x: i32 = 13;x;}",
vec!(vec!(0)), false),
// the use of b after the + should be renamed, the other one not:
- ("macro_rules! f (($x:ident) => (b + $x)); fn a() -> int { let b = 13; f!(b)}",
+ ("macro_rules! f (($x:ident) => (b + $x)); fn a() -> i32 { let b = 13; f!(b)}",
vec!(vec!(1)), false),
// the b before the plus should not be renamed (requires marks)
- ("macro_rules! f (($x:ident) => ({let b=9; ($x + b)})); fn a() -> int { f!(b)}",
+ ("macro_rules! f (($x:ident) => ({let b=9; ($x + b)})); fn a() -> i32 { f!(b)}",
vec!(vec!(1)), false),
// the marks going in and out of letty should cancel, allowing that $x to
// capture the one following the semicolon.
// this was an awesome test case, and caught a *lot* of bugs.
("macro_rules! letty(($x:ident) => (let $x = 15;));
macro_rules! user(($x:ident) => ({letty!($x); $x}));
- fn main() -> int {user!(z)}",
+ fn main() -> i32 {user!(z)}",
vec!(vec!(0)), false)
);
for (idx,s) in tests.iter().enumerate() {
// can't write this test case until we have macro-generating macros.
// method arg hygiene
- // method expands to fn get_x(&self_0, x_1:int) {self_0 + self_2 + x_3 + x_1}
+ // method expands to fn get_x(&self_0, x_1: i32) {self_0 + self_2 + x_3 + x_1}
#[test] fn method_arg_hygiene(){
run_renaming_test(
&("macro_rules! inject_x (()=>(x));
macro_rules! inject_self (()=>(self));
struct A;
- impl A{fn get_x(&self, x: int) {self + inject_self!() + inject_x!() + x;} }",
+ impl A{fn get_x(&self, x: i32) {self + inject_self!() + inject_x!() + x;} }",
vec!(vec!(0),vec!(3)),
true),
0)
}
// item fn hygiene
- // expands to fn q(x_1:int){fn g(x_2:int){x_2 + x_1};}
+ // expands to fn q(x_1: i32){fn g(x_2: i32){x_2 + x_1};}
#[test] fn issue_9383(){
run_renaming_test(
- &("macro_rules! bad_macro (($ex:expr) => (fn g(x:int){ x + $ex }));
- fn q(x:int) { bad_macro!(x); }",
+ &("macro_rules! bad_macro (($ex:expr) => (fn g(x: i32){ x + $ex }));
+ fn q(x: i32) { bad_macro!(x); }",
vec!(vec!(1),vec!(0)),true),
0)
}
// closure arg hygiene (ExprClosure)
- // expands to fn f(){(|x_1 : int| {(x_2 + x_1)})(3);}
+ // expands to fn f(){(|x_1 : i32| {(x_2 + x_1)})(3);}
#[test] fn closure_arg_hygiene(){
run_renaming_test(
&("macro_rules! inject_x (()=>(x));
- fn f(){(|x : int| {(inject_x!() + x)})(3);}",
+ fn f(){(|x : i32| {(inject_x!() + x)})(3);}",
vec!(vec!(1)),
true),
0)
// macro_rules in method position. Sadly, unimplemented.
#[test] fn macro_in_method_posn(){
expand_crate_str(
- "macro_rules! my_method (() => (fn thirteen(&self) -> int {13}));
+ "macro_rules! my_method (() => (fn thirteen(&self) -> i32 {13}));
struct A;
impl A{ my_method!(); }
fn f(){A.thirteen;}".to_string());
// it's the name of a 0-ary variant, and that 'i' appears twice in succession.
#[test]
fn crate_bindings_test(){
- let the_crate = string_to_crate("fn main (a : int) -> int {|b| {
+ let the_crate = string_to_crate("fn main (a: i32) -> i32 {|b| {
match 34 {None => 3, Some(i) | i => j, Foo{k:z,l:y} => \"banana\"}} }".to_string());
let idents = crate_bindings(&the_crate);
assert_eq!(idents, strs_to_idents(vec!("a","b","None","i","i","z","y")));
// test the IdentRenamer directly
#[test]
fn ident_renamer_test () {
- let the_crate = string_to_crate("fn f(x : int){let x = x; x}".to_string());
+ let the_crate = string_to_crate("fn f(x: i32){let x = x; x}".to_string());
let f_ident = token::str_to_ident("f");
let x_ident = token::str_to_ident("x");
- let int_ident = token::str_to_ident("int");
+ let int_ident = token::str_to_ident("i32");
let renames = vec!((x_ident,Name(16)));
let mut renamer = IdentRenamer{renames: &renames};
let renamed_crate = renamer.fold_crate(the_crate);
// test the PatIdentRenamer; only PatIdents get renamed
#[test]
fn pat_ident_renamer_test () {
- let the_crate = string_to_crate("fn f(x : int){let x = x; x}".to_string());
+ let the_crate = string_to_crate("fn f(x: i32){let x = x; x}".to_string());
let f_ident = token::str_to_ident("f");
let x_ident = token::str_to_ident("x");
- let int_ident = token::str_to_ident("int");
+ let int_ident = token::str_to_ident("i32");
let renames = vec!((x_ident,Name(16)));
let mut renamer = PatIdentRenamer{renames: &renames};
let renamed_crate = renamer.fold_crate(the_crate);
projects / rust.git / commitdiff