auto merge of rust-lang#14483 : ahmedcharles/rust/patbox, r=alexcrichton

Author: bors

src/librustc/middle/cfg/construct.rs

@@ -113,7 +113,7 @@ impl<'a> CFGBuilder<'a> {
  self.add_node(pat.id, [pred])
  }
 
- ast::PatUniq(subpat) |
+ ast::PatBox(subpat) |
  ast::PatRegion(subpat) |
  ast::PatIdent(_, _, Some(subpat)) => {
  let subpat_exit = self.pat(subpat, pred);

src/librustc/middle/check_match.rs

@@ -383,7 +383,7 @@ fn pat_ctor_id(cx: &MatchCheckCtxt, p: @Pat) -> Option<ctor> {
  _ => Some(single)
  }
  }
- PatUniq(_) | PatTup(_) | PatRegion(..) => {
+ PatBox(_) | PatTup(_) | PatRegion(..) => {
  Some(single)
  }
  PatVec(ref before, slice, ref after) => {
@@ -764,7 +764,7 @@ fn specialize(cx: &MatchCheckCtxt,
  PatTup(args) => {
  Some(args.iter().map(|x| *x).collect::<Vec<_>>().append(r.tail()))
  }
- PatUniq(a) | PatRegion(a) => {
+ PatBox(a) | PatRegion(a) => {
  Some((vec!(a)).append(r.tail()))
  }
  PatLit(expr) => {
@@ -924,7 +924,7 @@ fn find_refutable(cx: &MatchCheckCtxt, pat: &Pat, spans: &mut Vec<Span>) {
  }
 
  match pat.node {
- PatUniq(sub) | PatRegion(sub) | PatIdent(_, _, Some(sub)) => {
+ PatBox(sub) | PatRegion(sub) | PatIdent(_, _, Some(sub)) => {
  find_refutable(cx, sub, spans)
  }
  PatWild | PatWildMulti | PatIdent(_, _, None) => {}

src/librustc/middle/mem_categorization.rs

@@ -1064,7 +1064,7 @@ impl<'t,TYPER:Typer> MemCategorizationContext<'t,TYPER> {
  }
  }
 
- ast::PatUniq(subpat) | ast::PatRegion(subpat) => {
+ ast::PatBox(subpat) | ast::PatRegion(subpat) => {
  // @p1, ~p1
  let subcmt = self.cat_deref(pat, cmt, 0);
  if_ok!(self.cat_pattern(subcmt, subpat, op));

src/librustc/middle/region.rs

@@ -671,7 +671,7 @@ fn resolve_local(visitor: &mut RegionResolutionVisitor,
  subpats.iter().any(|&p| is_binding_pat(p))
  }
 
- ast::PatUniq(subpat) => {
+ ast::PatBox(subpat) => {
  is_binding_pat(subpat)
  }
 

src/librustc/middle/trans/_match.rs

@@ -838,7 +838,7 @@ fn enter_uniq<'a, 'b>(
  let dummy = @ast::Pat {id: 0, node: ast::PatWild, span: DUMMY_SP};
  enter_match(bcx, dm, m, col, val, |p| {
  match p.node {
- ast::PatUniq(sub) => {
+ ast::PatBox(sub) => {
  Some(vec!(sub))
  }
  _ => {
@@ -1105,7 +1105,7 @@ macro_rules! any_pat (
 )
 
 fn any_uniq_pat(m: &[Match], col: uint) -> bool {
- any_pat!(m, ast::PatUniq(_))
+ any_pat!(m, ast::PatBox(_))
 }
 
 fn any_region_pat(m: &[Match], col: uint) -> bool {
@@ -2270,7 +2270,7 @@ fn bind_irrefutable_pat<'a>(
  binding_mode, cleanup_scope);
  }
  }
- ast::PatUniq(inner) => {
+ ast::PatBox(inner) => {
  let llbox = Load(bcx, val);
  bcx = bind_irrefutable_pat(bcx, inner, llbox, binding_mode, cleanup_scope);
  }

src/librustc/middle/trans/debuginfo.rs

@@ -2632,7 +2632,7 @@ fn populate_scope_map(cx: &CrateContext,
  }
  }
 
- ast::PatUniq(sub_pat) | ast::PatRegion(sub_pat) => {
+ ast::PatBox(sub_pat) | ast::PatRegion(sub_pat) => {
  scope_map.insert(pat.id, scope_stack.last().unwrap().scope_metadata);
  walk_pattern(cx, sub_pat, scope_stack, scope_map);
  }

src/librustc/middle/typeck/check/_match.rs

@@ -626,7 +626,7 @@ pub fn check_pat(pcx: &pat_ctxt, pat: &ast::Pat, expected: ty::t) {
  }
  }
  }
- ast::PatUniq(inner) => {
+ ast::PatBox(inner) => {
  check_pointer_pat(pcx, Send, inner, pat.id, pat.span, expected);
  }
  ast::PatRegion(inner) => {

src/librustdoc/clean/mod.rs

@@ -1721,7 +1721,7 @@ fn name_from_pat(p: &ast::Pat) -> String {
  PatStruct(..) => fail!("tried to get argument name from pat_struct, \
  which is not allowed in function arguments"),
  PatTup(..) => "(tuple arg NYI)".to_string(),
- PatUniq(p) => name_from_pat(p),
+ PatBox(p) => name_from_pat(p),
  PatRegion(p) => name_from_pat(p),
  PatLit(..) => {
  warn!("tried to get argument name from PatLit, \

src/libsyntax/ast.rs

@@ -347,7 +347,7 @@ pub enum Pat_ {
  * we don't bind the fields to names */
  PatStruct(Path, Vec<FieldPat> , bool),
  PatTup(Vec<@Pat> ),
- PatUniq(@Pat),
+ PatBox(@Pat),
  PatRegion(@Pat), // reference pattern
  PatLit(@Expr),
  PatRange(@Expr, @Expr),

src/libsyntax/ast_util.rs

@@ -657,7 +657,7 @@ pub fn walk_pat(pat: &Pat, it: |&Pat| -> bool) -> bool {
  PatEnum(_, Some(ref s)) | PatTup(ref s) => {
  s.iter().advance(|&p| walk_pat(p, |p| it(p)))
  }
- PatUniq(s) | PatRegion(s) => {
+ PatBox(s) | PatRegion(s) => {
  walk_pat(s, it)
  }
  PatVec(ref before, ref slice, ref after) => {