---

yaml
---
r: 232453
b: refs/heads/try
c: c8b6d5b
h: refs/heads/master
i:
  232451: 1b64ffc
v: v3

Author: huonw

[refs]

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

branches/try/src/librustc/middle/ty.rs

@@ -3312,10 +3312,10 @@ impl<'tcx, 'container> AdtDefData<'tcx, 'container> {
            variants: Vec<VariantDefData<'tcx, 'container>>) -> Self {
         let mut flags = AdtFlags::NO_ADT_FLAGS;
         let attrs = tcx.get_attrs(did);
-        if attrs.iter().any(|item| item.check_name("fundamental")) {
+        if attr::contains_name(&attrs, "fundamental") {
             flags = flags | AdtFlags::IS_FUNDAMENTAL;
         }
-        if attrs.iter().any(|item| item.check_name("simd")) {
+        if tcx.lookup_simd(did) {
             flags = flags | AdtFlags::IS_SIMD;
         }
         if Some(did) == tcx.lang_items.phantom_data() {
@@ -6116,6 +6116,7 @@ impl<'tcx> ctxt<'tcx> {
     /// Determine whether an item is annotated with `#[simd]`
     pub fn lookup_simd(&self, did: DefId) -> bool {
         self.has_attr(did, "simd")
+            || self.lookup_repr_hints(did).contains(&attr::ReprSimd)
     }
 
     /// Obtain the representation annotation for a struct definition.

branches/try/src/librustc_trans/trans/adt.rs

@@ -615,6 +615,9 @@ fn range_to_inttype(cx: &CrateContext, hint: Hint, bounds: &IntBounds) -> IntTyp
         attr::ReprPacked => {
             cx.tcx().sess.bug("range_to_inttype: found ReprPacked on an enum");
         }
+        attr::ReprSimd => {
+            cx.tcx().sess.bug("range_to_inttype: found ReprSimd on an enum");
+        }
     }
     for &ity in attempts {
         if bounds_usable(cx, ity, bounds) {

branches/try/src/librustc_typeck/check/_match.rs

@@ -528,31 +528,60 @@ pub fn check_pat_struct<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, pat: &'tcx ast::Pat,
     let tcx = pcx.fcx.ccx.tcx;
 
     let def = tcx.def_map.borrow().get(&pat.id).unwrap().full_def();
-    let variant = match fcx.def_struct_variant(def) {
-        Some((_, variant)) => variant,
-        None => {
+    let (adt_def, variant) = match def {
+        def::DefTrait(_) => {
             let name = pprust::path_to_string(path);
-            span_err!(tcx.sess, pat.span, E0163,
-                      "`{}` does not name a struct or a struct variant", name);
+            span_err!(tcx.sess, pat.span, E0168,
+                "use of trait `{}` in a struct pattern", name);
             fcx.write_error(pat.id);
 
             for field in fields {
-                check_pat(pcx, &field.node.pat, tcx.types.err);
+                check_pat(pcx, &*field.node.pat, tcx.types.err);
             }
             return;
+        },
+        _ => {
+            let def_type = tcx.lookup_item_type(def.def_id());
+            match def_type.ty.sty {
+                ty::TyStruct(struct_def, _) =>
+                    (struct_def, struct_def.struct_variant()),
+                ty::TyEnum(enum_def, _)
+                    if def == def::DefVariant(enum_def.did, def.def_id(), true) =>
+                    (enum_def, enum_def.variant_of_def(def)),
+                _ => {
+                    let name = pprust::path_to_string(path);
+                    span_err!(tcx.sess, pat.span, E0163,
+                        "`{}` does not name a struct or a struct variant", name);
+                    fcx.write_error(pat.id);
+
+                    for field in fields {
+                        check_pat(pcx, &*field.node.pat, tcx.types.err);
+                    }
+                    return;
+                }
+            }
         }
     };
 
-    let pat_ty = pcx.fcx.instantiate_type(def.def_id(), path);
-    let item_substs = match pat_ty.sty {
-        ty::TyStruct(_, substs) | ty::TyEnum(_, substs) => substs,
-        _ => tcx.sess.span_bug(pat.span, "struct variant is not an ADT")
-    };
+    instantiate_path(pcx.fcx,
+                     &path.segments,
+                     adt_def.type_scheme(tcx),
+                     &adt_def.predicates(tcx),
+                     None,
+                     def,
+                     pat.span,
+                     pat.id);
+
+    let pat_ty = fcx.node_ty(pat.id);
     demand::eqtype(fcx, pat.span, expected, pat_ty);
-    check_struct_pat_fields(pcx, pat.span, fields, variant, &item_substs, etc);
 
-    fcx.write_ty(pat.id, pat_ty);
-    fcx.write_substs(pat.id, ty::ItemSubsts { substs: item_substs.clone() });
+    let item_substs = fcx
+        .item_substs()
+        .get(&pat.id)
+        .map(|substs| substs.substs.clone())
+        .unwrap_or_else(|| Substs::empty());
+
+    check_struct_pat_fields(pcx, pat.span, fields, variant, &item_substs, etc);
 }
 
 pub fn check_pat_enum<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>,