---

yaml
---
r: 235827
b: refs/heads/stable
c: 11aa875
h: refs/heads/master
i:
  235825: babffaa
  235823: f32498a
v: v3

Author: arielb1

[refs]

@@ -29,7 +29,7 @@ refs/heads/tmp: afae2ff723393b3ab4ccffef6ac7c6d1809e2da0
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: f859507de8c410b648d934d8f5ec1c52daac971d
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: 7276d8b7613c81c09feeec3bf94d47c4a5174bc8
+refs/heads/stable: 11aa8756c1a6439fa73ef804665d13fc1bb29fef
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375
 refs/tags/1.1.0: bc3c16f09287e5545c1d3f76b7abd54f2eca868b
 refs/tags/1.2.0: f557861f822c34f07270347b94b5280de20a597e

branches/stable/src/librustc/middle/check_static_recursion.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// This compiler pass detects constants that refer to themselves
+// This compiler pass detects static items that refer to themselves
 // recursively.
 
 use ast_map;
@@ -18,7 +18,6 @@ use util::nodemap::NodeMap;
 
 use syntax::{ast, ast_util};
 use syntax::codemap::Span;
-use syntax::feature_gate::emit_feature_err;
 use syntax::visit::Visitor;
 use syntax::visit;
 
@@ -126,27 +125,8 @@ impl<'a, 'ast: 'a> CheckItemRecursionVisitor<'a, 'ast> {
     }
     fn with_item_id_pushed<F>(&mut self, id: ast::NodeId, f: F)
           where F: Fn(&mut Self) {
-        if self.idstack.iter().any(|&x| x == id) {
-            let any_static = self.idstack.iter().any(|&x| {
-                if let ast_map::NodeItem(item) = self.ast_map.get(x) {
-                    if let ast::ItemStatic(..) = item.node {
-                        true
-                    } else {
-                        false
-                    }
-                } else {
-                    false
-                }
-            });
-            if any_static {
-                if !self.sess.features.borrow().static_recursion {
-                    emit_feature_err(&self.sess.parse_sess.span_diagnostic,
-                                     "static_recursion",
-                                     *self.root_span, "recursive static");
-                }
-            } else {
-                span_err!(self.sess, *self.root_span, E0265, "recursive constant");
-            }
+        if self.idstack.iter().any(|x| *x == id) {
+            span_err!(self.sess, *self.root_span, E0265, "recursive constant");
             return;
         }
         self.idstack.push(id);

branches/stable/src/librustc/middle/infer/mod.rs

@@ -698,8 +698,8 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         }
     }
 
-    fn rollback_to(&self, cause: &str, snapshot: CombinedSnapshot) {
-        debug!("rollback_to(cause={})", cause);
+    fn rollback_to(&self, snapshot: CombinedSnapshot) {
+        debug!("rollback!");
         let CombinedSnapshot { type_snapshot,
                                int_snapshot,
                                float_snapshot,
@@ -759,7 +759,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         debug!("commit_if_ok() -- r.is_ok() = {}", r.is_ok());
         match r {
             Ok(_) => { self.commit_from(snapshot); }
-            Err(_) => { self.rollback_to("commit_if_ok -- error", snapshot); }
+            Err(_) => { self.rollback_to(snapshot); }
         }
         r
     }
@@ -778,8 +778,6 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
 
         let r = self.commit_if_ok(|_| f());
 
-        debug!("commit_regions_if_ok: rolling back everything but regions");
-
         // Roll back any non-region bindings - they should be resolved
         // inside `f`, with, e.g. `resolve_type_vars_if_possible`.
         self.type_variables
@@ -806,7 +804,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         debug!("probe()");
         let snapshot = self.start_snapshot();
         let r = f(&snapshot);
-        self.rollback_to("probe", snapshot);
+        self.rollback_to(snapshot);
         r
     }
 

branches/stable/src/librustc/middle/traits/select.rs

@@ -1351,15 +1351,11 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             // correct trait, but also the correct type parameters.
             // For example, we may be trying to upcast `Foo` to `Bar<i32>`,
             // but `Foo` is declared as `trait Foo : Bar<u32>`.
-            let upcast_trait_refs =
-                util::supertraits(self.tcx(), poly_trait_ref)
-                .filter(|upcast_trait_ref| {
-                    self.infcx.probe(|_| {
-                        let upcast_trait_ref = upcast_trait_ref.clone();
-                        self.match_poly_trait_ref(obligation, upcast_trait_ref).is_ok()
-                    })
-                })
-                .count();
+            let upcast_trait_refs = util::supertraits(self.tcx(), poly_trait_ref)
+                .filter(|upcast_trait_ref| self.infcx.probe(|_| {
+                    let upcast_trait_ref = upcast_trait_ref.clone();
+                    self.match_poly_trait_ref(obligation, upcast_trait_ref).is_ok()
+                })).count();
 
             if upcast_trait_refs > 1 {
                 // can be upcast in many ways; need more type information
@@ -1631,9 +1627,9 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                             let principal =
                                 data.principal_trait_ref_with_self_ty(self.tcx(),
                                                                       self.tcx().types.err);
-                            let copy_def_id = obligation.predicate.def_id();
+                            let desired_def_id = obligation.predicate.def_id();
                             for tr in util::supertraits(self.tcx(), principal) {
-                                if tr.def_id() == copy_def_id {
+                                if tr.def_id() == desired_def_id {
                                     return ok_if(Vec::new())
                                 }
                             }
@@ -2286,41 +2282,31 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             }
         };
 
+        // Upcast the object type to the obligation type. There must
+        // be exactly one applicable trait-reference; if this were not
+        // the case, we would have reported an ambiguity error rather
+        // than successfully selecting one of the candidates.
+        let mut upcast_trait_refs = util::supertraits(self.tcx(), poly_trait_ref)
+            .map(|upcast_trait_ref| {
+                (upcast_trait_ref.clone(), self.infcx.probe(|_| {
+                    self.match_poly_trait_ref(obligation, upcast_trait_ref)
+                }).is_ok())
+            });
         let mut upcast_trait_ref = None;
-        let vtable_base;
-
-        {
-            // We want to find the first supertrait in the list of
-            // supertraits that we can unify with, and do that
-            // unification. We know that there is exactly one in the list
-            // where we can unify because otherwise select would have
-            // reported an ambiguity. (When we do find a match, also
-            // record it for later.)
-            let nonmatching =
-                util::supertraits(self.tcx(), poly_trait_ref)
-                .take_while(|&t| {
-                    match
-                        self.infcx.commit_if_ok(
-                            |_| self.match_poly_trait_ref(obligation, t))
-                    {
-                        Ok(_) => { upcast_trait_ref = Some(t); false }
-                        Err(_) => { true }
-                    }
-                });
-
-            // Additionally, for each of the nonmatching predicates that
-            // we pass over, we sum up the set of number of vtable
-            // entries, so that we can compute the offset for the selected
-            // trait.
-            vtable_base =
-                nonmatching.map(|t| util::count_own_vtable_entries(self.tcx(), t))
-                           .sum();
+        let mut vtable_base = 0;
 
+        while let Some((supertrait, matches)) = upcast_trait_refs.next() {
+            if matches {
+                upcast_trait_ref = Some(supertrait);
+                break;
+            }
+            vtable_base += util::count_own_vtable_entries(self.tcx(), supertrait);
         }
+        assert!(upcast_trait_refs.all(|(_, matches)| !matches));
 
         VtableObjectData {
             upcast_trait_ref: upcast_trait_ref.unwrap(),
-            vtable_base: vtable_base,
+            vtable_base: vtable_base
         }
     }
 

branches/stable/src/librustc/middle/ty.rs

@@ -1985,7 +1985,7 @@ impl<'tcx> PolyTraitRef<'tcx> {
 /// erase, or otherwise "discharge" these bound regions, we change the
 /// type from `Binder<T>` to just `T` (see
 /// e.g. `liberate_late_bound_regions`).
-#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
+#[derive(Clone, PartialEq, Eq, Hash, Debug)]
 pub struct Binder<T>(pub T);
 
 impl<T> Binder<T> {

branches/stable/src/librustc_trans/trans/base.rs

@@ -2090,7 +2090,7 @@ pub fn trans_item(ccx: &CrateContext, item: &ast::Item) {
           let mut v = TransItemVisitor{ ccx: ccx };
           v.visit_expr(&**expr);
 
-          let g = consts::trans_static(ccx, m, expr, item.id, &item.attrs);
+          let g = consts::trans_static(ccx, m, item.id);
           update_linkage(ccx, g, Some(item.id), OriginalTranslation);
       },
       ast::ItemForeignMod(ref foreign_mod) => {
@@ -2334,25 +2334,44 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef {
             let sym = || exported_name(ccx, id, ty, &i.attrs);
 
             let v = match i.node {
-                ast::ItemStatic(..) => {
+                ast::ItemStatic(_, _, ref expr) => {
                     // If this static came from an external crate, then
                     // we need to get the symbol from csearch instead of
                     // using the current crate's name/version
                     // information in the hash of the symbol
                     let sym = sym();
                     debug!("making {}", sym);
 
-                    // Create the global before evaluating the initializer;
-                    // this is necessary to allow recursive statics.
-                    let llty = type_of(ccx, ty);
-                    let g = declare::define_global(ccx, &sym[..],
-                                                   llty).unwrap_or_else(|| {
-                        ccx.sess().span_fatal(i.span, &format!("symbol `{}` is already defined",
-                                                                sym))
-                    });
-
-                    ccx.item_symbols().borrow_mut().insert(i.id, sym);
-                    g
+                    // We need the translated value here, because for enums the
+                    // LLVM type is not fully determined by the Rust type.
+                    let empty_substs = ccx.tcx().mk_substs(Substs::trans_empty());
+                    let (v, ty) = consts::const_expr(ccx, &**expr, empty_substs, None);
+                    ccx.static_values().borrow_mut().insert(id, v);
+                    unsafe {
+                        // boolean SSA values are i1, but they have to be stored in i8 slots,
+                        // otherwise some LLVM optimization passes don't work as expected
+                        let llty = if ty.is_bool() {
+                            llvm::LLVMInt8TypeInContext(ccx.llcx())
+                        } else {
+                            llvm::LLVMTypeOf(v)
+                        };
+
+                        // FIXME(nagisa): probably should be declare_global, because no definition
+                        // is happening here, but we depend on it being defined here from
+                        // const::trans_static. This all logic should be replaced.
+                        let g = declare::define_global(ccx, &sym[..],
+                                                       Type::from_ref(llty)).unwrap_or_else(||{
+                            ccx.sess().span_fatal(i.span, &format!("symbol `{}` is already defined",
+                                                                   sym))
+                        });
+
+                        if attr::contains_name(&i.attrs,
+                                               "thread_local") {
+                            llvm::set_thread_local(g, true);
+                        }
+                        ccx.item_symbols().borrow_mut().insert(i.id, sym);
+                        g
+                    }
                 }
 
                 ast::ItemFn(_, _, _, abi, _, _) => {
@@ -2719,13 +2738,6 @@ pub fn trans_crate(tcx: &ty::ctxt, analysis: ty::CrateAnalysis) -> CrateTranslat
         if ccx.sess().opts.debuginfo != NoDebugInfo {
             debuginfo::finalize(&ccx);
         }
-        for &(old_g, new_g) in ccx.statics_to_rauw().borrow().iter() {
-            unsafe {
-                let bitcast = llvm::LLVMConstPointerCast(new_g, llvm::LLVMTypeOf(old_g));
-                llvm::LLVMReplaceAllUsesWith(old_g, bitcast);
-                llvm::LLVMDeleteGlobal(old_g);
-            }
-        }
     }
 
     // Translate the metadata.

branches/stable/src/librustc_trans/trans/consts.rs

@@ -37,9 +37,8 @@ use middle::subst::Substs;
 use middle::ty::{self, Ty};
 use util::nodemap::NodeMap;
 
-use std::ffi::{CStr, CString};
 use libc::c_uint;
-use syntax::{ast, ast_util, attr};
+use syntax::{ast, ast_util};
 use syntax::parse::token;
 use syntax::ptr::P;
 
@@ -899,70 +898,37 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                                 "bad constant expression type in consts::const_expr"),
     }
 }
-pub fn trans_static(ccx: &CrateContext,
-                    m: ast::Mutability,
-                    expr: &ast::Expr,
-                    id: ast::NodeId,
-                    attrs: &Vec<ast::Attribute>)
-                    -> ValueRef {
+
+pub fn trans_static(ccx: &CrateContext, m: ast::Mutability, id: ast::NodeId) -> ValueRef {
     unsafe {
         let _icx = push_ctxt("trans_static");
         let g = base::get_item_val(ccx, id);
-
-        let empty_substs = ccx.tcx().mk_substs(Substs::trans_empty());
-        let (v, _) = const_expr(ccx, expr, empty_substs, None);
-
+        // At this point, get_item_val has already translated the
+        // constant's initializer to determine its LLVM type.
+        let v = ccx.static_values().borrow().get(&id).unwrap().clone();
         // boolean SSA values are i1, but they have to be stored in i8 slots,
         // otherwise some LLVM optimization passes don't work as expected
-        let mut val_llty = llvm::LLVMTypeOf(v);
-        let v = if val_llty == Type::i1(ccx).to_ref() {
-            val_llty = Type::i8(ccx).to_ref();
-            llvm::LLVMConstZExt(v, val_llty)
+        let v = if llvm::LLVMTypeOf(v) == Type::i1(ccx).to_ref() {
+            llvm::LLVMConstZExt(v, Type::i8(ccx).to_ref())
         } else {
             v
         };
-
-        let ty = ccx.tcx().node_id_to_type(id);
-        let llty = type_of::type_of(ccx, ty);
-        let g = if val_llty == llty.to_ref() {
-            g
-        } else {
-            // If we created the global with the wrong type,
-            // correct the type.
-            let empty_string = CString::new("").unwrap();
-            let name_str_ref = CStr::from_ptr(llvm::LLVMGetValueName(g));
-            let name_string = CString::new(name_str_ref.to_bytes()).unwrap();
-            llvm::LLVMSetValueName(g, empty_string.as_ptr());
-            let new_g = llvm::LLVMGetOrInsertGlobal(
-                ccx.llmod(), name_string.as_ptr(), val_llty);
-            // To avoid breaking any invariants, we leave around the old
-            // global for the moment; we'll replace all references to it
-            // with the new global later. (See base::trans_crate.)
-            ccx.statics_to_rauw().borrow_mut().push((g, new_g));
-            new_g
-        };
         llvm::LLVMSetInitializer(g, v);
 
         // As an optimization, all shared statics which do not have interior
         // mutability are placed into read-only memory.
         if m != ast::MutMutable {
-            let tcontents = ty.type_contents(ccx.tcx());
+            let node_ty = ccx.tcx().node_id_to_type(id);
+            let tcontents = node_ty.type_contents(ccx.tcx());
             if !tcontents.interior_unsafe() {
-                llvm::LLVMSetGlobalConstant(g, llvm::True);
+                llvm::LLVMSetGlobalConstant(g, True);
             }
         }
-
         debuginfo::create_global_var_metadata(ccx, id, g);
-
-        if attr::contains_name(attrs,
-                               "thread_local") {
-            llvm::set_thread_local(g, true);
-        }
         g
     }
 }
 
-
 fn get_static_val<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, did: ast::DefId,
                             ty: Ty<'tcx>) -> ValueRef {
     if ast_util::is_local(did) { return base::get_item_val(ccx, did.node) }