Various small bits of cleanup.

Author: nikomatsakis

src/librustc/middle/typeck/check/method/confirm.rs

@@ -64,43 +64,45 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> {
                supplied_method_types: Vec<ty::t>)
                -> MethodCallee
     {
-        //
+        // Adjust the self expression the user provided and obtain the adjusted type.
         let self_ty = self.adjust_self_ty(unadjusted_self_ty, &pick.adjustment);
 
-        //
+        // Make sure nobody calls `drop()` explicitly.
         self.enforce_drop_trait_limitations(&pick);
 
-        //
+        // Create substitutions for the method's type parameters.
         let (rcvr_substs, method_origin) =
             self.fresh_receiver_substs(self_ty, &pick);
         let (method_types, method_regions) =
             self.instantiate_method_substs(&pick, supplied_method_types);
         let all_substs = rcvr_substs.with_method(method_types, method_regions);
         debug!("all_substs={}", all_substs.repr(self.tcx()));
 
-        //
+        // Create the final signature for the method, replacing late-bound regions.
         let method_sig = self.instantiate_method_sig(&pick, &all_substs);
         let method_self_ty = method_sig.inputs[0];
 
-        //
+        // Unify the (adjusted) self type with what the method expects.
         self.unify_receivers(self_ty, method_self_ty);
 
-        //
+        // Add any trait/regions obligations specified on the method's type parameters.
         self.add_obligations(&pick, &all_substs);
 
-        //
+        // Create the final `MethodCallee`.
         let fty = ty::mk_bare_fn(self.tcx(), ty::BareFnTy {
             sig: method_sig,
             fn_style: pick.method_ty.fty.fn_style,
             abi: pick.method_ty.fty.abi.clone(),
         });
-
         let callee = MethodCallee {
             origin: method_origin,
             ty: fty,
             substs: all_substs
         };
 
+        // If this is an `&mut self` method, bias the receiver
+        // expression towards mutability (this will switch
+        // e.g. `Deref` to `DerefMut` in oveloaded derefs and so on).
         self.fixup_derefs_on_method_receiver_if_necessary(&callee);
 
         callee
@@ -147,18 +149,17 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> {
                     autoref: None
                 }
             }
+            probe::AutoUnsizeLength(autoderefs, len) => {
+                ty::AutoDerefRef {
+                    autoderefs: autoderefs,
+                    autoref: Some(ty::AutoUnsize(ty::UnsizeLength(len)))
+                }
+            }
             probe::AutoRef(mutability, ref sub_adjustment) => {
                 let deref = self.create_ty_adjustment(&**sub_adjustment);
                 let region = self.infcx().next_region_var(infer::Autoref(self.span));
                 wrap_autoref(deref, |base| ty::AutoPtr(region, mutability, base))
             }
-            probe::AutoUnsizeLength(n, ref sub_adjustment) => {
-                let deref = self.create_ty_adjustment(&**sub_adjustment);
-                wrap_autoref(deref, |wrap| {
-                    assert!(wrap.is_none());
-                    ty::AutoUnsize(ty::UnsizeLength(n))
-                })
-            }
         }
     }
 

src/librustc/middle/typeck/check/method/doc.rs

@@ -110,7 +110,7 @@ might have two candidates:
 
 Finally, to actually pick the method, we will search down the steps,
 trying to match the receiver type against the candidate types. At
-step, we also consider an auto-ref and auto-mut-ref to see whether
+each step, we also consider an auto-ref and auto-mut-ref to see whether
 that makes any of the candidates match. We pick the first step where
 we find a match.
 

src/librustc/middle/typeck/check/method/mod.rs

@@ -53,18 +53,12 @@ pub enum CandidateSource {
 
 type MethodIndex = uint; // just for doc purposes
 
-//struct CacheKey {
-//    skol_self_ty: ty::t,
-//    method_name: ast::Name,
-//}
-
-pub fn exists(
-    fcx: &FnCtxt,
-    span: Span,
-    method_name: ast::Name,
-    self_ty: ty::t,
-    call_expr_id: ast::NodeId)
-    -> bool
+pub fn exists(fcx: &FnCtxt,
+              span: Span,
+              method_name: ast::Name,
+              self_ty: ty::t,
+              call_expr_id: ast::NodeId)
+              -> bool
 {
     /*!
      * Determines whether the type `self_ty` supports a method name `method_name` or not.
@@ -77,15 +71,14 @@ pub fn exists(
     }
 }
 
-pub fn lookup(
-    fcx: &FnCtxt,
-    span: Span,
-    method_name: ast::Name,
-    self_ty: ty::t,
-    supplied_method_types: Vec<ty::t>,
-    call_expr_id: ast::NodeId,
-    self_expr: &ast::Expr)
-    -> Result<MethodCallee, MethodError>
+pub fn lookup(fcx: &FnCtxt,
+              span: Span,
+              method_name: ast::Name,
+              self_ty: ty::t,
+              supplied_method_types: Vec<ty::t>,
+              call_expr_id: ast::NodeId,
+              self_expr: &ast::Expr)
+              -> Result<MethodCallee, MethodError>
 {
     /*!
      * Performs method lookup. If lookup is successful, it will return the callee
@@ -114,31 +107,29 @@ pub fn lookup(
     Ok(confirm::confirm(fcx, span, self_expr, self_ty, pick, supplied_method_types))
 }
 
-pub fn lookup_in_trait<'a, 'tcx>(
-    fcx: &'a FnCtxt<'a, 'tcx>,
-    span: Span,
-    self_expr: Option<&'a ast::Expr>,
-    m_name: ast::Name,
-    trait_def_id: DefId,
-    self_ty: ty::t,
-    opt_input_types: Option<Vec<ty::t>>)
-    -> Option<MethodCallee>
+pub fn lookup_in_trait<'a, 'tcx>(fcx: &'a FnCtxt<'a, 'tcx>,
+                                 span: Span,
+                                 self_expr: Option<&'a ast::Expr>,
+                                 m_name: ast::Name,
+                                 trait_def_id: DefId,
+                                 self_ty: ty::t,
+                                 opt_input_types: Option<Vec<ty::t>>)
+                                 -> Option<MethodCallee>
 {
     lookup_in_trait_adjusted(fcx, span, self_expr, m_name, trait_def_id,
                              ty::AutoDerefRef { autoderefs: 0, autoref: None },
                              self_ty, opt_input_types)
 }
 
-pub fn lookup_in_trait_adjusted<'a, 'tcx>(
-    fcx: &'a FnCtxt<'a, 'tcx>,
-    span: Span,
-    self_expr: Option<&'a ast::Expr>,
-    m_name: ast::Name,
-    trait_def_id: DefId,
-    autoderefref: ty::AutoDerefRef,
-    self_ty: ty::t,
-    opt_input_types: Option<Vec<ty::t>>)
-    -> Option<MethodCallee>
+pub fn lookup_in_trait_adjusted<'a, 'tcx>(fcx: &'a FnCtxt<'a, 'tcx>,
+                                          span: Span,
+                                          self_expr: Option<&'a ast::Expr>,
+                                          m_name: ast::Name,
+                                          trait_def_id: DefId,
+                                          autoderefref: ty::AutoDerefRef,
+                                          self_ty: ty::t,
+                                          opt_input_types: Option<Vec<ty::t>>)
+                                          -> Option<MethodCallee>
 {
     debug!("lookup_in_trait_adjusted(self_ty={}, self_expr={}, m_name={}, trait_def_id={})",
            self_ty.repr(fcx.tcx()),

src/librustc/middle/typeck/check/method/probe.rs

@@ -84,18 +84,30 @@ pub type PickResult = Result<Pick, MethodError>;
 // needed.
 #[deriving(Clone,Show)]
 pub enum PickAdjustment {
-    AutoDeref(/* number of autoderefs */ uint),     // A = expr, *expr, **expr
-    AutoRef(ast::Mutability, Box<PickAdjustment>),  // A = &A | &mut A
-    AutoUnsizeLength(uint, Box<PickAdjustment>),    // [T, ..n] => [T]
+    // Indicates that the source expression should be autoderef'd N times
+    //
+    // A = expr | *expr | **expr
+    AutoDeref(uint),
+
+    // Indicates that the source expression should be autoderef'd N
+    // times and then "unsized". This should probably eventually go
+    // away in favor of just coercing method receivers.
+    //
+    // A = unsize(expr | *expr | **expr)
+    AutoUnsizeLength(/* number of autoderefs */ uint, /* length*/ uint),
+
+    // Indicates that an autoref is applied after some number of other adjustments
+    //
+    // A = &A | &mut A
+    AutoRef(ast::Mutability, Box<PickAdjustment>),
 }
 
-pub fn probe(
-    fcx: &FnCtxt,
-    span: Span,
-    method_name: ast::Name,
-    self_ty: ty::t,
-    call_expr_id: ast::NodeId)
-    -> PickResult
+pub fn probe(fcx: &FnCtxt,
+             span: Span,
+             method_name: ast::Name,
+             self_ty: ty::t,
+             call_expr_id: ast::NodeId)
+             -> PickResult
 {
     debug!("probe(self_ty={}, method_name={}, call_expr_id={})",
            self_ty.repr(fcx.tcx()),
@@ -143,7 +155,7 @@ fn create_steps(fcx: &FnCtxt, span: Span, self_ty: ty::t) -> Vec<CandidateStep>
         ty::ty_vec(elem_ty, Some(len)) => {
             steps.push(CandidateStep {
                 self_ty: ty::mk_vec(fcx.tcx(), elem_ty, None),
-                adjustment: AutoUnsizeLength(len, box AutoDeref(dereferences))
+                adjustment: AutoUnsizeLength(dereferences, len),
             });
         }
         _ => {
@@ -609,8 +621,8 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
     }
 
     fn pick_autorefrefd_method(&mut self,
-                            step: &CandidateStep)
-                            -> Option<PickResult>
+                               step: &CandidateStep)
+                               -> Option<PickResult>
     {
         let tcx = self.tcx();
         self.search_mutabilities(

src/test/compile-fail/method-ambig-one-trait-coerce.rs

@@ -27,11 +27,11 @@ impl foo for Box<Object+Send> {
 }
 
 fn test1(x: Box<Object+Send+Sync>) {
-    // FIXME -- we ought to consider this to be ambiguous, since
-    // we could coerce to either impl. However, what actually
+    // FIXME(#18737) -- we ought to consider this to be ambiguous,
+    // since we could coerce to either impl. However, what actually
     // happens is that we consider both impls applicable because of
-    // incorrect subtyping relation. We then decide to call this
-    // a call to the `foo` trait, leading to the following error
+    // incorrect subtyping relation. We then decide to call this a
+    // call to the `foo` trait, leading to the following error
     // message.
 
     x.foo(); //~ ERROR `foo` is not implemented