---

yaml
---
r: 46458
b: refs/heads/auto
c: 48c1c3c
h: refs/heads/master
v: v3

Author: luqmana

[refs]

@@ -14,4 +14,4 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 1869df30a66243f6f44e37a4f6c8b3d1f098dc94
+refs/heads/auto: 48c1c3cfc076bf155c1e54afa41ec560b343f52d

branches/auto/src/compiletest/common.rs

@@ -21,7 +21,7 @@ pub enum mode {
     mode_debug_info,
 }
 
-pub type config = {
+pub struct config {
     // The library paths required for running the compiler
     compile_lib_path: ~str,
 
@@ -68,4 +68,4 @@ pub type config = {
     // Explain what's going on
     verbose: bool
 
-};
+}

branches/auto/src/compiletest/compiletest.rc

@@ -11,7 +11,6 @@
 #[crate_type = "bin"];
 
 #[no_core];
-#[legacy_records];
 
 #[allow(vecs_implicitly_copyable)];
 #[allow(non_camel_case_types)];
@@ -77,26 +76,28 @@ pub fn parse_config(args: ~[~str]) -> config {
         Path(getopts::opt_str(m, nm))
     }
 
-    return {compile_lib_path: getopts::opt_str(matches, ~"compile-lib-path"),
-         run_lib_path: getopts::opt_str(matches, ~"run-lib-path"),
-         rustc_path: opt_path(matches, ~"rustc-path"),
-         src_base: opt_path(matches, ~"src-base"),
-         build_base: opt_path(matches, ~"build-base"),
-         aux_base: opt_path(matches, ~"aux-base"),
-         stage_id: getopts::opt_str(matches, ~"stage-id"),
-         mode: str_mode(getopts::opt_str(matches, ~"mode")),
-         run_ignored: getopts::opt_present(matches, ~"ignored"),
-         filter:
+    config {
+        compile_lib_path: getopts::opt_str(matches, ~"compile-lib-path"),
+        run_lib_path: getopts::opt_str(matches, ~"run-lib-path"),
+        rustc_path: opt_path(matches, ~"rustc-path"),
+        src_base: opt_path(matches, ~"src-base"),
+        build_base: opt_path(matches, ~"build-base"),
+        aux_base: opt_path(matches, ~"aux-base"),
+        stage_id: getopts::opt_str(matches, ~"stage-id"),
+        mode: str_mode(getopts::opt_str(matches, ~"mode")),
+        run_ignored: getopts::opt_present(matches, ~"ignored"),
+        filter:
              if vec::len(matches.free) > 0u {
                  option::Some(matches.free[0])
              } else { option::None },
-         logfile: option::map(&getopts::opt_maybe_str(matches,
+        logfile: option::map(&getopts::opt_maybe_str(matches,
                                                      ~"logfile"),
-                              |s| Path(*s)),
-         runtool: getopts::opt_maybe_str(matches, ~"runtool"),
-         rustcflags: getopts::opt_maybe_str(matches, ~"rustcflags"),
-         jit: getopts::opt_present(matches, ~"jit"),
-         verbose: getopts::opt_present(matches, ~"verbose")};
+                             |s| Path(*s)),
+        runtool: getopts::opt_maybe_str(matches, ~"runtool"),
+        rustcflags: getopts::opt_maybe_str(matches, ~"rustcflags"),
+        jit: getopts::opt_present(matches, ~"jit"),
+        verbose: getopts::opt_present(matches, ~"verbose")
+    }
 }
 
 pub fn log_config(config: config) {

branches/auto/src/librustc/middle/astencode.rs

@@ -1278,13 +1278,13 @@ fn test_simplification() {
     let item_in = ast::ii_item(quote_item!(
         fn new_int_alist<B:Copy>() -> alist<int, B> {
             fn eq_int(&&a: int, &&b: int) -> bool { a == b }
-            return {eq_fn: eq_int, data: ~[]};
+            return alist {eq_fn: eq_int, data: ~[]};
         }
     ).get());
     let item_out = simplify_ast(item_in);
     let item_exp = ast::ii_item(quote_item!(
         fn new_int_alist<B:Copy>() -> alist<int, B> {
-            return {eq_fn: eq_int, data: ~[]};
+            return alist {eq_fn: eq_int, data: ~[]};
         }
     ).get());
     match (item_out, item_exp) {

branches/auto/src/librustc/middle/lint.rs

@@ -706,23 +706,21 @@ fn check_item_deprecated_self(cx: ty::ctxt, item: @ast::item) {
 }
 
 fn check_item_structural_records(cx: ty::ctxt, it: @ast::item) {
-    if !cx.legacy_records {
-        let visit = item_stopping_visitor(
-            visit::mk_simple_visitor(@visit::SimpleVisitor {
-                visit_expr: |e: @ast::expr| {
-                    match e.node {
-                        ast::expr_rec(*) =>
-                            cx.sess.span_lint(
-                                structural_records, e.id, it.id,
-                                e.span,
-                                ~"structural records are deprecated"),
-                        _ => ()
-                    }
-                },
-                .. *visit::default_simple_visitor()
-            }));
-        visit::visit_item(it, (), visit);
-    }
+    let visit = item_stopping_visitor(
+        visit::mk_simple_visitor(@visit::SimpleVisitor {
+            visit_expr: |e: @ast::expr| {
+                match e.node {
+                    ast::expr_rec(*) =>
+                        cx.sess.span_lint(
+                            structural_records, e.id, it.id,
+                            e.span,
+                            ~"structural records are deprecated"),
+                    _ => ()
+                }
+            },
+            .. *visit::default_simple_visitor()
+        }));
+    visit::visit_item(it, (), visit);
 }
 
 fn check_item_ctypes(cx: ty::ctxt, it: @ast::item) {

branches/auto/src/librustc/middle/trans/monomorphize.rs

@@ -137,9 +137,9 @@ pub fn monomorphic_fn(ccx: @CrateContext,
 
     let depth = option::get_or_default(ccx.monomorphizing.find(&fn_id), 0u);
     // Random cut-off -- code that needs to instantiate the same function
-    // recursively more than thirty times can probably safely be assumed to be
+    // recursively more than ten times can probably safely be assumed to be
     // causing an infinite expansion.
-    if depth > 30 {
+    if depth > 10 {
         ccx.sess.span_fatal(
             span, ~"overly deep expansion of inlined function");
     }

branches/auto/src/librustc/middle/ty.rs

@@ -233,7 +233,6 @@ struct ctxt_ {
     mut next_id: uint,
     vecs_implicitly_copyable: bool,
     legacy_modes: bool,
-    legacy_records: bool,
     cstore: @mut metadata::cstore::CStore,
     sess: session::Session,
     def_map: resolve::DefMap,
@@ -789,16 +788,10 @@ pub fn mk_ctxt(s: session::Session,
                crate: @ast::crate)
             -> ctxt {
     let mut legacy_modes = false;
-    let mut legacy_records = false;
     for crate.node.attrs.each |attribute| {
         match attribute.node.value.node {
             ast::meta_word(w) if *w == ~"legacy_modes" => {
                 legacy_modes = true;
-                if legacy_records { break; }
-            }
-            ast::meta_word(w) if *w == ~"legacy_records" => {
-                legacy_records = true;
-                if legacy_modes { break; }
             }
             _ => {}
         }
@@ -814,7 +807,6 @@ pub fn mk_ctxt(s: session::Session,
         mut next_id: 0u,
         vecs_implicitly_copyable: vecs_implicitly_copyable,
         legacy_modes: legacy_modes,
-        legacy_records: legacy_records,
         cstore: s.cstore,
         sess: s,
         def_map: dm,

branches/auto/src/librusti/rusti.rc

@@ -17,7 +17,6 @@
 
 #[crate_type = "lib"];
 
-#[legacy_records];
 #[no_core];
 
 #[allow(vecs_implicitly_copyable,

branches/auto/src/librusti/wrapper.rs

@@ -16,7 +16,6 @@
 #[allow(non_implicitly_copyable_typarams)];
 #[allow(owned_heap_memory)];
 #[allow(path_statement)];
-#[allow(structural_records)];
 #[allow(unrecognized_lint)];
 #[allow(unused_imports)];
 #[allow(vecs_implicitly_copyable)];

branches/auto/src/librustpkg/rustpkg.rc

@@ -20,8 +20,6 @@
 #[allow(vecs_implicitly_copyable,
         non_implicitly_copyable_typarams)];
 
-#[legacy_records];
-
 extern mod core(vers = "0.6");
 extern mod std(vers = "0.6");
 extern mod rustc(vers = "0.6");

branches/auto/src/libstd/json.rs

@@ -1294,6 +1294,8 @@ mod tests {
         }
     }
 
+    // testing both auto_encode's calling patterns
+    // and json... not sure where to put these tests.
     #[test]
     fn test_write_enum () {
         let bw = @io::BytesWriter();

branches/auto/src/libsyntax/diagnostic.rs

@@ -26,9 +26,17 @@ use std::term;
 pub type Emitter = fn@(cmsp: Option<(@codemap::CodeMap, span)>,
                    msg: &str, lvl: level);
 
-// a handler deals with errors; certain errors
-// (fatal, bug, unimpl) may cause immediate exit,
-// others log errors for later reporting.
+
+pub trait span_handler {
+    fn span_fatal(@mut self, sp: span, msg: &str) -> !;
+    fn span_err(@mut self, sp: span, msg: &str);
+    fn span_warn(@mut self, sp: span, msg: &str);
+    fn span_note(@mut self, sp: span, msg: &str);
+    fn span_bug(@mut self, sp: span, msg: &str) -> !;
+    fn span_unimpl(@mut self, sp: span, msg: &str) -> !;
+    fn handler(@mut self) -> handler;
+}
+
 pub trait handler {
     fn fatal(@mut self, msg: &str) -> !;
     fn err(@mut self, msg: &str);
@@ -37,7 +45,6 @@ pub trait handler {
     fn abort_if_errors(@mut self);
     fn warn(@mut self, msg: &str);
     fn note(@mut self, msg: &str);
-    // used to indicate a bug in the compiler:
     fn bug(@mut self, msg: &str) -> !;
     fn unimpl(@mut self, msg: &str) -> !;
     fn emit(@mut self,
@@ -46,19 +53,6 @@ pub trait handler {
             lvl: level);
 }
 
-// a span-handler is like a handler but also
-// accepts span information for source-location
-// reporting.
-pub trait span_handler {
-    fn span_fatal(@mut self, sp: span, msg: &str) -> !;
-    fn span_err(@mut self, sp: span, msg: &str);
-    fn span_warn(@mut self, sp: span, msg: &str);
-    fn span_note(@mut self, sp: span, msg: &str);
-    fn span_bug(@mut self, sp: span, msg: &str) -> !;
-    fn span_unimpl(@mut self, sp: span, msg: &str) -> !;
-    fn handler(@mut self) -> handler;
-}
-
 struct HandlerT {
     err_count: uint,
     emit: Emitter,

branches/auto/src/libsyntax/ext/deriving.rs

@@ -489,20 +489,36 @@ fn expand_deriving_eq_struct_def(cx: ext_ctxt,
     // Create the methods.
     let eq_ident = cx.ident_of(~"eq");
     let ne_ident = cx.ident_of(~"ne");
-    let eq_method = expand_deriving_eq_struct_method(cx,
-                                                     span,
-                                                     struct_def,
-                                                     eq_ident,
-                                                     type_ident,
-                                                     ty_params,
-                                                     Conjunction);
-    let ne_method = expand_deriving_eq_struct_method(cx,
-                                                     span,
-                                                     struct_def,
-                                                     ne_ident,
-                                                     type_ident,
-                                                     ty_params,
-                                                     Disjunction);
+
+    let is_struct_tuple =
+    struct_def.fields.len() > 0 && struct_def.fields.all(|f| {
+        match f.node.kind {
+            named_field(*) => false,
+            unnamed_field => true
+        }
+    });
+
+    let derive_struct_fn = if is_struct_tuple {
+        expand_deriving_eq_struct_tuple_method
+    } else {
+        expand_deriving_eq_struct_method
+    };
+
+
+    let eq_method = derive_struct_fn(cx,
+                                     span,
+                                     struct_def,
+                                     eq_ident,
+                                     type_ident,
+                                     ty_params,
+                                     Conjunction);
+    let ne_method = derive_struct_fn(cx,
+                                     span,
+                                     struct_def,
+                                     ne_ident,
+                                     type_ident,
+                                     ty_params,
+                                     Disjunction);
 
     // Create the implementation.
     return create_derived_eq_impl(cx,
@@ -811,6 +827,65 @@ fn expand_deriving_eq_enum_method(cx: ext_ctxt,
                             self_match_expr);
 }
 
+fn expand_deriving_eq_struct_tuple_method(cx: ext_ctxt,
+                                          span: span,
+                                          struct_def: &struct_def,
+                                          method_ident: ident,
+                                          type_ident: ident,
+                                          ty_params: &[ty_param],
+                                          junction: Junction)
+                                        -> @method {
+    let self_str = ~"self";
+    let other_str = ~"__other";
+    let type_path = build::mk_raw_path(span, ~[type_ident]);
+    let fields = struct_def.fields;
+
+    // Create comparison expression, comparing each of the fields
+    let mut match_body = None;
+    for fields.eachi |i, _| {
+        let other_field_ident = cx.ident_of(other_str + i.to_str());
+        let other_field = build::mk_path(cx, span, ~[ other_field_ident ]);
+
+        let self_field_ident = cx.ident_of(self_str + i.to_str());
+        let self_field = build::mk_path(cx, span, ~[ self_field_ident ]);
+
+        call_substructure_eq_method(cx, span, self_field, other_field,
+            method_ident, junction, &mut match_body);
+    }
+    let match_body = finish_eq_chain_expr(cx, span, match_body, junction);
+
+    // Create arm for the '__other' match, containing the comparison expr
+    let other_subpats = create_subpatterns(cx, span, other_str, fields.len());
+    let other_arm = ast::arm {
+        pats: ~[ build::mk_pat_enum(cx, span, type_path, other_subpats) ],
+        guard: None,
+        body: build::mk_simple_block(cx, span, match_body),
+    };
+
+    // Create the match on '__other'
+    let other_expr = build::mk_path(cx, span, ~[ cx.ident_of(other_str) ]);
+    let other_expr = build::mk_unary(cx, span, deref, other_expr);
+    let other_match_expr = expr_match(other_expr, ~[other_arm]);
+    let other_match_expr = build::mk_expr(cx, span, other_match_expr);
+
+    // Create arm for the 'self' match, which contains the '__other' match
+    let self_subpats = create_subpatterns(cx, span, self_str, fields.len());
+    let self_arm = ast::arm {
+        pats: ~[build::mk_pat_enum(cx, span, type_path, self_subpats)],
+        guard: None,
+        body: build::mk_simple_block(cx, span, other_match_expr),
+    };
+
+    // Create the match on 'self'
+    let self_expr = build::mk_path(cx, span, ~[ cx.ident_of(self_str) ]);
+    let self_expr = build::mk_unary(cx, span, deref, self_expr);
+    let self_match_expr = expr_match(self_expr, ~[self_arm]);
+    let self_match_expr = build::mk_expr(cx, span, self_match_expr);
+
+    create_eq_method(cx, span, method_ident,
+        type_ident, ty_params, self_match_expr)
+}
+
 fn expand_deriving_iter_bytes_enum_method(cx: ext_ctxt,
                                           span: span,
                                           enum_definition: &enum_def)

branches/auto/src/libsyntax/parse/attr.rs

@@ -18,7 +18,6 @@ use parse::token;
 
 use core::either::{Either, Left, Right};
 
-// a parser that can parse attributes.
 pub trait parser_attr {
     fn parse_outer_attributes() -> ~[ast::attribute];
     fn parse_attribute(style: ast::attr_style) -> ast::attribute;
@@ -82,9 +81,6 @@ impl parser_attr for Parser {
     // attribute of the next item (since we can't know whether the attribute
     // is an inner attribute of the containing item or an outer attribute of
     // the first contained item until we see the semi).
-
-    // you can make the 'next' field an Option, but the result is going to be
-    // more useful as a vector.
     fn parse_inner_attrs_and_next() ->
         (~[ast::attribute], ~[ast::attribute]) {
         let mut inner_attrs: ~[ast::attribute] = ~[];