bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

librustc: Remove mutable fields from the language.

Browse source 
They're still parsed though, to get through bootstrapping.
This commit is contained in:
Patrick Walton 2013-05-03 18:51:58 -07:00
parent c7522417d4
commit db4573a776
19 changed files with 69 additions and 177 deletions
Download patch file Download diff file Expand all files Collapse all files

15
src/librustc/metadata/decoder.rs
View file

@ -204,18 +204,6 @@ fn each_reexport(d: ebml::Doc, f: &fn(ebml::Doc) -> bool) {
}
}
fn field_mutability(d: ebml::Doc) -> ast::struct_mutability {
// Use maybe_get_doc in case it's a method
reader::maybe_get_doc(d, tag_struct_mut).map_default(
ast::struct_immutable,
|d| {
match reader::doc_as_u8(*d) as char {
'm' => ast::struct_mutable,
_ => ast::struct_immutable
}
})
}
fn variant_disr_val(d: ebml::Doc) -> Option<int> {
do reader::maybe_get_doc(d, tag_disr_val).chain |val_doc| {
int::parse_bytes(reader::doc_data(val_doc), 10u)
@ -923,12 +911,10 @@ pub fn get_struct_fields(intr: @ident_interner, cdata: cmd, id: ast::node_id)
if f == PublicField || f == PrivateField || f == InheritedField {
let name = item_name(intr, an_item);
let did = item_def_id(an_item, cdata);
let mt = field_mutability(an_item);
result.push(ty::field_ty {
ident: name,
id: did, vis:
struct_field_family_to_visibility(f),
mutability: mt,
});
}
}
@ -938,7 +924,6 @@ pub fn get_struct_fields(intr: @ident_interner, cdata: cmd, id: ast::node_id)
ident: special_idents::unnamed_field,
id: did,
vis: ast::inherited,
mutability: ast::struct_immutable,
});
}
result

23
src/librustc/metadata/encoder.rs
View file

@ -119,16 +119,6 @@ fn encode_region_param(ecx: @EncodeContext,
}
}
fn encode_mutability(ebml_w: &mut writer::Encoder, mt: struct_mutability) {
ebml_w.start_tag(tag_struct_mut);
let val = match mt {
struct_immutable => 'a',
struct_mutable => 'm'
};
ebml_w.writer.write(&[val as u8]);
ebml_w.end_tag();
}
struct entry<T> {
val: T,
pos: uint
@ -518,13 +508,9 @@ fn encode_info_for_struct(ecx: @EncodeContext,
/* We encode both private and public fields -- need to include
private fields to get the offsets right */
for fields.each |field| {
let (nm, mt, vis) = match field.node.kind {
named_field(nm, mt, vis) => (nm, mt, vis),
unnamed_field => (
special_idents::unnamed_field,
struct_immutable,
inherited
)
let (nm, vis) = match field.node.kind {
named_field(nm, vis) => (nm, vis),
unnamed_field => (special_idents::unnamed_field, inherited)
};
let id = field.node.id;
@ -537,7 +523,6 @@ fn encode_info_for_struct(ecx: @EncodeContext,
encode_name(ecx, ebml_w, nm);
encode_path(ecx, ebml_w, path, ast_map::path_name(nm));
encode_type(ecx, ebml_w, node_id_to_type(tcx, id));
encode_mutability(ebml_w, mt);
encode_def_id(ebml_w, local_def(id));
ebml_w.end_tag();
}
@ -828,7 +813,7 @@ fn encode_info_for_item(ecx: @EncodeContext,
needs to know*/
for struct_def.fields.each |f| {
match f.node.kind {
named_field(ident, _, vis) => {
named_field(ident, vis) => {
ebml_w.start_tag(tag_item_field);
encode_struct_field_family(ebml_w, vis);
encode_name(ecx, ebml_w, ident);

23
src/librustc/middle/lint.rs
View file

@ -56,7 +56,6 @@ pub enum lint {
non_camel_case_types,
type_limits,
default_methods,
deprecated_mutable_fields,
unused_unsafe,
managed_heap_memory,
@ -455,7 +454,6 @@ fn check_item(i: @ast::item, cx: ty::ctxt) {
check_item_heap(cx, i);
check_item_type_limits(cx, i);
check_item_default_methods(cx, i);
check_item_deprecated_mutable_fields(cx, i);
check_item_unused_unsafe(cx, i);
check_item_unused_mut(cx, i);
}
@ -640,28 +638,7 @@ fn check_item_default_methods(cx: ty::ctxt, item: @ast::item) {
}
}
fn check_item_deprecated_mutable_fields(cx: ty::ctxt, item: @ast::item) {
match item.node {
ast::item_struct(struct_def, _) => {
for struct_def.fields.each |field| {
match field.node.kind {
ast::named_field(_, ast::struct_mutable, _) => {
cx.sess.span_lint(deprecated_mutable_fields,
item.id,
item.id,
field.span,
"mutable fields are deprecated");
}
ast::named_field(*) | ast::unnamed_field => {}
}
}
}
_ => {}
}
}
fn check_item_ctypes(cx: ty::ctxt, it: @ast::item) {
fn check_foreign_fn(cx: ty::ctxt, fn_id: ast::node_id,
decl: &ast::fn_decl) {
let tys = vec::map(decl.inputs, |a| a.ty );

24
src/librustc/middle/mem_categorization.rs
View file

@ -581,17 +581,7 @@ pub impl mem_categorization_ctxt {
f_name: ast::ident,
f_ty: ty::t,
field_id: ast::node_id) -> cmt {
let f_mutbl = match field_mutbl(self.tcx, base_cmt.ty,
f_name, field_id) {
Some(f_mutbl) => f_mutbl,
None => {
self.tcx.sess.span_bug(
node.span(),
fmt!("Cannot find field `%s` in type `%s`",
*self.tcx.sess.str_of(f_name),
ty_to_str(self.tcx, base_cmt.ty)));
}
};
let f_mutbl = m_imm;
let m = self.inherited_mutability(base_cmt.mutbl, f_mutbl);
let f_interior = interior_field(f_name, f_mutbl);
@cmt_ {
@ -968,11 +958,7 @@ pub fn field_mutbl(tcx: ty::ctxt,
ty::ty_struct(did, _) => {
for ty::lookup_struct_fields(tcx, did).each |fld| {
if fld.ident == f_name {
let m = match fld.mutability {
ast::struct_mutable => ast::m_mutbl,
ast::struct_immutable => ast::m_imm
};
return Some(m);
return Some(ast::m_imm);
}
}
}
@ -981,11 +967,7 @@ pub fn field_mutbl(tcx: ty::ctxt,
ast::def_variant(_, variant_id) => {
for ty::lookup_struct_fields(tcx, variant_id).each |fld| {
if fld.ident == f_name {
let m = match fld.mutability {
ast::struct_mutable => ast::m_mutbl,
ast::struct_immutable => ast::m_imm
};
return Some(m);
return Some(ast::m_imm);
}
}
}

10
src/librustc/middle/region.rs
View file

@ -894,17 +894,7 @@ pub fn determine_rp_in_struct_field(
cm: @ast::struct_field,
cx: @mut DetermineRpCtxt,
visitor: visit::vt<@mut DetermineRpCtxt>) {
match cm.node.kind {
ast::named_field(_, ast::struct_mutable, _) => {
do cx.with_ambient_variance(rv_invariant) {
visit::visit_struct_field(cm, cx, visitor);
}
}
ast::named_field(_, ast::struct_immutable, _) |
ast::unnamed_field => {
visit::visit_struct_field(cm, cx, visitor);
}
}
}
pub fn determine_rp_in_crate(sess: Session,

2
src/librustc/middle/resolve.rs
View file

@ -4667,7 +4667,7 @@ pub impl Resolver {
for vec::each(class_def.fields) |field| {
match field.node.kind {
unnamed_field => {},
named_field(ident, _, _) => {
named_field(ident, _) => {
if str::eq_slice(*this.session.str_of(ident),
name) {
return true

14
src/librustc/middle/trans/expr.rs
View file

@ -120,14 +120,14 @@ lvalues are *never* stored by value.
*/
use back::abi;
use lib;
use lib::llvm::{ValueRef, TypeRef, llvm};
use lib;
use metadata::csearch;
use middle::trans::_match;
use middle::trans::adt;
use middle::trans::asm;
use middle::trans::base;
use middle::trans::base::*;
use middle::trans::base;
use middle::trans::build::*;
use middle::trans::callee::DoAutorefArg;
use middle::trans::callee;
@ -142,8 +142,10 @@ use middle::trans::machine;
use middle::trans::meth;
use middle::trans::tvec;
use middle::trans::type_of;
use middle::ty::struct_fields;
use middle::ty::{AutoDerefRef, AutoAddEnv};
use middle::ty::{AutoPtr, AutoBorrowVec, AutoBorrowVecRef, AutoBorrowFn};
use middle::ty;
use middle::ty::struct_mutable_fields;
use middle::ty::{AutoPtr, AutoBorrowVec, AutoBorrowVecRef, AutoBorrowFn,
AutoDerefRef, AutoAddEnv, AutoUnsafe};
use util::common::indenter;
@ -1107,7 +1109,7 @@ pub fn with_field_tys<R>(tcx: ty::ctxt,
op: &fn(int, (&[ty::field])) -> R) -> R {
match ty::get(ty).sty {
ty::ty_struct(did, ref substs) => {
op(0, struct_mutable_fields(tcx, did, substs))
op(0, struct_fields(tcx, did, substs))
}
ty::ty_enum(_, ref substs) => {
@ -1124,8 +1126,8 @@ pub fn with_field_tys<R>(tcx: ty::ctxt,
ast::def_variant(enum_id, variant_id) => {
let variant_info = ty::enum_variant_with_id(
tcx, enum_id, variant_id);
op(variant_info.disr_val, struct_mutable_fields(
tcx, variant_id, substs))
op(variant_info.disr_val,
struct_fields(tcx, variant_id, substs))
}
_ => {
tcx.sess.bug(~"resolve didn't map this expr to a \

4
src/librustc/middle/trans/glue.rs
View file

@ -496,9 +496,7 @@ pub fn trans_struct_drop(bcx: block,
Call(bcx, dtor_addr, args);
// Drop the fields
let field_tys =
ty::struct_mutable_fields(bcx.tcx(), class_did,
substs);
let field_tys = ty::struct_fields(bcx.tcx(), class_did, substs);
for vec::eachi(field_tys) |i, fld| {
let llfld_a = adt::trans_field_ptr(bcx, repr, v0, 0, i);
bcx = drop_ty(bcx, llfld_a, fld.mt.ty);

41
src/librustc/middle/ty.rs
View file

@ -109,7 +109,6 @@ pub struct field_ty {
ident: ident,
id: def_id,
vis: ast::visibility,
mutability: ast::struct_mutability,
}
// Contains information needed to resolve types and (in the future) look up
@ -4027,12 +4026,11 @@ pub fn lookup_struct_field(cx: ctxt,
fn struct_field_tys(fields: &[@struct_field]) -> ~[field_ty] {
do fields.map |field| {
match field.node.kind {
named_field(ident, mutability, visibility) => {
named_field(ident, visibility) => {
field_ty {
ident: ident,
id: ast_util::local_def(field.node.id),
vis: visibility,
mutability: mutability,
}
}
unnamed_field => {
@ -4041,51 +4039,22 @@ fn struct_field_tys(fields: &[@struct_field]) -> ~[field_ty] {
syntax::parse::token::special_idents::unnamed_field,
id: ast_util::local_def(field.node.id),
vis: ast::public,
mutability: ast::struct_immutable,
}
}
}
}
}
// Return a list of fields corresponding to the struct's items
// (as if the struct was a record). trans uses this
// Takes a list of substs with which to instantiate field types
// Keep in mind that this function reports that all fields are
// mutable, regardless of how they were declared. It's meant to
// be used in trans.
pub fn struct_mutable_fields(cx: ctxt,
did: ast::def_id,
substs: &substs)
-> ~[field] {
struct_item_fields(cx, did, substs, |_mt| m_mutbl)
}
// Same as struct_mutable_fields, but doesn't change
// mutability.
pub fn struct_fields(cx: ctxt,
did: ast::def_id,
substs: &substs)
-> ~[field] {
struct_item_fields(cx, did, substs, |mt| match mt {
struct_mutable => m_mutbl,
struct_immutable => m_imm })
}
fn struct_item_fields(cx:ctxt,
did: ast::def_id,
substs: &substs,
frob_mutability: &fn(struct_mutability) -> mutability)
// Returns a list of fields corresponding to the struct's items. trans uses
// this. Takes a list of substs with which to instantiate field types.
pub fn struct_fields(cx: ctxt, did: ast::def_id, substs: &substs)
-> ~[field] {
do lookup_struct_fields(cx, did).map |f| {
// consider all instance vars mut, because the
// constructor may mutate all vars
field {
ident: f.ident,
mt: mt {
ty: lookup_field_type(cx, did, f.id, substs),
mutbl: frob_mutability(f.mutability)
mutbl: m_imm
}
}
}

2
src/librustdoc/extract.rs
View file

@ -274,7 +274,7 @@ fn structdoc_from_struct(
item: itemdoc,
fields: do struct_def.fields.map |field| {
match field.node.kind {
ast::named_field(ident, _, _) => to_str(ident),
ast::named_field(ident, _) => to_str(ident),
ast::unnamed_field => ~"(unnamed)",
}
},

37
src/libsyntax/ast.rs
View file

@ -1168,7 +1168,7 @@ pub type struct_field = spanned<struct_field_>;
#[auto_decode]
#[deriving(Eq)]
pub enum struct_field_kind {
named_field(ident, struct_mutability, visibility),
named_field(ident, visibility),
unnamed_field // element of a tuple-like struct
}
@ -1218,17 +1218,6 @@ pub enum item_ {
item_mac(mac),
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub enum struct_mutability { struct_mutable, struct_immutable }
impl to_bytes::IterBytes for struct_mutability {
fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) {
(*self as u8).iter_bytes(lsb0, f)
}
}
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
@ -1289,6 +1278,21 @@ mod test {
assert_eq! (s,~[14]);
}
#[test] fn test_marksof () {
let stopname = uints_to_name(&~[12,14,78]);
assert_eq!(s,~[]);
xorPush(&mut s,14);
assert_eq!(s,~[14]);
xorPush(&mut s,15);
assert_eq!(s,~[14,15]);
xorPush (&mut s,16);
assert_eq! (s,~[14,15,16]);
xorPush (&mut s,16);
assert_eq! (s,~[14,15]);
xorPush (&mut s,15);
assert_eq! (s,~[14]);
}
#[test] fn test_marksof () {
let stopname = uints_to_name(&~[12,14,78]);
let name1 = uints_to_name(&~[4,9,7]);
@ -1347,3 +1351,12 @@ mod test {
}
*/
//
// Local Variables:
// mode: rust
// fill-column: 78;
// indent-tabs-mode: nil
// c-basic-offset: 4
// buffer-file-coding-system: utf-8-unix
// End:
//

2
src/libsyntax/ast_util.rs
View file

@ -285,7 +285,7 @@ pub fn split_trait_methods(trait_methods: &[trait_method])
pub fn struct_field_visibility(field: ast::struct_field) -> visibility {
match field.node.kind {
ast::named_field(_, _, visibility) => visibility,
ast::named_field(_, visibility) => visibility,
ast::unnamed_field => ast::public
}
}

12
src/libsyntax/ext/auto_encode.rs
View file

@ -914,19 +914,15 @@ struct field {
fn mk_struct_fields(fields: &[@ast::struct_field]) -> ~[field] {
do fields.map |field| {
let (ident, mutbl) = match field.node.kind {
ast::named_field(ident, mutbl, _) => (ident, mutbl),
_ => fail!(~"[auto_encode] does not support \
unnamed fields")
let ident = match field.node.kind {
ast::named_field(ident, _) => ident,
_ => fail!(~"[auto_encode] does not support unnamed fields")
};
field {
span: field.span,
ident: ident,
mutbl: match mutbl {
ast::struct_mutable => ast::m_mutbl,
ast::struct_immutable => ast::m_imm,
},
mutbl: ast::m_imm,
}
}
}

2
src/libsyntax/ext/deriving/decodable.rs
View file

@ -280,7 +280,7 @@ fn expand_deriving_decodable_struct_method(
let mut fields = ~[];
for struct_def.fields.each |struct_field| {
match struct_field.node.kind {
named_field(ident, _, _) => {
named_field(ident, _) => {
fields.push(create_read_struct_field(cx, span, i, ident));
}
unnamed_field => {

2
src/libsyntax/ext/deriving/encodable.rs
View file

@ -211,7 +211,7 @@ fn expand_deriving_encodable_struct_method(
let mut statements = ~[];
for struct_def.fields.each |struct_field| {
match struct_field.node.kind {
named_field(ident, _, _) => {
named_field(ident, _) => {
// Create the accessor for this field.
let self_field = build::mk_access(
cx,

4
src/libsyntax/ext/pipes/pipec.rs
View file

@ -410,9 +410,7 @@ impl gen_init for protocol {
@spanned {
node: ast::struct_field_ {
kind: ast::named_field(
cx.ident_of(s.name),
ast::struct_immutable,
kind: ast::named_field(cx.ident_of(s.name),
ast::inherited),
id: cx.next_id(),
ty: fty,

8
src/libsyntax/parse/parser.rs
View file

@ -45,7 +45,7 @@ use ast::{pat_tup, pat_uniq, pat_wild, private};
use ast::{rem, required};
use ast::{ret_style, return_val, self_ty, shl, shr, stmt, stmt_decl};
use ast::{stmt_expr, stmt_semi, stmt_mac, struct_def, struct_field};
use ast::{struct_immutable, struct_mutable, struct_variant_kind, subtract};
use ast::{struct_variant_kind, subtract};
use ast::{sty_box, sty_region, sty_static, sty_uniq, sty_value};
use ast::{token_tree, trait_method, trait_ref, tt_delim, tt_seq, tt_tok};
use ast::{tt_nonterminal, tuple_variant_kind, Ty, ty_, ty_bot, ty_box};
@ -2528,10 +2528,10 @@ pub impl Parser {
fn parse_name_and_ty(&self,
pr: visibility,
attrs: ~[attribute]) -> @struct_field {
let mut is_mutbl = struct_immutable;
let lo = self.span.lo;
if self.eat_keyword(&~"mut") {
is_mutbl = struct_mutable;
// Do nothing, for backwards compatibility.
// XXX: Remove after snapshot.
}
if !is_plain_ident(&*self.token) {
self.fatal(~"expected ident");
@ -2540,7 +2540,7 @@ pub impl Parser {
self.expect(&token::COLON);
let ty = self.parse_ty(false);
@spanned(lo, self.last_span.hi, ast::struct_field_ {
kind: named_field(name, is_mutbl, pr),
kind: named_field(name, pr),
id: self.get_id(),
ty: ty,
attrs: attrs,

5
src/libsyntax/print/pprust.rs
View file

@ -703,14 +703,11 @@ pub fn print_struct(s: @ps,
for struct_def.fields.each |field| {
match field.node.kind {
ast::unnamed_field => fail!(~"unexpected unnamed field"),
ast::named_field(ident, mutability, visibility) => {
ast::named_field(ident, visibility) => {
hardbreak_if_not_bol(s);
maybe_print_comment(s, field.span.lo);
print_outer_attributes(s, field.node.attrs);
print_visibility(s, visibility);
if mutability == ast::struct_mutable {
word_nbsp(s, ~"mut");
}
print_ident(s, ident);
word_nbsp(s, ~":");
print_type(s, field.node.ty);