---

yaml
---
r: 83923
b: refs/heads/dist-snap
c: 908a22b
h: refs/heads/master
i:
  83921: df1cd1e
  83919: f75fcf2
v: v3

Author: Dretch

[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: 648c5e9c92c635f3fa11bcf82623f4af2c201f0c
+refs/heads/dist-snap: 908a22b62697fcb6c943527492158729dc762f10
 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,13 +538,12 @@ 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 %s",
+                    fmt!("`%s` moved here because it has type `%s`, \
+                          which is moved by default (use `copy` to override)",
                          self.loan_path_to_str(moved_lp),
-                         expr_ty.user_string(self.tcx), suggestion));
+                         expr_ty.user_string(self.tcx)));
             }
 
             move_data::MovePat(pat) => {
@@ -558,28 +557,12 @@ 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 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,
+                    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)));
             }
         }
     }

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

@@ -510,6 +510,13 @@ 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,
@@ -3554,23 +3561,7 @@ impl Resolver {
 
                     // Resolve derived traits.
                     for traits.iter().advance |trt| {
-                        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);
-                            }
-                        }
+                        self.resolve_trait_reference(*trt, visitor, TraitDerivation);
                     }
 
                     for (*methods).iter().advance |method| {
@@ -3821,22 +3812,31 @@ impl Resolver {
                                         visitor: ResolveVisitor) {
         match *type_parameter_bound {
             TraitTyParamBound(tref) => {
-                self.resolve_trait_reference(tref, visitor)
+                self.resolve_trait_reference(tref, visitor, TraitBoundingTypeParameter)
             }
             RegionTyParamBound => {}
         }
     }
 
     pub fn resolve_trait_reference(@mut self,
                                    trait_reference: &trait_ref,
-                                   visitor: ResolveVisitor) {
+                                   visitor: ResolveVisitor,
+                                   reference_type: TraitReferenceType) {
         match self.resolve_path(trait_reference.path, TypeNS, true, visitor) {
             None => {
-                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));
+                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);
             }
             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);
+                    self.resolve_trait_reference(trait_reference, visitor, TraitImplementation);
 
                     // Record the current set of trait references.
                     let mut new_trait_refs = ~[];

branches/dist-snap/src/test/compile-fail/moves-based-on-type-tuple.rs renamed to branches/dist-snap/src/test/compile-fail/move-based-on-type-tuple.rs

@@ -0,0 +1,20 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+
+trait NewTrait : SomeNonExistentTrait {}
+//~^ ERROR attempt to derive a nonexistent trait `SomeNonExistentTrait`
+
+impl SomeNonExistentTrait for int {}
+//~^ ERROR attempt to implement a nonexistent trait `SomeNonExistentTrait`
+
+fn f<T:SomeNonExistentTrait>() {}
+//~^ ERROR attempt to bound type parameter with a nonexistent trait `SomeNonExistentTrait`
+