---

yaml
---
r: 167486
b: refs/heads/snap-stage3
c: ea94a90
h: refs/heads/master
v: v3

Author: Jorge Aparicio

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 023dfb0c898d851dee6ace2f8339b73b5287136b
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 7d4f4876d65bddf101784230c0347adcb01e5c21
+refs/heads/snap-stage3: ea94a90488e6b4701581079339de3595389e5b15
 refs/heads/try: 5204084bd2e46af7cc6e0147430e44dd0d657bbb
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

branches/snap-stage3/src/librustc/metadata/encoder.rs

@@ -1402,7 +1402,6 @@ fn encode_info_for_item(ecx: &EncodeContext,
                 }
                 ty::TypeTraitItem(associated_type) => {
                     encode_name(rbml_w, associated_type.name);
-                    encode_def_id(rbml_w, associated_type.def_id);
 
                     let elem = ast_map::PathName(associated_type.name);
                     encode_path(rbml_w,

branches/snap-stage3/src/librustc/middle/traits/error_reporting.rs

@@ -77,7 +77,13 @@ pub fn report_selection_error<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
                     "overflow evaluating the requirement `{}`",
                     predicate.user_string(infcx.tcx)).as_slice());
 
-            suggest_new_overflow_limit(infcx, obligation.cause.span);
+            let current_limit = infcx.tcx.sess.recursion_limit.get();
+            let suggested_limit = current_limit * 2;
+            infcx.tcx.sess.span_note(
+                obligation.cause.span,
+                format!(
+                    "consider adding a `#![recursion_limit=\"{}\"]` attribute to your crate",
+                    suggested_limit)[]);
 
             note_obligation_cause(infcx, obligation);
         }
@@ -159,76 +165,73 @@ pub fn maybe_report_ambiguity<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
     // ambiguous impls. The latter *ought* to be a
     // coherence violation, so we don't report it here.
 
-    let predicate = infcx.resolve_type_vars_if_possible(&obligation.predicate);
+    let trait_ref = match obligation.predicate {
+        ty::Predicate::Trait(ref trait_predicate) => {
+            infcx.resolve_type_vars_if_possible(
+                &trait_predicate.to_poly_trait_ref())
+        }
+        _ => {
+            infcx.tcx.sess.span_bug(
+                obligation.cause.span,
+                format!("ambiguity from something other than a trait: {}",
+                        obligation.predicate.repr(infcx.tcx)).as_slice());
+        }
+    };
 
-    debug!("maybe_report_ambiguity(predicate={}, obligation={})",
-           predicate.repr(infcx.tcx),
-           obligation.repr(infcx.tcx));
+    let self_ty = trait_ref.self_ty();
 
-    match predicate {
-        ty::Predicate::Trait(ref data) => {
-            let trait_ref = data.to_poly_trait_ref();
-            let self_ty = trait_ref.self_ty();
-            let all_types = &trait_ref.substs().types;
-            if all_types.iter().any(|&t| ty::type_is_error(t)) {
-            } else if all_types.iter().any(|&t| ty::type_needs_infer(t)) {
-                // This is kind of a hack: it frequently happens that some earlier
-                // error prevents types from being fully inferred, and then we get
-                // a bunch of uninteresting errors saying something like "<generic
-                // #0> doesn't implement Sized".  It may even be true that we
-                // could just skip over all checks where the self-ty is an
-                // inference variable, but I was afraid that there might be an
-                // inference variable created, registered as an obligation, and
-                // then never forced by writeback, and hence by skipping here we'd
-                // be ignoring the fact that we don't KNOW the type works
-                // out. Though even that would probably be harmless, given that
-                // we're only talking about builtin traits, which are known to be
-                // inhabited. But in any case I just threw in this check for
-                // has_errors() to be sure that compilation isn't happening
-                // anyway. In that case, why inundate the user.
-                if !infcx.tcx.sess.has_errors() {
-                    if
-                        infcx.tcx.lang_items.sized_trait()
-                        .map_or(false, |sized_id| sized_id == trait_ref.def_id())
-                    {
-                        infcx.tcx.sess.span_err(
-                            obligation.cause.span,
-                            format!(
-                                "unable to infer enough type information about `{}`; \
-                                 type annotations required",
-                                self_ty.user_string(infcx.tcx)).as_slice());
-                    } else {
-                        infcx.tcx.sess.span_err(
-                            obligation.cause.span,
-                            format!(
-                                "type annotations required: cannot resolve `{}`",
-                                predicate.user_string(infcx.tcx)).as_slice());
-                        note_obligation_cause(infcx, obligation);
-                    }
-                }
-            } else if !infcx.tcx.sess.has_errors() {
-                // Ambiguity. Coherence should have reported an error.
-                infcx.tcx.sess.span_bug(
+    debug!("maybe_report_ambiguity(trait_ref={}, self_ty={}, obligation={})",
+           trait_ref.repr(infcx.tcx),
+           self_ty.repr(infcx.tcx),
+           obligation.repr(infcx.tcx));
+    let all_types = &trait_ref.substs().types;
+    if all_types.iter().any(|&t| ty::type_is_error(t)) {
+    } else if all_types.iter().any(|&t| ty::type_needs_infer(t)) {
+        // This is kind of a hack: it frequently happens that some earlier
+        // error prevents types from being fully inferred, and then we get
+        // a bunch of uninteresting errors saying something like "<generic
+        // #0> doesn't implement Sized".  It may even be true that we
+        // could just skip over all checks where the self-ty is an
+        // inference variable, but I was afraid that there might be an
+        // inference variable created, registered as an obligation, and
+        // then never forced by writeback, and hence by skipping here we'd
+        // be ignoring the fact that we don't KNOW the type works
+        // out. Though even that would probably be harmless, given that
+        // we're only talking about builtin traits, which are known to be
+        // inhabited. But in any case I just threw in this check for
+        // has_errors() to be sure that compilation isn't happening
+        // anyway. In that case, why inundate the user.
+        if !infcx.tcx.sess.has_errors() {
+            if infcx.tcx.lang_items.sized_trait()
+                  .map_or(false, |sized_id| sized_id == trait_ref.def_id()) {
+                infcx.tcx.sess.span_err(
                     obligation.cause.span,
                     format!(
-                        "coherence failed to report ambiguity: \
-                         cannot locate the impl of the trait `{}` for \
-                         the type `{}`",
-                        trait_ref.user_string(infcx.tcx),
+                        "unable to infer enough type information about `{}`; type annotations \
+                         required",
                         self_ty.user_string(infcx.tcx)).as_slice());
-            }
-        }
-
-        _ => {
-            if !infcx.tcx.sess.has_errors() {
+            } else {
                 infcx.tcx.sess.span_err(
                     obligation.cause.span,
                     format!(
-                        "type annotations required: cannot resolve `{}`",
-                        predicate.user_string(infcx.tcx)).as_slice());
+                        "unable to infer enough type information to \
+                         locate the impl of the trait `{}` for \
+                         the type `{}`; type annotations required",
+                        trait_ref.user_string(infcx.tcx),
+                        self_ty.user_string(infcx.tcx)).as_slice());
                 note_obligation_cause(infcx, obligation);
             }
         }
+    } else if !infcx.tcx.sess.has_errors() {
+         // Ambiguity. Coherence should have reported an error.
+        infcx.tcx.sess.span_bug(
+            obligation.cause.span,
+            format!(
+                "coherence failed to report ambiguity: \
+                 cannot locate the impl of the trait `{}` for \
+                 the type `{}`",
+                trait_ref.user_string(infcx.tcx),
+                self_ty.user_string(infcx.tcx)).as_slice());
     }
 }
 
@@ -332,12 +335,3 @@ fn note_obligation_cause_code<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
     }
 }
 
-pub fn suggest_new_overflow_limit(infcx: &InferCtxt, span: Span) {
-    let current_limit = infcx.tcx.sess.recursion_limit.get();
-    let suggested_limit = current_limit * 2;
-    infcx.tcx.sess.span_note(
-        span,
-        format!(
-            "consider adding a `#![recursion_limit=\"{}\"]` attribute to your crate",
-            suggested_limit)[]);
-}

branches/snap-stage3/src/librustc/middle/traits/fulfill.rs

@@ -8,9 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use middle::infer::{InferCtxt};
+use middle::infer::{mod, InferCtxt};
 use middle::mem_categorization::Typer;
-use middle::ty::{mod, RegionEscape, Ty};
+use middle::ty::{mod, AsPredicate, RegionEscape, Ty, ToPolyTraitRef};
 use std::collections::HashSet;
 use std::collections::hash_map::Entry::{Occupied, Vacant};
 use std::default::Default;
@@ -23,6 +23,7 @@ use super::CodeAmbiguity;
 use super::CodeProjectionError;
 use super::CodeSelectionError;
 use super::FulfillmentError;
+use super::Obligation;
 use super::ObligationCause;
 use super::PredicateObligation;
 use super::project;
@@ -109,8 +110,6 @@ impl<'tcx> FulfillmentContext<'tcx> {
     /// `projection_ty` again.
     pub fn normalize_projection_type<'a>(&mut self,
                                          infcx: &InferCtxt<'a,'tcx>,
-                                         param_env: &ty::ParameterEnvironment<'tcx>,
-                                         typer: &Typer<'tcx>,
                                          projection_ty: ty::ProjectionTy<'tcx>,
                                          cause: ObligationCause<'tcx>)
                                          -> Ty<'tcx>
@@ -122,16 +121,18 @@ impl<'tcx> FulfillmentContext<'tcx> {
 
         // FIXME(#20304) -- cache
 
-        let mut selcx = SelectionContext::new(infcx, param_env, typer);
-        let normalized = project::normalize_projection_type(&mut selcx, projection_ty, cause, 0);
-
-        for obligation in normalized.obligations.into_iter() {
-            self.register_predicate_obligation(infcx, obligation);
-        }
+        let ty_var = infcx.next_ty_var();
+        let projection =
+            ty::Binder(ty::ProjectionPredicate {
+                projection_ty: projection_ty,
+                ty: ty_var
+            });
+        let obligation = Obligation::new(cause, projection.as_predicate());
+        self.register_predicate(infcx, obligation);
 
-        debug!("normalize_associated_type: result={}", normalized.value.repr(infcx.tcx));
+        debug!("normalize_associated_type: result={}", ty_var.repr(infcx.tcx));
 
-        normalized.value
+        ty_var
     }
 
     pub fn register_builtin_bound<'a>(&mut self,
@@ -142,7 +143,7 @@ impl<'tcx> FulfillmentContext<'tcx> {
     {
         match predicate_for_builtin_bound(infcx.tcx, cause, builtin_bound, 0, ty) {
             Ok(predicate) => {
-                self.register_predicate_obligation(infcx, predicate);
+                self.register_predicate(infcx, predicate);
             }
             Err(ErrorReported) => { }
         }
@@ -157,14 +158,10 @@ impl<'tcx> FulfillmentContext<'tcx> {
         register_region_obligation(infcx.tcx, t_a, r_b, cause, &mut self.region_obligations);
     }
 
-    pub fn register_predicate_obligation<'a>(&mut self,
-                                             infcx: &InferCtxt<'a,'tcx>,
-                                             obligation: PredicateObligation<'tcx>)
+    pub fn register_predicate<'a>(&mut self,
+                                  infcx: &InferCtxt<'a,'tcx>,
+                                  obligation: PredicateObligation<'tcx>)
     {
-        // this helps to reduce duplicate errors, as well as making
-        // debug output much nicer to read and so on.
-        let obligation = infcx.resolve_type_vars_if_possible(&obligation);
-
         if !self.duplicate_set.insert(obligation.predicate.clone()) {
             debug!("register_predicate({}) -- already seen, skip", obligation.repr(infcx.tcx));
             return;
@@ -293,7 +290,7 @@ impl<'tcx> FulfillmentContext<'tcx> {
             // Now go through all the successful ones,
             // registering any nested obligations for the future.
             for new_obligation in new_obligations.into_iter() {
-                self.register_predicate_obligation(selcx.infcx(), new_obligation);
+                self.register_predicate(selcx.infcx(), new_obligation);
             }
         }
 
@@ -401,18 +398,104 @@ fn process_predicate<'a,'tcx>(selcx: &mut SelectionContext<'a,'tcx>,
                    project_obligation.repr(tcx),
                    result.repr(tcx));
             match result {
-                Ok(Some(obligations)) => {
-                    new_obligations.extend(obligations.into_iter());
+                Ok(()) => {
                     true
                 }
-                Ok(None) => {
+                Err(project::ProjectionError::TooManyCandidates) => {
+                    // Without more type information, we can't say much.
                     false
                 }
-                Err(err) => {
+                Err(project::ProjectionError::NoCandidate) => {
+                    // This means that we have a type like `<T as
+                    // Trait>::name = U` but we couldn't find any more
+                    // information. This could just be that we're in a
+                    // function like:
+                    //
+                    //     fn foo<T:Trait>(...)
+                    //
+                    // in which case this is not an error. But it
+                    // might also mean we're in a situation where we
+                    // don't actually know that `T : Trait` holds,
+                    // which would be weird (e.g., if `T` was not a
+                    // parameter type but a normal type, like `int`).
+                    //
+                    // So what we do is to (1) add a requirement that
+                    // `T : Trait` (just in case) and (2) try to unify
+                    // `U` with `<T as Trait>::name`.
+
+                    if !ty::binds_late_bound_regions(selcx.tcx(), data) {
+                        // Check that `T : Trait` holds.
+                        let trait_ref = data.to_poly_trait_ref();
+                        new_obligations.push(obligation.with(trait_ref.as_predicate()));
+
+                        // Fallback to `<T as Trait>::name`. If this
+                        // fails, then the output must be at least
+                        // somewhat constrained, and we cannot verify
+                        // that constraint, so yield an error.
+                        let ty_projection = ty::mk_projection(tcx,
+                                                              trait_ref.0.clone(),
+                                                              data.0.projection_ty.item_name);
+
+                        debug!("process_predicate: falling back to projection {}",
+                               ty_projection.repr(selcx.tcx()));
+
+                        match infer::mk_eqty(selcx.infcx(),
+                                             true,
+                                             infer::EquatePredicate(obligation.cause.span),
+                                             ty_projection,
+                                             data.0.ty) {
+                            Ok(()) => { }
+                            Err(_) => {
+                                debug!("process_predicate: fallback failed to unify; error");
+                                errors.push(
+                                    FulfillmentError::new(
+                                        obligation.clone(),
+                                        CodeSelectionError(Unimplemented)));
+                            }
+                        }
+
+                        true
+                    } else {
+                        // If we have something like
+                        //
+                        //     for<'a> <T<'a> as Trait>::name == &'a int
+                        //
+                        // there is no "canonical form" for us to
+                        // make, so just report the lack of candidates
+                        // as an error.
+
+                        debug!("process_predicate: can't fallback, higher-ranked");
+                        errors.push(
+                            FulfillmentError::new(
+                                obligation.clone(),
+                                CodeSelectionError(Unimplemented)));
+
+                        true
+                    }
+                }
+                Err(project::ProjectionError::MismatchedTypes(e)) => {
                     errors.push(
                         FulfillmentError::new(
                             obligation.clone(),
-                            CodeProjectionError(err)));
+                            CodeProjectionError(e)));
+                    true
+                }
+                Err(project::ProjectionError::TraitSelectionError(_)) => {
+                    // There was an error matching `T : Trait` (which
+                    // is a pre-requisite for `<T as Trait>::Name`
+                    // being valid).  We could just report the error
+                    // now, but that tends to lead to double error
+                    // reports for the user (one for the obligation `T
+                    // : Trait`, typically incurred somewhere else,
+                    // and one from here). Instead, we'll create the
+                    // `T : Trait` obligation and add THAT as a
+                    // requirement. This will (eventually) trigger the
+                    // same error, but it will also wind up flagged as
+                    // a duplicate if another requirement that `T :
+                    // Trait` arises from somewhere else.
+                    let trait_predicate = data.to_poly_trait_ref();
+                    let trait_obligation = obligation.with(trait_predicate.as_predicate());
+                    new_obligations.push(trait_obligation);
                     true
                 }
             }