---

yaml
---
r: 232829
b: refs/heads/try
c: 8ae2b1d
h: refs/heads/master
i:
  232827: 772787c
v: v3

Author: AlisdairO

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: edeb4f1c86cbf6af8ef9874d4b3af50f721ea1b8
 refs/heads/snap-stage3: 1af31d4974e33027a68126fa5a5a3c2c6491824f
-refs/heads/try: f3f23bf9c5ee16dab8c25bb5d301d689fbbe0cf1
+refs/heads/try: 8ae2b1d7dd9e25b09439d6494a3a9d2540c08dbf
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try/src/librustc/diagnostics.rs

@@ -1487,26 +1487,6 @@ fn main() {
 ```
 "##,
 
-E0281: r##"
-You tried to supply a type which doesn't implement some trait in a location
-which expected that trait. This error typically occurs when working with
-`Fn`-based types. Erroneous code example:
-
-```
-fn foo<F: Fn()>(x: F) { }
-
-fn main() {
-    // type mismatch: the type ... implements the trait `core::ops::Fn<(_,)>`,
-    // but the trait `core::ops::Fn<()>` is required (expected (), found tuple
-    // [E0281]
-    foo(|y| { });
-}
-```
-
-The issue in this case is that `foo` is defined as accepting a `Fn` with no
-arguments, but the closure we attempted to pass to it requires one argument.
-"##,
-
 E0282: r##"
 This error indicates that type inference did not result in one unique possible
 type, and extra information is required. In most cases this can be provided
@@ -1887,6 +1867,7 @@ register_diagnostics! {
     E0278, // requirement is not satisfied
     E0279, // requirement is not satisfied
     E0280, // requirement is not satisfied
+    E0281, // type implements trait but other trait is required
     E0283, // cannot resolve type
     E0284, // cannot resolve type
     E0285, // overflow evaluation builtin bounds

branches/try/src/librustc/plugin/registry.rs

@@ -145,6 +145,11 @@ impl<'a> Registry<'a> {
     /// `Whitelisted` attributes will additionally not trigger the `unused_attribute`
     /// lint. `CrateLevel` attributes will not be allowed on anything other than a crate.
     pub fn register_attribute(&mut self, name: String, ty: AttributeType) {
+        if let AttributeType::Gated(..) = ty {
+            self.sess.span_err(self.krate_span, "plugin tried to register a gated \
+                                                 attribute. Only `Normal`, `Whitelisted`, \
+                                                 and `CrateLevel` attributes are allowed");
+        }
         self.attributes.push((name, ty));
     }
 }

branches/try/src/librustc_lint/builtin.rs

@@ -887,9 +887,10 @@ impl LintPass for UnusedAttributes {
 
     fn check_attribute(&mut self, cx: &Context, attr: &ast::Attribute) {
         // Note that check_name() marks the attribute as used if it matches.
-        for &(ref name, ty, _) in KNOWN_ATTRIBUTES {
+        for &(ref name, ty) in KNOWN_ATTRIBUTES {
             match ty {
-                AttributeType::Whitelisted if attr.check_name(name) => {
+                AttributeType::Whitelisted
+                | AttributeType::Gated(_, _) if attr.check_name(name) => {
                     break;
                 },
                 _ => ()
@@ -906,11 +907,8 @@ impl LintPass for UnusedAttributes {
         if !attr::is_used(attr) {
             cx.span_lint(UNUSED_ATTRIBUTES, attr.span, "unused attribute");
             // Is it a builtin attribute that must be used at the crate level?
-            let known_crate = KNOWN_ATTRIBUTES.iter().find(|&&(name, ty, _)| {
-                attr.name() == name &&
-                ty == AttributeType::CrateLevel
-            }).is_some();
-
+            let known_crate = KNOWN_ATTRIBUTES.contains(&(&attr.name(),
+                                                          AttributeType::CrateLevel));
             // Has a plugin registered this attribute as one which must be used at
             // the crate level?
             let plugin_crate = plugin_attributes.iter()

branches/try/src/librustc_typeck/diagnostics.rs

@@ -1642,6 +1642,26 @@ static BAR: _ = "test"; // error, explicitly write out the type instead
 ```
 "##,
 
+E0122: r##"
+An attempt was made to add a generic constraint to a type alias. While Rust will
+allow this with a warning, it will not currently enforce the constraint.
+Consider the example below:
+
+```
+trait Foo{}
+
+type MyType<R: Foo> = (R, ());
+
+fn main() {
+    let t: MyType<u32>;
+}
+```
+
+We're able to declare a variable of type `MyType<u32>`, despite the fact that
+`u32` does not implement `Foo`. As a result, one should avoid using generic
+constraints in concert with type aliases.
+"##,
+
 E0124: r##"
 You declared two fields of a struct with the same name. Erroneous code
 example:
@@ -3010,7 +3030,6 @@ register_diagnostics! {
     E0103, // @GuillaumeGomez: I was unable to get this error, try your best!
     E0104,
     E0118,
-    E0122,
 //  E0123,
 //  E0127,
 //  E0129,

branches/try/src/libsyntax/ext/deriving/bounds.rs

@@ -40,7 +40,6 @@ pub fn expand_deriving_copy(cx: &mut ExtCtxt,
         path: path,
         additional_bounds: Vec::new(),
         generics: LifetimeBounds::empty(),
-        is_unsafe: false,
         methods: Vec::new(),
         associated_types: Vec::new(),
     };

branches/try/src/libsyntax/ext/deriving/clone.rs

@@ -31,7 +31,6 @@ pub fn expand_deriving_clone(cx: &mut ExtCtxt,
         path: path_std!(cx, core::clone::Clone),
         additional_bounds: Vec::new(),
         generics: LifetimeBounds::empty(),
-        is_unsafe: false,
         methods: vec!(
             MethodDef {
                 name: "clone",

branches/try/src/libsyntax/ext/deriving/cmp/eq.rs

@@ -51,7 +51,6 @@ pub fn expand_deriving_eq(cx: &mut ExtCtxt,
         path: path_std!(cx, core::cmp::Eq),
         additional_bounds: Vec::new(),
         generics: LifetimeBounds::empty(),
-        is_unsafe: false,
         methods: vec!(
             MethodDef {
                 name: "assert_receiver_is_total_eq",

branches/try/src/libsyntax/ext/deriving/cmp/ord.rs

@@ -32,7 +32,6 @@ pub fn expand_deriving_ord(cx: &mut ExtCtxt,
         path: path_std!(cx, core::cmp::Ord),
         additional_bounds: Vec::new(),
         generics: LifetimeBounds::empty(),
-        is_unsafe: false,
         methods: vec!(
             MethodDef {
                 name: "cmp",

branches/try/src/libsyntax/ext/deriving/cmp/partial_eq.rs

@@ -85,7 +85,6 @@ pub fn expand_deriving_partial_eq(cx: &mut ExtCtxt,
         path: path_std!(cx, core::cmp::PartialEq),
         additional_bounds: Vec::new(),
         generics: LifetimeBounds::empty(),
-        is_unsafe: false,
         methods: vec!(
             md!("eq", cs_eq),
             md!("ne", cs_ne)

branches/try/src/libsyntax/ext/deriving/cmp/partial_ord.rs

@@ -73,7 +73,6 @@ pub fn expand_deriving_partial_ord(cx: &mut ExtCtxt,
         path: path_std!(cx, core::cmp::PartialOrd),
         additional_bounds: vec![],
         generics: LifetimeBounds::empty(),
-        is_unsafe: false,
         methods: vec![
             partial_cmp_def,
             md!("lt", true, false),

branches/try/src/libsyntax/ext/deriving/decodable.rs

@@ -59,7 +59,6 @@ fn expand_deriving_decodable_imp(cx: &mut ExtCtxt,
         path: Path::new_(vec!(krate, "Decodable"), None, vec!(), true),
         additional_bounds: Vec::new(),
         generics: LifetimeBounds::empty(),
-        is_unsafe: false,
         methods: vec!(
             MethodDef {
                 name: "decode",

branches/try/src/libsyntax/ext/deriving/default.rs

@@ -31,7 +31,6 @@ pub fn expand_deriving_default(cx: &mut ExtCtxt,
         path: path_std!(cx, core::default::Default),
         additional_bounds: Vec::new(),
         generics: LifetimeBounds::empty(),
-        is_unsafe: false,
         methods: vec!(
             MethodDef {
                 name: "default",

branches/try/src/libsyntax/ext/deriving/encodable.rs

@@ -135,7 +135,6 @@ fn expand_deriving_encodable_imp(cx: &mut ExtCtxt,
         path: Path::new_(vec!(krate, "Encodable"), None, vec!(), true),
         additional_bounds: Vec::new(),
         generics: LifetimeBounds::empty(),
-        is_unsafe: false,
         methods: vec!(
             MethodDef {
                 name: "encode",

branches/try/src/libsyntax/ext/deriving/generic/mod.rs

@@ -229,9 +229,6 @@ pub struct TraitDef<'a> {
     /// Any extra lifetimes and/or bounds, e.g. `D: serialize::Decoder`
     pub generics: LifetimeBounds<'a>,
 
-    /// Is it an `unsafe` trait?
-    pub is_unsafe: bool,
-
     pub methods: Vec<MethodDef<'a>>,
 
     pub associated_types: Vec<(ast::Ident, Ty<'a>)>,
@@ -628,18 +625,11 @@ impl<'a> TraitDef<'a> {
                                            InternedString::new("unused_qualifications"))]));
         let mut a = vec![attr, unused_qual];
         a.extend(self.attributes.iter().cloned());
-
-        let unsafety = if self.is_unsafe {
-            ast::Unsafety::Unsafe
-        } else {
-            ast::Unsafety::Normal
-        };
-
         cx.item(
             self.span,
             ident,
             a,
-            ast::ItemImpl(unsafety,
+            ast::ItemImpl(ast::Unsafety::Normal,
                           ast::ImplPolarity::Positive,
                           trait_generics,
                           opt_trait_ref,

branches/try/src/libsyntax/ext/deriving/hash.rs

@@ -32,7 +32,6 @@ pub fn expand_deriving_hash(cx: &mut ExtCtxt,
         path: path,
         additional_bounds: Vec::new(),
         generics: LifetimeBounds::empty(),
-        is_unsafe: false,
         methods: vec!(
             MethodDef {
                 name: "hash",

branches/try/src/libsyntax/ext/deriving/primitive.rs

@@ -32,7 +32,6 @@ pub fn expand_deriving_from_primitive(cx: &mut ExtCtxt,
         path: path_std!(cx, core::num::FromPrimitive),
         additional_bounds: Vec::new(),
         generics: LifetimeBounds::empty(),
-        is_unsafe: false,
         methods: vec!(
             MethodDef {
                 name: "from_i64",

branches/try/src/libsyntax/ext/deriving/show.rs

@@ -34,7 +34,6 @@ pub fn expand_deriving_show(cx: &mut ExtCtxt,
         path: path_std!(cx, core::fmt::Debug),
         additional_bounds: Vec::new(),
         generics: LifetimeBounds::empty(),
-        is_unsafe: false,
         methods: vec![
             MethodDef {
                 name: "fmt",