Tag some code duplication with FIXME for #18741.

Author: nikomatsakis

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

@@ -131,6 +131,21 @@ pub fn lookup_in_trait_adjusted<'a, 'tcx>(fcx: &'a FnCtxt<'a, 'tcx>,
                                           opt_input_types: Option<Vec<ty::t>>)
                                           -> Option<MethodCallee>
 {
+    /*!
+     * `lookup_in_trait_adjusted` is used for overloaded operators. It
+     * does a very narrow slice of what the normal probe/confirm path
+     * does. In particular, it doesn't really do any probing: it
+     * simply constructs an obligation for a particular trait with the
+     * given self-type and checks whether that trait is implemented.
+     *
+     * FIXME(#18741) -- It seems likely that we can consolidate some of this
+     * code with the other method-lookup code. In particular,
+     * autoderef on index is basically identical to autoderef with
+     * normal probes, except that the test also looks for built-in
+     * indexing. Also, the second half of this method is basically
+     * the same as confirmation.
+     */
+
     debug!("lookup_in_trait_adjusted(self_ty={}, self_expr={}, m_name={}, trait_def_id={})",
            self_ty.repr(fcx.tcx()),
            self_expr.repr(fcx.tcx()),

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

@@ -114,7 +114,7 @@ pub fn probe(fcx: &FnCtxt,
            method_name,
            call_expr_id);
 
-    // FIXME -- right now, creating the steps involves evaluating the
+    // FIXME(#18741) -- right now, creating the steps involves evaluating the
     // `*` operator, which registers obligations that then escape into
     // the global fulfillment context and thus has global
     // side-effects. This is a bit of a pain to refactor. So just let

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

@@ -2265,6 +2265,10 @@ fn autoderef_for_index<T>(fcx: &FnCtxt,
                           step: |ty::t, ty::AutoDerefRef| -> Option<T>)
                           -> Option<T>
 {
+    // FIXME(#18741) -- this is almost but not quite the same as the
+    // autoderef that normal method probing does. They could likely be
+    // consolidated.
+
     let (ty, autoderefs, final_mt) =
         autoderef(fcx, base_expr.span, base_ty, Some(base_expr.id), lvalue_pref, |adj_ty, idx| {
             let autoderefref = ty::AutoDerefRef { autoderefs: idx, autoref: None };