---

yaml
---
r: 40193
b: refs/heads/dist-snap
c: 4da58a5
h: refs/heads/master
i:
  40191: 367ab00
v: v3

Author: pcwalton

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278
 refs/heads/incoming: e90142e536c150df0d9b4b2f11352152177509b5
-refs/heads/dist-snap: 0707780eace5bafa07c114319b9a0d774f196da4
+refs/heads/dist-snap: 4da58a5bd6f921b446e46cf65790975598289308
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/libsyntax/ast.rs

@@ -1444,6 +1444,31 @@ enum struct_field_kind {
     unnamed_field   // element of a tuple-like struct
 }
 
+impl struct_field_kind : cmp::Eq {
+    pure fn eq(other: &struct_field_kind) -> bool {
+        match self {
+            named_field(ident_a, class_mutability_a, visibility_a) => {
+                match *other {
+                    named_field(ident_b, class_mutability_b, visibility_b)
+                            => {
+                        ident_a == ident_b &&
+                        class_mutability_a == class_mutability_b &&
+                        visibility_a == visibility_b
+                    }
+                    unnamed_field => false
+                }
+            }
+            unnamed_field => {
+                match *other {
+                    named_field(*) => false,
+                    unnamed_field => true
+                }
+            }
+        }
+    }
+    pure fn ne(other: &struct_field_kind) -> bool { !self.eq(other) }
+}
+
 #[auto_serialize]
 #[auto_deserialize]
 type struct_def = {
@@ -1452,7 +1477,10 @@ type struct_def = {
     methods: ~[@method],    /* methods */
     /* (not including ctor or dtor) */
     /* dtor is optional */
-    dtor: Option<class_dtor>
+    dtor: Option<class_dtor>,
+    /* ID of the constructor. This is only used for tuple- or enum-like
+     * structs. */
+    ctor_id: node_id
 };
 
 /*

branches/dist-snap/src/libsyntax/fold.rs

@@ -280,7 +280,8 @@ fn fold_struct_def(struct_def: @ast::struct_def, fld: ast_fold)
         traits: vec::map(struct_def.traits, |p| fold_trait_ref(*p, fld)),
         fields: vec::map(struct_def.fields, |f| fold_struct_field(*f, fld)),
         methods: vec::map(struct_def.methods, |m| fld.fold_method(*m)),
-        dtor: dtor
+        dtor: dtor,
+        ctor_id: fld.new_id(struct_def.ctor_id)
     };
 }
 
@@ -563,7 +564,8 @@ fn noop_fold_variant(v: variant_, fld: ast_fold) -> variant_ {
                                  |f| fld.fold_struct_field(*f)),
                 methods: vec::map(struct_def.methods,
                                   |m| fld.fold_method(*m)),
-                dtor: dtor
+                dtor: dtor,
+                ctor_id: fld.new_id(struct_def.ctor_id)
             })
         }
 

branches/dist-snap/src/libsyntax/parse/parser.rs

@@ -2722,12 +2722,14 @@ impl Parser {
                     self_id: self.get_id(),
                     body: d_body},
              span: d_s}};
+        let _ = self.get_id();  // XXX: Workaround for crazy bug.
         (class_name,
          item_class(@{
              traits: traits,
              fields: move fields,
              methods: move methods,
-             dtor: actual_dtor
+             dtor: actual_dtor,
+             ctor_id: self.get_id()
          }, ty_params),
          None)
     }
@@ -3073,7 +3075,8 @@ impl Parser {
             traits: ~[],
             fields: move fields,
             methods: move methods,
-            dtor: actual_dtor
+            dtor: actual_dtor,
+            ctor_id: self.get_id()
         };
     }
 

branches/dist-snap/src/rustc/middle/lint.rs

@@ -54,7 +54,6 @@ enum lint {
     deprecated_pattern,
     non_camel_case_types,
     structural_records,
-    type_limits,
 
     managed_heap_memory,
     owned_heap_memory,
@@ -187,11 +186,6 @@ fn get_lint_dict() -> lint_dict {
            desc: ~"allow legacy modes",
            default: forbid}),
 
-        (~"type_limits",
-         @{lint: type_limits,
-           desc: ~"comparisons made useless by limits of the types involved",
-           default: warn})
-
         /* FIXME(#3266)--make liveness warnings lintable
         (~"unused_variable",
          @{lint: unused_variable,
@@ -403,7 +397,6 @@ fn check_item(i: @ast::item, cx: ty::ctxt) {
     check_item_heap(cx, i);
     check_item_structural_records(cx, i);
     check_item_deprecated_modes(cx, i);
-    check_item_type_limits(cx, i);
 }
 
 // Take a visitor, and modify it so that it will not proceed past subitems.
@@ -437,122 +430,6 @@ fn check_item_while_true(cx: ty::ctxt, it: @ast::item) {
     visit::visit_item(it, (), visit);
 }
 
-fn check_item_type_limits(cx: ty::ctxt, it: @ast::item) {
-    pure fn is_valid<T: cmp::Ord>(binop: ast::binop, v: T,
-            min: T, max: T) -> bool {
-        match binop {
-            ast::lt => v <= max,
-            ast::le => v < max,
-            ast::gt => v >= min,
-            ast::ge => v > min,
-            ast::eq | ast::ne => v >= min && v <= max,
-            _ => fail
-        }
-    }
-
-    pure fn rev_binop(binop: ast::binop) -> ast::binop {
-        match binop {
-            ast::lt => ast::gt,
-            ast::le => ast::ge,
-            ast::gt => ast::lt,
-            ast::ge => ast::le,
-            _ => binop
-        }
-    }
-
-    pure fn int_ty_range(int_ty: ast::int_ty) -> (i64, i64) {
-        match int_ty {
-            ast::ty_i =>    (int::min_value as i64, int::max_value as i64),
-            ast::ty_char => (u32::min_value as i64, u32::max_value as i64),
-            ast::ty_i8 =>   (i8::min_value  as i64, i8::max_value  as i64),
-            ast::ty_i16 =>  (i16::min_value as i64, i16::max_value as i64),
-            ast::ty_i32 =>  (i32::min_value as i64, i32::max_value as i64),
-            ast::ty_i64 =>  (i64::min_value,        i64::max_value)
-        }
-    }
-
-    pure fn uint_ty_range(uint_ty: ast::uint_ty) -> (u64, u64) {
-        match uint_ty {
-            ast::ty_u =>   (uint::min_value as u64, uint::max_value as u64),
-            ast::ty_u8 =>  (u8::min_value   as u64, u8::max_value   as u64),
-            ast::ty_u16 => (u16::min_value  as u64, u16::max_value  as u64),
-            ast::ty_u32 => (u32::min_value  as u64, u32::max_value  as u64),
-            ast::ty_u64 => (u64::min_value,         u64::max_value)
-        }
-    }
-
-    fn check_limits(cx: ty::ctxt, binop: ast::binop, l: &ast::expr,
-                    r: &ast::expr) -> bool {
-        let (lit, expr, swap) = match (l.node, r.node) {
-            (ast::expr_lit(_), _) => (l, r, true),
-            (_, ast::expr_lit(_)) => (r, l, false),
-            _ => return true
-        };
-        // Normalize the binop so that the literal is always on the RHS in
-        // the comparison
-        let norm_binop = if (swap) {
-            rev_binop(binop)
-        } else {
-            binop
-        };
-        match ty::get(ty::expr_ty(cx, @*expr)).sty {
-            ty::ty_int(int_ty) => {
-                let (min, max) = int_ty_range(int_ty);
-                let lit_val: i64 = match lit.node {
-                    ast::expr_lit(@li) => match li.node {
-                        ast::lit_int(v, _) => v,
-                        ast::lit_uint(v, _) => v as i64,
-                        ast::lit_int_unsuffixed(v) => v,
-                        _ => return true
-                    },
-                    _ => fail
-                };
-                is_valid(norm_binop, lit_val, min, max)
-            }
-            ty::ty_uint(uint_ty) => {
-                let (min, max): (u64, u64) = uint_ty_range(uint_ty);
-                let lit_val: u64 = match lit.node {
-                    ast::expr_lit(@li) => match li.node {
-                        ast::lit_int(v, _) => v as u64,
-                        ast::lit_uint(v, _) => v,
-                        ast::lit_int_unsuffixed(v) => v as u64,
-                        _ => return true
-                    },
-                    _ => fail
-                };
-                is_valid(norm_binop, lit_val, min, max)
-            }
-            _ => true
-        }
-    }
-
-    pure fn is_comparison(binop: ast::binop) -> bool {
-        match binop {
-            ast::eq | ast::lt | ast::le |
-            ast::ne | ast::ge | ast::gt => true,
-            _ => false
-        }
-    }
-
-    let visit = item_stopping_visitor(visit::mk_simple_visitor(@{
-        visit_expr: fn@(e: @ast::expr) {
-            match e.node {
-                ast::expr_binary(binop, @l, @r) => {
-                    if is_comparison(binop)
-                       && !check_limits(cx, binop, &l, &r) {
-                        cx.sess.span_lint(
-                            type_limits, e.id, it.id, e.span,
-                            ~"comparison is useless due to type limits");
-                    }
-                }
-                _ => ()
-            }
-        },
-        .. *visit::default_simple_visitor()
-    }));
-    visit::visit_item(it, (), visit);
-}
-
 fn check_item_structural_records(cx: ty::ctxt, it: @ast::item) {
     let visit = item_stopping_visitor(visit::mk_simple_visitor(@{
         visit_expr: fn@(e: @ast::expr) {

branches/dist-snap/src/rustc/middle/resolve.rs

@@ -9,8 +9,7 @@ use middle::pat_util::{pat_bindings};
 use syntax::ast::{_mod, add, arm};
 use syntax::ast::{bind_by_ref, bind_by_implicit_ref, bind_by_value};
 use syntax::ast::{bitand, bitor, bitxor};
-use syntax::ast::{binding_mode, blk,
-                     capture_clause, class_ctor, class_dtor};
+use syntax::ast::{binding_mode, blk, capture_clause, class_ctor, class_dtor};
 use syntax::ast::{crate, crate_num, decl_item};
 use syntax::ast::{def, def_arg, def_binding, def_class, def_const, def_fn};
 use syntax::ast::{def_foreign_mod, def_id, def_label, def_local, def_mod};
@@ -39,7 +38,7 @@ use syntax::ast::{trait_ref, tuple_variant_kind, Ty, ty_bool, ty_char};
 use syntax::ast::{ty_f, ty_f32, ty_f64, ty_float, ty_i, ty_i16, ty_i32};
 use syntax::ast::{ty_i64, ty_i8, ty_int, ty_param, ty_path, ty_str, ty_u};
 use syntax::ast::{ty_u16, ty_u32, ty_u64, ty_u8, ty_uint, type_value_ns};
-use syntax::ast::{ty_param_bound};
+use syntax::ast::{ty_param_bound, unnamed_field};
 use syntax::ast::{variant, view_item, view_item_export, view_item_import};
 use syntax::ast::{view_item_use, view_path_glob, view_path_list};
 use syntax::ast::{view_path_simple, visibility, anonymous, named};
@@ -1179,12 +1178,22 @@ impl Resolver {
             }
 
             // These items live in both the type and value namespaces.
-            item_class(*) => {
+            item_class(struct_def, _) => {
                 let (name_bindings, new_parent) =
                     self.add_child(ident, parent, ForbidDuplicateTypes, sp);
 
-                (*name_bindings).define_type
-                    (privacy, def_ty(local_def(item.id)), sp);
+                name_bindings.define_type(
+                    privacy, def_ty(local_def(item.id)), sp);
+
+                // If this struct is tuple-like or enum-like, define a name
+                // in the value namespace.
+                if struct_def.fields.len() == 0 ||
+                        struct_def.fields[0].node.kind == unnamed_field {
+                    name_bindings.define_value(
+                        privacy,
+                        def_class(local_def(struct_def.ctor_id)),
+                        sp);
+                }
 
                 // Record the def ID of this struct.
                 self.structs.insert(local_def(item.id), ());

branches/dist-snap/src/rustc/middle/typeck/collect.rs

@@ -22,6 +22,7 @@ are represented as `ty_param()` instances.
 
 use astconv::{ast_conv, ty_of_fn_decl, ty_of_arg, ast_ty_to_ty};
 use ast_util::trait_method_to_ty_method;
+use middle::ty::{FnMeta, FnSig, FnTyBase};
 use rscope::*;
 use ty::{FnTyBase, FnMeta, FnSig, InstantiatedTraitRef};
 use util::common::pluralize;
@@ -559,6 +560,39 @@ fn convert_struct(ccx: @crate_ctxt,
         write_ty_to_tcx(tcx, trait_ref.impl_id, tpt.ty);
         tcx.tcache.insert(local_def(trait_ref.impl_id), tpt);
     }
+
+    // If this struct is enum-like or tuple-like, create the type of its
+    // constructor.
+    if struct_def.fields.len() == 0 {
+        // Enum-like.
+        write_ty_to_tcx(tcx, struct_def.ctor_id, selfty);
+        tcx.tcache.insert(local_def(struct_def.ctor_id), tpt);
+    } else if struct_def.fields[0].node.kind == ast::unnamed_field {
+        // Tuple-like.
+        let ctor_fn_ty = ty::mk_fn(tcx, FnTyBase {
+            meta: FnMeta {
+                purity: ast::pure_fn,
+                proto: ty::proto_bare,
+                bounds: @~[],
+                ret_style: ast::return_val,
+            },
+            sig: FnSig {
+                inputs: do struct_def.fields.map |field| {
+                    {
+                        mode: ast::expl(ast::by_copy),
+                        ty: ccx.tcx.tcache.get(local_def(field.node.id)).ty
+                    }
+                },
+                output: selfty
+            }
+        });
+        write_ty_to_tcx(tcx, struct_def.ctor_id, ctor_fn_ty);
+        tcx.tcache.insert(local_def(struct_def.ctor_id), {
+            bounds: tpt.bounds,
+            region_param: tpt.region_param,
+            ty: ctor_fn_ty
+        });
+    }
 }
 
 fn convert_foreign(ccx: @crate_ctxt, i: @ast::foreign_item) {