nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-02-20 02:43:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix rebase conflicts

Browse Source
This commit is contained in:
Niko Matsakis 2014-12-30 12:09:21 -05:00
parent 919975d0a5
commit e186accbc4
5 changed files with 48 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/librustc_typeck/check/closure.rs
View File

@ -48,7 +48,7 @@ pub fn check_expr_closure<'a,'tcx>(fcx: &FnCtxt<'a,'tcx>,
match expected_sig_and_kind {
None => { // doesn't look like an unboxed closure
let region = astconv::opt_ast_region_to_region(fcx,
fcx.infcx(),
fcx,
expr.span,
&None);
@ -117,7 +117,7 @@ fn check_unboxed_closure<'a,'tcx>(fcx: &FnCtxt<'a,'tcx>,
abi::RustCall,
expected_sig);
let region = match fcx.infcx().anon_regions(expr.span, 1) {
let region = match fcx.anon_regions(expr.span, 1) {
Err(_) => {
fcx.ccx.tcx.sess.span_bug(expr.span,
"can't make anon regions here?!")

122
src/librustc_typeck/check/mod.rs
View File

@ -1933,7 +1933,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
}
pub fn to_ty(&self, ast_t: &ast::Ty) -> Ty<'tcx> {
let t = ast_ty_to_ty(self, self.infcx(), ast_t);
let t = ast_ty_to_ty(self, self, ast_t);
let mut bounds_checker = wf::BoundsChecker::new(self,
ast_t.span,
@ -2123,18 +2123,18 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
}
}
//impl<'a, 'tcx> RegionScope for infer::InferCtxt<'a, 'tcx> {
// fn default_region_bound(&self, span: Span) -> Option<ty::Region> {
// Some(self.next_region_var(infer::MiscVariable(span)))
// }
//
// fn anon_regions(&self, span: Span, count: uint)
// -> Result<Vec<ty::Region>, Option<Vec<(String, uint)>>> {
// Ok(Vec::from_fn(count, |_| {
// self.next_region_var(infer::MiscVariable(span))
// }))
// }
//}
impl<'a, 'tcx> RegionScope for FnCtxt<'a, 'tcx> {
fn default_region_bound(&self, span: Span) -> Option<ty::Region> {
Some(self.infcx().next_region_var(infer::MiscVariable(span)))
}
fn anon_regions(&self, span: Span, count: uint)
-> Result<Vec<ty::Region>, Option<Vec<(String, uint)>>> {
Ok(Vec::from_fn(count, |_| {
self.infcx().next_region_var(infer::MiscVariable(span))
}))
}
}
#[deriving(Copy, Show, PartialEq, Eq)]
pub enum LvaluePreference {
@ -2347,58 +2347,6 @@ fn autoderef_for_index<'a, 'tcx, T, F>(fcx: &FnCtxt<'a, 'tcx>,
}
}
/// Autoderefs `base_expr`, looking for a `Slice` impl. If it finds one, installs the relevant
/// method info and returns the result type (else None).
fn try_overloaded_slice<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
method_call: MethodCall,
expr: &ast::Expr,
base_expr: &ast::Expr,
base_ty: Ty<'tcx>,
start_expr: &Option<P<ast::Expr>>,
end_expr: &Option<P<ast::Expr>>,
mutbl: ast::Mutability)
-> Option<Ty<'tcx>> // return type is result of slice
{
let lvalue_pref = match mutbl {
ast::MutMutable => PreferMutLvalue,
ast::MutImmutable => NoPreference
};
let opt_method_ty =
autoderef_for_index(fcx, base_expr, base_ty, lvalue_pref, |adjusted_ty, autoderefref| {
try_overloaded_slice_step(fcx, method_call, expr, base_expr,
adjusted_ty, autoderefref, mutbl,
start_expr, end_expr)
});
// Regardless of whether the lookup succeeds, check the method arguments
// so that we have *some* type for each argument.
let method_ty_or_err = opt_method_ty.unwrap_or(fcx.tcx().types.err);
let mut args = vec![];
start_expr.as_ref().map(|x| args.push(x));
end_expr.as_ref().map(|x| args.push(x));
check_method_argument_types(fcx,
expr.span,
method_ty_or_err,
expr,
args.as_slice(),
AutorefArgs::Yes,
DontTupleArguments);
opt_method_ty.map(|method_ty| {
let result_ty = ty::ty_fn_ret(method_ty);
match result_ty {
ty::FnConverging(result_ty) => result_ty,
ty::FnDiverging => {
fcx.tcx().sess.span_bug(expr.span,
"slice trait does not define a `!` return")
}
}
})
}
/// Checks for a `Slice` (or `SliceMut`) impl at the relevant level of autoderef. If it finds one,
/// installs method info and returns type of method (else None).
fn try_overloaded_slice_step<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
@ -4327,7 +4275,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
let actual_structure_type = fcx.expr_ty(&*expr);
if !ty::type_is_error(actual_structure_type) {
let type_and_substs = astconv::ast_path_to_ty_relaxed(fcx,
fcx.infcx(),
fcx,
struct_id,
path);
match fcx.mk_subty(false,
@ -4410,8 +4358,8 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
},
base_t,
None);
fcx.write_ty(idx.id, ty::mk_err());
fcx.write_ty(id, ty::mk_err())
fcx.write_ty(idx.id, fcx.tcx().types.err);
fcx.write_ty(id, fcx.tcx().types.err);
}
}
}
@ -4440,7 +4388,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
fcx.write_ty(id, element_ty);
}
_ => {
check_expr_has_type(fcx, &**idx, ty::mk_err());
check_expr_has_type(fcx, &**idx, fcx.tcx().types.err);
fcx.type_error_message(
expr.span,
|actual| {
@ -4449,7 +4397,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
},
base_t,
None);
fcx.write_ty(id, ty::mk_err())
fcx.write_ty(id, fcx.tcx().types.err);
}
}
}
@ -4468,19 +4416,21 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
});
let idx_type = match (t_start, t_end) {
(Some(ty), None) | (None, Some(ty)) => Some(ty),
(Some(t_start), Some(t_end))
if ty::type_is_error(t_start) || ty::type_is_error(t_end) => {
Some(ty::mk_err())
}
(Some(t_start), Some(t_end)) => {
Some(infer::common_supertype(fcx.infcx(),
infer::RangeExpression(expr.span),
true,
t_start,
t_end))
}
_ => None
(Some(ty), None) | (None, Some(ty)) => {
Some(ty)
}
(Some(t_start), Some(t_end)) if (ty::type_is_error(t_start) ||
ty::type_is_error(t_end)) => {
Some(fcx.tcx().types.err)
}
(Some(t_start), Some(t_end)) => {
Some(infer::common_supertype(fcx.infcx(),
infer::RangeExpression(expr.span),
true,
t_start,
t_end))
}
_ => None
};
// Note that we don't check the type of start/end satisfy any
@ -4489,7 +4439,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
let range_type = match idx_type {
Some(idx_type) if ty::type_is_error(idx_type) => {
ty::mk_err()
fcx.tcx().types.err
}
Some(idx_type) => {
// Find the did from the appropriate lang item.
@ -4515,7 +4465,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
ty::mk_struct(tcx, did, tcx.mk_substs(substs))
} else {
tcx.sess.span_err(expr.span, "No lang item for range syntax");
ty::mk_err()
fcx.tcx().types.err
}
}
None => {
@ -4525,7 +4475,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
ty::mk_struct(tcx, did, tcx.mk_substs(substs))
} else {
tcx.sess.span_err(expr.span, "No lang item for range syntax");
ty::mk_err()
fcx.tcx().types.err
}
}
};

1
src/librustc_typeck/collect.rs
View File

@ -1098,7 +1098,6 @@ fn ty_generics_for_trait<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,
let bounds = compute_bounds(ccx,
assoc_ty,
assoc_type_def.bounds.as_slice(),
&assoc_type_def.unbound,
assoc_type_def.span);
ty::predicates(ccx.tcx, assoc_ty, &bounds).into_iter()

2
src/librustdoc/clean/mod.rs
View File

@ -1474,7 +1474,7 @@ impl<'tcx> Clean<Type> for ty::Ty<'tcx> {
ty::ty_projection(ref data) => {
let trait_ref = match data.trait_ref.clean(cx) {
TyParamBound::TraitBound(t) => t.trait_,
TyParamBound::TraitBound(t, _) => t.trait_,
TyParamBound::RegionBound(_) => panic!("cleaning a trait got a region??"),
};
Type::QPath {

21
src/test/run-pass/trait-static-method-generic-inference.rs → src/test/compile-fail/trait-static-method-generic-inference.rs
View File

@ -8,6 +8,11 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
// Issue #3902. We are (at least currently) unable to infer `Self`
// based on `T`, even though there is only a single impl, because of
// the possibility of associated types and other things (basically: no
// constraints on `Self` here at all).
mod base {
pub trait HasNew<T> {
fn new() -> T;
@ -22,19 +27,11 @@ mod base {
Foo { dummy: () }
}
}
pub struct Bar {
dummy: (),
}
impl HasNew<Bar> for Bar {
fn new() -> Bar {
Bar { dummy: () }
}
}
}
pub fn main() {
pub fn foo() {
let _f: base::Foo = base::HasNew::new();
let _b: base::Bar = base::HasNew::new();
//~^ ERROR type annotations required
}
fn main() { }