Auto merge of #46778 - petrochenkov:nounwrap, r=arielb1

bors · bors · commit 53a6d14e5bb8 · 2017-12-17T04:23:55.000Z
syntax: Rename `P::unwrap` into something less alarming
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
@@ -2063,9 +2063,9 @@ impl Clean<Type> for hir::Ty {
                         for (i, ty_param) in generics.ty_params.iter().enumerate() {
                             let ty_param_def = Def::TyParam(cx.tcx.hir.local_def_id(ty_param.id));
                             if let Some(ty) = provided_params.types.get(i).cloned() {
-                                ty_substs.insert(ty_param_def, ty.unwrap().clean(cx));
+                                ty_substs.insert(ty_param_def, ty.into_inner().clean(cx));
                             } else if let Some(default) = ty_param.default.clone() {
-                                ty_substs.insert(ty_param_def, default.unwrap().clean(cx));
+                                ty_substs.insert(ty_param_def, default.into_inner().clean(cx));
                             }
                         }
                         for (i, lt_param) in generics.lifetimes.iter().enumerate() {
diff --git a/src/libsyntax/config.rs b/src/libsyntax/config.rs
@@ -284,13 +284,13 @@ impl<'a> fold::Folder for StripUnconfigured<'a> {
     }
 
     fn fold_expr(&mut self, expr: P<ast::Expr>) -> P<ast::Expr> {
-        let mut expr = self.configure_expr(expr).unwrap();
+        let mut expr = self.configure_expr(expr).into_inner();
         expr.node = self.configure_expr_kind(expr.node);
         P(fold::noop_fold_expr(expr, self))
     }
 
     fn fold_opt_expr(&mut self, expr: P<ast::Expr>) -> Option<P<ast::Expr>> {
-        let mut expr = configure!(self, expr).unwrap();
+        let mut expr = configure!(self, expr).into_inner();
         expr.node = self.configure_expr_kind(expr.node);
         Some(P(fold::noop_fold_expr(expr, self)))
     }
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
@@ -85,14 +85,14 @@ impl Annotatable {
 
     pub fn expect_trait_item(self) -> ast::TraitItem {
         match self {
-            Annotatable::TraitItem(i) => i.unwrap(),
+            Annotatable::TraitItem(i) => i.into_inner(),
             _ => panic!("expected Item")
         }
     }
 
     pub fn expect_impl_item(self) -> ast::ImplItem {
         match self {
-            Annotatable::ImplItem(i) => i.unwrap(),
+            Annotatable::ImplItem(i) => i.into_inner(),
             _ => panic!("expected Item")
         }
     }
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
@@ -242,7 +242,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
             tokens: None,
         })));
 
-        match self.expand(krate_item).make_items().pop().map(P::unwrap) {
+        match self.expand(krate_item).make_items().pop().map(P::into_inner) {
             Some(ast::Item { attrs, node: ast::ItemKind::Mod(module), .. }) => {
                 krate.attrs = attrs;
                 krate.module = module;
@@ -504,8 +504,8 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
             AttrProcMacro(ref mac) => {
                 let item_tok = TokenTree::Token(DUMMY_SP, Token::interpolated(match item {
                     Annotatable::Item(item) => token::NtItem(item),
-                    Annotatable::TraitItem(item) => token::NtTraitItem(item.unwrap()),
-                    Annotatable::ImplItem(item) => token::NtImplItem(item.unwrap()),
+                    Annotatable::TraitItem(item) => token::NtTraitItem(item.into_inner()),
+                    Annotatable::ImplItem(item) => token::NtImplItem(item.into_inner()),
                 })).into();
                 let tok_result = mac.expand(self.cx, attr.span, attr.tokens, item_tok);
                 self.parse_expansion(tok_result, kind, &attr.path, attr.span)
@@ -863,7 +863,7 @@ pub fn find_attr_invoc(attrs: &mut Vec<ast::Attribute>) -> Option<ast::Attribute
 
 impl<'a, 'b> Folder for InvocationCollector<'a, 'b> {
     fn fold_expr(&mut self, expr: P<ast::Expr>) -> P<ast::Expr> {
-        let mut expr = self.cfg.configure_expr(expr).unwrap();
+        let mut expr = self.cfg.configure_expr(expr).into_inner();
         expr.node = self.cfg.configure_expr_kind(expr.node);
 
         if let ast::ExprKind::Mac(mac) = expr.node {
@@ -875,7 +875,7 @@ impl<'a, 'b> Folder for InvocationCollector<'a, 'b> {
     }
 
     fn fold_opt_expr(&mut self, expr: P<ast::Expr>) -> Option<P<ast::Expr>> {
-        let mut expr = configure!(self, expr).unwrap();
+        let mut expr = configure!(self, expr).into_inner();
         expr.node = self.cfg.configure_expr_kind(expr.node);
 
         if let ast::ExprKind::Mac(mac) = expr.node {
@@ -906,7 +906,7 @@ impl<'a, 'b> Folder for InvocationCollector<'a, 'b> {
         };
 
         let (mac, style, attrs) = if let StmtKind::Mac(mac) = stmt.node {
-            mac.unwrap()
+            mac.into_inner()
         } else {
             // The placeholder expander gives ids to statements, so we avoid folding the id here.
             let ast::Stmt { id, node, span } = stmt;
@@ -1056,7 +1056,7 @@ impl<'a, 'b> Folder for InvocationCollector<'a, 'b> {
 
     fn fold_ty(&mut self, ty: P<ast::Ty>) -> P<ast::Ty> {
         let ty = match ty.node {
-            ast::TyKind::Mac(_) => ty.unwrap(),
+            ast::TyKind::Mac(_) => ty.into_inner(),
             _ => return fold::noop_fold_ty(ty, self),
         };
 
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
@@ -1456,7 +1456,7 @@ impl<'a> Parser<'a> {
             self.expect(&token::CloseDelim(token::Paren))?;
 
             if ts.len() == 1 && !last_comma {
-                let ty = ts.into_iter().nth(0).unwrap().unwrap();
+                let ty = ts.into_iter().nth(0).unwrap().into_inner();
                 let maybe_bounds = allow_plus && self.token == token::BinOp(token::Plus);
                 match ty.node {
                     // `(TY_BOUND_NOPAREN) + BOUND + ...`.
@@ -6077,7 +6077,7 @@ impl<'a> Parser<'a> {
     fn parse_item_(&mut self, attrs: Vec<Attribute>,
                    macros_allowed: bool, attributes_allowed: bool) -> PResult<'a, Option<P<Item>>> {
         maybe_whole!(self, NtItem, |item| {
-            let mut item = item.unwrap();
+            let mut item = item.into_inner();
             let mut attrs = attrs;
             mem::swap(&mut item.attrs, &mut attrs);
             item.attrs.extend(attrs);
diff --git a/src/libsyntax/ptr.rs b/src/libsyntax/ptr.rs
@@ -68,7 +68,7 @@ impl<T: 'static> P<T> {
         f(*self.ptr)
     }
     /// Equivalent to and_then(|x| x)
-    pub fn unwrap(self) -> T {
+    pub fn into_inner(self) -> T {
         *self.ptr
     }
 
diff --git a/src/libsyntax/test.rs b/src/libsyntax/test.rs
@@ -141,7 +141,7 @@ impl<'a> fold::Folder for TestHarnessGenerator<'a> {
             }
         }
 
-        let mut item = i.unwrap();
+        let mut item = i.into_inner();
         // We don't want to recurse into anything other than mods, since
         // mods or tests inside of functions will break things
         if let ast::ItemKind::Mod(module) = item.node {

Original file line number	Diff line number	Diff line change
`@@ -2063,9 +2063,9 @@ impl Clean<Type> for hir::Ty {`
`2063`	`2063`	`for (i, ty_param) in generics.ty_params.iter().enumerate() {`
`2064`	`2064`	`let ty_param_def = Def::TyParam(cx.tcx.hir.local_def_id(ty_param.id));`
`2065`	`2065`	`if let Some(ty) = provided_params.types.get(i).cloned() {`
`2066`		`- ty_substs.insert(ty_param_def, ty.unwrap().clean(cx));`
	`2066`	`+ ty_substs.insert(ty_param_def, ty.into_inner().clean(cx));`
`2067`	`2067`	`} else if let Some(default) = ty_param.default.clone() {`
`2068`		`- ty_substs.insert(ty_param_def, default.unwrap().clean(cx));`
	`2068`	`+ ty_substs.insert(ty_param_def, default.into_inner().clean(cx));`
`2069`	`2069`	`}`
`2070`	`2070`	`}`
`2071`	`2071`	`for (i, lt_param) in generics.lifetimes.iter().enumerate() {`
Original file line number	Diff line number	Diff line change
`@@ -284,13 +284,13 @@ impl<'a> fold::Folder for StripUnconfigured<'a> {`
`284`	`284`	`}`
`285`	`285`
`286`	`286`	`fn fold_expr(&mut self, expr: P<ast::Expr>) -> P<ast::Expr> {`
`287`		`- let mut expr = self.configure_expr(expr).unwrap();`
	`287`	`+ let mut expr = self.configure_expr(expr).into_inner();`
`288`	`288`	`expr.node = self.configure_expr_kind(expr.node);`
`289`	`289`	`P(fold::noop_fold_expr(expr, self))`
`290`	`290`	`}`
`291`	`291`
`292`	`292`	`fn fold_opt_expr(&mut self, expr: P<ast::Expr>) -> Option<P<ast::Expr>> {`
`293`		`- let mut expr = configure!(self, expr).unwrap();`
	`293`	`+ let mut expr = configure!(self, expr).into_inner();`
`294`	`294`	`expr.node = self.configure_expr_kind(expr.node);`
`295`	`295`	`Some(P(fold::noop_fold_expr(expr, self)))`
`296`	`296`	`}`
Original file line number	Diff line number	Diff line change
`@@ -85,14 +85,14 @@ impl Annotatable {`
`85`	`85`
`86`	`86`	`pub fn expect_trait_item(self) -> ast::TraitItem {`
`87`	`87`	`match self {`
`88`		`- Annotatable::TraitItem(i) => i.unwrap(),`
	`88`	`+ Annotatable::TraitItem(i) => i.into_inner(),`
`89`	`89`	`_ => panic!("expected Item")`
`90`	`90`	`}`
`91`	`91`	`}`
`92`	`92`
`93`	`93`	`pub fn expect_impl_item(self) -> ast::ImplItem {`
`94`	`94`	`match self {`
`95`		`- Annotatable::ImplItem(i) => i.unwrap(),`
	`95`	`+ Annotatable::ImplItem(i) => i.into_inner(),`
`96`	`96`	`_ => panic!("expected Item")`
`97`	`97`	`}`
`98`	`98`	`}`
Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,7 @@ impl<T: 'static> P<T> {`
`68`	`68`	`f(*self.ptr)`
`69`	`69`	`}`
`70`	`70`	`/// Equivalent to and_then(\|x\| x)`
`71`		`- pub fn unwrap(self) -> T {`
	`71`	`+ pub fn into_inner(self) -> T {`
`72`	`72`	`*self.ptr`
`73`	`73`	`}`
`74`	`74`
Original file line number	Diff line number	Diff line change
`@@ -141,7 +141,7 @@ impl<'a> fold::Folder for TestHarnessGenerator<'a> {`
`141`	`141`	`}`
`142`	`142`	`}`
`143`	`143`
`144`		`- let mut item = i.unwrap();`
	`144`	`+ let mut item = i.into_inner();`
`145`	`145`	`// We don't want to recurse into anything other than mods, since`
`146`	`146`	`// mods or tests inside of functions will break things`
`147`	`147`	`if let ast::ItemKind::Mod(module) = item.node {`