---

yaml
---
r: 95967
b: refs/heads/dist-snap
c: f57a28b
h: refs/heads/master
i:
  95965: 276f991
  95963: 3589094
  95959: be85e12
  95951: 8e7cb90
  95935: e99de74
v: v3

Author: nikomatsakis

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 168ac5290e9d4a787e020735f96fa789060a8f76
+refs/heads/dist-snap: f57a28b2dbb1823b88b5db270145a4f324820390
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/librustc/middle/typeck/infer/error_reporting.rs

@@ -73,6 +73,7 @@ use middle::typeck::infer::region_inference::SubSupConflict;
 use middle::typeck::infer::region_inference::SupSupConflict;
 use syntax::opt_vec::OptVec;
 use util::ppaux::UserString;
+use util::ppaux::bound_region_to_str;
 use util::ppaux::note_and_explain_region;
 
 pub trait ErrorReporting {
@@ -110,6 +111,13 @@ pub trait ErrorReporting {
                                region2: Region);
 }
 
+trait ErrorReportingHelpers {
+    fn report_inference_failure(@mut self,
+                                var_origin: RegionVariableOrigin);
+
+    fn note_region_origin(@mut self,
+                          origin: SubregionOrigin);
+}
 
 impl ErrorReporting for InferCtxt {
     fn report_region_errors(@mut self,
@@ -398,30 +406,23 @@ impl ErrorReporting for InferCtxt {
                                sub_region: Region,
                                sup_origin: SubregionOrigin,
                                sup_region: Region) {
-        self.tcx.sess.span_err(
-            var_origin.span(),
-            format!("cannot infer an appropriate lifetime \
-                  due to conflicting requirements"));
+        self.report_inference_failure(var_origin);
 
         note_and_explain_region(
             self.tcx,
             "first, the lifetime cannot outlive ",
             sup_region,
             "...");
 
-        self.tcx.sess.span_note(
-            sup_origin.span(),
-            format!("...due to the following expression"));
+        self.note_region_origin(sup_origin);
 
         note_and_explain_region(
             self.tcx,
             "but, the lifetime must be valid for ",
             sub_region,
             "...");
 
-        self.tcx.sess.span_note(
-            sub_origin.span(),
-            format!("...due to the following expression"));
+        self.note_region_origin(sub_origin);
     }
 
     fn report_sup_sup_conflict(@mut self,
@@ -430,30 +431,183 @@ impl ErrorReporting for InferCtxt {
                                region1: Region,
                                origin2: SubregionOrigin,
                                region2: Region) {
-        self.tcx.sess.span_err(
-            var_origin.span(),
-            format!("cannot infer an appropriate lifetime \
-                  due to conflicting requirements"));
+        self.report_inference_failure(var_origin);
 
         note_and_explain_region(
             self.tcx,
             "first, the lifetime must be contained by ",
             region1,
             "...");
 
-        self.tcx.sess.span_note(
-            origin1.span(),
-            format!("...due to the following expression"));
+        self.note_region_origin(origin1);
 
         note_and_explain_region(
             self.tcx,
             "but, the lifetime must also be contained by ",
             region2,
             "...");
 
-        self.tcx.sess.span_note(
-            origin2.span(),
-            format!("...due to the following expression"));
+        self.note_region_origin(origin2);
+    }
+}
+
+impl ErrorReportingHelpers for InferCtxt {
+    fn report_inference_failure(@mut self,
+                                var_origin: RegionVariableOrigin) {
+        let var_description = match var_origin {
+            infer::MiscVariable(_) => ~"",
+            infer::PatternRegion(_) => ~" for pattern",
+            infer::AddrOfRegion(_) => ~" for borrow expression",
+            infer::AddrOfSlice(_) => ~" for slice expression",
+            infer::Autoref(_) => ~" for autoref",
+            infer::Coercion(_) => ~" for automatic coercion",
+            infer::BoundRegionInFnCall(_, br) => {
+                format!(" for {}in function call",
+                        bound_region_to_str(self.tcx, "region ", true, br))
+            }
+            infer::BoundRegionInFnType(_, br) => {
+                format!(" for {}in function type",
+                        bound_region_to_str(self.tcx, "region ", true, br))
+            }
+            infer::BoundRegionInTypeOrImpl(_) => {
+                format!(" for region in type/impl")
+            }
+            infer::BoundRegionInCoherence(*) => {
+                format!(" for coherence check")
+            }
+        };
+
+        self.tcx.sess.span_err(
+            var_origin.span(),
+            format!("cannot infer an appropriate lifetime{} \
+                    due to conflicting requirements",
+                    var_description));
+    }
+
+    fn note_region_origin(@mut self,
+                          origin: SubregionOrigin) {
+        match origin {
+            infer::Subtype(ref trace) => {
+                let desc = match trace.origin {
+                    infer::Misc(_) => {
+                        format!("types are compatible")
+                    }
+                    infer::MethodCompatCheck(_) => {
+                        format!("method type is compatible with trait")
+                    }
+                    infer::ExprAssignable(_) => {
+                        format!("expression is assignable")
+                    }
+                    infer::RelateTraitRefs(_) => {
+                        format!("traits are compatible")
+                    }
+                    infer::RelateSelfType(_) => {
+                        format!("type matches impl")
+                    }
+                    infer::MatchExpression(_) => {
+                        format!("match arms have compatible types")
+                    }
+                    infer::IfExpression(_) => {
+                        format!("if and else have compatible types")
+                    }
+                };
+
+                match self.values_str(&trace.values) {
+                    Some(values_str) => {
+                        self.tcx.sess.span_note(
+                            trace.origin.span(),
+                            format!("...so that {} ({})",
+                                    desc, values_str));
+                    }
+                    None => {
+                        // Really should avoid printing this error at
+                        // all, since it is derived, but that would
+                        // require more refactoring than I feel like
+                        // doing right now. - nmatsakis
+                        self.tcx.sess.span_note(
+                            trace.origin.span(),
+                            format!("...so that {}", desc));
+                    }
+                }
+            }
+            infer::Reborrow(span) => {
+                self.tcx.sess.span_note(
+                    span,
+                    "...so that borrowed pointer does not outlive \
+                    borrowed content");
+            }
+            infer::InfStackClosure(span) => {
+                self.tcx.sess.span_note(
+                    span,
+                    "...so that closure does not outlive its stack frame");
+            }
+            infer::InvokeClosure(span) => {
+                self.tcx.sess.span_note(
+                    span,
+                    "...so that closure is not invoked outside its lifetime");
+            }
+            infer::DerefPointer(span) => {
+                self.tcx.sess.span_note(
+                    span,
+                    "...so that pointer is not dereferenced \
+                    outside its lifetime");
+            }
+            infer::FreeVariable(span) => {
+                self.tcx.sess.span_note(
+                    span,
+                    "...so that captured variable does not outlive the \
+                    enclosing closure");
+            }
+            infer::IndexSlice(span) => {
+                self.tcx.sess.span_note(
+                    span,
+                    "...so that slice is not indexed outside the lifetime");
+            }
+            infer::RelateObjectBound(span) => {
+                self.tcx.sess.span_note(
+                    span,
+                    "...so that source pointer does not outlive \
+                     lifetime bound of the object type");
+            }
+            infer::CallRcvr(span) => {
+                self.tcx.sess.span_note(
+                    span,
+                    "...so that method receiver is valid for the method call");
+            }
+            infer::CallArg(span) => {
+                self.tcx.sess.span_note(
+                    span,
+                    "...so that argument is valid for the call");
+            }
+            infer::CallReturn(span) => {
+                self.tcx.sess.span_note(
+                    span,
+                    "...so that return value is valid for the call");
+            }
+            infer::AddrOf(span) => {
+                self.tcx.sess.span_note(
+                    span,
+                    "...so that borrowed pointer is valid \
+                     at the time of borrow");
+            }
+            infer::AutoBorrow(span) => {
+                self.tcx.sess.span_note(
+                    span,
+                    "...so that automatically borrowed pointer is valid \
+                     at the time of borrow");
+            }
+            infer::BindingTypeIsNotValidAtDecl(span) => {
+                self.tcx.sess.span_note(
+                    span,
+                    "...so that variable is valid at time of its declaration");
+            }
+            infer::ReferenceOutlivesReferent(_, span) => {
+                self.tcx.sess.span_note(
+                    span,
+                    "...so that the pointer does not outlive the \
+                    data it points at");
+            }
+        }
     }
 }