Remove support for gen arg

Author: alexcrichton

src/doc/unstable-book/src/language-features/generators.md

@@ -36,11 +36,11 @@ fn main() {
         return "foo"
     };
 
-    match generator.resume(()) {
+    match generator.resume() {
         State::Yielded(1) => {}
         _ => panic!("unexpected value from resume"),
     }
-    match generator.resume(()) {
+    match generator.resume() {
         State::Complete("foo") => {}
         _ => panic!("unexpected value from resume"),
     }
@@ -69,9 +69,9 @@ fn main() {
     };
 
     println!("1");
-    generator.resume(());
+    generator.resume();
     println!("3");
-    generator.resume(());
+    generator.resume();
     println!("5");
 }
 ```
@@ -175,8 +175,8 @@ fn main() {
         return ret
     };
 
-    generator.resume(());
-    generator.resume(());
+    generator.resume();
+    generator.resume();
 }
 ```
 
@@ -200,7 +200,7 @@ fn main() {
             type Yield = i32;
             type Return = &'static str;
 
-            fn resume(&mut self, arg: ()) -> State<i32, &'static str> {
+            fn resume(&mut self) -> State<i32, &'static str> {
                 use std::mem;
                 match mem::replace(self, __Generator::Done) {
                     __Generator::Start(s) => {
@@ -223,8 +223,8 @@ fn main() {
         __Generator::Start(ret)
     };
 
-    generator.resume(());
-    generator.resume(());
+    generator.resume();
+    generator.resume();
 }
 ```
 

src/liballoc/boxed.rs

@@ -786,12 +786,12 @@ impl<T: ?Sized> AsMut<T> for Box<T> {
 }
 
 #[unstable(feature = "generator_trait", issue = "43122")]
-impl<T, U> Generator<U> for Box<T>
-    where T: Generator<U> + ?Sized
+impl<T> Generator for Box<T>
+    where T: Generator + ?Sized
 {
     type Yield = T::Yield;
     type Return = T::Return;
-    fn resume(&mut self, arg: U) -> State<Self::Yield, Self::Return> {
-        (**self).resume(arg)
+    fn resume(&mut self) -> State<Self::Yield, Self::Return> {
+        (**self).resume()
     }
 }

src/libcore/ops/generator.rs

@@ -56,11 +56,11 @@ pub enum State<Y, R> {
 ///         return "foo"
 ///     };
 ///
-///     match generator.resume(()) {
+///     match generator.resume() {
 ///         State::Yielded(1) => {}
 ///         _ => panic!("unexpected return from resume"),
 ///     }
-///     match generator.resume(()) {
+///     match generator.resume() {
 ///         State::Complete("foo") => {}
 ///         _ => panic!("unexpected return from resume"),
 ///     }
@@ -73,7 +73,7 @@ pub enum State<Y, R> {
 #[cfg_attr(not(stage0), lang = "generator")]
 #[unstable(feature = "generator_trait", issue = "43122")]
 #[fundamental]
-pub trait Generator<Arg = ()> {
+pub trait Generator {
     /// The type of value this generator yields.
     ///
     /// This associated type corresponds to the `yield` expression and the
@@ -116,16 +116,16 @@ pub trait Generator<Arg = ()> {
     /// been returned previously. While generator literals in the language are
     /// guaranteed to panic on resuming after `Complete`, this is not guaranteed
     /// for all implementations of the `Generator` trait.
-    fn resume(&mut self, arg: Arg) -> State<Self::Yield, Self::Return>;
+    fn resume(&mut self) -> State<Self::Yield, Self::Return>;
 }
 
 #[unstable(feature = "generator_trait", issue = "43122")]
-impl<'a, T, U> Generator<U> for &'a mut T
-    where T: Generator<U> + ?Sized
+impl<'a, T> Generator for &'a mut T
+    where T: Generator + ?Sized
 {
     type Yield = T::Yield;
     type Return = T::Return;
-    fn resume(&mut self, arg: U) -> State<Self::Yield, Self::Return> {
-        (**self).resume(arg)
+    fn resume(&mut self) -> State<Self::Yield, Self::Return> {
+        (**self).resume()
     }
 }

src/librustc/cfg/construct.rs

@@ -402,7 +402,6 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
 
             hir::ExprClosure(..) |
             hir::ExprLit(..) |
-            hir::ExprImplArg(_) |
             hir::ExprPath(_) => {
                 self.straightline(expr, pred, None::<hir::Expr>.iter())
             }

src/librustc/hir/intravisit.rs

@@ -399,9 +399,6 @@ pub fn walk_body<'v, V: Visitor<'v>>(visitor: &mut V, body: &'v Body) {
         visitor.visit_id(argument.id);
         visitor.visit_pat(&argument.pat);
     }
-    if let Some(ref impl_arg) = body.impl_arg {
-        visitor.visit_id(impl_arg.id);
-    }
     visitor.visit_expr(&body.value);
 }
 
@@ -1048,9 +1045,6 @@ pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr) {
         ExprYield(ref subexpression) => {
             visitor.visit_expr(subexpression);
         }
-        ExprImplArg(id) => {
-            visitor.visit_id(id);
-        },
     }
 }
 

src/librustc/hir/lowering.rs

@@ -92,7 +92,7 @@ pub struct LoweringContext<'a> {
     trait_impls: BTreeMap<DefId, Vec<NodeId>>,
     trait_default_impl: BTreeMap<DefId, NodeId>,
 
-    impl_arg: Option<NodeId>,
+    is_generator: hir::IsGenerator,
 
     catch_scopes: Vec<NodeId>,
     loop_scopes: Vec<NodeId>,
@@ -139,14 +139,14 @@ pub fn lower_crate(sess: &Session,
         trait_impls: BTreeMap::new(),
         trait_default_impl: BTreeMap::new(),
         exported_macros: Vec::new(),
-        impl_arg: None,
         catch_scopes: Vec::new(),
         loop_scopes: Vec::new(),
         is_in_loop_condition: false,
         type_def_lifetime_params: DefIdMap(),
         current_hir_id_owner: vec![(CRATE_DEF_INDEX, 0)],
         item_local_id_counters: NodeMap(),
         node_id_to_hir_id: IndexVec::new(),
+        is_generator: hir::IsGenerator::No,
     }.lower_crate(krate)
 }
 
@@ -365,24 +365,13 @@ impl<'a> LoweringContext<'a> {
         })
     }
 
-    fn impl_arg_id(&mut self) -> NodeId {
-        if self.impl_arg.is_none() {
-            self.impl_arg = Some(self.next_id());
-        }
-        self.impl_arg.unwrap()
-    }
-
     fn record_body(&mut self, value: hir::Expr, decl: Option<&FnDecl>)
                    -> hir::BodyId {
-        let span = value.span;
         let body = hir::Body {
             arguments: decl.map_or(hir_vec![], |decl| {
                 decl.inputs.iter().map(|x| self.lower_arg(x)).collect()
             }),
-            impl_arg: self.impl_arg.map(|id| hir::ImplArg {
-                id,
-                span,
-            }),
+            is_generator: self.is_generator == hir::IsGenerator::Yes,
             value,
         };
         let id = body.id();
@@ -443,12 +432,11 @@ impl<'a> LoweringContext<'a> {
     fn lower_body<F>(&mut self, decl: Option<&FnDecl>, f: F) -> hir::BodyId
         where F: FnOnce(&mut LoweringContext) -> hir::Expr
     {
-        let old_impl_arg = self.impl_arg;
-        self.impl_arg = None;
+        let prev = mem::replace(&mut self.is_generator, hir::IsGenerator::No);
         let result = f(self);
         let r = self.record_body(result, decl);
-        self.impl_arg = old_impl_arg;
-        r
+        self.is_generator = prev;
+        return r
     }
 
     fn with_loop_scope<T, F>(&mut self, loop_id: NodeId, f: F) -> T
@@ -1952,13 +1940,13 @@ impl<'a> LoweringContext<'a> {
             ExprKind::Closure(capture_clause, ref decl, ref body, fn_decl_span) => {
                 self.with_new_scopes(|this| {
                     this.with_parent_def(e.id, |this| {
-                        let mut gen = None;
+                        let mut gen = hir::IsGenerator::No;
                         let body_id = this.lower_body(Some(decl), |this| {
                             let e = this.lower_expr(body);
-                            gen = this.impl_arg.map(|_| hir::GeneratorClause::Movable);
+                            gen = this.is_generator;
                             e
                         });
-                        if gen.is_some() && !decl.inputs.is_empty() {
+                        if gen == hir::IsGenerator::Yes && !decl.inputs.is_empty() {
                             this.sess.span_fatal(
                                     fn_decl_span,
                                     &format!("generators cannot have explicit arguments"));
@@ -2104,17 +2092,13 @@ impl<'a> LoweringContext<'a> {
             }
 
             ExprKind::Yield(ref opt_expr) => {
-                self.impl_arg_id();
+                self.is_generator = hir::IsGenerator::Yes;
                 let expr = opt_expr.as_ref().map(|x| self.lower_expr(x)).unwrap_or_else(|| {
                     self.expr(e.span, hir::ExprTup(hir_vec![]), ThinVec::new())
                 });
                 hir::ExprYield(P(expr))
             }
 
-            ExprKind::ImplArg => {
-                hir::ExprImplArg(self.impl_arg_id())
-            }
-
             // Desugar ExprIfLet
             // From: `if let <pat> = <sub_expr> <body> [<else_opt>]`
             ExprKind::IfLet(ref pat, ref sub_expr, ref body, ref else_opt) => {

src/librustc/hir/map/collector.rs

@@ -182,13 +182,6 @@ impl<'hir> Visitor<'hir> for NodeCollector<'hir> {
         });
     }
 
-    fn visit_body(&mut self, b: &'hir Body) {
-        if let Some(ref impl_arg) = b.impl_arg {
-            self.insert(impl_arg.id, NodeImplArg(impl_arg));
-        }
-        intravisit::walk_body(self, b);
-    }
-
     fn visit_fn(&mut self, fk: intravisit::FnKind<'hir>, fd: &'hir FnDecl,
                 b: BodyId, s: Span, id: NodeId) {
         assert_eq!(self.parent_node, id);

src/librustc/hir/map/mod.rs

@@ -55,7 +55,6 @@ pub enum Node<'hir> {
     NodeTraitRef(&'hir TraitRef),
     NodeLocal(&'hir Pat),
     NodePat(&'hir Pat),
-    NodeImplArg(&'hir ImplArg),
     NodeBlock(&'hir Block),
 
     /// NodeStructCtor represents a tuple struct.
@@ -85,7 +84,6 @@ enum MapEntry<'hir> {
     EntryTy(NodeId, &'hir Ty),
     EntryTraitRef(NodeId, &'hir TraitRef),
     EntryLocal(NodeId, &'hir Pat),
-    EntryImplArg(NodeId, &'hir ImplArg),
     EntryPat(NodeId, &'hir Pat),
     EntryBlock(NodeId, &'hir Block),
     EntryStructCtor(NodeId, &'hir VariantData),
@@ -117,7 +115,6 @@ impl<'hir> MapEntry<'hir> {
             NodeTy(n) => EntryTy(p, n),
             NodeTraitRef(n) => EntryTraitRef(p, n),
             NodeLocal(n) => EntryLocal(p, n),
-            NodeImplArg(n) => EntryImplArg(p, n),
             NodePat(n) => EntryPat(p, n),
             NodeBlock(n) => EntryBlock(p, n),
             NodeStructCtor(n) => EntryStructCtor(p, n),
@@ -139,7 +136,6 @@ impl<'hir> MapEntry<'hir> {
             EntryStmt(id, _) => id,
             EntryTy(id, _) => id,
             EntryTraitRef(id, _) => id,
-            EntryImplArg(id, _) => id,
             EntryLocal(id, _) => id,
             EntryPat(id, _) => id,
             EntryBlock(id, _) => id,
@@ -166,7 +162,6 @@ impl<'hir> MapEntry<'hir> {
             EntryTy(_, n) => NodeTy(n),
             EntryTraitRef(_, n) => NodeTraitRef(n),
             EntryLocal(_, n) => NodeLocal(n),
-            EntryImplArg(_, n) => NodeImplArg(n),
             EntryPat(_, n) => NodePat(n),
             EntryBlock(_, n) => NodeBlock(n),
             EntryStructCtor(_, n) => NodeStructCtor(n),
@@ -327,7 +322,6 @@ impl<'hir> Map<'hir> {
                 EntryTy(p, _) |
                 EntryTraitRef(p, _) |
                 EntryLocal(p, _) |
-                EntryImplArg(p, _) |
                 EntryPat(p, _) |
                 EntryBlock(p, _) |
                 EntryStructCtor(p, _) |
@@ -903,7 +897,6 @@ impl<'hir> Map<'hir> {
             Some(EntryTy(_, ty)) => ty.span,
             Some(EntryTraitRef(_, tr)) => tr.path.span,
             Some(EntryLocal(_, pat)) => pat.span,
-            Some(EntryImplArg(_, impl_arg)) => impl_arg.span,
             Some(EntryPat(_, pat)) => pat.span,
             Some(EntryBlock(_, block)) => block.span,
             Some(EntryStructCtor(_, _)) => self.expect_item(self.get_parent(id)).span,
@@ -1113,7 +1106,6 @@ impl<'a> print::State<'a> {
             }
             NodeLifetime(a)    => self.print_lifetime(&a),
             NodeVisibility(a)  => self.print_visibility(&a),
-            NodeImplArg(_)     => bug!("cannot print ImplArg"),
             NodeTyParam(_)     => bug!("cannot print TyParam"),
             NodeField(_)       => bug!("cannot print StructField"),
             // these cases do not carry enough information in the
@@ -1215,9 +1207,6 @@ fn node_id_to_string(map: &Map, id: NodeId, include_id: bool) -> String {
         Some(NodeLocal(_)) => {
             format!("local {}{}", map.node_to_pretty_string(id), id_str)
         }
-        Some(NodeImplArg(_)) => {
-            format!("impl_arg {}{}", map.node_to_pretty_string(id), id_str)
-        }
         Some(NodePat(_)) => {
             format!("pat {}{}", map.node_to_pretty_string(id), id_str)
         }