Add ast::ExprCompletion

Author: sanxiyn

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())

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,
             _ => ()
         }
 

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(_) => { }

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(..) => {

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))
           }
 

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(

src/librustc_back/svh.rs

@@ -293,6 +293,7 @@ mod svh_visitor {
             ExprIfLet(..)            => unreachable!(),
             ExprWhileLet(..)         => unreachable!(),
             ExprMac(..)              => unreachable!(),
+            ExprCompletion(..)       => unreachable!(),
         }
     }
 

src/librustc_privacy/lib.rs

@@ -954,6 +954,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> {
                     _ => {}
                 }
             }
+            ast::ExprCompletion(_) => return,
             _ => {}
         }
 

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) => {

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);
 

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 */),
 

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)),

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();

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));

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)
         }