---

yaml
---
r: 213983
b: refs/heads/master
c: 29c8653
h: refs/heads/master
i:
  213981: ac8d1f0
  213979: 8d11211
  213975: b2cc8c5
  213967: 3e45faf
  213951: 3870f00
v: v3

Author: nikomatsakis

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: e4efb47b9d23a96ff4684df80360bbed0ec68bc9
+refs/heads/master: 29c86539b392b98ba84570143c625781ba248a9b
 refs/heads/snap-stage3: ba0e1cd8147d452c356aacb29fb87568ca26f111
 refs/heads/try: b53c0f93eedcdedd4fd89bccc5a3a09d1c5cd23e
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

trunk/src/librustc/diagnostics.rs

@@ -256,21 +256,6 @@ See [RFC 911] for more details on the design of `const fn`s.
 [RFC 911]: https://github.com/rust-lang/rfcs/blob/master/text/0911-const-fn.md
 "##,
 
-E0016: r##"
-Blocks in constants may only contain items (such as constant, function
-definition, etc...) and a tail expression. Example:
-
-```
-const FOO: i32 = { let x = 0; x }; // 'x' isn't an item!
-```
-
-To avoid it, you have to replace the non-item object:
-
-```
-const FOO: i32 = { const X : i32 = 0; X };
-```
-"##,
-
 E0018: r##"
 The value of static and const variables must be known at compile time. You
 can't cast a pointer as an integer because we can't know what value the
@@ -294,42 +279,6 @@ println!("{}", Y);
 ```
 "##,
 
-E0019: r##"
-A function call isn't allowed in the const's initialization expression
-because the expression's value must be known at compile-time. Example of
-erroneous code:
-
-```
-enum Test {
-    V1
-}
-
-impl Test {
-    fn test(&self) -> i32 {
-        12
-    }
-}
-
-fn main() {
-    const FOO: Test = Test::V1;
-
-    const A: i32 = FOO.test(); // You can't call Test::func() here !
-}
-```
-
-Remember: you can't use a function call inside a const's initialization
-expression! However, you can totally use it elsewhere you want:
-
-```
-fn main() {
-    const FOO: Test = Test::V1;
-
-    FOO.func(); // here is good
-    let x = FOO.func(); // or even here!
-}
-```
-"##,
-
 E0020: r##"
 This error indicates that an attempt was made to divide by zero (or take the
 remainder of a zero divisor) in a static or constant expression.
@@ -1001,7 +950,9 @@ static mut BAR: Option<Vec<i32>> = None;
 
 
 register_diagnostics! {
+    E0016,
     E0017,
+    E0019,
     E0022,
     E0038,
     E0109,

trunk/src/librustc/lib.rs

@@ -51,7 +51,6 @@
 #![feature(ref_slice)]
 #![feature(rustc_diagnostic_macros)]
 #![feature(rustc_private)]
-#![feature(scoped_tls)]
 #![feature(slice_bytes)]
 #![feature(slice_extras)]
 #![feature(slice_patterns)]

trunk/src/librustc/metadata/tydecode.rs

@@ -898,7 +898,7 @@ fn parse_builtin_bounds<F>(st: &mut PState, mut _conv: F) -> ty::BuiltinBounds w
 fn parse_builtin_bounds_<F>(st: &mut PState, _conv: &mut F) -> ty::BuiltinBounds where
     F: FnMut(DefIdSource, ast::DefId) -> ast::DefId,
 {
-    let mut builtin_bounds = ty::BuiltinBounds::empty();
+    let mut builtin_bounds = ty::empty_builtin_bounds();
 
     loop {
         match next(st) {

trunk/src/librustc/middle/astconv_util.rs

@@ -17,6 +17,7 @@
 use middle::def;
 use middle::ty::{self, Ty};
 use syntax::ast;
+use util::ppaux::Repr;
 
 pub const NO_REGIONS: usize = 1;
 pub const NO_TPS: usize = 2;
@@ -62,7 +63,7 @@ pub fn ast_ty_to_prim_ty<'tcx>(tcx: &ty::ctxt<'tcx>, ast_ty: &ast::Ty)
         let def = match tcx.def_map.borrow().get(&ast_ty.id) {
             None => {
                 tcx.sess.span_bug(ast_ty.span,
-                                  &format!("unbound path {:?}", path))
+                                  &format!("unbound path {}", path.repr(tcx)))
             }
             Some(d) => d.full_def()
         };

trunk/src/librustc/middle/astencode.rs

@@ -31,6 +31,7 @@ use middle::privacy::{AllPublic, LastMod};
 use middle::subst;
 use middle::subst::VecPerParamSpace;
 use middle::ty::{self, Ty, MethodCall, MethodCallee, MethodOrigin};
+use util::ppaux::ty_to_string;
 
 use syntax::{ast, ast_util, codemap, fold};
 use syntax::codemap::Span;
@@ -1622,8 +1623,8 @@ fn decode_side_tables(dcx: &DecodeContext,
                     }
                     c::tag_table_node_type => {
                         let ty = val_dsr.read_ty(dcx);
-                        debug!("inserting ty for node {}: {:?}",
-                               id,  ty);
+                        debug!("inserting ty for node {}: {}",
+                               id, ty_to_string(dcx.tcx, ty));
                         dcx.tcx.node_type_insert(id, ty);
                     }
                     c::tag_table_item_subst => {

trunk/src/librustc/middle/cfg/mod.rs

@@ -63,6 +63,7 @@ impl CFG {
     }
 
     pub fn node_is_reachable(&self, id: ast::NodeId) -> bool {
-        self.graph.depth_traverse(self.entry).any(|node| node.id() == id)
+        self.graph.depth_traverse(self.entry)
+                  .any(|idx| self.graph.node_data(idx).id() == id)
     }
 }

trunk/src/librustc/middle/check_const.rs

@@ -33,6 +33,7 @@ use middle::mem_categorization as mc;
 use middle::traits;
 use middle::ty::{self, Ty};
 use util::nodemap::NodeMap;
+use util::ppaux::Repr;
 
 use syntax::ast;
 use syntax::codemap::Span;
@@ -299,7 +300,7 @@ impl<'a, 'tcx> CheckCrateVisitor<'a, 'tcx> {
 
 impl<'a, 'tcx, 'v> Visitor<'v> for CheckCrateVisitor<'a, 'tcx> {
     fn visit_item(&mut self, i: &ast::Item) {
-        debug!("visit_item(item={})", self.tcx.map.node_to_string(i.id));
+        debug!("visit_item(item={})", i.repr(self.tcx));
         match i.node {
             ast::ItemStatic(_, ast::MutImmutable, ref expr) => {
                 self.check_static_type(&**expr);

trunk/src/librustc/middle/check_match.rs

@@ -36,6 +36,7 @@ use syntax::print::pprust::pat_to_string;
 use syntax::parse::token;
 use syntax::ptr::P;
 use syntax::visit::{self, Visitor, FnKind};
+use util::ppaux::ty_to_string;
 use util::nodemap::FnvHashMap;
 
 pub const DUMMY_WILD_PAT: &'static Pat = &Pat {
@@ -208,8 +209,9 @@ fn check_expr(cx: &mut MatchCheckCtxt, ex: &ast::Expr) {
                 if !type_is_empty(cx.tcx, pat_ty) {
                     // We know the type is inhabited, so this must be wrong
                     span_err!(cx.tcx.sess, ex.span, E0002,
-                              "non-exhaustive patterns: type {} is non-empty",
-                              pat_ty);
+                        "non-exhaustive patterns: type {} is non-empty",
+                        ty_to_string(cx.tcx, pat_ty)
+                    );
                 }
                 // If the type *is* empty, it's vacuously exhaustive
                 return;
@@ -242,11 +244,11 @@ fn check_for_bindings_named_the_same_as_variants(cx: &MatchCheckCtxt, pat: &Pat)
                             span_warn!(cx.tcx.sess, p.span, E0170,
                                 "pattern binding `{}` is named the same as one \
                                  of the variants of the type `{}`",
-                                &token::get_ident(ident.node), pat_ty);
+                                &token::get_ident(ident.node), ty_to_string(cx.tcx, pat_ty));
                             fileline_help!(cx.tcx.sess, p.span,
                                 "if you meant to match on a variant, \
                                  consider making the path in the pattern qualified: `{}::{}`",
-                                pat_ty, &token::get_ident(ident.node));
+                                ty_to_string(cx.tcx, pat_ty), &token::get_ident(ident.node));
                         }
                     }
                 }

trunk/src/librustc/middle/check_rvalues.rs

@@ -15,6 +15,7 @@ use middle::expr_use_visitor as euv;
 use middle::mem_categorization as mc;
 use middle::ty::ParameterEnvironment;
 use middle::ty;
+use util::ppaux::ty_to_string;
 
 use syntax::ast;
 use syntax::codemap::Span;
@@ -58,11 +59,11 @@ impl<'a, 'tcx> euv::Delegate<'tcx> for RvalueContextDelegate<'a, 'tcx> {
                span: Span,
                cmt: mc::cmt<'tcx>,
                _: euv::ConsumeMode) {
-        debug!("consume; cmt: {:?}; type: {:?}", *cmt, cmt.ty);
+        debug!("consume; cmt: {:?}; type: {}", *cmt, ty_to_string(self.tcx, cmt.ty));
         if !ty::type_is_sized(Some(self.param_env), self.tcx, span, cmt.ty) {
             span_err!(self.tcx.sess, span, E0161,
                 "cannot move a value of type {0}: the size of {0} cannot be statically determined",
-                cmt.ty);
+                ty_to_string(self.tcx, cmt.ty));
         }
     }
 

trunk/src/librustc/middle/const_eval.rs

@@ -23,6 +23,7 @@ use middle::pat_util::def_to_path;
 use middle::ty::{self, Ty};
 use middle::astconv_util::ast_ty_to_prim_ty;
 use util::num::ToPrimitive;
+use util::ppaux::Repr;
 
 use syntax::ast::{self, Expr};
 use syntax::ast_util;
@@ -1029,8 +1030,8 @@ fn resolve_trait_associated_const<'a, 'tcx: 'a>(tcx: &'a ty::ctxt<'tcx>,
                                                            rcvr_self,
                                                            Vec::new()));
     let trait_substs = tcx.mk_substs(trait_substs);
-    debug!("resolve_trait_associated_const: trait_substs={:?}",
-           trait_substs);
+    debug!("resolve_trait_associated_const: trait_substs={}",
+           trait_substs.repr(tcx));
     let trait_ref = ty::Binder(ty::TraitRef { def_id: trait_id,
                                               substs: trait_substs });
 
@@ -1051,10 +1052,10 @@ fn resolve_trait_associated_const<'a, 'tcx: 'a>(tcx: &'a ty::ctxt<'tcx>,
         }
         Err(e) => {
             tcx.sess.span_bug(ti.span,
-                              &format!("Encountered error `{:?}` when trying \
+                              &format!("Encountered error `{}` when trying \
                                         to select an implementation for \
                                         constant trait item reference.",
-                                       e))
+                                       e.repr(tcx)))
         }
     };
 

trunk/src/librustc/middle/effect.rs

@@ -15,6 +15,7 @@ use self::UnsafeContext::*;
 use middle::def;
 use middle::ty::{self, Ty};
 use middle::ty::MethodCall;
+use util::ppaux;
 
 use syntax::ast;
 use syntax::codemap::Span;
@@ -65,8 +66,8 @@ impl<'a, 'tcx> EffectCheckVisitor<'a, 'tcx> {
             ast::ExprIndex(ref base, _) => ty::node_id_to_type(self.tcx, base.id),
             _ => return
         };
-        debug!("effect: checking index with base type {:?}",
-                 base_type);
+        debug!("effect: checking index with base type {}",
+                ppaux::ty_to_string(self.tcx, base_type));
         match base_type.sty {
             ty::TyBox(ty) | ty::TyRef(_, ty::mt{ty, ..}) => if ty::TyStr == ty.sty {
                 span_err!(self.tcx.sess, e.span, E0134,
@@ -141,25 +142,25 @@ impl<'a, 'tcx, 'v> Visitor<'v> for EffectCheckVisitor<'a, 'tcx> {
             ast::ExprMethodCall(_, _, _) => {
                 let method_call = MethodCall::expr(expr.id);
                 let base_type = self.tcx.method_map.borrow().get(&method_call).unwrap().ty;
-                debug!("effect: method call case, base type is {:?}",
-                        base_type);
+                debug!("effect: method call case, base type is {}",
+                       ppaux::ty_to_string(self.tcx, base_type));
                 if type_is_unsafe_function(base_type) {
                     self.require_unsafe(expr.span,
                                         "invocation of unsafe method")
                 }
             }
             ast::ExprCall(ref base, _) => {
                 let base_type = ty::node_id_to_type(self.tcx, base.id);
-                debug!("effect: call case, base type is {:?}",
-                        base_type);
+                debug!("effect: call case, base type is {}",
+                       ppaux::ty_to_string(self.tcx, base_type));
                 if type_is_unsafe_function(base_type) {
                     self.require_unsafe(expr.span, "call to unsafe function")
                 }
             }
             ast::ExprUnary(ast::UnDeref, ref base) => {
                 let base_type = ty::node_id_to_type(self.tcx, base.id);
-                debug!("effect: unary case, base type is {:?}",
-                        base_type);
+                debug!("effect: unary case, base type is {}",
+                       ppaux::ty_to_string(self.tcx, base_type));
                 if let ty::TyRawPtr(_) = base_type.sty {
                     self.require_unsafe(expr.span, "dereference of raw pointer")
                 }