rustc: Parse by-reference pattern bindings with the "ref" keyword

Author: pcwalton

src/cargo/cargo.rs

@@ -20,7 +20,7 @@ type package = {
     url: ~str,
     method: ~str,
     description: ~str,
-    ref: option<~str>,
+    reference: option<~str>,
     tags: ~[~str],
     versions: ~[(~str, ~str)]
 };
@@ -497,7 +497,7 @@ fn load_one_source_package(src: source, p: map::hashmap<~str, json::json>) {
         }
     };
 
-    let ref = alt p.find(~"ref") {
+    let reference = alt p.find(~"ref") {
         some(json::string(n)) { some(*n) }
         _ { none }
     };
@@ -530,7 +530,7 @@ fn load_one_source_package(src: source, p: map::hashmap<~str, json::json>) {
         url: url,
         method: method,
         description: description,
-        ref: ref,
+        reference: reference,
         tags: tags,
         versions: ~[]
     };
@@ -815,10 +815,10 @@ fn install_source(c: cargo, path: ~str) {
     }
 }
 
-fn install_git(c: cargo, wd: ~str, url: ~str, ref: option<~str>) {
+fn install_git(c: cargo, wd: ~str, url: ~str, reference: option<~str>) {
     run::program_output(~"git", ~[~"clone", url, wd]);
-    if option::is_some(ref) {
-        let r = option::get(ref);
+    if option::is_some(reference) {
+        let r = option::get(reference);
         os::change_dir(wd);
         run::run_program(~"git", ~[~"checkout", r]);
     }
@@ -855,7 +855,7 @@ fn install_package(c: cargo, src: ~str, wd: ~str, pkg: package) {
     info(fmt!{"installing %s/%s via %s...", src, pkg.name, method});
 
     alt method {
-        ~"git" { install_git(c, wd, url, copy pkg.ref); }
+        ~"git" { install_git(c, wd, url, copy pkg.reference); }
         ~"file" { install_file(c, wd, url); }
         ~"curl" { install_curl(c, wd, copy url); }
         _ {}
@@ -1034,12 +1034,12 @@ fn install_query(c: cargo, wd: ~str, target: ~str) {
         install_file(c, wd, target);
         ret;
     } else if is_git_url(target) {
-        let ref = if c.opts.free.len() >= 4u {
+        let reference = if c.opts.free.len() >= 4u {
             some(c.opts.free[3u])
         } else {
             none
         };
-        install_git(c, wd, target, ref);
+        install_git(c, wd, target, reference);
     } else if !valid_pkg_name(target) && has_archive_extension(target) {
         install_curl(c, wd, target);
         ret;

src/libcore/vec.rs

@@ -536,7 +536,7 @@ fn push_slow<T>(&v: ~[const T], +initval: T) {
 
 // Unchecked vector indexing
 #[inline(always)]
-unsafe fn ref<T: copy>(v: &[const T], i: uint) -> T {
+unsafe fn get_ref<T: copy>(v: &[const T], i: uint) -> T {
     as_buf(v, |p, _len| *ptr::offset(p, i))
 }
 
@@ -555,7 +555,7 @@ fn push_all<T: copy>(&v: ~[const T], rhs: &[const T]) {
     reserve(v, v.len() + rhs.len());
 
     for uint::range(0u, rhs.len()) |i| {
-        push(v, unsafe { ref(rhs, i) })
+        push(v, unsafe { get_ref(rhs, i) })
     }
 }
 

src/libsyntax/ast.rs

@@ -145,6 +145,12 @@ type pat = {id: node_id, node: pat_, span: span};
 #[auto_serialize]
 type field_pat = {ident: ident, pat: @pat};
 
+#[auto_serialize]
+enum binding_mode {
+    bind_by_value,
+    bind_by_ref
+}
+
 #[auto_serialize]
 enum pat_ {
     pat_wild,
@@ -155,7 +161,7 @@ enum pat_ {
     // which it is. The resolver determines this, and
     // records this pattern's node_id in an auxiliary
     // set (of "pat_idents that refer to nullary enums")
-    pat_ident(@path, option<@pat>),
+    pat_ident(binding_mode, @path, option<@pat>),
     pat_enum(@path, option<~[@pat]>), // "none" means a * pattern where
                                   // we don't bind the fields to names
     pat_rec(~[field_pat], bool),

src/libsyntax/ast_map.rs

@@ -158,7 +158,7 @@ fn map_block(b: blk, cx: ctx, v: vt) {
 fn number_pat(cx: ctx, pat: @pat) {
     do ast_util::walk_pat(pat) |p| {
         alt p.node {
-          pat_ident(_, _) {
+          pat_ident(*) {
             cx.map.insert(p.id, node_local(cx.local_id));
             cx.local_id += 1u;
           }

src/libsyntax/ast_util.rs

@@ -568,15 +568,15 @@ pure fn is_item_impl(item: @ast::item) -> bool {
 fn walk_pat(pat: @pat, it: fn(@pat)) {
     it(pat);
     alt pat.node {
-      pat_ident(pth, some(p)) { walk_pat(p, it); }
+      pat_ident(_, pth, some(p)) { walk_pat(p, it); }
       pat_rec(fields, _) {
         for fields.each |f| { walk_pat(f.pat, it); }
       }
       pat_enum(_, some(s)) | pat_tup(s) {
         for s.each |p| { walk_pat(p, it); }
       }
       pat_box(s) | pat_uniq(s) { walk_pat(s, it); }
-      pat_wild | pat_lit(_) | pat_range(_, _) | pat_ident(_, _)
+      pat_wild | pat_lit(_) | pat_range(_, _) | pat_ident(_, _, _)
         | pat_enum(_, _) {}
     }
 }

src/libsyntax/ext/auto_serialize.rs

@@ -228,7 +228,7 @@ impl helpers of ext_ctxt_helpers for ext_ctxt {
         let path = @{span: span, global: false, idents: ~[nm],
                      rp: none, types: ~[]};
         @{id: self.next_id(),
-          node: ast::pat_ident(path, none),
+          node: ast::pat_ident(ast::bind_by_ref, path, none),
           span: span}
     }
 
@@ -834,7 +834,9 @@ fn ser_enum(cx: ext_ctxt, tps: ser_tps_map, e_name: ast::ident,
             // Generate pattern var(v1, v2, v3)
             |pats| {
                 if vec::is_empty(pats) {
-                    ast::pat_ident(cx.path(v_span, ~[v_name]), none)
+                    ast::pat_ident(ast::bind_by_ref,
+                                   cx.path(v_span, ~[v_name]),
+                                   none)
                 } else {
                     ast::pat_enum(cx.path(v_span, ~[v_name]), some(pats))
                 }

src/libsyntax/ext/pipes/ast_builder.rs

@@ -116,8 +116,10 @@ impl ast_builder of ext_ctxt_ast_builder for ext_ctxt {
             @{node: {is_mutbl: false,
                      ty: self.ty_infer(),
                      pat: @{id: self.next_id(),
-                            node: ast::pat_ident(
-                                path(ident, self.empty_span()), none),
+                            node: ast::pat_ident(ast::bind_by_ref,
+                                                 path(ident,
+                                                      self.empty_span()),
+                                                 none),
                             span: self.empty_span()},
                      init: some({op: ast::init_move,
                                  expr: e}),

src/libsyntax/ext/qquote.rs

@@ -170,7 +170,7 @@ fn parse_crate(p: parser) -> @ast::crate { p.parse_crate_mod(~[]) }
 fn parse_ty(p: parser) -> @ast::ty { p.parse_ty(false) }
 fn parse_stmt(p: parser) -> @ast::stmt { p.parse_stmt(~[]) }
 fn parse_expr(p: parser) -> @ast::expr { p.parse_expr() }
-fn parse_pat(p: parser) -> @ast::pat { p.parse_pat() }
+fn parse_pat(p: parser) -> @ast::pat { p.parse_pat(true) }
 
 fn parse_item(p: parser) -> @ast::item {
     alt p.parse_item(~[], ast::public) {

src/libsyntax/ext/tt/earley_parser.rs

@@ -326,7 +326,7 @@ fn parse_nt(p: parser, name: ~str) -> nonterminal {
       }}
       ~"block" { token::nt_block(p.parse_block()) }
       ~"stmt" { token::nt_stmt(p.parse_stmt(~[])) }
-      ~"pat" { token::nt_pat(p.parse_pat()) }
+      ~"pat" { token::nt_pat(p.parse_pat(true)) }
       ~"expr" { token::nt_expr(p.parse_expr()) }
       ~"ty" { token::nt_ty(p.parse_ty(false /* no need to disambiguate*/)) }
       // this could be handled like a token, since it is one

src/libsyntax/fold.rs

@@ -332,8 +332,9 @@ fn noop_fold_arm(a: arm, fld: ast_fold) -> arm {
 fn noop_fold_pat(p: pat_, fld: ast_fold) -> pat_ {
     ret alt p {
           pat_wild { pat_wild }
-          pat_ident(pth, sub) {
-            pat_ident(fld.fold_path(pth),
+          pat_ident(binding_mode, pth, sub) {
+            pat_ident(binding_mode,
+                      fld.fold_path(pth),
                       option::map(sub, |x| fld.fold_pat(x)))
           }
           pat_lit(e) { pat_lit(fld.fold_expr(e)) }