Implement type ascription.

eddyb · eddyb · commit 85a710528ed1 · 2015-02-01T10:53:42.000+02:00
diff --git a/src/librustc/lint/builtin.rs b/src/librustc/lint/builtin.rs
@@ -1154,6 +1154,7 @@ impl UnusedParens {
                 }
                 ast::ExprUnary(_, ref x) |
                 ast::ExprCast(ref x, _) |
+                ast::ExprType(ref x, _) |
                 ast::ExprField(ref x, _) |
                 ast::ExprTupField(ref x, _) |
                 ast::ExprIndex(ref x, _) => {
diff --git a/src/librustc/middle/cfg/construct.rs b/src/librustc/middle/cfg/construct.rs
@@ -434,6 +434,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
             ast::ExprBox(None, ref e) |
             ast::ExprAddrOf(_, ref e) |
             ast::ExprCast(ref e, _) |
+            ast::ExprType(ref e, _) |
             ast::ExprUnary(_, ref e) |
             ast::ExprParen(ref e) |
             ast::ExprField(ref e, _) |
diff --git a/src/librustc/middle/check_const.rs b/src/librustc/middle/check_const.rs
@@ -167,6 +167,7 @@ fn check_expr(v: &mut CheckCrateVisitor, e: &ast::Expr) {
         ast::ExprTupField(..) |
         ast::ExprIndex(..) |
         ast::ExprTup(..) |
+        ast::ExprType(..) |
         ast::ExprRepeat(..) |
         ast::ExprStruct(..) => {}
 
diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs
@@ -232,8 +232,8 @@ impl<'a, 'tcx> ConstEvalVisitor<'a, 'tcx> {
                 }
             }
 
-            ast::ExprField(ref base, _) => self.classify(&**base),
-
+            ast::ExprType(ref base, _) |
+            ast::ExprField(ref base, _) |
             ast::ExprTupField(ref base, _) => self.classify(&**base),
 
             ast::ExprIndex(ref base, ref idx) =>
@@ -556,7 +556,8 @@ pub fn eval_const_expr_partial(tcx: &ty::ctxt, e: &Expr) -> Result<const_val, St
           }
       }
       ast::ExprLit(ref lit) => Ok(lit_to_const(&**lit)),
-      ast::ExprParen(ref e)     => eval_const_expr_partial(tcx, &**e),
+      ast::ExprParen(ref e) |
+      ast::ExprType(ref e, _) => eval_const_expr_partial(tcx, &**e),
       ast::ExprBlock(ref block) => {
         match block.expr {
             Some(ref expr) => eval_const_expr_partial(tcx, &**expr),
diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs
@@ -423,7 +423,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) => {
+            ast::ExprParen(ref subexpr) |
+            ast::ExprType(ref subexpr, _) => {
                 self.walk_expr(&**subexpr)
             }
 
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::ExprType(..) => {
           visit::walk_expr(ir, expr);
       }
     }
@@ -1188,6 +1188,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
           ast::ExprBox(None, ref e) |
           ast::ExprAddrOf(_, ref e) |
           ast::ExprCast(ref e, _) |
+          ast::ExprType(ref e, _) |
           ast::ExprUnary(_, ref e) |
           ast::ExprParen(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::ExprType(..) => {
         visit::walk_expr(this, expr);
       }
       ast::ExprIfLet(..) => {
diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs
@@ -520,7 +520,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
             self.cat_def(expr.id, expr.span, expr_ty, def)
           }
 
-          ast::ExprParen(ref e) => {
+          ast::ExprParen(ref e) | ast::ExprType(ref e, _) => {
             self.cat_expr(&**e)
           }
 
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
@@ -4618,7 +4618,8 @@ pub fn expr_kind(tcx: &ctxt, expr: &ast::Expr) -> ExprKind {
             }
         }
 
-        ast::ExprParen(ref e) => expr_kind(tcx, &**e),
+        ast::ExprParen(ref e) |
+        ast::ExprType(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
@@ -235,6 +235,7 @@ mod svh_visitor {
         SawExprUnary(ast::UnOp),
         SawExprLit(ast::Lit_),
         SawExprCast,
+        SawExprType,
         SawExprIf,
         SawExprWhile,
         SawExprMatch,
@@ -265,6 +266,7 @@ mod svh_visitor {
             ExprUnary(op, _)         => SawExprUnary(op),
             ExprLit(ref lit)         => SawExprLit(lit.node.clone()),
             ExprCast(..)             => SawExprCast,
+            ExprType(..)             => SawExprType,
             ExprIf(..)               => SawExprIf,
             ExprWhile(..)            => SawExprWhile,
             ExprLoop(_, id)          => SawExprLoop(id.map(content)),
diff --git a/src/librustc_trans/trans/consts.rs b/src/librustc_trans/trans/consts.rs
@@ -663,7 +663,8 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr) -> ValueRef {
                   _ => cx.sess().span_bug(e.span, "expected a struct or variant def")
               }
           }
-          ast::ExprParen(ref e) => const_expr(cx, &**e).0,
+          ast::ExprParen(ref e) |
+          ast::ExprType(ref e, _) => const_expr(cx, &**e).0,
           ast::ExprBlock(ref block) => {
             match block.expr {
                 Some(ref expr) => const_expr(cx, &**expr).0,
diff --git a/src/librustc_trans/trans/debuginfo.rs b/src/librustc_trans/trans/debuginfo.rs
@@ -3502,7 +3502,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::ExprType(ref sub_exp, _) =>
                 walk_expr(cx, &**sub_exp, scope_stack, scope_map),
 
             ast::ExprBox(ref place, ref sub_expr) => {
diff --git a/src/librustc_trans/trans/expr.rs b/src/librustc_trans/trans/expr.rs
@@ -564,7 +564,8 @@ fn trans_datum_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
     let _icx = push_ctxt("trans_datum_unadjusted");
 
     match expr.node {
-        ast::ExprParen(ref e) => {
+        ast::ExprParen(ref e) |
+        ast::ExprType(ref e, _) => {
             trans(bcx, &**e)
         }
         ast::ExprPath(_) | ast::ExprQPath(_) => {
@@ -890,7 +891,8 @@ fn trans_rvalue_stmt_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
     debuginfo::set_source_location(bcx.fcx, expr.id, expr.span);
 
     match expr.node {
-        ast::ExprParen(ref e) => {
+        ast::ExprParen(ref e) |
+        ast::ExprType(ref e, _) => {
             trans_into(bcx, &**e, Ignore)
         }
         ast::ExprBreak(label_opt) => {
@@ -990,7 +992,8 @@ fn trans_rvalue_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
     debuginfo::set_source_location(bcx.fcx, expr.id, expr.span);
 
     match expr.node {
-        ast::ExprParen(ref e) => {
+        ast::ExprParen(ref e) |
+        ast::ExprType(ref e, _) => {
             trans_into(bcx, &**e, dest)
         }
         ast::ExprPath(_) | ast::ExprQPath(_) => {
diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
@@ -3711,6 +3711,11 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
         }
         check_cast(fcx, expr, &**e, &**t);
       }
+      ast::ExprType(ref e, ref t) => {
+        let typ = fcx.to_ty(&**t);
+        check_expr_coercable_to_type(fcx, &**e, typ);
+        fcx.write_ty(id, typ);
+      }
       ast::ExprVec(ref args) => {
         let uty = expected.to_option(fcx).and_then(|uty| {
             match uty.sty {
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
@@ -724,6 +724,7 @@ pub enum Expr_ {
     ExprUnary(UnOp, P<Expr>),
     ExprLit(P<Lit>),
     ExprCast(P<Expr>, P<Ty>),
+    ExprType(P<Expr>, P<Ty>),
     ExprIf(P<Expr>, P<Block>, Option<P<Expr>>),
     ExprIfLet(P<Pat>, P<Expr>, P<Block>, Option<P<Expr>>),
     // FIXME #6993: change to Option<Name> ... or not, if these are hygienic.
diff --git a/src/libsyntax/ext/asm.rs b/src/libsyntax/ext/asm.rs
@@ -18,8 +18,7 @@ use codemap;
 use codemap::Span;
 use ext::base;
 use ext::base::*;
-use parse::token::InternedString;
-use parse::token;
+use parse::{self, token};
 use ptr::P;
 
 enum State {
@@ -48,8 +47,17 @@ static OPTIONS: &'static [&'static str] = &["volatile", "alignstack", "intel"];
 
 pub fn expand_asm<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
                        -> Box<base::MacResult+'cx> {
-    let mut p = cx.new_parser_from_tts(tts);
-    let mut asm = InternedString::new("");
+    // Split the tts before the first colon, to avoid `asm!("x": y)`  being
+    // parsed as `asm!(z)` with `z = "x": y` which is type ascription.
+    let first_colon = tts.iter().position(|tt| {
+        match *tt {
+            ast::TtToken(_, token::Colon) |
+            ast::TtToken(_, token::ModSep) => true,
+            _ => false
+        }
+    }).unwrap_or(tts.len());
+    let mut p = cx.new_parser_from_tts(&tts[first_colon..]);
+    let mut asm = token::InternedString::new("");
     let mut asm_str_style = None;
     let mut outputs = Vec::new();
     let mut inputs = Vec::new();
@@ -69,12 +77,22 @@ pub fn expand_asm<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
                     cx.span_err(sp, "malformed inline assembly");
                     return DummyResult::expr(sp);
                 }
-                let (s, style) = match expr_to_string(cx, p.parse_expr(),
+                // Nested parser, stop before the first colon (see above).
+                let mut p2 = cx.new_parser_from_tts(&tts[..first_colon]);
+                let (s, style) = match expr_to_string(cx, p2.parse_expr(),
                                                    "inline assembly must be a string literal") {
                     Some((s, st)) => (s, st),
                     // let compilation continue
                     None => return DummyResult::expr(sp),
                 };
+
+                // This is most likely malformed.
+                if p2.token != token::Eof {
+                    let mut extra_tts = p2.parse_all_token_trees();
+                    extra_tts.extend(tts[first_colon..].iter().cloned());
+                    p = parse::tts_to_parser(cx.parse_sess, extra_tts, cx.cfg());
+                }
+
                 asm = s;
                 asm_str_style = Some(style);
             }
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
@@ -1287,6 +1287,9 @@ pub fn noop_fold_expr<T: Folder>(Expr {id, node, span}: Expr, folder: &mut T) ->
             ExprCast(expr, ty) => {
                 ExprCast(folder.fold_expr(expr), folder.fold_ty(ty))
             }
+            ExprType(expr, ty) => {
+                ExprType(folder.fold_expr(expr), folder.fold_ty(ty))
+            }
             ExprAddrOf(m, ohs) => ExprAddrOf(m, folder.fold_expr(ohs)),
             ExprIf(cond, tr, fl) => {
                 ExprIf(folder.fold_expr(cond),
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
@@ -26,7 +26,7 @@ use ast::{ExprBreak, ExprCall, ExprCast};
 use ast::{ExprField, ExprTupField, ExprClosure, ExprIf, ExprIfLet, ExprIndex};
 use ast::{ExprLit, ExprLoop, ExprMac, ExprRange};
 use ast::{ExprMethodCall, ExprParen, ExprPath, ExprQPath};
-use ast::{ExprRepeat, ExprRet, ExprStruct, ExprTup, ExprUnary};
+use ast::{ExprRepeat, ExprRet, ExprStruct, ExprTup, ExprType, ExprUnary};
 use ast::{ExprVec, ExprWhile, ExprWhileLet, ExprForLoop, Field, FnDecl};
 use ast::{FnClosureKind, FnMutClosureKind};
 use ast::{FnOnceClosureKind};
@@ -2873,23 +2873,29 @@ impl<'a> Parser<'a> {
                     let rhs_span = rhs.span;
                     let binary = self.mk_binary(codemap::respan(cur_op_span, cur_op), lhs, rhs);
                     let bin = self.mk_expr(lhs_span.lo, rhs_span.hi, binary);
-                    self.parse_more_binops(bin, min_prec)
-                } else {
-                    lhs
+                    return self.parse_more_binops(bin, min_prec);
                 }
             }
             None => {
-                if AS_PREC >= min_prec && self.eat_keyword(keywords::As) {
-                    let rhs = self.parse_ty();
-                    let _as = self.mk_expr(lhs.span.lo,
-                                           rhs.span.hi,
-                                           ExprCast(lhs, rhs));
-                    self.parse_more_binops(_as, min_prec)
-                } else {
-                    lhs
+                if AS_PREC >= min_prec {
+                    if self.eat_keyword(keywords::As) {
+                        let rhs = self.parse_ty();
+                        let _as = self.mk_expr(lhs.span.lo,
+                                               rhs.span.hi,
+                                               ExprCast(lhs, rhs));
+                        return self.parse_more_binops(_as, min_prec);
+                    } else if self.token == token::Colon {
+                        self.bump();
+                        let rhs = self.parse_ty();
+                        let ex = self.mk_expr(lhs.span.lo,
+                                              rhs.span.hi,
+                                              ExprType(lhs, rhs));
+                        return self.parse_more_binops(ex, min_prec);
+                    }
                 }
             }
         }
+        lhs
     }
 
     /// Produce an error if comparison operators are chained (RFC #558).
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
@@ -449,7 +449,8 @@ fn needs_parentheses(expr: &ast::Expr) -> bool {
     match expr.node {
         ast::ExprAssign(..) | ast::ExprBinary(..) |
         ast::ExprClosure(..) |
-        ast::ExprAssignOp(..) | ast::ExprCast(..) => true,
+        ast::ExprAssignOp(..) | ast::ExprCast(..) |
+        ast::ExprType(..) => true,
         _ => false,
     }
 }
@@ -1684,6 +1685,11 @@ impl<'a> State<'a> {
                 try!(self.word_space("as"));
                 try!(self.print_type(&**ty));
             }
+            ast::ExprType(ref expr, ref ty) => {
+                try!(self.print_expr(&**expr));
+                try!(self.word_space(":"));
+                try!(self.print_type(&**ty));
+            }
             ast::ExprIf(ref test, ref blk, ref elseopt) => {
                 try!(self.print_if(&**test, &**blk, elseopt.as_ref().map(|e| &**e)));
             }
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
@@ -804,6 +804,10 @@ pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr) {
             visitor.visit_expr(&**subexpression);
             visitor.visit_ty(&**typ)
         }
+        ExprType(ref subexpression, ref typ) => {
+            visitor.visit_expr(&**subexpression);
+            visitor.visit_ty(&**typ)
+        }
         ExprIf(ref head_expression, ref if_block, ref optional_else) => {
             visitor.visit_expr(&**head_expression);
             visitor.visit_block(&**if_block);
diff --git a/src/test/compile-fail/struct-literal-in-for.rs b/src/test/compile-fail/struct-literal-in-for.rs
@@ -20,7 +20,7 @@ impl Foo {
 
 fn main() {
     for x in Foo {
-        x: 3    //~ ERROR expected one of `!`, `.`, `::`, `;`, `{`, `}`, or an operator, found `:`
+        x: 3    //~ ERROR expected type, found `3`
     }.hi() {
         println!("yo");
     }
diff --git a/src/test/compile-fail/struct-literal-in-if.rs b/src/test/compile-fail/struct-literal-in-if.rs
@@ -20,7 +20,7 @@ impl Foo {
 
 fn main() {
     if Foo {
-        x: 3    //~ ERROR expected one of `!`, `.`, `::`, `;`, `{`, `}`, or an operator, found `:`
+        x: 3    //~ ERROR expected type, found `3`
     }.hi() {
         println!("yo");
     }
diff --git a/src/test/compile-fail/struct-literal-in-while.rs b/src/test/compile-fail/struct-literal-in-while.rs
@@ -20,7 +20,7 @@ impl Foo {
 
 fn main() {
     while Foo {
-        x: 3    //~ ERROR expected one of `!`, `.`, `::`, `;`, `{`, `}`, or an operator, found `:`
+        x: 3    //~ ERROR expected type, found `3`
     }.hi() {
         println!("yo");
     }
diff --git a/src/test/run-pass/coerce-expect-unsized-ascribed.rs b/src/test/run-pass/coerce-expect-unsized-ascribed.rs

Original file line number	Diff line number	Diff line change
`@@ -1154,6 +1154,7 @@ impl UnusedParens {`
`1154`	`1154`	`}`
`1155`	`1155`	`ast::ExprUnary(_, ref x) \|`
`1156`	`1156`	`ast::ExprCast(ref x, _) \|`
	`1157`	`+ ast::ExprType(ref x, _) \|`
`1157`	`1158`	`ast::ExprField(ref x, _) \|`
`1158`	`1159`	`ast::ExprTupField(ref x, _) \|`
`1159`	`1160`	`ast::ExprIndex(ref x, _) => {`
Original file line number	Diff line number	Diff line change
`@@ -232,8 +232,8 @@ impl<'a, 'tcx> ConstEvalVisitor<'a, 'tcx> {`
`232`	`232`	`}`
`233`	`233`	`}`
`234`	`234`
`235`		`- ast::ExprField(ref base, _) => self.classify(&**base),`
`236`		`-`
	`235`	`+ ast::ExprType(ref base, _) \|`
	`236`	`+ ast::ExprField(ref base, _) \|`
`237`	`237`	`ast::ExprTupField(ref base, _) => self.classify(&**base),`
`238`	`238`
`239`	`239`	`ast::ExprIndex(ref base, ref idx) =>`
`@@ -556,7 +556,8 @@ pub fn eval_const_expr_partial(tcx: &ty::ctxt, e: &Expr) -> Result<const_val, St`
`556`	`556`	`}`
`557`	`557`	`}`
`558`	`558`	`ast::ExprLit(ref lit) => Ok(lit_to_const(&**lit)),`
`559`		`- ast::ExprParen(ref e) => eval_const_expr_partial(tcx, &**e),`
	`559`	`+ ast::ExprParen(ref e) \|`
	`560`	`+ ast::ExprType(ref e, _) => eval_const_expr_partial(tcx, &**e),`
`560`	`561`	`ast::ExprBlock(ref block) => {`
`561`	`562`	`match block.expr {`
`562`	`563`	`Some(ref expr) => eval_const_expr_partial(tcx, &**expr),`
Original file line number	Diff line number	Diff line change
`@@ -423,7 +423,8 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {`
`423`	`423`	`self.walk_adjustment(expr);`
`424`	`424`
`425`	`425`	`match expr.node {`
`426`		`- ast::ExprParen(ref subexpr) => {`
	`426`	`+ ast::ExprParen(ref subexpr) \|`
	`427`	`+ ast::ExprType(ref subexpr, _) => {`
`427`	`428`	`self.walk_expr(&**subexpr)`
`428`	`429`	`}`
`429`	`430`
Original file line number	Diff line number	Diff line change
`@@ -520,7 +520,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {`
`520`	`520`	`self.cat_def(expr.id, expr.span, expr_ty, def)`
`521`	`521`	`}`
`522`	`522`
`523`		`- ast::ExprParen(ref e) => {`
	`523`	`+ ast::ExprParen(ref e) \| ast::ExprType(ref e, _) => {`
`524`	`524`	`self.cat_expr(&**e)`
`525`	`525`	`}`
`526`	`526`
Original file line number	Diff line number	Diff line change
`@@ -4618,7 +4618,8 @@ pub fn expr_kind(tcx: &ctxt, expr: &ast::Expr) -> ExprKind {`
`4618`	`4618`	`}`
`4619`	`4619`	`}`
`4620`	`4620`
`4621`		`- ast::ExprParen(ref e) => expr_kind(tcx, &**e),`
	`4621`	`+ ast::ExprParen(ref e) \|`
	`4622`	`+ ast::ExprType(ref e, _) => expr_kind(tcx, &**e),`
`4622`	`4623`
`4623`	`4624`	`ast::ExprMac(..) => {`
`4624`	`4625`	`tcx.sess.span_bug(`
Original file line number	Diff line number	Diff line change
`@@ -663,7 +663,8 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr) -> ValueRef {`
`663`	`663`	`_ => cx.sess().span_bug(e.span, "expected a struct or variant def")`
`664`	`664`	`}`
`665`	`665`	`}`
`666`		`- ast::ExprParen(ref e) => const_expr(cx, &**e).0,`
	`666`	`+ ast::ExprParen(ref e) \|`
	`667`	`+ ast::ExprType(ref e, _) => const_expr(cx, &**e).0,`
`667`	`668`	`ast::ExprBlock(ref block) => {`
`668`	`669`	`match block.expr {`
`669`	`670`	`Some(ref expr) => const_expr(cx, &**expr).0,`