---

yaml
---
r: 38783
b: refs/heads/incoming
c: d6b3d65
h: refs/heads/master
i:
  38781: 040fdb4
  38779: 7317c27
  38775: 8758126
  38767: 7062199
  38751: 311a76a
  38719: 774bb48
  38655: 2107ed0
v: v3

Author: pcwalton

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 3d5418789064fdb463e872a4e651af1c628a3650
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278
-refs/heads/incoming: 588ea599927d62a04c12ccca87196ca415b86274
+refs/heads/incoming: d6b3d65010d08b570a1d926de31218121c193f92
 refs/heads/dist-snap: 22efa39382d41b084fde1719df7ae8ce5697d8c9
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/src/rustc/middle/mem_categorization.rs

@@ -464,7 +464,7 @@ impl &mem_categorization_ctxt {
             }
 
             let base_cmt = self.cat_expr(base);
-            self.cat_field(expr, base_cmt, f_name, expr.id)
+            self.cat_field(expr, base_cmt, f_name)
           }
 
           ast::expr_index(base, _) => {
@@ -632,14 +632,9 @@ impl &mem_categorization_ctxt {
         }
     }
 
-    /// The `field_id` parameter is the ID of the enclosing expression or
-    /// pattern. It is used to determine which variant of an enum is in use.
-    fn cat_field<N:ast_node>(node: N,
-                             base_cmt: cmt,
-                             f_name: ast::ident,
-                             field_id: ast::node_id) -> cmt {
-        let f_mutbl = match field_mutbl(self.tcx, base_cmt.ty, f_name,
-                                        field_id) {
+    fn cat_field<N:ast_node>(node: N, base_cmt: cmt,
+                             f_name: ast::ident) -> cmt {
+        let f_mutbl = match field_mutbl(self.tcx, base_cmt.ty, f_name) {
           Some(f_mutbl) => f_mutbl,
           None => {
             self.tcx.sess.span_bug(
@@ -856,15 +851,15 @@ impl &mem_categorization_ctxt {
           ast::pat_rec(field_pats, _) => {
             // {f1: p1, ..., fN: pN}
             for field_pats.each |fp| {
-                let cmt_field = self.cat_field(fp.pat, cmt, fp.ident, pat.id);
+                let cmt_field = self.cat_field(fp.pat, cmt, fp.ident);
                 self.cat_pattern(cmt_field, fp.pat, op);
             }
           }
 
           ast::pat_struct(_, field_pats, _) => {
             // {f1: p1, ..., fN: pN}
             for field_pats.each |fp| {
-                let cmt_field = self.cat_field(fp.pat, cmt, fp.ident, pat.id);
+                let cmt_field = self.cat_field(fp.pat, cmt, fp.ident);
                 self.cat_pattern(cmt_field, fp.pat, op);
             }
           }
@@ -1003,13 +998,9 @@ impl &mem_categorization_ctxt {
     }
 }
 
-/// The node_id here is the node of the expression that references the field.
-/// This function looks it up in the def map in case the type happens to be
-/// an enum to determine which variant is in use.
 fn field_mutbl(tcx: ty::ctxt,
                base_ty: ty::t,
-               f_name: ast::ident,
-               node_id: ast::node_id) -> Option<ast::mutability> {
+               f_name: ast::ident) -> Option<ast::mutability> {
     // Need to refactor so that records/class fields can be treated uniformly.
     match ty::get(base_ty).sty {
       ty::ty_rec(fields) => {
@@ -1030,22 +1021,6 @@ fn field_mutbl(tcx: ty::ctxt,
             }
         }
       }
-      ty::ty_enum(*) => {
-        match tcx.def_map.get(node_id) {
-          ast::def_variant(_, variant_id) => {
-            for ty::lookup_class_fields(tcx, variant_id).each |fld| {
-                if fld.ident == f_name {
-                    let m = match fld.mutability {
-                      ast::class_mutable => ast::m_mutbl,
-                      ast::class_immutable => ast::m_imm
-                    };
-                    return Some(m);
-                }
-            }
-          }
-          _ => {}
-        }
-      }
       _ => { }
     }
 

branches/incoming/src/rustc/middle/privacy.rs

@@ -239,31 +239,6 @@ fn check_crate(tcx: ty::ctxt, method_map: &method_map, crate: @ast::crate) {
                                 }
                             }
                         }
-                        ty_enum(enum_id, _) => {
-                            if enum_id.crate != local_crate ||
-                                    !privileged_items.contains(
-                                        &enum_id.node) {
-                                match tcx.def_map.find(pattern.id) {
-                                    Some(def_variant(_, variant_id)) => {
-                                        for fields.each |field| {
-                                            debug!("(privacy checking) \
-                                                    checking field in \
-                                                    struct variant pattern");
-                                            check_field(pattern.span,
-                                                        variant_id,
-                                                        field.ident);
-                                        }
-                                    }
-                                    _ => {
-                                        tcx.sess.span_bug(pattern.span,
-                                                          ~"resolve didn't \
-                                                            map enum struct \
-                                                            pattern to a \
-                                                            variant def");
-                                    }
-                                }
-                            }
-                        }
                         _ => {
                             tcx.sess.span_bug(pattern.span,
                                               ~"struct pattern didn't have \

branches/incoming/src/rustc/middle/typeck/check/alt.rs

@@ -186,139 +186,6 @@ fn check_pat_variant(pcx: pat_ctxt, pat: @ast::pat, path: @ast::path,
     }
 }
 
-/// `path` is the AST path item naming the type of this struct.
-/// `fields` is the field patterns of the struct pattern.
-/// `class_fields` describes the type of each field of the struct.
-/// `class_id` is the ID of the struct.
-/// `substitutions` are the type substitutions applied to this struct type
-/// (e.g. K,V in HashMap<K,V>).
-/// `etc` is true if the pattern said '...' and false otherwise.
-fn check_struct_pat_fields(pcx: pat_ctxt,
-                           span: span,
-                           path: @ast::path,
-                           fields: ~[ast::field_pat],
-                           class_fields: ~[ty::field_ty],
-                           class_id: ast::def_id,
-                           substitutions: &ty::substs,
-                           etc: bool) {
-    let tcx = pcx.fcx.ccx.tcx;
-
-    // Index the class fields.
-    let field_map = std::map::HashMap();
-    for class_fields.eachi |i, class_field| {
-        field_map.insert(class_field.ident, i);
-    }
-
-    // Typecheck each field.
-    let found_fields = std::map::HashMap();
-    for fields.each |field| {
-        match field_map.find(field.ident) {
-            Some(index) => {
-                let class_field = class_fields[index];
-                let field_type = ty::lookup_field_type(tcx,
-                                                       class_id,
-                                                       class_field.id,
-                                                       substitutions);
-                check_pat(pcx, field.pat, field_type);
-                found_fields.insert(index, ());
-            }
-            None => {
-                let name = pprust::path_to_str(path, tcx.sess.intr());
-                tcx.sess.span_err(span,
-                                  fmt!("struct `%s` does not have a field
-                                        named `%s`", name,
-                                       tcx.sess.str_of(field.ident)));
-            }
-        }
-    }
-
-    // Report an error if not all the fields were specified.
-    if !etc {
-        for class_fields.eachi |i, field| {
-            if found_fields.contains_key(i) {
-                loop;
-            }
-            tcx.sess.span_err(span,
-                              fmt!("pattern does not mention field `%s`",
-                                   tcx.sess.str_of(field.ident)));
-        }
-    }
-}
-
-fn check_struct_pat(pcx: pat_ctxt, pat_id: ast::node_id, span: span,
-                    expected: ty::t, path: @ast::path,
-                    fields: ~[ast::field_pat], etc: bool,
-                    class_id: ast::def_id, substitutions: &ty::substs) {
-    let fcx = pcx.fcx;
-    let tcx = pcx.fcx.ccx.tcx;
-
-    let class_fields = ty::lookup_class_fields(tcx, class_id);
-
-    // Check to ensure that the struct is the one specified.
-    match tcx.def_map.find(pat_id) {
-        Some(ast::def_class(supplied_def_id))
-                if supplied_def_id == class_id => {
-            // OK.
-        }
-        Some(ast::def_class(*)) | Some(ast::def_variant(*)) => {
-            let name = pprust::path_to_str(path, tcx.sess.intr());
-            tcx.sess.span_err(span,
-                              fmt!("mismatched types: expected `%s` but \
-                                    found `%s`",
-                                   fcx.infcx().ty_to_str(expected),
-                                   name));
-        }
-        _ => {
-            tcx.sess.span_bug(span, ~"resolve didn't write in class");
-        }
-    }
-
-    // Forbid pattern-matching structs with destructors.
-    if ty::has_dtor(tcx, class_id) {
-        tcx.sess.span_err(span, ~"deconstructing struct not allowed in \
-                                  pattern (it has a destructor)");
-    }
-
-    check_struct_pat_fields(pcx, span, path, fields, class_fields, class_id,
-                            substitutions, etc);
-}
-
-fn check_struct_like_enum_variant_pat(pcx: pat_ctxt,
-                                      pat_id: ast::node_id,
-                                      span: span,
-                                      expected: ty::t,
-                                      path: @ast::path,
-                                      fields: ~[ast::field_pat],
-                                      etc: bool,
-                                      enum_id: ast::def_id,
-                                      substitutions: &ty::substs) {
-    let fcx = pcx.fcx;
-    let tcx = pcx.fcx.ccx.tcx;
-
-    // Find the variant that was specified.
-    match tcx.def_map.find(pat_id) {
-        Some(ast::def_variant(found_enum_id, variant_id))
-                if found_enum_id == enum_id => {
-            // Get the struct fields from this struct-like enum variant.
-            let class_fields = ty::lookup_class_fields(tcx, variant_id);
-
-            check_struct_pat_fields(pcx, span, path, fields, class_fields,
-                                    variant_id, substitutions, etc);
-        }
-        Some(ast::def_class(*)) | Some(ast::def_variant(*)) => {
-            let name = pprust::path_to_str(path, tcx.sess.intr());
-            tcx.sess.span_err(span,
-                              fmt!("mismatched types: expected `%s` but \
-                                    found `%s`",
-                                   fcx.infcx().ty_to_str(expected),
-                                   name));
-        }
-        _ => {
-            tcx.sess.span_bug(span, ~"resolve didn't write in variant");
-        }
-    }
-}
-
 // Pattern checking is top-down rather than bottom-up so that bindings get
 // their types immediately.
 fn check_pat(pcx: pat_ctxt, pat: @ast::pat, expected: ty::t) {
@@ -439,16 +306,13 @@ fn check_pat(pcx: pat_ctxt, pat: @ast::pat, expected: ty::t) {
       }
       ast::pat_struct(path, fields, etc) => {
         // Grab the class data that we care about.
+        let class_fields, class_id, substitutions;
         let structure = structure_of(fcx, pat.span, expected);
         match structure {
             ty::ty_class(cid, ref substs) => {
-                check_struct_pat(pcx, pat.id, pat.span, expected, path,
-                                 fields, etc, cid, substs);
-            }
-            ty::ty_enum(eid, ref substs) => {
-                check_struct_like_enum_variant_pat(
-                    pcx, pat.id, pat.span, expected, path, fields, etc, eid,
-                    substs);
+                class_id = cid;
+                substitutions = substs;
+                class_fields = ty::lookup_class_fields(tcx, class_id);
             }
             _ => {
                 // XXX: This should not be fatal.
@@ -459,6 +323,72 @@ fn check_pat(pcx: pat_ctxt, pat: @ast::pat, expected: ty::t) {
             }
         }
 
+        // Check to ensure that the struct is the one specified.
+        match tcx.def_map.get(pat.id) {
+            ast::def_class(supplied_def_id)
+                    if supplied_def_id == class_id => {
+                // OK.
+            }
+            ast::def_class(*) => {
+                let name = pprust::path_to_str(path, tcx.sess.intr());
+                tcx.sess.span_err(pat.span,
+                                  fmt!("mismatched types: expected `%s` but \
+                                        found `%s`",
+                                       fcx.infcx().ty_to_str(expected),
+                                       name));
+            }
+            _ => {
+                tcx.sess.span_bug(pat.span, ~"resolve didn't write in class");
+            }
+        }
+
+        // Forbid pattern-matching structs with destructors.
+        if ty::has_dtor(tcx, class_id) {
+            tcx.sess.span_err(pat.span, ~"deconstructing struct not allowed \
+                                          in pattern (it has a destructor)");
+        }
+
+        // Index the class fields.
+        let field_map = std::map::HashMap();
+        for class_fields.eachi |i, class_field| {
+            field_map.insert(class_field.ident, i);
+        }
+
+        // Typecheck each field.
+        let found_fields = std::map::HashMap();
+        for fields.each |field| {
+            match field_map.find(field.ident) {
+                Some(index) => {
+                    let class_field = class_fields[index];
+                    let field_type = ty::lookup_field_type(tcx,
+                                                           class_id,
+                                                           class_field.id,
+                                                           substitutions);
+                    check_pat(pcx, field.pat, field_type);
+                    found_fields.insert(index, ());
+                }
+                None => {
+                    let name = pprust::path_to_str(path, tcx.sess.intr());
+                    tcx.sess.span_err(pat.span,
+                                      fmt!("struct `%s` does not have a field
+                                            named `%s`", name,
+                                           tcx.sess.str_of(field.ident)));
+                }
+            }
+        }
+
+        // Report an error if not all the fields were specified.
+        if !etc {
+            for class_fields.eachi |i, field| {
+                if found_fields.contains_key(i) {
+                    loop;
+                }
+                tcx.sess.span_err(pat.span,
+                                  fmt!("pattern does not mention field `%s`",
+                                       tcx.sess.str_of(field.ident)));
+            }
+        }
+
         // Finally, write in the type.
         fcx.write_ty(pat.id, expected);
       }