msg "configuring LLVM with:"
msg "$CMAKE_ARGS"
- (cd $LLVM_BUILD_DIR && eval "$CFG_CMAKE" $CMAKE_ARGS)
+ (cd $LLVM_BUILD_DIR && eval "\"$CFG_CMAKE\"" $CMAKE_ARGS)
need_ok "LLVM cmake configure failed"
fi
use core::clone::Clone;
use core::cmp::{Eq, Ord, Ordering, PartialEq, PartialOrd};
use core::convert::AsRef;
+use core::default::Default;
use core::hash::{Hash, Hasher};
use core::marker::Sized;
use core::ops::Deref;
}
}
+#[stable(feature = "default", since = "1.11.0")]
+impl<'a, B: ?Sized> Default for Cow<'a, B>
+ where B: ToOwned,
+ <B as ToOwned>::Owned: Default
+{
+ fn default() -> Cow<'a, B> {
+ Owned(<B as ToOwned>::Owned::default())
+ }
+}
+
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, B: ?Sized> Hash for Cow<'a, B> where B: Hash + ToOwned {
#[inline]
ret.push(clean::Item {
inner: clean::ImplItem(clean::Impl {
unsafety: hir::Unsafety::Normal, // FIXME: this should be decoded
- derived: clean::detect_derived(&attrs),
provided_trait_methods: provided,
trait_: trait_,
for_: for_,
pub trait_: Option<Type>,
pub for_: Type,
pub items: Vec<Item>,
- pub derived: bool,
pub polarity: Option<ImplPolarity>,
}
-fn detect_derived<M: AttrMetaMethods>(attrs: &[M]) -> bool {
- attr::contains_name(attrs, "automatically_derived")
-}
-
impl Clean<Vec<Item>> for doctree::Impl {
fn clean(&self, cx: &DocContext) -> Vec<Item> {
let mut ret = Vec::new();
trait_: trait_,
for_: self.for_.clean(cx),
items: items,
- derived: detect_derived(&self.attrs),
polarity: Some(self.polarity.clean(cx)),
}),
});
"methods",
"deref-methods",
"implementations",
- "derived_implementations"
].into_iter().map(|id| (String::from(*id), 1)).collect()
}
}
write!(w, "<h2 id='implementations'>Trait \
Implementations</h2>")?;
- let (derived, manual): (Vec<_>, Vec<&Impl>) = traits.iter().partition(|i| {
- i.inner_impl().derived
- });
- for i in &manual {
+ for i in &traits {
let did = i.trait_did().unwrap();
let assoc_link = AssocItemLink::GotoSource(did, &i.inner_impl().provided_trait_methods);
render_impl(w, cx, i, assoc_link, true, containing_item.stable_since())?;
}
- if !derived.is_empty() {
- write!(w, "<h3 id='derived_implementations'>\
- Derived Implementations \
- </h3>")?;
- for i in &derived {
- let did = i.trait_did().unwrap();
- let assoc_link = AssocItemLink::GotoSource(did,
- &i.inner_impl().provided_trait_methods);
- render_impl(w, cx, i, assoc_link, true, containing_item.stable_since())?;
- }
- }
}
Ok(())
}
if comma {
try!(self.word_space(","))
}
- try!(self.print_lifetime_def(lifetime_def));
+ try!(self.print_lifetime_bounds(&lifetime_def.lifetime, &lifetime_def.bounds));
comma = true;
}
try!(word(&mut self.s, ">"));
self.print_name(lifetime.name)
}
- pub fn print_lifetime_def(&mut self,
- lifetime: &ast::LifetimeDef)
- -> io::Result<()>
+ pub fn print_lifetime_bounds(&mut self,
+ lifetime: &ast::Lifetime,
+ bounds: &[ast::Lifetime])
+ -> io::Result<()>
{
- try!(self.print_lifetime(&lifetime.lifetime));
- let mut sep = ":";
- for v in &lifetime.bounds {
- try!(word(&mut self.s, sep));
- try!(self.print_lifetime(v));
- sep = "+";
+ try!(self.print_lifetime(lifetime));
+ if !bounds.is_empty() {
+ try!(word(&mut self.s, ": "));
+ for (i, bound) in bounds.iter().enumerate() {
+ if i != 0 {
+ try!(word(&mut self.s, " + "));
+ }
+ try!(self.print_lifetime(bound));
+ }
}
Ok(())
}
try!(self.commasep(Inconsistent, &ints[..], |s, &idx| {
if idx < generics.lifetimes.len() {
- let lifetime = &generics.lifetimes[idx];
- s.print_lifetime_def(lifetime)
+ let lifetime_def = &generics.lifetimes[idx];
+ s.print_lifetime_bounds(&lifetime_def.lifetime, &lifetime_def.bounds)
} else {
let idx = idx - generics.lifetimes.len();
let param = &generics.ty_params[idx];
ast::WherePredicate::RegionPredicate(ast::WhereRegionPredicate{ref lifetime,
ref bounds,
..}) => {
- try!(self.print_lifetime(lifetime));
- try!(word(&mut self.s, ":"));
-
- for (i, bound) in bounds.iter().enumerate() {
- try!(self.print_lifetime(bound));
-
- if i != 0 {
- try!(word(&mut self.s, ":"));
- }
- }
+ try!(self.print_lifetime_bounds(lifetime, bounds));
}
ast::WherePredicate::EqPredicate(ast::WhereEqPredicate{ref path, ref ty, ..}) => {
try!(self.print_path(path, false, 0));
--- /dev/null
+// Copyright 2016 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 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <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.
+
+// pp-exact
+
+fn f1<'a, 'b, 'c>(_x: &'a u32, _y: &'b u32, _z: &'c u32) where 'c: 'a + 'b { }
+
+fn main() { }
// pp-exact
-fn f<'a, 'b, T>(t: T) -> isize where T: 'a, 'a:'b, T: Eq { 0 }
+fn f<'a, 'b, T>(t: T) -> isize where T: 'a, 'a: 'b, T: Eq { 0 }
fn main() { }