librustc: Remove structural record types from the compiler

Author: pcwalton

src/librustc/metadata/tydecode.rs

@@ -299,16 +299,6 @@ fn parse_ty(st: @mut PState, conv: conv_did) -> ty::t {
         let v = parse_vstore(st);
         return ty::mk_estr(st.tcx, v);
       }
-      'R' => {
-        assert (next(st) == '[');
-        let mut fields: ~[ty::field] = ~[];
-        while peek(st) != ']' {
-            let name = st.tcx.sess.ident_of(parse_str(st, '='));
-            fields.push(ty::field { ident: name, mt: parse_mt(st, conv) });
-        }
-        st.pos = st.pos + 1u;
-        return ty::mk_rec(st.tcx, fields);
-      }
       'T' => {
         assert (next(st) == '[');
         let mut params = ~[];

src/librustc/metadata/tyencode.rs

@@ -283,15 +283,6 @@ fn enc_sty(w: io::Writer, cx: @ctxt, +st: ty::sty) {
         enc_vstore(w, cx, v);
       }
       ty::ty_unboxed_vec(mt) => { w.write_char('U'); enc_mt(w, cx, mt); }
-      ty::ty_rec(fields) => {
-        w.write_str(&"R[");
-        for fields.each |field| {
-            w.write_str(*cx.tcx.sess.str_of(field.ident));
-            w.write_char('=');
-            enc_mt(w, cx, field.mt);
-        }
-        w.write_char(']');
-      }
       ty::ty_closure(ref f) => {
         w.write_char('f');
         enc_closure_ty(w, cx, f);

src/librustc/middle/check_match.rs

@@ -352,7 +352,7 @@ pub fn missing_ctor(cx: @MatchCheckCtxt,
                  -> Option<ctor> {
     match ty::get(left_ty).sty {
       ty::ty_box(_) | ty::ty_uniq(_) | ty::ty_rptr(*) | ty::ty_tup(_) |
-      ty::ty_rec(_) | ty::ty_struct(*) => {
+      ty::ty_struct(*) => {
         for m.each |r| {
             if !is_wild(cx, r[0]) { return None; }
         }
@@ -449,7 +449,6 @@ pub fn missing_ctor(cx: @MatchCheckCtxt,
 pub fn ctor_arity(cx: @MatchCheckCtxt, ctor: ctor, ty: ty::t) -> uint {
     match /*bad*/copy ty::get(ty).sty {
       ty::ty_tup(fs) => fs.len(),
-      ty::ty_rec(fs) => fs.len(),
       ty::ty_box(_) | ty::ty_uniq(_) | ty::ty_rptr(*) => 1u,
       ty::ty_enum(eid, _) => {
           let id = match ctor { variant(id) => id,
@@ -548,19 +547,7 @@ pub fn specialize(cx: @MatchCheckCtxt,
                     _ => None
                 }
             }
-            pat_rec(ref flds, _) => {
-                let ty_flds = match /*bad*/copy ty::get(left_ty).sty {
-                    ty::ty_rec(flds) => flds,
-                    _ => fail!(~"bad type for pat_rec")
-                };
-                let args = vec::map(ty_flds, |ty_fld| {
-                    match flds.find(|f| f.ident == ty_fld.ident) {
-                        Some(f) => f.pat,
-                        _ => wild()
-                    }
-                });
-                Some(vec::append(args, vec::from_slice(r.tail())))
-            }
+            pat_rec(ref flds, _) => fail!(),
             pat_struct(_, ref flds, _) => {
                 // Is this a struct or an enum variant?
                 match cx.tcx.def_map.get(&pat_id) {

src/librustc/middle/mem_categorization.rs

@@ -1114,15 +1114,8 @@ pub fn field_mutbl(tcx: ty::ctxt,
                    f_name: ast::ident,
                    node_id: ast::node_id)
                 -> Option<ast::mutability> {
-    // Need to refactor so that records/class fields can be treated uniformly.
+    // Need to refactor so that struct/enum fields can be treated uniformly.
     match /*bad*/copy ty::get(base_ty).sty {
-      ty::ty_rec(fields) => {
-        for fields.each |f| {
-            if f.ident == f_name {
-                return Some(f.mt.mutbl);
-            }
-        }
-      }
       ty::ty_struct(did, _) => {
         for ty::lookup_struct_fields(tcx, did).each |fld| {
             if fld.ident == f_name {

src/librustc/middle/moves.rs

@@ -480,7 +480,6 @@ pub impl VisitContext {
                     // then `with` is consumed, otherwise it is only read
                     let with_ty = ty::expr_ty(self.tcx, *with_expr);
                     let with_fields = match ty::get(with_ty).sty {
-                        ty::ty_rec(ref f) => copy *f,
                         ty::ty_struct(did, ref substs) => {
                             ty::struct_fields(self.tcx, did, substs)
                         }

src/librustc/middle/region.rs

@@ -729,12 +729,6 @@ pub fn determine_rp_in_ty(ty: @ast::Ty,
         visit_mt(mt, cx, visitor);
       }
 
-      ast::ty_rec(ref fields) => {
-        for (*fields).each |field| {
-            visit_mt(field.node.mt, cx, visitor);
-        }
-      }
-
       ast::ty_path(path, _) => {
         // type parameters are---for now, anyway---always invariant
         do cx.with_ambient_variance(rv_invariant) {

src/librustc/middle/trans/adt.rs

@@ -11,10 +11,10 @@
 /*!
  * # Representation of Algebraic Data Types
  *
- * This module determines how to represent enums, structs, tuples, and
- * (deprecated) structural records based on their monomorphized types;
- * it is responsible both for choosing a representation and
- * translating basic operations on values of those types.
+ * This module determines how to represent enums, structs, and tuples
+ * based on their monomorphized types; it is responsible both for
+ * choosing a representation and translating basic operations on
+ * values of those types.
  *
  * Note that the interface treats everything as a general case of an
  * enum, so structs/tuples/etc. have one pseudo-variant with
@@ -131,11 +131,6 @@ pub fn represent_type(cx: @CrateContext, t: ty::t) -> @Repr {
         ty::ty_tup(ref elems) => {
             Univariant(mk_struct(cx, *elems), NonStruct)
         }
-        ty::ty_rec(ref fields) => {
-            // XXX: Are these in the right order?
-            Univariant(mk_struct(cx, fields.map(|f| f.mt.ty)),
-                       StructWithoutDtor)
-        }
         ty::ty_struct(def_id, ref substs) => {
             let fields = ty::lookup_struct_fields(cx.tcx, def_id);
             let dt = ty::ty_dtor(cx.tcx, def_id).is_present();

src/librustc/middle/trans/base.rs

@@ -639,7 +639,7 @@ pub fn iter_structural_ty(cx: block, av: ValueRef, t: ty::t,
 
     let mut cx = cx;
     match /*bad*/copy ty::get(t).sty {
-      ty::ty_rec(*) | ty::ty_struct(*) => {
+      ty::ty_struct(*) => {
           let repr = adt::represent_type(cx.ccx(), t);
           do expr::with_field_tys(cx.tcx(), t, None) |discr, field_tys| {
               for vec::eachi(field_tys) |i, field_ty| {

src/librustc/middle/trans/debuginfo.rs

@@ -473,33 +473,6 @@ fn add_member(cx: @mut StructCtxt,
     cx.total_size += size * 8;
 }
 
-fn create_record(cx: @CrateContext, t: ty::t, fields: ~[ast::ty_field],
-                 span: span) -> @Metadata<TyDescMetadata> {
-    let fname = filename_from_span(cx, span);
-    let file_node = create_file(cx, fname);
-    let scx = create_structure(file_node,
-                               cx.sess.str_of(
-                                   ((/*bad*/copy cx.dbg_cx).get().names)
-                                   (~"rec")),
-                               line_from_span(cx.sess.codemap,
-                                              span) as int);
-    for fields.each |field| {
-        let field_t = ty::get_field(cx.tcx, t, field.node.ident).mt.ty;
-        let ty_md = create_ty(cx, field_t, field.node.mt.ty);
-        let (size, align) = size_and_align_of(cx, field_t);
-        add_member(scx, *cx.sess.str_of(field.node.ident),
-                   line_from_span(cx.sess.codemap, field.span) as int,
-                   size as int, align as int, ty_md.node);
-    }
-    let mdval = @Metadata {
-        node: finish_structure(scx),
-        data: TyDescMetadata {
-            hash: ty::type_id(t)
-        }
-    };
-    return mdval;
-}
-
 fn create_boxed_type(cx: @CrateContext, outer: ty::t, _inner: ty::t,
                      span: span, boxed: @Metadata<TyDescMetadata>)
     -> @Metadata<TyDescMetadata> {
@@ -628,16 +601,6 @@ fn create_ty(_cx: @CrateContext, _t: ty::t, _ty: @ast::Ty)
                                         mutbl: mt.mutbl}) }
           ty::ty_uniq(mt) { ast::ty_uniq({ty: t_to_ty(cx, mt.ty, span),
                                           mutbl: mt.mutbl}) }
-          ty::ty_rec(fields) {
-            let fs = ~[];
-            for field in fields {
-                fs.push({node: {ident: field.ident,
-                               mt: {ty: t_to_ty(cx, field.mt.ty, span),
-                                    mutbl: field.mt.mutbl}},
-                        span: span});
-            }
-            ast::ty_rec(fs)
-          }
           ty::ty_vec(mt) { ast::ty_vec({ty: t_to_ty(cx, mt.ty, span),
                                         mutbl: mt.mutbl}) }
           _ {
@@ -673,10 +636,6 @@ fn create_ty(_cx: @CrateContext, _t: ty::t, _ty: @ast::Ty)
         return create_ty(cx, t, inferred);
       }
 
-      ast::ty_rec(fields) {
-        return create_record(cx, t, fields, ty.span);
-      }
-
       ast::ty_vec(mt) {
         let inner_t = ty::sequence_element_type(cx.tcx, t);
         let inner_ast_t = t_to_ty(cx, inner_t, mt.ty.span);

src/librustc/middle/trans/expr.rs

@@ -1141,10 +1141,6 @@ pub fn with_field_tys<R>(tcx: ty::ctxt,
                          node_id_opt: Option<ast::node_id>,
                          op: fn(int, (&[ty::field])) -> R) -> R {
     match ty::get(ty).sty {
-        ty::ty_rec(ref fields) => {
-            op(0, *fields)
-        }
-
         ty::ty_struct(did, ref substs) => {
             op(0, struct_mutable_fields(tcx, did, substs))
         }