---

yaml
---
r: 34324
b: refs/heads/snap-stage3
c: efb8711
h: refs/heads/master
v: v3

Author: erickt

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 2b6c456bf648e5a7b408b550649d409378e39539
+refs/heads/snap-stage3: efb8711f90778db1031053e3f379a8dcc92be6c6
 refs/heads/try: d324a424d8f84b1eb049b12cf34182bda91b0024
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/doc/rust.md

@@ -1107,6 +1107,19 @@ let mut a: Animal = Dog;
 a = Cat;
 ~~~~
 
+Enumeration constructors can have either named or unnamed fields:
+~~~~
+enum Animal {
+    Dog (~str, float),
+    Cat { name: ~str, weight: float }
+}
+
+let mut a: Animal = Dog(~"Cocoa", 37.2);
+a = Cat{ name: ~"Spotty", weight: 2.7 };
+~~~~
+
+In this example, `Cat` is a _struct-like enum variant_,
+whereas `Dog` is simply called an enum variant.
 ### Constants
 
 ~~~~~~~~ {.ebnf .gram}

branches/snap-stage3/doc/tutorial.md

@@ -733,6 +733,24 @@ fn point_from_direction(dir: Direction) -> Point {
 }
 ~~~~
 
+A special kind of enum variant, called _struct-like enums_,
+can have its fields extracted with dot notation and not just destructuring.
+For example:
+
+~~~~
+# struct Point {x: float, y: float}
+# fn square(x: float) -> float { x * x }
+enum Shape {
+    Circle { center: Point, radius: float },
+    Rectangle { left: Point, right: Point }
+}
+fn area(sh: Shape) -> float {
+   match sh {
+      Circle(c) => float::consts::pi * square(c.radius),
+      Rectangle(r) => r.right.x - r.left.x * r.right.y - r.right.y
+   }
+}
+~~~~
 ## Tuples
 
 Tuples in Rust behave exactly like structs, except that their fields

branches/snap-stage3/src/etc/vim/syntax/rust.vim

@@ -2,7 +2,7 @@
 " Language:     Rust
 " Maintainer:   Patrick Walton <[email protected]>
 " Maintainer:   Ben Blum <[email protected]>
-" Last Change:  2012 Dec 14
+" Last Change:  2012 Dec 25
 
 if version < 600
   syntax clear
@@ -44,8 +44,8 @@ syn keyword   rustType        off_t dev_t ino_t pid_t mode_t ssize_t
 
 syn keyword   rustTrait       Const Copy Send Owned " inherent traits
 syn keyword   rustTrait       Eq Ord Num Ptr
-syn keyword   rustTrait       Add Sub Mul Div Modulo Neg BitAnd BitOr BitXor
-syn keyword   rustTrait       Shl Shr Index
+syn keyword   rustTrait       Drop Add Sub Mul Div Modulo Neg BitAnd BitOr
+syn keyword   rustTrait       BitXor Shl Shr Index
 
 syn keyword   rustSelf        self
 syn keyword   rustBoolean     true false

branches/snap-stage3/src/librustc/middle/trans/base.rs

@@ -545,7 +545,10 @@ fn iter_structural_ty(cx: block, av: ValueRef, t: ty::t,
                 j += 1u;
             }
           }
-          _ => cx.tcx().sess.bug(~"iter_variant: not a function type")
+          _ => cx.tcx().sess.bug(fmt!("iter_variant: not a function type: \
+                                       %s (variant name = %s)",
+                                      cx.ty_to_str(fn_ty),
+                                      cx.sess().str_of(variant.name)))
         }
         return cx;
     }

branches/snap-stage3/src/librustc/middle/typeck/collect.rs

@@ -158,13 +158,26 @@ fn get_enum_variant_types(ccx: @crate_ctxt,
                 result_ty = Some(enum_ty);
             }
             ast::struct_variant_kind(struct_def) => {
-                result_ty = Some(enum_ty);
                 // XXX: Merge with computation of the the same value below?
                 let tpt = {bounds: ty_param_bounds(ccx, ty_params),
                            region_param: rp,
                            ty: enum_ty};
                 convert_struct(
                     ccx, rp, struct_def, ty_params, tpt, variant.node.id);
+                // Compute the ctor arg types from the struct fields
+                let struct_fields = do struct_def.fields.map |struct_field| {
+                    {mode: ast::expl(ast::by_val),
+                     ty: ty::node_id_to_type(ccx.tcx, (*struct_field).node.id)
+                    }
+                };
+                result_ty = Some(ty::mk_fn(tcx, FnTyBase {
+                    meta: FnMeta {purity: ast::pure_fn,
+                                  proto: ast::ProtoBare,
+                                  onceness: ast::Many,
+                                  bounds: @~[],
+                                  region: ty::re_static,
+                                  ret_style: ast::return_val},
+                    sig: FnSig {inputs: struct_fields, output: enum_ty }}));
             }
             ast::enum_variant_kind(ref enum_definition) => {
                 get_enum_variant_types(ccx,

branches/snap-stage3/src/libstd/ebml.rs

@@ -360,7 +360,7 @@ pub mod reader {
             f()
         }
 
-        fn read_struct<T>(&self, name: &str, _len: uint, f: fn() -> T) -> T {
+        fn read_struct<T>(&self, name: &str, f: fn() -> T) -> T {
             debug!("read_struct(name=%s)", name);
             f()
         }
@@ -631,7 +631,7 @@ pub mod writer {
         }
 
         fn emit_rec(&self, f: fn()) { f() }
-        fn emit_struct(&self, _name: &str, _len: uint, f: fn()) { f() }
+        fn emit_struct(&self, _name: &str, f: fn()) { f() }
         fn emit_field(&self, name: &str, _idx: uint, f: fn()) {
             self._emit_label(name);
             f()

branches/snap-stage3/src/libstd/json.rs

@@ -148,7 +148,7 @@ pub impl Encoder: serialize::Encoder {
         f();
         self.wr.write_char('}');
     }
-    fn emit_struct(&self, _name: &str, _len: uint, f: fn()) {
+    fn emit_struct(&self, _name: &str, f: fn()) {
         self.wr.write_char('{');
         f();
         self.wr.write_char('}');
@@ -261,7 +261,7 @@ pub impl PrettyEncoder: serialize::Encoder {
         self.indent -= 2;
         self.wr.write_char('}');
     }
-    fn emit_struct(&self, _name: &str, _len: uint, f: fn()) {
+    fn emit_struct(&self, _name: &str, f: fn()) {
         self.emit_rec(f)
     }
     fn emit_field(&self, name: &str, idx: uint, f: fn()) {
@@ -861,7 +861,7 @@ pub impl Decoder: serialize::Decoder {
         move value
     }
 
-    fn read_struct<T>(&self, _name: &str, _len: uint, f: fn() -> T) -> T {
+    fn read_struct<T>(&self, _name: &str, f: fn() -> T) -> T {
         debug!("read_struct()");
         let value = f();
         self.pop();

branches/snap-stage3/src/libstd/prettyprint.rs

@@ -160,7 +160,7 @@ pub impl Encoder: serialize::Encoder {
         self.wr.write_str(~"}");
     }
 
-    fn emit_struct(&self, name: &str, _len: uint, f: fn()) {
+    fn emit_struct(&self, name: &str, f: fn()) {
         self.wr.write_str(fmt!("%s {", name));
         f();
         self.wr.write_str(~"}");

branches/snap-stage3/src/libstd/serialize.rs

@@ -54,7 +54,7 @@ pub trait Encoder {
     fn emit_vec_elt(&self, idx: uint, f: fn());
 
     fn emit_rec(&self, f: fn());
-    fn emit_struct(&self, name: &str, _len: uint, f: fn());
+    fn emit_struct(&self, name: &str, f: fn());
     fn emit_field(&self, f_name: &str, f_idx: uint, f: fn());
 
     fn emit_tup(&self, len: uint, f: fn());
@@ -95,7 +95,7 @@ pub trait Decoder {
     fn read_vec_elt<T>(&self, idx: uint, f: fn() -> T) -> T;
 
     fn read_rec<T>(&self, f: fn() -> T) -> T;
-    fn read_struct<T>(&self, name: &str, _len: uint, f: fn() -> T) -> T;
+    fn read_struct<T>(&self, name: &str, f: fn() -> T) -> T;
     fn read_field<T>(&self, name: &str, idx: uint, f: fn() -> T) -> T;
 
     fn read_tup<T>(&self, sz: uint, f: fn() -> T) -> T;

branches/snap-stage3/src/libsyntax/ext/auto_encode.rs

@@ -25,15 +25,15 @@ would generate two implementations like:
 
     impl<S: Encoder> node_id: Encodable<S> {
         fn encode(s: &S) {
-            do s.emit_struct("Node", 1) {
+            do s.emit_struct("Node") {
                 s.emit_field("id", 0, || s.emit_uint(self))
             }
         }
     }
 
     impl<D: Decoder> node_id: Decodable {
         static fn decode(d: &D) -> Node {
-            do d.read_struct("Node", 1) {
+            do d.read_struct("Node") {
                 Node {
                     id: d.read_field(~"x", 0, || decode(d))
                 }
@@ -686,7 +686,6 @@ fn mk_struct_ser_impl(
         ),
         ~[
             cx.lit_str(span, @cx.str_of(ident)),
-            cx.lit_uint(span, vec::len(fields)),
             cx.lambda_stmts(span, fields),
         ]
     );
@@ -713,7 +712,6 @@ fn mk_struct_deser_impl(
         ),
         ~[
             cx.lit_str(span, @cx.str_of(ident)),
-            cx.lit_uint(span, vec::len(fields)),
             cx.lambda_expr(
                 cx.expr(
                     span,

branches/snap-stage3/src/test/run-pass/enum-variants.rs

@@ -0,0 +1,11 @@
+enum Animal {
+    Dog (~str, float),
+    Cat { name: ~str, weight: float }
+}
+
+fn main() {
+    let mut a: Animal = Dog(~"Cocoa", 37.2);
+    a = Cat{ name: ~"Spotty", weight: 2.7 };
+    // permuting the fields should work too
+    let c = Cat { weight: 3.1, name: ~"Spreckles" };
+}