Skip to content

Commit

Permalink
auto merge of #5819 : erickt/rust/incoming, r=erickt
Browse files Browse the repository at this point in the history 
Good morning,

This first patch series adds support for `#[deriving(Decodable, Encodable)]`, but does not yet remove `#[auto_encode]` and `#[auto_decode]`. I need a snapshot to remove the old code. Along the way it also extends support for tuple structs and struct enum variants.

Also, it includes a minor fix to the pretty printer. We decided a while ago to use 4 spaces to indent a match arm instead of 2. This updates the pretty printer to reflect that.
  • Loading branch information
@bors
bors committed Apr 11, 2013
2 parents e0defb8 + 26ecb30 commit 2f8b36f
Show file tree
Hide file tree
Showing 16 changed files with 1,419 additions and 158 deletions.
97 changes: 97 additions & 0 deletions src/librustc/middle/astencode.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -556,6 +556,7 @@ trait read_method_map_entry_helper {
-> method_map_entry;
}
#[cfg(stage0)]
fn encode_method_map_entry(ecx: @e::EncodeContext,
ebml_w: writer::Encoder,
mme: method_map_entry) {
Expand All @@ -572,7 +573,27 @@ fn encode_method_map_entry(ecx: @e::EncodeContext,
}
}
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn encode_method_map_entry(ecx: @e::EncodeContext,
ebml_w: writer::Encoder,
mme: method_map_entry) {
do ebml_w.emit_struct("method_map_entry", 3) {
do ebml_w.emit_struct_field("self_arg", 0u) {
ebml_w.emit_arg(ecx, mme.self_arg);
}
do ebml_w.emit_struct_field("explicit_self", 2u) {
mme.explicit_self.encode(&ebml_w);
}
do ebml_w.emit_struct_field("origin", 1u) {
mme.origin.encode(&ebml_w);
}
}
}
impl read_method_map_entry_helper for reader::Decoder {
#[cfg(stage0)]
fn read_method_map_entry(&self, xcx: @ExtendedDecodeContext)
-> method_map_entry {
do self.read_struct("method_map_entry", 3) {
Expand All @@ -592,6 +613,29 @@ impl read_method_map_entry_helper for reader::Decoder {
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn read_method_map_entry(&self, xcx: @ExtendedDecodeContext)
-> method_map_entry {
do self.read_struct("method_map_entry", 3) {
method_map_entry {
self_arg: self.read_struct_field("self_arg", 0u, || {
self.read_arg(xcx)
}),
explicit_self: self.read_struct_field("explicit_self", 2u, || {
let self_type: ast::self_ty_ = Decodable::decode(self);
self_type
}),
origin: self.read_struct_field("origin", 1u, || {
let method_origin: method_origin =
Decodable::decode(self);
method_origin.tr(xcx)
}),
}
}
}
}
impl tr for method_origin {
Expand Down Expand Up @@ -782,6 +826,7 @@ impl ebml_writer_helpers for writer::Encoder {
}
}
#[cfg(stage0)]
fn emit_tpbt(&self, ecx: @e::EncodeContext,
tpbt: ty::ty_param_bounds_and_ty) {
do self.emit_struct("ty_param_bounds_and_ty", 2) {
Expand All @@ -804,6 +849,32 @@ impl ebml_writer_helpers for writer::Encoder {
}
}
}
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn emit_tpbt(&self, ecx: @e::EncodeContext,
tpbt: ty::ty_param_bounds_and_ty) {
do self.emit_struct("ty_param_bounds_and_ty", 2) {
do self.emit_struct_field("generics", 0) {
do self.emit_struct("Generics", 2) {
do self.emit_struct_field("type_param_defs", 0) {
do self.emit_from_vec(*tpbt.generics.type_param_defs)
|type_param_def|
{
self.emit_type_param_def(ecx, type_param_def);
}
}
do self.emit_struct_field("region_param", 1) {
tpbt.generics.region_param.encode(self);
}
}
}
do self.emit_struct_field("ty", 1) {
self.emit_ty(ecx, tpbt.ty);
}
}
}
}
trait write_tag_and_id {
Expand Down Expand Up @@ -1053,6 +1124,7 @@ impl ebml_decoder_decoder_helpers for reader::Decoder {
}
}
#[cfg(stage0)]
fn read_ty_param_bounds_and_ty(&self, xcx: @ExtendedDecodeContext)
-> ty::ty_param_bounds_and_ty
{
Expand All @@ -1075,6 +1147,31 @@ impl ebml_decoder_decoder_helpers for reader::Decoder {
}
}
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn read_ty_param_bounds_and_ty(&self, xcx: @ExtendedDecodeContext)
-> ty::ty_param_bounds_and_ty
{
do self.read_struct("ty_param_bounds_and_ty", 2) {
ty::ty_param_bounds_and_ty {
generics: do self.read_struct("Generics", 2) {
ty::Generics {
type_param_defs: self.read_struct_field("type_param_defs", 0, || {
@self.read_to_vec(|| self.read_type_param_def(xcx))
}),
region_param: self.read_struct_field(~"region_param", 1, || {
Decodable::decode(self)
})
}
},
ty: self.read_struct_field("ty", 1, || {
self.read_ty(xcx)
})
}
}
}
fn convert_def_id(&self, xcx: @ExtendedDecodeContext,
source: tydecode::DefIdSource,
did: ast::def_id) -> ast::def_id {
Expand Down
102 changes: 85 additions & 17 deletions src/libstd/ebml.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -335,31 +335,61 @@ pub mod reader {
f()
}
fn read_seq<T>(&self, f: &fn(uint) -> T) -> T {
debug!("read_seq()");
do self.push_doc(self.next_doc(EsVec)) {
let len = self._next_uint(EsVecLen);
debug!(" len=%u", len);
f(len)
fn read_enum_struct_variant<T>(&self, _names: &[&str], f: &fn(uint) -> T) -> T {
debug!("read_enum_struct_variant()");
let idx = self._next_uint(EsEnumVid);
debug!(" idx=%u", idx);
do self.push_doc(self.next_doc(EsEnumBody)) {
f(idx)
}
}
fn read_seq_elt<T>(&self, idx: uint, f: &fn() -> T) -> T {
debug!("read_seq_elt(idx=%u)", idx);
self.push_doc(self.next_doc(EsVecElt), f)
fn read_enum_struct_variant_field<T>(&self, name: &str, idx: uint, f: &fn() -> T) -> T {
debug!("read_enum_struct_variant_arg(name=%?, idx=%u)", name, idx);
f()
}
fn read_struct<T>(&self, name: &str, _len: uint, f: &fn() -> T) -> T {
debug!("read_struct(name=%s)", name);
f()
}
#[cfg(stage0)]
fn read_field<T>(&self, name: &str, idx: uint, f: &fn() -> T) -> T {
debug!("read_field(name=%s, idx=%u)", name, idx);
debug!("read_field(name=%?, idx=%u)", name, idx);
self._check_label(name);
f()
}
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn read_struct_field<T>(&self, name: &str, idx: uint, f: &fn() -> T) -> T {
debug!("read_struct_field(name=%?, idx=%u)", name, idx);
self._check_label(name);
f()
}
fn read_tuple<T>(&self, f: &fn(uint) -> T) -> T {
debug!("read_tuple()");
self.read_seq(f)
}
fn read_tuple_arg<T>(&self, idx: uint, f: &fn() -> T) -> T {
debug!("read_tuple_arg(idx=%u)", idx);
self.read_seq_elt(idx, f)
}
fn read_tuple_struct<T>(&self, name: &str, f: &fn(uint) -> T) -> T {
debug!("read_tuple_struct(name=%?)", name);
self.read_tuple(f)
}
fn read_tuple_struct_arg<T>(&self, idx: uint, f: &fn() -> T) -> T {
debug!("read_tuple_struct_arg(idx=%u)", idx);
self.read_tuple_arg(idx, f)
}
fn read_option<T>(&self, f: &fn(bool) -> T) -> T {
debug!("read_option()");
do self.read_enum("Option") || {
Expand All @@ -373,6 +403,20 @@ pub mod reader {
}
}
fn read_seq<T>(&self, f: &fn(uint) -> T) -> T {
debug!("read_seq()");
do self.push_doc(self.next_doc(EsVec)) {
let len = self._next_uint(EsVecLen);
debug!(" len=%u", len);
f(len)
}
}
fn read_seq_elt<T>(&self, idx: uint, f: &fn() -> T) -> T {
debug!("read_seq_elt(idx=%u)", idx);
self.push_doc(self.next_doc(EsVecElt), f)
}
fn read_map<T>(&self, _f: &fn(uint) -> T) -> T {
debug!("read_map()");
fail!(~"read_map is unimplemented");
Expand Down Expand Up @@ -606,29 +650,42 @@ pub mod writer {
self._emit_label(name);
self.wr_tag(EsEnum as uint, f)
}
fn emit_enum_variant(&self, _v_name: &str, v_id: uint, _cnt: uint,
f: &fn()) {
self._emit_tagged_uint(EsEnumVid, v_id);
self.wr_tag(EsEnumBody as uint, f)
}
fn emit_enum_variant_arg(&self, _idx: uint, f: &fn()) { f() }
fn emit_seq(&self, len: uint, f: &fn()) {
do self.wr_tag(EsVec as uint) {
self._emit_tagged_uint(EsVecLen, len);
f()
}
fn emit_enum_struct_variant(&self, v_name: &str, v_id: uint, cnt: uint, f: &fn()) {
self.emit_enum_variant(v_name, v_id, cnt, f)
}
fn emit_seq_elt(&self, _idx: uint, f: &fn()) {
self.wr_tag(EsVecElt as uint, f)
fn emit_enum_struct_variant_field(&self, _f_name: &str, idx: uint, f: &fn()) {
self.emit_enum_variant_arg(idx, f)
}
fn emit_struct(&self, _name: &str, _len: uint, f: &fn()) { f() }
#[cfg(stage0)]
fn emit_field(&self, name: &str, _idx: uint, f: &fn()) {
self._emit_label(name);
f()
}
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
fn emit_struct_field(&self, name: &str, _idx: uint, f: &fn()) {
self._emit_label(name);
f()
}
fn emit_tuple(&self, len: uint, f: &fn()) { self.emit_seq(len, f) }
fn emit_tuple_arg(&self, idx: uint, f: &fn()) { self.emit_seq_elt(idx, f) }
fn emit_tuple_struct(&self, _name: &str, len: uint, f: &fn()) { self.emit_seq(len, f) }
fn emit_tuple_struct_arg(&self, idx: uint, f: &fn()) { self.emit_seq_elt(idx, f) }
fn emit_option(&self, f: &fn()) {
self.emit_enum("Option", f);
Expand All @@ -640,6 +697,17 @@ pub mod writer {
self.emit_enum_variant("Some", 1, 1, f)
}
fn emit_seq(&self, len: uint, f: &fn()) {
do self.wr_tag(EsVec as uint) {
self._emit_tagged_uint(EsVecLen, len);
f()
}
}
fn emit_seq_elt(&self, _idx: uint, f: &fn()) {
self.wr_tag(EsVecElt as uint, f)
}
fn emit_map(&self, _len: uint, _f: &fn()) {
fail!(~"emit_map is unimplemented");
}
Expand Down
Loading

0 comments on commit 2f8b36f

Please sign in to comment.