---

yaml
---
r: 47731
b: refs/heads/incoming
c: c53b4f3
h: refs/heads/master
i:
  47729: f3212aa
  47727: 505868c
v: v3

Author: bors

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 2a8fb58d79e685d5ca07b039badcf2ae3ef077ea
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/incoming: 548c0982cabe12fba5ee106e542f615f750af6e6
+refs/heads/incoming: c53b4f3b91be10560bf2f2094f39b7a8a7e9166f
 refs/heads/dist-snap: 8b98e5a296d95c5e832db0756828e5bec31c6f50
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/src/etc/emacs/rust-mode.el

@@ -7,7 +7,6 @@
 
 (require 'cm-mode)
 (require 'cc-mode)
-(eval-when-compile (require 'cl))
 
 (defun rust-electric-brace (arg)
   (interactive "*P")
@@ -17,6 +16,12 @@
                           '(font-lock-comment-face font-lock-string-face))))
     (cm-indent)))
 
+(defcustom rust-capitalized-idents-are-types t
+  "If non-nil, capitalized identifiers will be treated as types for the purposes of font-lock mode"
+  :type 'boolean
+  :require 'rust-mode
+  :group 'rust-mode)
+
 (defvar rust-indent-unit 4)
 (defvar rust-syntax-table (let ((table (make-syntax-table)))
                             (c-populate-syntax-table table)
@@ -101,14 +106,7 @@
            (rust-push-context st 'string (current-column) t)
            (setf (rust-state-tokenize st) 'rust-token-string)
            (rust-token-string st))
-      (def ?\' (forward-char)
-           (setf rust-tcat 'atom)
-           (let ((is-escape (eq (char-after) ?\\))
-                 (start (point)))
-             (if (not (rust-eat-until-unescaped ?\'))
-                 'font-lock-warning-face
-               (if (or is-escape (= (point) (+ start 2)))
-                   'font-lock-string-face 'font-lock-warning-face))))
+      (def ?\' (rust-single-quote))
       (def ?/ (forward-char)
            (case (char-after)
              (?/ (end-of-line) 'font-lock-comment-face)
@@ -122,12 +120,7 @@
                  ((rust-eat-re "[a-z_]+") (setf rust-tcat 'macro)))
            'font-lock-preprocessor-face)
       (def ((?a . ?z) (?A . ?Z) ?_)
-           (rust-eat-re "[a-zA-Z_][a-zA-Z0-9_]*")
-           (setf rust-tcat 'ident)
-           (if (and (eq (char-after) ?:) (eq (char-after (+ (point) 1)) ?:)
-                    (not (eq (char-after (+ (point) 2)) ?:)))
-               (progn (forward-char 2) 'font-lock-builtin-face)
-             (match-string 0)))
+           (rust-token-identifier))
       (def ((?0 . ?9))
            (rust-eat-re "0x[0-9a-fA-F_]+\\|0b[01_]+\\|[0-9_]+\\(\\.[0-9_]+\\)?\\(e[+\\-]?[0-9_]+\\)?")
            (setf rust-tcat 'atom)
@@ -150,6 +143,31 @@
            (setf rust-tcat 'op) nil)
       table)))
 
+(defun rust-token-identifier ()
+  (rust-eat-re "[a-zA-Z_][a-zA-Z0-9_]*")
+  (setf rust-tcat 'ident)
+  (if (and (eq (char-after) ?:) (eq (char-after (+ (point) 1)) ?:)
+           (not (eq (char-after (+ (point) 2)) ?:)))
+      (progn (forward-char 2) 'font-lock-builtin-face)
+    (match-string 0)))
+
+(defun rust-single-quote ()
+  (forward-char)
+  (setf rust-tcat 'atom)
+  ; Is this a lifetime?
+  (if (or (looking-at "[a-zA-Z_]$")
+          (looking-at "[a-zA-Z_][^']"))
+      ; If what we see is 'abc, use font-lock-builtin-face:
+      (progn (rust-eat-re "[a-zA-Z_][a-zA-Z_0-9]*")
+             'font-lock-builtin-face)
+    ; Otherwise, handle as a character constant:
+    (let ((is-escape (eq (char-after) ?\\))
+          (start (point)))
+      (if (not (rust-eat-until-unescaped ?\'))
+          'font-lock-warning-face
+        (if (or is-escape (= (point) (+ start 2)))
+            'font-lock-string-face 'font-lock-warning-face)))))
+
 (defun rust-token-base (st)
   (funcall (char-table-range rust-char-table (char-after)) st))
 
@@ -190,6 +208,10 @@
   (dolist (cx (rust-state-context st))
     (when (eq (rust-context-type cx) ?\}) (return (rust-context-info cx)))))
 
+(defun rust-is-capitalized (string)
+  (let ((case-fold-search nil))
+    (string-match-p "[A-Z]" string)))
+
 (defun rust-token (st)
   (let ((cx (car (rust-state-context st))))
     (when (bolp)
@@ -206,6 +228,8 @@
         (setf tok (cond ((eq tok-id 'atom) 'font-lock-constant-face)
                         (tok-id 'font-lock-keyword-face)
                         ((equal (rust-state-last-token st) 'def) 'font-lock-function-name-face)
+                        ((and rust-capitalized-idents-are-types
+                              (rust-is-capitalized tok)) 'font-lock-type-face)
                         (t nil))))
       (when rust-tcat
         (when (eq (rust-context-align cx) 'unset)

branches/incoming/src/librustc/middle/trans/base.rs

@@ -3030,7 +3030,6 @@ pub fn trans_crate(sess: session::Session,
               const_values: HashMap(),
               module_data: HashMap(),
               lltypes: ty::new_ty_hash(),
-              llsizingtypes: ty::new_ty_hash(),
               names: new_namegen(sess.parse_sess.interner),
               next_addrspace: new_addrspace_gen(),
               symbol_hasher: symbol_hasher,

branches/incoming/src/librustc/middle/trans/common.rs

@@ -202,7 +202,6 @@ pub struct crate_ctxt {
      const_values: HashMap<ast::node_id, ValueRef>,
      module_data: HashMap<~str, ValueRef>,
      lltypes: HashMap<ty::t, TypeRef>,
-     llsizingtypes: HashMap<ty::t, TypeRef>,
      names: namegen,
      next_addrspace: addrspace_gen,
      symbol_hasher: @hash::State,

branches/incoming/src/librustc/middle/trans/machine.rs

@@ -13,8 +13,60 @@
 
 use middle::trans::common::*;
 use middle::trans::type_of;
+use middle::ty::field;
 use middle::ty;
-use util::ppaux::ty_to_str;
+
+use syntax::parse::token::special_idents;
+
+// Creates a simpler, size-equivalent type. The resulting type is guaranteed
+// to have (a) the same size as the type that was passed in; (b) to be non-
+// recursive. This is done by replacing all boxes in a type with boxed unit
+// types.
+// This should reduce all pointers to some simple pointer type, to
+// ensure that we don't recurse endlessly when computing the size of a
+// nominal type that has pointers to itself in it.
+pub fn simplify_type(tcx: ty::ctxt, typ: ty::t) -> ty::t {
+    fn nilptr(tcx: ty::ctxt) -> ty::t {
+        ty::mk_ptr(tcx, ty::mt {ty: ty::mk_nil(tcx), mutbl: ast::m_imm})
+    }
+    fn simplifier(tcx: ty::ctxt, typ: ty::t) -> ty::t {
+        match ty::get(typ).sty {
+          ty::ty_box(_) | ty::ty_opaque_box | ty::ty_uniq(_) |
+          ty::ty_evec(_, ty::vstore_uniq) | ty::ty_evec(_, ty::vstore_box) |
+          ty::ty_estr(ty::vstore_uniq) | ty::ty_estr(ty::vstore_box) |
+          ty::ty_ptr(_) | ty::ty_rptr(*) => nilptr(tcx),
+
+          ty::ty_bare_fn(*) | // FIXME(#4804) Bare fn repr
+          ty::ty_closure(*) => ty::mk_tup(tcx, ~[nilptr(tcx), nilptr(tcx)]),
+
+          ty::ty_evec(_, ty::vstore_slice(_)) |
+          ty::ty_estr(ty::vstore_slice(_)) => {
+            ty::mk_tup(tcx, ~[nilptr(tcx), ty::mk_int(tcx)])
+          }
+          // Reduce a class type to a record type in which all the fields are
+          // simplified
+          ty::ty_struct(did, ref substs) => {
+            let simpl_fields = (if ty::ty_dtor(tcx, did).is_present() {
+                // remember the drop flag
+                  ~[field {
+                    ident: special_idents::dtor,
+                    mt: ty::mt {ty: ty::mk_u8(tcx), mutbl: ast::m_mutbl}
+                   }] }
+                else { ~[] }) +
+                do ty::lookup_struct_fields(tcx, did).map |f| {
+                 let t = ty::lookup_field_type(tcx, did, f.id, substs);
+                 field {
+                    ident: f.ident,
+                    mt: ty::mt {ty: simplify_type(tcx, t), mutbl: ast::m_const
+                 }}
+            };
+            ty::mk_rec(tcx, simpl_fields)
+          }
+          _ => typ
+        }
+    }
+    ty::fold_ty(tcx, typ, |t| simplifier(tcx, t))
+}
 
 // ______________________________________________________________________
 // compute sizeof / alignof
@@ -128,40 +180,27 @@ pub fn llalign_of(cx: @crate_ctxt, t: TypeRef) -> ValueRef {
 
 // Computes the size of the data part of an enum.
 pub fn static_size_of_enum(cx: @crate_ctxt, t: ty::t) -> uint {
-    if cx.enum_sizes.contains_key(&t) {
-        return cx.enum_sizes.get(&t);
-    }
-
-    debug!("static_size_of_enum %s", ty_to_str(cx.tcx, t));
-
+    if cx.enum_sizes.contains_key(&t) { return cx.enum_sizes.get(&t); }
     match ty::get(t).sty {
-        ty::ty_enum(tid, ref substs) => {
-            // Compute max(variant sizes).
-            let mut max_size = 0;
-            let variants = ty::enum_variants(cx.tcx, tid);
-            for variants.each |variant| {
-                if variant.args.len() == 0 {
-                    loop;
-                }
-
-                let lltypes = variant.args.map(|&variant_arg| {
-                    let substituted = ty::subst(cx.tcx, substs, variant_arg);
-                    type_of::sizing_type_of(cx, substituted)
-                });
-
-                debug!("static_size_of_enum: variant %s type %s",
-                       cx.tcx.sess.str_of(variant.name),
-                       ty_str(cx.tn, T_struct(lltypes)));
-
-                let this_size = llsize_of_real(cx, T_struct(lltypes));
-                if max_size < this_size {
-                    max_size = this_size;
-                }
-            }
-            cx.enum_sizes.insert(t, max_size);
-            return max_size;
+      ty::ty_enum(tid, ref substs) => {
+        // Compute max(variant sizes).
+        let mut max_size = 0u;
+        let variants = ty::enum_variants(cx.tcx, tid);
+        for vec::each(*variants) |variant| {
+            let tup_ty = simplify_type(
+                cx.tcx,
+                ty::mk_tup(cx.tcx, /*bad*/copy variant.args));
+            // Perform any type parameter substitutions.
+            let tup_ty = ty::subst(cx.tcx, substs, tup_ty);
+            // Here we possibly do a recursive call.
+            let this_size =
+                llsize_of_real(cx, type_of::type_of(cx, tup_ty));
+            if max_size < this_size { max_size = this_size; }
         }
-        _ => cx.sess.bug(~"static_size_of_enum called on non-enum")
+        cx.enum_sizes.insert(t, max_size);
+        return max_size;
+      }
+      _ => cx.sess.bug(~"static_size_of_enum called on non-enum")
     }
 }
 

branches/incoming/src/librustc/middle/trans/type_of.rs

@@ -89,95 +89,6 @@ pub fn type_of_non_gc_box(cx: @crate_ctxt, t: ty::t) -> TypeRef {
     }
 }
 
-// A "sizing type" is an LLVM type, the size and alignment of which are
-// guaranteed to be equivalent to what you would get out of `type_of()`. It's
-// useful because:
-//
-// (1) It may be cheaper to compute the sizing type than the full type if all
-//     you're interested in is the size and/or alignment;
-//
-// (2) It won't make any recursive calls to determine the structure of the
-//     type behind pointers. This can help prevent infinite loops for
-//     recursive types. For example, `static_size_of_enum()` relies on this
-//     behavior.
-
-pub fn sizing_type_of(cx: @crate_ctxt, t: ty::t) -> TypeRef {
-    if cx.llsizingtypes.contains_key(&t) {
-        return cx.llsizingtypes.get(&t);
-    }
-
-    let llsizingty = match ty::get(t).sty {
-        ty::ty_nil | ty::ty_bot => T_nil(),
-        ty::ty_bool => T_bool(),
-        ty::ty_int(t) => T_int_ty(cx, t),
-        ty::ty_uint(t) => T_uint_ty(cx, t),
-        ty::ty_float(t) => T_float_ty(cx, t),
-
-        ty::ty_estr(ty::vstore_uniq) |
-        ty::ty_estr(ty::vstore_box) |
-        ty::ty_evec(_, ty::vstore_uniq) |
-        ty::ty_evec(_, ty::vstore_box) |
-        ty::ty_box(*) |
-        ty::ty_opaque_box |
-        ty::ty_uniq(*) |
-        ty::ty_ptr(*) |
-        ty::ty_rptr(*) |
-        ty::ty_type |
-        ty::ty_opaque_closure_ptr(*) => T_ptr(T_i8()),
-
-        ty::ty_estr(ty::vstore_slice(*)) |
-        ty::ty_evec(_, ty::vstore_slice(*)) => {
-            T_struct(~[T_ptr(T_i8()), T_ptr(T_i8())])
-        }
-
-        // FIXME(#4804) Bare fn repr
-        ty::ty_bare_fn(*) => T_struct(~[T_ptr(T_i8()), T_ptr(T_i8())]),
-        ty::ty_closure(*) => T_struct(~[T_ptr(T_i8()), T_ptr(T_i8())]),
-        ty::ty_trait(_, _, vstore) => T_opaque_trait(cx, vstore),
-
-        ty::ty_estr(ty::vstore_fixed(size)) => T_array(T_i8(), size),
-        ty::ty_evec(mt, ty::vstore_fixed(size)) => {
-            T_array(sizing_type_of(cx, mt.ty), size)
-        }
-
-        ty::ty_unboxed_vec(mt) => T_vec(cx, sizing_type_of(cx, mt.ty)),
-
-        ty::ty_tup(ref elems) => {
-            T_struct(elems.map(|&t| sizing_type_of(cx, t)))
-        }
-
-        ty::ty_rec(ref fields) => {
-            T_struct(fields.map(|f| sizing_type_of(cx, f.mt.ty)))
-        }
-
-        ty::ty_struct(def_id, ref substs) => {
-            let fields = ty::lookup_struct_fields(cx.tcx, def_id);
-            let lltype = T_struct(fields.map(|field| {
-                let field_type = ty::lookup_field_type(cx.tcx,
-                                                       def_id,
-                                                       field.id,
-                                                       substs);
-                sizing_type_of(cx, field_type)
-            }));
-            if ty::ty_dtor(cx.tcx, def_id).is_present() {
-                T_struct(~[lltype, T_i8()])
-            } else {
-                lltype
-            }
-        }
-
-        ty::ty_enum(def_id, _) => T_struct(enum_body_types(cx, def_id, t)),
-
-        ty::ty_self | ty::ty_infer(*) | ty::ty_param(*) | ty::ty_err(*) => {
-            cx.tcx.sess.bug(~"fictitious type in sizing_type_of()")
-        }
-    };
-
-    cx.llsizingtypes.insert(t, llsizingty);
-    llsizingty
-}
-
-// NB: If you update this, be sure to update `sizing_type_of()` as well.
 pub fn type_of(cx: @crate_ctxt, t: ty::t) -> TypeRef {
     debug!("type_of %?: %?", t, ty::get(t));
 
@@ -325,23 +236,23 @@ pub fn type_of(cx: @crate_ctxt, t: ty::t) -> TypeRef {
     return llty;
 }
 
-pub fn enum_body_types(cx: @crate_ctxt, did: ast::def_id, t: ty::t)
-                    -> ~[TypeRef] {
-    let univar = ty::enum_is_univariant(cx.tcx, did);
-    let size = machine::static_size_of_enum(cx, t);
-    if !univar {
-        ~[T_enum_discrim(cx), T_array(T_i8(), size)]
-    } else {
-        ~[T_array(T_i8(), size)]
-    }
-}
-
-pub fn fill_type_of_enum(cx: @crate_ctxt,
-                         did: ast::def_id,
-                         t: ty::t,
+pub fn fill_type_of_enum(cx: @crate_ctxt, did: ast::def_id, t: ty::t,
                          llty: TypeRef) {
+
     debug!("type_of_enum %?: %?", t, ty::get(t));
-    common::set_struct_body(llty, enum_body_types(cx, did, t));
+
+    let lltys = {
+        let univar = ty::enum_is_univariant(cx.tcx, did);
+        let size = machine::static_size_of_enum(cx, t);
+        if !univar {
+            ~[T_enum_discrim(cx), T_array(T_i8(), size)]
+        }
+        else {
+            ~[T_array(T_i8(), size)]
+        }
+    };
+
+    common::set_struct_body(llty, lltys);
 }
 
 // Want refinements! (Or case classes, I guess

branches/incoming/src/libsyntax/ast.rs

@@ -67,6 +67,12 @@ pub impl to_bytes::IterBytes for ident {
 // Functions may or may not have names.
 pub type fn_ident = Option<ident>;
 
+pub struct Lifetime {
+    id: node_id,
+    span: span,
+    ident: ident
+}
+
 #[auto_encode]
 #[auto_decode]
 #[deriving_eq]