Add ast::ExprCompletion

sanxiyn · sanxiyn · commit 0a0dc5a99857 · 2015-02-11T00:20:55.000+09:00
diff --git a/src/librustc/middle/cfg/construct.rs b/src/librustc/middle/cfg/construct.rs
@@ -436,6 +436,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
             ast::ExprCast(ref e, _) |
             ast::ExprUnary(_, ref e) |
             ast::ExprParen(ref e) |
+            ast::ExprCompletion(ref e) |
             ast::ExprField(ref e, _) |
             ast::ExprTupField(ref e, _) => {
                 self.straightline(expr, pred, Some(&**e).into_iter())
diff --git a/src/librustc/middle/dead.rs b/src/librustc/middle/dead.rs
@@ -277,6 +277,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for MarkSymbolVisitor<'a, 'tcx> {
             ast::ExprTupField(ref lhs, idx) => {
                 self.handle_tup_field_access(&**lhs, idx.node);
             }
+            ast::ExprCompletion(..) => return,
             _ => ()
         }
 
diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs
@@ -421,8 +421,8 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
         self.walk_adjustment(expr);
 
         match expr.node {
-            ast::ExprParen(ref subexpr) => {
-                self.walk_expr(&**subexpr)
+            ast::ExprParen(ref e) | ast::ExprCompletion(ref e) => {
+                self.walk_expr(&e)
             }
 
             ast::ExprPath(_) | ast::ExprQPath(_) => { }
diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs
@@ -505,7 +505,7 @@ fn visit_expr(ir: &mut IrMaps, expr: &Expr) {
       ast::ExprBlock(..) | ast::ExprAssign(..) | ast::ExprAssignOp(..) |
       ast::ExprMac(..) | ast::ExprStruct(..) | ast::ExprRepeat(..) |
       ast::ExprParen(..) | ast::ExprInlineAsm(..) | ast::ExprBox(..) |
-      ast::ExprRange(..) => {
+      ast::ExprRange(..) | ast::ExprCompletion(..) => {
           visit::walk_expr(ir, expr);
       }
     }
@@ -1189,7 +1189,8 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
           ast::ExprAddrOf(_, ref e) |
           ast::ExprCast(ref e, _) |
           ast::ExprUnary(_, ref e) |
-          ast::ExprParen(ref e) => {
+          ast::ExprParen(ref e) |
+          ast::ExprCompletion(ref e) => {
             self.propagate_through_expr(&**e, succ)
           }
 
@@ -1468,7 +1469,7 @@ fn check_expr(this: &mut Liveness, expr: &Expr) {
       ast::ExprBlock(..) | ast::ExprMac(..) | ast::ExprAddrOf(..) |
       ast::ExprStruct(..) | ast::ExprRepeat(..) | ast::ExprParen(..) |
       ast::ExprClosure(..) | ast::ExprPath(..) | ast::ExprBox(..) |
-      ast::ExprRange(..) | ast::ExprQPath(..) => {
+      ast::ExprRange(..) | ast::ExprQPath(..) | ast::ExprCompletion(..) => {
         visit::walk_expr(this, expr);
       }
       ast::ExprIfLet(..) => {
diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs
@@ -548,7 +548,8 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
           ast::ExprBlock(..) | ast::ExprLoop(..) | ast::ExprMatch(..) |
           ast::ExprLit(..) | ast::ExprBreak(..) | ast::ExprMac(..) |
           ast::ExprAgain(..) | ast::ExprStruct(..) | ast::ExprRepeat(..) |
-          ast::ExprInlineAsm(..) | ast::ExprBox(..) => {
+          ast::ExprInlineAsm(..) | ast::ExprBox(..) |
+          ast::ExprCompletion(..) => {
             Ok(self.cat_rvalue_node(expr.id(), expr.span(), expr_ty))
           }
 
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
@@ -4617,7 +4617,9 @@ pub fn expr_kind(tcx: &ctxt, expr: &ast::Expr) -> ExprKind {
             }
         }
 
-        ast::ExprParen(ref e) => expr_kind(tcx, &**e),
+        ast::ExprParen(ref e) | ast::ExprCompletion(ref e) => {
+            expr_kind(tcx, &e)
+        }
 
         ast::ExprMac(..) => {
             tcx.sess.span_bug(
diff --git a/src/librustc_back/svh.rs b/src/librustc_back/svh.rs
@@ -293,6 +293,7 @@ mod svh_visitor {
             ExprIfLet(..)            => unreachable!(),
             ExprWhileLet(..)         => unreachable!(),
             ExprMac(..)              => unreachable!(),
+            ExprCompletion(..)       => unreachable!(),
         }
     }
 
diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs
@@ -954,6 +954,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> {
                     _ => {}
                 }
             }
+            ast::ExprCompletion(_) => return,
             _ => {}
         }
 
diff --git a/src/librustc_trans/trans/debuginfo.rs b/src/librustc_trans/trans/debuginfo.rs
@@ -3491,7 +3491,8 @@ fn create_scope_map(cx: &CrateContext,
             ast::ExprAddrOf(_, ref sub_exp)  |
             ast::ExprField(ref sub_exp, _) |
             ast::ExprTupField(ref sub_exp, _) |
-            ast::ExprParen(ref sub_exp) =>
+            ast::ExprParen(ref sub_exp) |
+            ast::ExprCompletion(ref sub_exp) =>
                 walk_expr(cx, &**sub_exp, scope_stack, scope_map),
 
             ast::ExprBox(ref place, ref sub_expr) => {
diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
@@ -3679,6 +3679,23 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
                                                     lvalue_pref);
         fcx.write_ty(id, fcx.expr_ty(&**a));
       }
+      ast::ExprCompletion(ref e) => {
+          fcx.write_ty(e.id, fcx.infcx().next_diverging_ty_var());
+          fcx.write_ty(id, fcx.infcx().next_diverging_ty_var());
+          if let ast::ExprField(ref base, _) = e.node {
+              check_expr_with_lvalue_pref(fcx, &base, lvalue_pref);
+              let expr_t = structurally_resolved_type(fcx, base.span, fcx.expr_ty(&base));
+              match expr_t.sty {
+                  ty::ty_struct(base_id, _) => {
+                      let fields = ty::lookup_struct_fields(tcx, base_id);
+                      for field in fields.iter() {
+                          println!("{}", field.name);
+                      }
+                  }
+                  _ => ()
+              }
+          }
+      }
       ast::ExprAssign(ref lhs, ref rhs) => {
         check_expr_with_lvalue_pref(fcx, &**lhs, PreferMutLvalue);
 
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
@@ -761,6 +761,8 @@ pub enum Expr_ {
 
     ExprMac(Mac),
 
+    ExprCompletion(P<Expr>),
+
     /// A struct literal expression.
     ExprStruct(Path, Vec<Field>, Option<P<Expr>> /* base */),
 
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
@@ -1388,6 +1388,7 @@ pub fn noop_fold_expr<T: Folder>(Expr {id, node, span}: Expr, folder: &mut T) ->
                 expn_id: expn_id,
             }),
             ExprMac(mac) => ExprMac(folder.fold_mac(mac)),
+            ExprCompletion(expr) => ExprCompletion(folder.fold_expr(expr)),
             ExprStruct(path, fields, maybe_expr) => {
                 ExprStruct(folder.fold_path(path),
                         fields.move_map(|x| folder.fold_field(x)),
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
@@ -22,7 +22,7 @@ use ast::{DeclLocal, DefaultBlock, DefaultReturn};
 use ast::{UnDeref, BiDiv, EMPTY_CTXT, EnumDef, ExplicitSelf};
 use ast::{Expr, Expr_, ExprAddrOf, ExprMatch, ExprAgain};
 use ast::{ExprAssign, ExprAssignOp, ExprBinary, ExprBlock, ExprBox};
-use ast::{ExprBreak, ExprCall, ExprCast};
+use ast::{ExprBreak, ExprCall, ExprCast, ExprCompletion};
 use ast::{ExprField, ExprTupField, ExprClosure, ExprIf, ExprIfLet, ExprIndex};
 use ast::{ExprLit, ExprLoop, ExprMac, ExprRange};
 use ast::{ExprMethodCall, ExprParen, ExprPath, ExprQPath};
@@ -2030,7 +2030,7 @@ impl<'a> Parser<'a> {
         }
     }
 
-    pub fn mk_expr(&mut self, lo: BytePos, hi: BytePos, node: Expr_) -> P<Expr> {
+    pub fn mk_expr(&self, lo: BytePos, hi: BytePos, node: Expr_) -> P<Expr> {
         P(Expr {
             id: ast::DUMMY_NODE_ID,
             node: node,
@@ -2505,6 +2505,15 @@ impl<'a> Parser<'a> {
                     self.abort_if_errors();
 
                   }
+                  token::GenerateCompletion => {
+                      // Important: do not bump
+                      let sp = self.span;
+                      let hi = self.last_span.hi;
+                      let id = codemap::respan(sp, special_idents::invalid);
+                      let field = self.mk_field(e, id);
+                      e = self.mk_expr(lo, hi,
+                          ExprCompletion(self.mk_expr(lo, hi, field)));
+                  }
                   _ => self.unexpected()
                 }
                 continue;
@@ -3942,12 +3951,17 @@ impl<'a> Parser<'a> {
             stmts: &mut Vec<P<Stmt>>,
             last_block_expr: &mut Option<P<Expr>>) {
         // expression without semicolon
-        if classify::expr_requires_semi_to_be_stmt(&*e) {
+        if classify::expr_requires_semi_to_be_stmt(&*e) &&
+            self.token != token::GenerateCompletion {
             // Just check for errors and recover; do not eat semicolon yet.
             self.commit_stmt(&[],
                              &[token::Semi, token::CloseDelim(token::Brace)]);
         }
 
+        if self.token == token::GenerateCompletion {
+            self.bump();
+        }
+
         match self.token {
             token::Semi => {
                 self.bump();
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
@@ -1943,6 +1943,10 @@ impl<'a> State<'a> {
                 try!(self.pclose());
             }
             ast::ExprMac(ref m) => try!(self.print_mac(m, token::Paren)),
+            ast::ExprCompletion(ref e) => {
+                try!(self.print_expr(&e));
+                try!(word(&mut self.s, &token_to_string(&token::GenerateCompletion)));
+            }
             ast::ExprParen(ref e) => {
                 try!(self.popen());
                 try!(self.print_expr(&**e));
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
@@ -877,6 +877,9 @@ pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr) {
             walk_expr_opt(visitor, optional_expression)
         }
         ExprMac(ref mac) => visitor.visit_mac(mac),
+        ExprCompletion(ref subexpression) => {
+            visitor.visit_expr(&subexpression);
+        }
         ExprParen(ref subexpression) => {
             visitor.visit_expr(&**subexpression)
         }

Original file line number	Diff line number	Diff line change
`@@ -277,6 +277,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for MarkSymbolVisitor<'a, 'tcx> {`
`277`	`277`	`ast::ExprTupField(ref lhs, idx) => {`
`278`	`278`	`self.handle_tup_field_access(&**lhs, idx.node);`
`279`	`279`	`}`
	`280`	`+ ast::ExprCompletion(..) => return,`
`280`	`281`	`_ => ()`
`281`	`282`	`}`
`282`	`283`
Original file line number	Diff line number	Diff line change
`@@ -421,8 +421,8 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {`
`421`	`421`	`self.walk_adjustment(expr);`
`422`	`422`
`423`	`423`	`match expr.node {`
`424`		`- ast::ExprParen(ref subexpr) => {`
`425`		`- self.walk_expr(&**subexpr)`
	`424`	`+ ast::ExprParen(ref e) \| ast::ExprCompletion(ref e) => {`
	`425`	`+ self.walk_expr(&e)`
`426`	`426`	`}`
`427`	`427`
`428`	`428`	`ast::ExprPath(_) \| ast::ExprQPath(_) => { }`
Original file line number	Diff line number	Diff line change
`@@ -548,7 +548,8 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {`
`548`	`548`	`ast::ExprBlock(..) \| ast::ExprLoop(..) \| ast::ExprMatch(..) \|`
`549`	`549`	`ast::ExprLit(..) \| ast::ExprBreak(..) \| ast::ExprMac(..) \|`
`550`	`550`	`ast::ExprAgain(..) \| ast::ExprStruct(..) \| ast::ExprRepeat(..) \|`
`551`		`- ast::ExprInlineAsm(..) \| ast::ExprBox(..) => {`
	`551`	`+ ast::ExprInlineAsm(..) \| ast::ExprBox(..) \|`
	`552`	`+ ast::ExprCompletion(..) => {`
`552`	`553`	`Ok(self.cat_rvalue_node(expr.id(), expr.span(), expr_ty))`
`553`	`554`	`}`
`554`	`555`
Original file line number	Diff line number	Diff line change
`@@ -4617,7 +4617,9 @@ pub fn expr_kind(tcx: &ctxt, expr: &ast::Expr) -> ExprKind {`
`4617`	`4617`	`}`
`4618`	`4618`	`}`
`4619`	`4619`
`4620`		`- ast::ExprParen(ref e) => expr_kind(tcx, &**e),`
	`4620`	`+ ast::ExprParen(ref e) \| ast::ExprCompletion(ref e) => {`
	`4621`	`+ expr_kind(tcx, &e)`
	`4622`	`+ }`
`4621`	`4623`
`4622`	`4624`	`ast::ExprMac(..) => {`
`4623`	`4625`	`tcx.sess.span_bug(`
Original file line number	Diff line number	Diff line change
`@@ -293,6 +293,7 @@ mod svh_visitor {`
`293`	`293`	`ExprIfLet(..) => unreachable!(),`
`294`	`294`	`ExprWhileLet(..) => unreachable!(),`
`295`	`295`	`ExprMac(..) => unreachable!(),`
	`296`	`+ ExprCompletion(..) => unreachable!(),`
`296`	`297`	`}`
`297`	`298`	`}`
`298`	`299`
Original file line number	Diff line number	Diff line change
`@@ -954,6 +954,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> {`
`954`	`954`	`_ => {}`
`955`	`955`	`}`
`956`	`956`	`}`
	`957`	`+ ast::ExprCompletion(_) => return,`
`957`	`958`	`_ => {}`
`958`	`959`	`}`
`959`	`960`