---

yaml
---
r: 47039
b: refs/heads/try
c: fe9f1d1
h: refs/heads/master
i:
  47037: e30f481
  47035: 2086dfe
  47031: 58dfff7
  47023: 3e87146
  47007: 2737d6b
  46975: a0ffc72
v: v3

Author: z0w0

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 3bbcac322669cff3abde5be937cc4ec3860f3985
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d9689399d091c3265f00434a69c551a61c28dc
-refs/heads/try: d3f3d0731cb1c6050b540bc5542b575dd19844fa
+refs/heads/try: fe9f1d155ab674e402cdb1b530df8ecb66bb7dd4
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

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

@@ -7,6 +7,7 @@
 
 (require 'cm-mode)
 (require 'cc-mode)
+(eval-when-compile (require 'cl))
 
 (defun rust-electric-brace (arg)
   (interactive "*P")
@@ -16,12 +17,6 @@
                           '(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)
@@ -106,7 +101,14 @@
            (rust-push-context st 'string (current-column) t)
            (setf (rust-state-tokenize st) 'rust-token-string)
            (rust-token-string st))
-      (def ?\' (rust-single-quote))
+      (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 ?/ (forward-char)
            (case (char-after)
              (?/ (end-of-line) 'font-lock-comment-face)
@@ -120,7 +122,12 @@
                  ((rust-eat-re "[a-z_]+") (setf rust-tcat 'macro)))
            'font-lock-preprocessor-face)
       (def ((?a . ?z) (?A . ?Z) ?_)
-           (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)))
       (def ((?0 . ?9))
            (rust-eat-re "0x[0-9a-fA-F_]+\\|0b[01_]+\\|[0-9_]+\\(\\.[0-9_]+\\)?\\(e[+\\-]?[0-9_]+\\)?")
            (setf rust-tcat 'atom)
@@ -143,31 +150,6 @@
            (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))
 
@@ -208,10 +190,6 @@
   (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)
@@ -228,8 +206,6 @@
         (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/try/src/librustc/back/link.rs

@@ -497,8 +497,7 @@ pub fn build_link_meta(sess: Session, c: &ast::crate, output: &Path,
 
         let cmh_items = attr::sort_meta_items(cmh_items);
 
-        symbol_hasher.reset();
-        for cmh_items.each |m| {
+        fn hash(symbol_hasher: &hash::State, m: &@ast::meta_item) {
             match m.node {
               ast::meta_name_value(ref key, value) => {
                 symbol_hasher.write_str(len_and_str((*key)));
@@ -507,13 +506,20 @@ pub fn build_link_meta(sess: Session, c: &ast::crate, output: &Path,
               ast::meta_word(ref name) => {
                 symbol_hasher.write_str(len_and_str((*name)));
               }
-              ast::meta_list(_, _) => {
-                // FIXME (#607): Implement this
-                fail!(~"unimplemented meta_item variant");
+              ast::meta_list(ref name, ref mis) => {
+                symbol_hasher.write_str(len_and_str((*name)));
+                for mis.each |m_| {
+                    hash(symbol_hasher, m_);
+                }
               }
             }
         }
 
+        symbol_hasher.reset();
+        for cmh_items.each |m| {
+            hash(symbol_hasher, m);
+        }
+
         for dep_hashes.each |dh| {
             symbol_hasher.write_str(len_and_str(*dh));
         }

branches/try/src/libsyntax/ast.rs

@@ -67,12 +67,6 @@ 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]

branches/try/src/libsyntax/attr.rs

@@ -192,13 +192,15 @@ fn eq(a: @ast::meta_item, b: @ast::meta_item) -> bool {
             }
             _ => false
           },
-          ast::meta_list(*) => {
-
-            // ~[Fixme-sorting]
-            // FIXME (#607): Needs implementing
-            // This involves probably sorting the list by name and
-            // meta_item variant
-            fail!(~"unimplemented meta_item variant")
+          ast::meta_list(ref na, misa) => match b.node {
+            ast::meta_list(ref nb, misb) => {
+                if na != nb { return false; }
+                for misa.each |&mi| {
+                    if !contains(misb, mi) { return false; }
+                }
+                true
+            }
+            _ => false
           }
         }
 }
@@ -253,8 +255,6 @@ pub fn last_meta_item_list_by_name(items: ~[@ast::meta_item], name: ~str)
 
 /* Higher-level applications */
 
-// FIXME (#607): This needs to sort by meta_item variant in addition to
-// the item name (See [Fixme-sorting])
 pub fn sort_meta_items(+items: ~[@ast::meta_item]) -> ~[@ast::meta_item] {
     pure fn lteq(ma: &@ast::meta_item, mb: &@ast::meta_item) -> bool {
         pure fn key(m: &ast::meta_item) -> ~str {
@@ -270,7 +270,17 @@ pub fn sort_meta_items(+items: ~[@ast::meta_item]) -> ~[@ast::meta_item] {
     // This is sort of stupid here, converting to a vec of mutables and back
     let mut v: ~[@ast::meta_item] = items;
     std::sort::quick_sort(v, lteq);
-    v
+
+    // There doesn't seem to be a more optimal way to do this
+    do v.map |&m| {
+        match m.node {
+          ast::meta_list(n, mis) => @spanned {
+              node: ast::meta_list(n, sort_meta_items(mis)),
+              .. *m
+          },
+          _ => m
+        }
+    }
 }
 
 pub fn remove_meta_items_by_name(items: ~[@ast::meta_item], name: ~str) ->