diff --git a/src/librustc/middle/typeck/astconv.rs b/src/librustc/middle/typeck/astconv.rs index 7db23ee264def..bed1a56880c4b 100644 --- a/src/librustc/middle/typeck/astconv.rs +++ b/src/librustc/middle/typeck/astconv.rs @@ -711,6 +711,7 @@ pub fn ast_ty_to_ty( .collect(); ty::mk_tup(tcx, flds) } + ast::TyParen(ref typ) => ast_ty_to_ty(this, rscope, &**typ), ast::TyBareFn(ref bf) => { if bf.decl.variadic && bf.abi != abi::C { tcx.sess.span_err(ast_ty.span, diff --git a/src/librustc/middle/typeck/infer/error_reporting.rs b/src/librustc/middle/typeck/infer/error_reporting.rs index 7c313d53b2c3e..16833bc3fd123 100644 --- a/src/librustc/middle/typeck/infer/error_reporting.rs +++ b/src/librustc/middle/typeck/infer/error_reporting.rs @@ -1138,6 +1138,7 @@ impl<'a> Rebuilder<'a> { } ast::TyTup(new_tys) } + ast::TyParen(ref typ) => ast::TyParen(build_to(*typ, to)), ref other => other.clone() }; box(GC) ast::Ty { id: from.id, node: new_node, span: from.span } diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index db65939bdfcc7..5fdc87e8eaf22 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -53,7 +53,7 @@ impl, U> Clean> for Vec { } } -impl, U> Clean for Gc { +impl, U> Clean for Gc { fn clean(&self) -> U { (**self).clean() } @@ -1171,6 +1171,7 @@ impl Clean for ast::Ty { TyClosure(ref c, region) => Closure(box c.clean(), region.clean()), TyProc(ref c) => Proc(box c.clean()), TyBareFn(ref barefn) => BareFunction(box barefn.clean()), + TyParen(ref ty) => ty.clean(), TyBot => Bottom, ref x => fail!("Unimplemented type {:?}", x), } diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 7c1e82a2a6f72..7fb42a475f0b3 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -792,6 +792,8 @@ pub enum Ty_ { TyUnboxedFn(Gc), TyTup(Vec> ), TyPath(Path, Option>, NodeId), // for #7264; see above + // No-op; kept solely so that we can pretty-print faithfully + TyParen(P), TyTypeof(Gc), // TyInfer means the type should be inferred instead of it having been // specified. This can appear anywhere in a type. diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index fcddbfa9a89b9..8e0a2218ea369 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -737,6 +737,7 @@ pub fn get_inner_tys(ty: P) -> Vec> { | ast::TyUniq(ty) | ast::TyFixedLengthVec(ty, _) => vec!(ty), ast::TyTup(ref tys) => tys.clone(), + ast::TyParen(ty) => get_inner_tys(ty), _ => Vec::new() } } diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index d8c7ffe4db7ac..d61a79e4e80be 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -192,6 +192,7 @@ pub trait Folder { }) } TyTup(ref tys) => TyTup(tys.iter().map(|&ty| self.fold_ty(ty)).collect()), + TyParen(ref ty) => TyParen(self.fold_ty(*ty)), TyPath(ref path, ref bounds, id) => { let id = self.new_id(id); TyPath(self.fold_path(path), diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 4d9b112cb5c3a..40f6488df9c86 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -51,7 +51,7 @@ use ast::{TokenTree, TraitMethod, TraitRef, TTDelim, TTSeq, TTTok}; use ast::{TTNonterminal, TupleVariantKind, Ty, Ty_, TyBot, TyBox}; use ast::{TypeField, TyFixedLengthVec, TyClosure, TyProc, TyBareFn}; use ast::{TyTypeof, TyInfer, TypeMethod}; -use ast::{TyNil, TyParam, TyParamBound, TyPath, TyPtr, TyRptr}; +use ast::{TyNil, TyParam, TyParamBound, TyParen, TyPath, TyPtr, TyRptr}; use ast::{TyTup, TyU32, TyUnboxedFn, TyUniq, TyVec, UnUniq}; use ast::{UnboxedFnTy, UnboxedFnTyParamBound, UnnamedField, UnsafeBlock}; use ast::{UnsafeFn, ViewItem, ViewItem_, ViewItemExternCrate, ViewItemUse}; @@ -105,7 +105,7 @@ pub enum PathParsingMode { /// the type parameters; e.g. `foo::bar::<'a>::Baz::` LifetimeAndTypesWithColons, /// A path with a lifetime and type parameters with bounds before the last - /// set of type parameters only; e.g. `foo::bar<'a>::Baz:X+Y` This + /// set of type parameters only; e.g. `foo::bar<'a>::Baz+X+Y` This /// form does not use extra double colons. LifetimeAndTypesAndBounds, } @@ -1015,7 +1015,14 @@ impl<'a> Parser<'a> { }; let (inputs, variadic) = self.parse_fn_args(false, false); - let (_, bounds) = self.parse_optional_ty_param_bounds(false); + let bounds = { + if self.eat(&token::COLON) { + let (_, bounds) = self.parse_ty_param_bounds(false); + Some(bounds) + } else { + None + } + }; let (ret_style, ret_ty) = self.parse_ret_ty(); let decl = P(FnDecl { inputs: inputs, @@ -1083,7 +1090,14 @@ impl<'a> Parser<'a> { (is_unboxed, inputs) }; - let (region, bounds) = self.parse_optional_ty_param_bounds(true); + let (region, bounds) = { + if self.eat(&token::COLON) { + let (region, bounds) = self.parse_ty_param_bounds(true); + (region, Some(bounds)) + } else { + (None, None) + } + }; let (return_style, output) = self.parse_ret_ty(); let decl = P(FnDecl { @@ -1220,7 +1234,7 @@ impl<'a> Parser<'a> { // parse a possibly mutable type pub fn parse_mt(&mut self) -> MutTy { let mutbl = self.parse_mutability(); - let t = self.parse_ty(false); + let t = self.parse_ty(true); MutTy { ty: t, mutbl: mutbl } } @@ -1231,7 +1245,7 @@ impl<'a> Parser<'a> { let mutbl = self.parse_mutability(); let id = self.parse_ident(); self.expect(&token::COLON); - let ty = self.parse_ty(false); + let ty = self.parse_ty(true); let hi = ty.span.hi; ast::TypeField { ident: id, @@ -1254,7 +1268,7 @@ impl<'a> Parser<'a> { }) ) } else { - (Return, self.parse_ty(false)) + (Return, self.parse_ty(true)) } } else { let pos = self.span.lo; @@ -1269,10 +1283,11 @@ impl<'a> Parser<'a> { } } - // parse a type. - // Useless second parameter for compatibility with quasiquote macros. - // Bleh! - pub fn parse_ty(&mut self, _: bool) -> P { + /// Parse a type. + /// + /// The second parameter specifies whether the `+` binary operator is + /// allowed in the type grammar. + pub fn parse_ty(&mut self, plus_allowed: bool) -> P { maybe_whole!(no_clone self, NtTy); let lo = self.span.lo; @@ -1286,12 +1301,12 @@ impl<'a> Parser<'a> { // (t) is a parenthesized ty // (t,) is the type of a tuple with only one field, // of type t - let mut ts = vec!(self.parse_ty(false)); + let mut ts = vec!(self.parse_ty(true)); let mut one_tuple = false; while self.token == token::COMMA { self.bump(); if self.token != token::RPAREN { - ts.push(self.parse_ty(false)); + ts.push(self.parse_ty(true)); } else { one_tuple = true; @@ -1300,17 +1315,17 @@ impl<'a> Parser<'a> { if ts.len() == 1 && !one_tuple { self.expect(&token::RPAREN); - return *ts.get(0) + TyParen(*ts.get(0)) + } else { + let t = TyTup(ts); + self.expect(&token::RPAREN); + t } - - let t = TyTup(ts); - self.expect(&token::RPAREN); - t } } else if self.token == token::AT { // MANAGED POINTER self.bump(); - TyBox(self.parse_ty(false)) + TyBox(self.parse_ty(plus_allowed)) } else if self.token == token::TILDE { // OWNED POINTER self.bump(); @@ -1319,7 +1334,7 @@ impl<'a> Parser<'a> { self.obsolete(self.last_span, ObsoleteOwnedVector), _ => self.obsolete(self.last_span, ObsoleteOwnedType), }; - TyUniq(self.parse_ty(false)) + TyUniq(self.parse_ty(true)) } else if self.token == token::BINOP(token::STAR) { // STAR POINTER (bare pointer?) self.bump(); @@ -1327,7 +1342,7 @@ impl<'a> Parser<'a> { } else if self.token == token::LBRACKET { // VECTOR self.expect(&token::LBRACKET); - let t = self.parse_ty(false); + let t = self.parse_ty(true); // Parse the `, ..e` in `[ int, ..e ]` // where `e` is a const expression @@ -1370,10 +1385,15 @@ impl<'a> Parser<'a> { } else if self.token == token::MOD_SEP || is_ident_or_path(&self.token) { // NAMED TYPE + let mode = if plus_allowed { + LifetimeAndTypesAndBounds + } else { + LifetimeAndTypesWithoutColons + }; let PathAndBounds { path, bounds - } = self.parse_path(LifetimeAndTypesAndBounds); + } = self.parse_path(mode); TyPath(path, bounds, ast::DUMMY_NODE_ID) } else if self.eat(&token::UNDERSCORE) { // TYPE TO BE INFERRED @@ -1431,7 +1451,7 @@ impl<'a> Parser<'a> { special_idents::invalid) }; - let t = self.parse_ty(false); + let t = self.parse_ty(true); Arg { ty: t, @@ -1449,7 +1469,7 @@ impl<'a> Parser<'a> { pub fn parse_fn_block_arg(&mut self) -> Arg { let pat = self.parse_pat(); let t = if self.eat(&token::COLON) { - self.parse_ty(false) + self.parse_ty(true) } else { P(Ty { id: ast::DUMMY_NODE_ID, @@ -1604,9 +1624,19 @@ impl<'a> Parser<'a> { } } - // Next, parse a colon and bounded type parameters, if applicable. + // Next, parse a plus and bounded type parameters, if applicable. + // + // NOTE(stage0, pcwalton): Remove `token::COLON` after a snapshot. let bounds = if mode == LifetimeAndTypesAndBounds { - let (_, bounds) = self.parse_optional_ty_param_bounds(false); + let bounds = { + if self.eat(&token::BINOP(token::PLUS)) || + self.eat(&token::COLON) { + let (_, bounds) = self.parse_ty_param_bounds(false); + Some(bounds) + } else { + None + } + }; bounds } else { None @@ -2431,7 +2461,7 @@ impl<'a> Parser<'a> { } None => { if as_prec > min_prec && self.eat_keyword(keywords::As) { - let rhs = self.parse_ty(true); + let rhs = self.parse_ty(false); let _as = self.mk_expr(lhs.span.lo, rhs.span.hi, ExprCast(lhs, rhs)); @@ -3060,7 +3090,9 @@ impl<'a> Parser<'a> { node: TyInfer, span: mk_sp(lo, lo), }); - if self.eat(&token::COLON) { ty = self.parse_ty(false); } + if self.eat(&token::COLON) { + ty = self.parse_ty(true); + } let init = self.parse_initializer(); box(GC) ast::Local { ty: ty, @@ -3088,7 +3120,7 @@ impl<'a> Parser<'a> { } let name = self.parse_ident(); self.expect(&token::COLON); - let ty = self.parse_ty(false); + let ty = self.parse_ty(true); spanned(lo, self.last_span.hi, ast::StructField_ { kind: NamedField(name, pr), id: ast::DUMMY_NODE_ID, @@ -3405,7 +3437,7 @@ impl<'a> Parser<'a> { } } - // matches optbounds = ( ( : ( boundseq )? )? ) + // matches bounds = ( boundseq )? // where boundseq = ( bound + boundseq ) | bound // and bound = 'static | ty // Returns "None" if there's no colon (e.g. "T"); @@ -3417,13 +3449,9 @@ impl<'a> Parser<'a> { // AST doesn't support arbitrary lifetimes in bounds on type parameters. In // the future, this flag should be removed, and the return value of this // function should be Option<~[TyParamBound]> - fn parse_optional_ty_param_bounds(&mut self, allow_any_lifetime: bool) - -> (Option, Option>) - { - if !self.eat(&token::COLON) { - return (None, None); - } - + fn parse_ty_param_bounds(&mut self, allow_any_lifetime: bool) + -> (Option, + OwnedSlice) { let mut ret_lifetime = None; let mut result = vec!(); loop { @@ -3467,7 +3495,7 @@ impl<'a> Parser<'a> { } } - return (ret_lifetime, Some(OwnedSlice::from_vec(result))); + return (ret_lifetime, OwnedSlice::from_vec(result)); } // matches typaram = type? IDENT optbounds ( EQ ty )? @@ -3475,13 +3503,20 @@ impl<'a> Parser<'a> { let sized = self.parse_sized(); let span = self.span; let ident = self.parse_ident(); - let (_, opt_bounds) = self.parse_optional_ty_param_bounds(false); + let opt_bounds = { + if self.eat(&token::COLON) { + let (_, bounds) = self.parse_ty_param_bounds(false); + Some(bounds) + } else { + None + } + }; // For typarams we don't care about the difference b/w "" and "". let bounds = opt_bounds.unwrap_or_default(); let default = if self.token == token::EQ { self.bump(); - Some(self.parse_ty(false)) + Some(self.parse_ty(true)) } else { None }; @@ -3526,7 +3561,7 @@ impl<'a> Parser<'a> { Some(token::COMMA), |p| { p.forbid_lifetime(); - p.parse_ty(false) + p.parse_ty(true) } ); (lifetimes, result.into_vec()) @@ -3782,7 +3817,7 @@ impl<'a> Parser<'a> { } }; let output = if self.eat(&token::RARROW) { - self.parse_ty(false) + self.parse_ty(true) } else { P(Ty { id: ast::DUMMY_NODE_ID, @@ -3808,7 +3843,7 @@ impl<'a> Parser<'a> { |p| p.parse_fn_block_arg()); let output = if self.eat(&token::RARROW) { - self.parse_ty(false) + self.parse_ty(true) } else { P(Ty { id: ast::DUMMY_NODE_ID, @@ -3920,7 +3955,7 @@ impl<'a> Parser<'a> { let could_be_trait = self.token != token::LPAREN; // Parse the trait. - let mut ty = self.parse_ty(false); + let mut ty = self.parse_ty(true); // Parse traits, if necessary. let opt_trait = if could_be_trait && self.eat_keyword(keywords::For) { @@ -3943,7 +3978,7 @@ impl<'a> Parser<'a> { } }; - ty = self.parse_ty(false); + ty = self.parse_ty(true); opt_trait_ref } else { None @@ -3986,7 +4021,7 @@ impl<'a> Parser<'a> { let generics = self.parse_generics(); let super_struct = if self.eat(&token::COLON) { - let ty = self.parse_ty(false); + let ty = self.parse_ty(true); match ty.node { TyPath(_, None, _) => { Some(ty) @@ -4029,7 +4064,7 @@ impl<'a> Parser<'a> { let struct_field_ = ast::StructField_ { kind: UnnamedField(p.parse_visibility()), id: ast::DUMMY_NODE_ID, - ty: p.parse_ty(false), + ty: p.parse_ty(true), attrs: attrs, }; spanned(lo, p.span.hi, struct_field_) @@ -4175,7 +4210,7 @@ impl<'a> Parser<'a> { let m = if self.eat_keyword(keywords::Mut) {MutMutable} else {MutImmutable}; let id = self.parse_ident(); self.expect(&token::COLON); - let ty = self.parse_ty(false); + let ty = self.parse_ty(true); self.expect(&token::EQ); let e = self.parse_expr(); self.commit_expr_expecting(e, token::SEMI); @@ -4356,7 +4391,7 @@ impl<'a> Parser<'a> { let ident = self.parse_ident(); self.expect(&token::COLON); - let ty = self.parse_ty(false); + let ty = self.parse_ty(true); let hi = self.span.hi; self.expect(&token::SEMI); box(GC) ast::ForeignItem { @@ -4484,7 +4519,7 @@ impl<'a> Parser<'a> { let ident = self.parse_ident(); let tps = self.parse_generics(); self.expect(&token::EQ); - let ty = self.parse_ty(false); + let ty = self.parse_ty(true); self.expect(&token::SEMI); (ident, ItemTy(ty, tps), None) } @@ -4532,7 +4567,7 @@ impl<'a> Parser<'a> { &token::LPAREN, &token::RPAREN, seq_sep_trailing_disallowed(token::COMMA), - |p| p.parse_ty(false) + |p| p.parse_ty(true) ); for ty in arg_tys.move_iter() { args.push(ast::VariantArg { diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 33b7086d7ae63..f01097fd04c43 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -495,6 +495,11 @@ impl<'a> State<'a> { } try!(self.pclose()); } + ast::TyParen(ref typ) => { + try!(self.popen()); + try!(self.print_type(&**typ)); + try!(self.pclose()); + } ast::TyBareFn(f) => { let generics = ast::Generics { lifetimes: f.lifetimes.clone(), @@ -1677,7 +1682,7 @@ impl<'a> State<'a> { match *opt_bounds { None => Ok(()), - Some(ref bounds) => self.print_bounds(&None, bounds, true), + Some(ref bounds) => self.print_bounds(&None, bounds, true, true), } } @@ -1936,9 +1941,16 @@ impl<'a> State<'a> { pub fn print_bounds(&mut self, region: &Option, bounds: &OwnedSlice, - print_colon_anyway: bool) -> IoResult<()> { + print_colon_anyway: bool, + print_plus_before_bounds: bool) + -> IoResult<()> { + let separator = if print_plus_before_bounds { + "+" + } else { + ":" + }; if !bounds.is_empty() || region.is_some() { - try!(word(&mut self.s, ":")); + try!(word(&mut self.s, separator)); let mut first = true; match *region { Some(ref lt) => { @@ -1980,7 +1992,7 @@ impl<'a> State<'a> { } Ok(()) } else if print_colon_anyway { - word(&mut self.s, ":") + word(&mut self.s, separator) } else { Ok(()) } @@ -2016,7 +2028,10 @@ impl<'a> State<'a> { try!(s.word_space("type")); } try!(s.print_ident(param.ident)); - try!(s.print_bounds(&None, ¶m.bounds, false)); + try!(s.print_bounds(&None, + ¶m.bounds, + false, + false)); match param.default { Some(ref default) => { try!(space(&mut s.s)); @@ -2219,7 +2234,7 @@ impl<'a> State<'a> { } opt_bounds.as_ref().map(|bounds| { - self.print_bounds(opt_region, bounds, true) + self.print_bounds(opt_region, bounds, true, false) }); try!(self.maybe_print_comment(decl.output.span.lo)); diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs index 59771a57dfa50..6f0fc217533fc 100644 --- a/src/libsyntax/visit.rs +++ b/src/libsyntax/visit.rs @@ -336,7 +336,7 @@ pub fn skip_ty>(_: &mut V, _: &Ty, _: E) { pub fn walk_ty>(visitor: &mut V, typ: &Ty, env: E) { match typ.node { - TyUniq(ty) | TyVec(ty) | TyBox(ty) => { + TyUniq(ty) | TyVec(ty) | TyBox(ty) | TyParen(ty) => { visitor.visit_ty(&*ty, env) } TyPtr(ref mutable_type) => { diff --git a/src/test/auxiliary/plugin_crate_outlive_expansion_phase.rs b/src/test/auxiliary/plugin_crate_outlive_expansion_phase.rs index 213fdd6b74a29..1592ffb6c6790 100644 --- a/src/test/auxiliary/plugin_crate_outlive_expansion_phase.rs +++ b/src/test/auxiliary/plugin_crate_outlive_expansion_phase.rs @@ -27,7 +27,7 @@ impl Drop for Foo { #[plugin_registrar] pub fn registrar(_: &mut Registry) { - local_data_key!(foo: Box); - foo.replace(Some(box Foo { foo: 10 } as Box)); + local_data_key!(foo: Box); + foo.replace(Some(box Foo { foo: 10 } as Box)); } diff --git a/src/test/compile-fail/issue-7013.rs b/src/test/compile-fail/issue-7013.rs index 1bc4e07655323..3028db00f5871 100644 --- a/src/test/compile-fail/issue-7013.rs +++ b/src/test/compile-fail/issue-7013.rs @@ -31,7 +31,7 @@ struct A { } fn main() { - let a = A {v: box B{v: None} as Box}; + let a = A {v: box B{v: None} as Box}; //~^ ERROR cannot pack type `~B`, which does not fulfill `Send` let v = Rc::new(RefCell::new(a)); let w = v.clone(); diff --git a/src/test/compile-fail/kindck-copy.rs b/src/test/compile-fail/kindck-copy.rs index 5404b32eb2421..651ea6abf08cc 100644 --- a/src/test/compile-fail/kindck-copy.rs +++ b/src/test/compile-fail/kindck-copy.rs @@ -45,15 +45,15 @@ fn test<'a,T,U:Copy>(_: &'a int) { // borrowed object types are generally ok assert_copy::<&'a Dummy>(); - assert_copy::<&'a Dummy:Copy>(); - assert_copy::<&'static Dummy:Copy>(); + assert_copy::<&'a Dummy+Copy>(); + assert_copy::<&'static Dummy+Copy>(); // owned object types are not ok assert_copy::>(); //~ ERROR does not fulfill - assert_copy::>(); //~ ERROR does not fulfill + assert_copy::>(); //~ ERROR does not fulfill // mutable object types are not ok - assert_copy::<&'a mut Dummy:Copy>(); //~ ERROR does not fulfill + assert_copy::<&'a mut Dummy+Copy>(); //~ ERROR does not fulfill // closures are like an `&mut` object assert_copy::<||>(); //~ ERROR does not fulfill diff --git a/src/test/compile-fail/kindck-send.rs b/src/test/compile-fail/kindck-send.rs index aa9d2dda22a96..0414e64f1b7bf 100644 --- a/src/test/compile-fail/kindck-send.rs +++ b/src/test/compile-fail/kindck-send.rs @@ -39,17 +39,17 @@ fn test<'a,T,U:Send>(_: &'a int) { // careful with object types, who knows what they close over... assert_send::<&'static Dummy>(); //~ ERROR does not fulfill `Send` assert_send::<&'a Dummy>(); //~ ERROR does not fulfill `Send` - assert_send::<&'a Dummy:Send>(); //~ ERROR does not fulfill `Send` - assert_send::>(); //~ ERROR does not fulfill `Send` + assert_send::<&'a Dummy+Send>(); //~ ERROR does not fulfill `Send` + assert_send::>(); //~ ERROR does not fulfill `Send` // ...unless they are properly bounded - assert_send::<&'static Dummy:Send>(); - assert_send::>(); + assert_send::<&'static Dummy+Send>(); + assert_send::>(); // but closure and object types can have lifetime bounds which make // them not ok (FIXME #5121) // assert_send::(); // ERROR does not fulfill `Send` - // assert_send::>(); // ERROR does not fulfill `Send` + // assert_send::>(); // ERROR does not fulfill `Send` // unsafe ptrs are ok unless they point at unsendable things assert_send::<*int>(); diff --git a/src/test/compile-fail/trait-bounds-cant-coerce.rs b/src/test/compile-fail/trait-bounds-cant-coerce.rs index 12205ef062da0..3737025da6c12 100644 --- a/src/test/compile-fail/trait-bounds-cant-coerce.rs +++ b/src/test/compile-fail/trait-bounds-cant-coerce.rs @@ -12,14 +12,14 @@ trait Foo { } -fn a(_x: Box) { +fn a(_x: Box) { } -fn c(x: Box) { +fn c(x: Box) { a(x); } -fn d(x: Box) { +fn d(x: Box) { a(x); //~ ERROR found no bounds } diff --git a/src/test/compile-fail/trait-bounds-sugar.rs b/src/test/compile-fail/trait-bounds-sugar.rs index 9447030a7f461..d548098ebe13e 100644 --- a/src/test/compile-fail/trait-bounds-sugar.rs +++ b/src/test/compile-fail/trait-bounds-sugar.rs @@ -13,17 +13,17 @@ trait Foo {} -fn a(_x: Box) { +fn a(_x: Box) { } -fn b(_x: &'static Foo) { // should be same as &'static Foo:'static +fn b(_x: &'static Foo) { // should be same as &'static Foo+'static } -fn c(x: Box) { +fn c(x: Box) { a(x); //~ ERROR expected bounds `Send` } -fn d(x: &'static Foo:Share) { +fn d(x: &'static Foo+Share) { b(x); //~ ERROR expected bounds `'static` } diff --git a/src/test/pretty/path-type-bounds.rs b/src/test/pretty/path-type-bounds.rs index 0fdbad67f160d..f90937c34a6d6 100644 --- a/src/test/pretty/path-type-bounds.rs +++ b/src/test/pretty/path-type-bounds.rs @@ -14,11 +14,11 @@ trait Tr { } impl Tr for int { } -fn foo(x: Box) -> Box { x } +fn foo(x: Box) -> Box { x } fn main() { - let x: Box; + let x: Box; - box() 1 as Box; + box() 1 as Box; } diff --git a/src/test/run-fail/fail-macro-any.rs b/src/test/run-fail/fail-macro-any.rs index 09b507433080e..c56eabbb3b4aa 100644 --- a/src/test/run-fail/fail-macro-any.rs +++ b/src/test/run-fail/fail-macro-any.rs @@ -12,5 +12,5 @@ fn main() { - fail!(box 413 as Box<::std::any::Any:Send>); + fail!(box 413 as Box<::std::any::Any+Send>); } diff --git a/src/test/run-pass/alignment-gep-tup-like-1.rs b/src/test/run-pass/alignment-gep-tup-like-1.rs index 38a3d3c5fffdc..4fa695de5228d 100644 --- a/src/test/run-pass/alignment-gep-tup-like-1.rs +++ b/src/test/run-pass/alignment-gep-tup-like-1.rs @@ -33,7 +33,7 @@ fn f(a: A, b: u16) -> Box:> { box Invoker { a: a, b: b, - } as Box>: + } as (Box>+) } pub fn main() { diff --git a/src/test/run-pass/as-precedence.rs b/src/test/run-pass/as-precedence.rs new file mode 100644 index 0000000000000..0760f13200c8f --- /dev/null +++ b/src/test/run-pass/as-precedence.rs @@ -0,0 +1,18 @@ +// Copyright 2012 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +fn main() { + assert_eq!(3 as uint * 3, 9); + assert_eq!(3 as (uint) * 3, 9); + assert_eq!(3 as (uint) / 3, 1); + assert_eq!(3 as uint + 3, 6); + assert_eq!(3 as (uint) + 3, 6); +} + diff --git a/src/test/run-pass/capturing-logging.rs b/src/test/run-pass/capturing-logging.rs index 3402db7c355a9..23607e16795ed 100644 --- a/src/test/run-pass/capturing-logging.rs +++ b/src/test/run-pass/capturing-logging.rs @@ -41,7 +41,7 @@ fn main() { let (tx, rx) = channel(); let (mut r, w) = (ChanReader::new(rx), ChanWriter::new(tx)); spawn(proc() { - set_logger(box MyWriter(w) as Box); + set_logger(box MyWriter(w) as Box); debug!("debug"); info!("info"); }); diff --git a/src/test/run-pass/close-over-big-then-small-data.rs b/src/test/run-pass/close-over-big-then-small-data.rs index acae61359370b..3d642be082c0a 100644 --- a/src/test/run-pass/close-over-big-then-small-data.rs +++ b/src/test/run-pass/close-over-big-then-small-data.rs @@ -33,11 +33,11 @@ impl Invokable for Invoker { } } -fn f(a: A, b: u16) -> Box:> { +fn f(a: A, b: u16) -> Box+> { box Invoker { a: a, b: b, - } as Box>: + } as (Box>+) } pub fn main() { diff --git a/src/test/run-pass/trait-bounds-basic.rs b/src/test/run-pass/trait-bounds-basic.rs index 68ebf2c6382ca..d1bb0db511b8f 100644 --- a/src/test/run-pass/trait-bounds-basic.rs +++ b/src/test/run-pass/trait-bounds-basic.rs @@ -12,21 +12,21 @@ trait Foo { } -fn a(_x: Box) { +fn a(_x: Box) { } -fn b(_x: Box) { +fn b(_x: Box) { } -fn c(x: Box) { +fn c(x: Box) { a(x); } -fn d(x: Box) { +fn d(x: Box) { b(x); } -fn e(x: Box) { // sugar for Box +fn e(x: Box) { // sugar for Box a(x); } diff --git a/src/test/run-pass/trait-bounds-in-arc.rs b/src/test/run-pass/trait-bounds-in-arc.rs index 4ca67811982d1..18a0e5d471c4a 100644 --- a/src/test/run-pass/trait-bounds-in-arc.rs +++ b/src/test/run-pass/trait-bounds-in-arc.rs @@ -71,10 +71,10 @@ pub fn main() { swim_speed: 998, name: "alec_guinness".to_string(), }; - let arc = Arc::new(vec!(box catte as Box, - box dogge1 as Box, - box fishe as Box, - box dogge2 as Box)); + let arc = Arc::new(vec!(box catte as Box, + box dogge1 as Box, + box fishe as Box, + box dogge2 as Box)); let (tx1, rx1) = channel(); let arc1 = arc.clone(); task::spawn(proc() { check_legs(arc1); tx1.send(()); }); @@ -89,21 +89,21 @@ pub fn main() { rx3.recv(); } -fn check_legs(arc: Arc>>) { +fn check_legs(arc: Arc>>) { let mut legs = 0; for pet in arc.iter() { legs += pet.num_legs(); } assert!(legs == 12); } -fn check_names(arc: Arc>>) { +fn check_names(arc: Arc>>) { for pet in arc.iter() { pet.name(|name| { assert!(name[0] == 'a' as u8 && name[1] == 'l' as u8); }) } } -fn check_pedigree(arc: Arc>>) { +fn check_pedigree(arc: Arc>>) { for pet in arc.iter() { assert!(pet.of_good_pedigree()); } diff --git a/src/test/run-pass/trait-cast.rs b/src/test/run-pass/trait-cast.rs index a9067ef87ba31..0f99998b7a6ed 100644 --- a/src/test/run-pass/trait-cast.rs +++ b/src/test/run-pass/trait-cast.rs @@ -20,7 +20,7 @@ struct Tree(@RefCell); struct TreeR { left: Option, right: Option, - val: Box + val: Box } trait to_str { @@ -57,10 +57,10 @@ fn foo(x: T) -> String { x.to_str_() } pub fn main() { let t1 = Tree(@RefCell::new(TreeR{left: None, right: None, - val: box 1 as Box})); + val: box 1 as Box})); let t2 = Tree(@RefCell::new(TreeR{left: Some(t1), right: Some(t1), - val: box 2 as Box})); + val: box 2 as Box})); let expected = "[2, some([1, none, none]), some([1, none, none])]".to_string(); assert!(t2.to_str_() == expected); diff --git a/src/test/run-pass/trait-contravariant-self.rs b/src/test/run-pass/trait-contravariant-self.rs index 1576c646286a4..d8df5d5600c90 100644 --- a/src/test/run-pass/trait-contravariant-self.rs +++ b/src/test/run-pass/trait-contravariant-self.rs @@ -10,8 +10,8 @@ // This is an interesting test case. We have a trait (Bar) that is // implemented for a `Box` object (note: no bounds). And then we -// have a `Box` object. The impl for `Box` is applicable -// to `Box` because: +// have a `Box` object. The impl for `Box` is applicable +// to `Box` because: // // 1. The trait Bar is contravariant w/r/t Self because `Self` appears // only in argument position. @@ -30,7 +30,7 @@ impl Bar for Box { fn dummy(&self) { } } fn wants_bar(b: &B) { } fn main() { - let x: Box = (box SFoo); + let x: Box = (box SFoo); wants_bar(&x); }