79d1e5df21
This includes a change to the way lifetime names are generated. Say we figure that `[#0, 'a, 'b]` have to be the same lifetimes, then instead of just generating a new lifetime `'c` like before to replace them, we would reuse `'a`. This is done so that when the lifetime name comes from an impl, we don't give something that's completely off, and we don't have to do much work to figure out where the name came from. For example, for the following code snippet: ```rust struct Baz<'x> { bar: &'x int } impl<'x> Baz<'x> { fn baz1(&self) -> &int { self.bar } } ``` `[#1, 'x]` (where `#1` is BrAnon(1) and refers to lifetime of `&int`) have to be marked the same lifetime. With the old method, we would generate a new lifetime `'a` and suggest `fn baz1(&self) -> &'a int` or `fn baz1<'a>(&self) -> &'a int`, both of which are wrong.
37 lines
1.2 KiB
Rust
37 lines
1.2 KiB
Rust
// Copyright 2014 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.
|
|
|
|
// ignore-tidy-linelength
|
|
|
|
use std::iter::{Range,range};
|
|
|
|
trait Itble<'r, T, I: Iterator<T>> { fn iter(&'r self) -> I; }
|
|
|
|
impl<'r> Itble<'r, uint, Range<uint>> for (uint, uint) {
|
|
fn iter(&'r self) -> Range<uint> {
|
|
let &(min, max) = self;
|
|
range(min, max)
|
|
}
|
|
}
|
|
|
|
fn check<'r, I: Iterator<uint>, T: Itble<'r, uint, I>>(cont: &T) -> bool {
|
|
//~^ NOTE: consider using an explicit lifetime parameter as shown: fn check<'r, I: Iterator<uint>, T: Itble<'r, uint, I>>(cont: &'r T) -> bool
|
|
let cont_iter = cont.iter(); //~ ERROR: cannot infer
|
|
let result = cont_iter.fold(Some(0u16), |state, val| {
|
|
state.map_or(None, |mask| {
|
|
let bit = 1 << val;
|
|
if mask & bit == 0 {Some(mask|bit)} else {None}
|
|
})
|
|
});
|
|
result.is_some()
|
|
}
|
|
|
|
fn main() {}
|