---

yaml
---
r: 83924
b: refs/heads/dist-snap
c: 3c0a162
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 0983ebe5310d4eb6d289f636f7ed0536c08bbc0e
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 908a22b62697fcb6c943527492158729dc762f10
+refs/heads/dist-snap: 3c0a1621b550936e862585667d8a58f7a2ab72c5
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/librustc/middle/borrowck/mod.rs

@@ -538,12 +538,13 @@ impl BorrowckCtxt {
 
             move_data::MoveExpr(expr) => {
                 let expr_ty = ty::expr_ty_adjusted(self.tcx, expr);
+                let suggestion = move_suggestion(self.tcx, expr_ty,
+                        "moved by default (use `copy` to override)");
                 self.tcx.sess.span_note(
                     expr.span,
-                    fmt!("`%s` moved here because it has type `%s`, \
-                          which is moved by default (use `copy` to override)",
+                    fmt!("`%s` moved here because it has type `%s`, which is %s",
                          self.loan_path_to_str(moved_lp),
-                         expr_ty.user_string(self.tcx)));
+                         expr_ty.user_string(self.tcx), suggestion));
             }
 
             move_data::MovePat(pat) => {
@@ -557,12 +558,28 @@ impl BorrowckCtxt {
             }
 
             move_data::Captured(expr) => {
+                let expr_ty = ty::expr_ty_adjusted(self.tcx, expr);
+                let suggestion = move_suggestion(self.tcx, expr_ty,
+                        "moved by default (make a copy and \
+                         capture that instead to override)");
                 self.tcx.sess.span_note(
                     expr.span,
-                    fmt!("`%s` moved into closure environment here \
-                          because its type is moved by default \
-                          (make a copy and capture that instead to override)",
-                         self.loan_path_to_str(moved_lp)));
+                    fmt!("`%s` moved into closure environment here because it \
+                          has type `%s`, which is %s",
+                         self.loan_path_to_str(moved_lp),
+                         expr_ty.user_string(self.tcx), suggestion));
+            }
+        }
+
+        fn move_suggestion(tcx: ty::ctxt, ty: ty::t, default_msg: &'static str)
+                          -> &'static str {
+            match ty::get(ty).sty {
+                ty::ty_closure(ref cty) if cty.sigil == ast::BorrowedSigil =>
+                    "a non-copyable stack closure (capture it in a new closure, \
+                     e.g. `|x| f(x)`, to override)",
+                _ if !ty::type_is_copyable(tcx, ty) =>
+                    "non-copyable (perhaps you meant to use clone()?)",
+                _ => default_msg,
             }
         }
     }

branches/dist-snap/src/librustc/middle/resolve.rs

@@ -510,13 +510,6 @@ pub struct NameBindings {
     value_def: Option<ValueNsDef>,  //< Meaning in value namespace.
 }
 
-/// Ways in which a trait can be referenced
-enum TraitReferenceType {
-    TraitImplementation,             // impl SomeTrait for T { ... }
-    TraitDerivation,                 // trait T : SomeTrait { ... }
-    TraitBoundingTypeParameter,      // fn f<T:SomeTrait>() { ... }
-}
-
 impl NameBindings {
     /// Creates a new module in this set of name bindings.
     pub fn define_module(@mut self,
@@ -3561,7 +3554,23 @@ impl Resolver {
 
                     // Resolve derived traits.
                     for traits.iter().advance |trt| {
-                        self.resolve_trait_reference(*trt, visitor, TraitDerivation);
+                        match self.resolve_path(trt.path, TypeNS, true,
+                                                visitor) {
+                            None =>
+                                self.session.span_err(trt.path.span,
+                                                      "attempt to derive a \
+                                                      nonexistent trait"),
+                            Some(def) => {
+                                // Write a mapping from the trait ID to the
+                                // definition of the trait into the definition
+                                // map.
+
+                                debug!("(resolving trait) found trait def: \
+                                       %?", def);
+
+                                self.record_def(trt.ref_id, def);
+                            }
+                        }
                     }
 
                     for (*methods).iter().advance |method| {
@@ -3812,31 +3821,22 @@ impl Resolver {
                                         visitor: ResolveVisitor) {
         match *type_parameter_bound {
             TraitTyParamBound(tref) => {
-                self.resolve_trait_reference(tref, visitor, TraitBoundingTypeParameter)
+                self.resolve_trait_reference(tref, visitor)
             }
             RegionTyParamBound => {}
         }
     }
 
     pub fn resolve_trait_reference(@mut self,
                                    trait_reference: &trait_ref,
-                                   visitor: ResolveVisitor,
-                                   reference_type: TraitReferenceType) {
+                                   visitor: ResolveVisitor) {
         match self.resolve_path(trait_reference.path, TypeNS, true, visitor) {
             None => {
-                let path_str = self.idents_to_str(trait_reference.path.idents);
-
-                let usage_str = match reference_type {
-                    TraitBoundingTypeParameter => "bound type parameter with",
-                    TraitImplementation        => "implement",
-                    TraitDerivation            => "derive"
-                };
-
-                let msg = fmt!("attempt to %s a nonexistent trait `%s`", usage_str, path_str);
-                self.session.span_err(trait_reference.path.span, msg);
+                let idents = self.idents_to_str(trait_reference.path.idents);
+                self.session.span_err(trait_reference.path.span,
+                                      fmt!("attempt to implement an unknown trait `%s`", idents));
             }
             Some(def) => {
-                debug!("(resolving trait) found trait def: %?", def);
                 self.record_def(trait_reference.ref_id, def);
             }
         }
@@ -3930,7 +3930,7 @@ impl Resolver {
             let original_trait_refs;
             match opt_trait_reference {
                 Some(trait_reference) => {
-                    self.resolve_trait_reference(trait_reference, visitor, TraitImplementation);
+                    self.resolve_trait_reference(trait_reference, visitor);
 
                     // Record the current set of trait references.
                     let mut new_trait_refs = ~[];