---

yaml
---
r: 187647
b: refs/heads/tmp
c: 38ef5ee
h: refs/heads/master
i:
  187645: bc9eb8b
  187643: 3fbb5f1
  187639: 6e4b6b8
  187631: 550ac99
  187615: 5eb3c92
  187583: 09eb19b
  187519: 8427372
  187391: 56b3b57
v: v3

Author: flaper87

[refs]

@@ -34,5 +34,5 @@ refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
 refs/heads/beta: 522d09dfecbeca1595f25ac58c6d0178bbd21d7d
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: e8df95d77f65a3a1456f7e10d9d1dd209acf2879
+refs/heads/tmp: 38ef5ee48f7a2994a7fd8e6a1a818d378d51d40e
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f

branches/tmp/src/librustc/middle/traits/select.rs

@@ -1152,7 +1152,14 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             }
             _ => {
                 if ty::trait_has_default_impl(self.tcx(), def_id) {
-                    candidates.vec.push(DefaultImplCandidate(def_id.clone()))
+                    match self.constituent_types_for_ty(self_ty) {
+                        Some(_) => {
+                            candidates.vec.push(DefaultImplCandidate(def_id.clone()))
+                        }
+                        None => {
+                            candidates.ambiguous = true;
+                        }
+                    }
                 }
             }
         }
@@ -1625,7 +1632,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         }
     }
 
-    fn constituent_ty_obligations(&self, t: Ty<'tcx>) -> Vec<Ty<'tcx>> {
+    fn constituent_types_for_ty(&self, t: Ty<'tcx>) -> Option<Vec<Ty<'tcx>>> {
         match t.sty {
             ty::ty_uint(_) |
             ty::ty_int(_) |
@@ -1636,7 +1643,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             ty::ty_err |
             ty::ty_param(..) |
             ty::ty_char => {
-                Vec::new()
+                Some(Vec::new())
             }
 
             ty::ty_trait(..) |
@@ -1649,50 +1656,50 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             }
 
             ty::ty_uniq(referent_ty) => {  // Box<T>
-                vec![referent_ty]
+                Some(vec![referent_ty])
             }
 
-            ty::ty_open(element_ty) => {vec![element_ty]},
+            ty::ty_open(element_ty) => {Some(vec![element_ty])},
 
             ty::ty_ptr(ty::mt { ty: element_ty, ..}) |
             ty::ty_rptr(_, ty::mt { ty: element_ty, ..}) => {
-                vec![element_ty]
+                Some(vec![element_ty])
             },
 
             ty::ty_vec(element_ty, _) => {
-                vec![element_ty]
+                Some(vec![element_ty])
             }
 
             ty::ty_tup(ref tys) => {
                 // (T1, ..., Tn) -- meets any bound that all of T1...Tn meet
-                tys.clone()
+                Some(tys.clone())
             }
 
             ty::ty_closure(def_id, _, substs) => {
                 assert_eq!(def_id.krate, ast::LOCAL_CRATE);
 
                 match self.closure_typer.closure_upvars(def_id, substs) {
                     Some(upvars) => {
-                        upvars.iter().map(|c| c.ty).collect()
+                        Some(upvars.iter().map(|c| c.ty).collect())
                     }
                     None => {
-                        Vec::new()
+                        None
                     }
                 }
             }
 
             ty::ty_struct(def_id, substs) => {
-                ty::struct_fields(self.tcx(), def_id, substs).iter()
-                    .map(|f| f.mt.ty)
-                    .collect()
+                Some(ty::struct_fields(self.tcx(), def_id, substs).iter()
+                     .map(|f| f.mt.ty)
+                     .collect())
             }
 
             ty::ty_enum(def_id, substs) => {
-                ty::substd_enum_variants(self.tcx(), def_id, substs)
-                    .iter()
-                    .flat_map(|variant| variant.args.iter())
-                    .map(|&ty| ty)
-                    .collect()
+                Some(ty::substd_enum_variants(self.tcx(), def_id, substs)
+                     .iter()
+                     .flat_map(|variant| variant.args.iter())
+                     .map(|&ty| ty)
+                     .collect())
             }
         }
     }
@@ -1891,8 +1898,17 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                impl_def_id.repr(self.tcx()));
 
         let self_ty = self.infcx.shallow_resolve(obligation.predicate.0.self_ty());
-        let types = self.constituent_ty_obligations(self_ty);
-        Ok(self.vtable_default_impl(obligation, impl_def_id, types))
+        match self.constituent_types_for_ty(self_ty) {
+            Some(types) => {
+                Ok(self.vtable_default_impl(obligation, impl_def_id, types))
+            }
+            None => {
+                self.tcx().sess.bug(
+                    &format!(
+                        "asked to confirm default implementation for ambiguous type: {}",
+                        self_ty.repr(self.tcx()))[]);
+            }
+        }
     }
 
     /// See `confirm_default_impl_candidate`