Auto merge of #41464 - frewsxcv:rollup, r=frewsxcv

Rollup of 3 pull requests

- Successful merges: #41077, #41355, #41450
- Failed merges:

src/doc/grammar.md

@@ -781,10 +781,11 @@ never_type : "!" ;
 ### Type parameter bounds
 
 ```antlr
+bound-list := bound | bound '+' bound-list '+' ?
 bound := ty_bound | lt_bound
 lt_bound := lifetime
-ty_bound := [?] [ for<lt_param_defs> ] simple_path
-bound-list := bound | bound '+' bound-list '+' ?
+ty_bound := ty_bound_noparen | (ty_bound_noparen)
+ty_bound_noparen := [?] [ for<lt_param_defs> ] simple_path
 ```
 
 ### Self types

src/librustc/dep_graph/dep_node.rs

@@ -88,6 +88,7 @@ pub enum DepNode<D: Clone + Debug> {
  // predicates for an item wind up in `ItemSignature`).
  AssociatedItems(D),
  ItemSignature(D),
+ IsForeignItem(D),
  TypeParamPredicates((D, D)),
  SizedConstraint(D),
  AdtDestructor(D),
@@ -171,6 +172,7 @@ impl<D: Clone + Debug> DepNode<D> {
  TransCrateItem,
  AssociatedItems,
  ItemSignature,
+ IsForeignItem,
  AssociatedItemDefIds,
  InherentImpls,
  TypeckTables,
@@ -221,6 +223,7 @@ impl<D: Clone + Debug> DepNode<D> {
  TransInlinedItem(ref d) => op(d).map(TransInlinedItem),
  AssociatedItems(ref d) => op(d).map(AssociatedItems),
  ItemSignature(ref d) => op(d).map(ItemSignature),
+ IsForeignItem(ref d) => op(d).map(IsForeignItem),
  TypeParamPredicates((ref item, ref param)) => {
  Some(TypeParamPredicates((try_opt!(op(item)), try_opt!(op(param)))))
  }

src/librustc/middle/reachable.rs

@@ -18,6 +18,7 @@
 use hir::map as hir_map;
 use hir::def::Def;
 use hir::def_id::{DefId, CrateNum};
+use std::rc::Rc;
 use ty::{self, TyCtxt};
 use ty::maps::Providers;
 use middle::privacy;
@@ -362,11 +363,11 @@ impl<'a, 'tcx: 'a> ItemLikeVisitor<'tcx> for CollectPrivateImplItemsVisitor<'a,
  }
 }
 
-pub fn find_reachable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> NodeSet {
+pub fn find_reachable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Rc<NodeSet> {
  ty::queries::reachable_set::get(tcx, DUMMY_SP, LOCAL_CRATE)
 }
 
-fn reachable_set<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum) -> NodeSet {
+fn reachable_set<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum) -> Rc<NodeSet> {
  debug_assert!(crate_num == LOCAL_CRATE);
 
  let access_levels = &ty::queries::privacy_access_levels::get(tcx, DUMMY_SP, LOCAL_CRATE);
@@ -411,7 +412,7 @@ fn reachable_set<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum) ->
  reachable_context.propagate();
 
  // Return the set of reachable symbols.
- reachable_context.reachable_symbols
+ Rc::new(reachable_context.reachable_symbols)
 }
 
 pub fn provide(providers: &mut Providers) {

src/librustc/traits/mod.rs

@@ -55,6 +55,7 @@ mod object_safety;
 mod select;
 mod specialize;
 mod structural_impls;
+pub mod trans;
 mod util;
 
 /// An `Obligation` represents some trait reference (e.g. `int:Eq`) for

src/librustc/traits/trans/mod.rs

@@ -0,0 +1,212 @@
+// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// This file contains various trait resolution methods used by trans.
+// They all assume regions can be erased and monomorphic types. It
+// seems likely that they should eventually be merged into more
+// general routines.
+
+use dep_graph::{DepGraph, DepNode, DepTrackingMap, DepTrackingMapConfig};
+use hir::def_id::DefId;
+use infer::TransNormalize;
+use std::cell::RefCell;
+use std::marker::PhantomData;
+use syntax::ast;
+use syntax_pos::Span;
+use traits::{FulfillmentContext, Obligation, ObligationCause, Reveal, SelectionContext, Vtable};
+use ty::{self, Ty, TyCtxt};
+use ty::subst::{Subst, Substs};
+use ty::fold::{TypeFoldable, TypeFolder};
+use util::common::MemoizationMap;
+
+impl<'a, 'tcx> TyCtxt<'a, 'tcx, 'tcx> {
+ /// Attempts to resolve an obligation to a vtable.. The result is
+ /// a shallow vtable resolution -- meaning that we do not
+ /// (necessarily) resolve all nested obligations on the impl. Note
+ /// that type check should guarantee to us that all nested
+ /// obligations *could be* resolved if we wanted to.
+ pub fn trans_fulfill_obligation(self,
+ span: Span,
+ trait_ref: ty::PolyTraitRef<'tcx>)
+ -> Vtable<'tcx, ()>
+ {
+ // Remove any references to regions; this helps improve caching.
+ let trait_ref = self.erase_regions(&trait_ref);
+
+ self.trans_trait_caches.trait_cache.memoize(trait_ref, || {
+ debug!("trans::fulfill_obligation(trait_ref={:?}, def_id={:?})",
+ trait_ref, trait_ref.def_id());
+
+ // Do the initial selection for the obligation. This yields the
+ // shallow result we are looking for -- that is, what specific impl.
+ self.infer_ctxt((), Reveal::All).enter(|infcx| {
+ let mut selcx = SelectionContext::new(&infcx);
+
+ let obligation_cause = ObligationCause::misc(span,
+ ast::DUMMY_NODE_ID);
+ let obligation = Obligation::new(obligation_cause,
+ trait_ref.to_poly_trait_predicate());
+
+ let selection = match selcx.select(&obligation) {
+ Ok(Some(selection)) => selection,
+ Ok(None) => {
+ // Ambiguity can happen when monomorphizing during trans
+ // expands to some humongo type that never occurred
+ // statically -- this humongo type can then overflow,
+ // leading to an ambiguous result. So report this as an
+ // overflow bug, since I believe this is the only case
+ // where ambiguity can result.
+ debug!("Encountered ambiguity selecting `{:?}` during trans, \
+ presuming due to overflow",
+ trait_ref);
+ self.sess.span_fatal(span,
+ "reached the recursion limit during monomorphization \
+ (selection ambiguity)");
+ }
+ Err(e) => {
+ span_bug!(span, "Encountered error `{:?}` selecting `{:?}` during trans",
+ e, trait_ref)
+ }
+ };
+
+ debug!("fulfill_obligation: selection={:?}", selection);
+
+ // Currently, we use a fulfillment context to completely resolve
+ // all nested obligations. This is because they can inform the
+ // inference of the impl's type parameters.
+ let mut fulfill_cx = FulfillmentContext::new();
+ let vtable = selection.map(|predicate| {
+ debug!("fulfill_obligation: register_predicate_obligation {:?}", predicate);
+ fulfill_cx.register_predicate_obligation(&infcx, predicate);
+ });
+ let vtable = infcx.drain_fulfillment_cx_or_panic(span, &mut fulfill_cx, &vtable);
+
+ info!("Cache miss: {:?} => {:?}", trait_ref, vtable);
+ vtable
+ })
+ })
+ }
+
+ /// Monomorphizes a type from the AST by first applying the in-scope
+ /// substitutions and then normalizing any associated types.
+ pub fn trans_apply_param_substs<T>(self,
+ param_substs: &Substs<'tcx>,
+ value: &T)
+ -> T
+ where T: TransNormalize<'tcx>
+ {
+ debug!("apply_param_substs(param_substs={:?}, value={:?})", param_substs, value);
+ let substituted = value.subst(self, param_substs);
+ let substituted = self.erase_regions(&substituted);
+ AssociatedTypeNormalizer::new(self).fold(&substituted)
+ }
+}
+
+struct AssociatedTypeNormalizer<'a, 'gcx: 'a> {
+ tcx: TyCtxt<'a, 'gcx, 'gcx>,
+}
+
+impl<'a, 'gcx> AssociatedTypeNormalizer<'a, 'gcx> {
+ fn new(tcx: TyCtxt<'a, 'gcx, 'gcx>) -> Self {
+ AssociatedTypeNormalizer { tcx }
+ }
+
+ fn fold<T:TypeFoldable<'gcx>>(&mut self, value: &T) -> T {
+ if !value.has_projection_types() {
+ value.clone()
+ } else {
+ value.fold_with(self)
+ }
+ }
+}
+
+impl<'a, 'gcx> TypeFolder<'gcx, 'gcx> for AssociatedTypeNormalizer<'a, 'gcx> {
+ fn tcx<'c>(&'c self) -> TyCtxt<'c, 'gcx, 'gcx> {
+ self.tcx
+ }
+
+ fn fold_ty(&mut self, ty: Ty<'gcx>) -> Ty<'gcx> {
+ if !ty.has_projection_types() {
+ ty
+ } else {
+ self.tcx.trans_trait_caches.project_cache.memoize(ty, || {
+ debug!("AssociatedTypeNormalizer: ty={:?}", ty);
+ self.tcx.normalize_associated_type(&ty)
+ })
+ }
+ }
+}
+
+/// Specializes caches used in trans -- in particular, they assume all
+/// types are fully monomorphized and that free regions can be erased.
+pub struct TransTraitCaches<'tcx> {
+ trait_cache: RefCell<DepTrackingMap<TraitSelectionCache<'tcx>>>,
+ project_cache: RefCell<DepTrackingMap<ProjectionCache<'tcx>>>,
+}
+
+impl<'tcx> TransTraitCaches<'tcx> {
+ pub fn new(graph: DepGraph) -> Self {
+ TransTraitCaches {
+ trait_cache: RefCell::new(DepTrackingMap::new(graph.clone())),
+ project_cache: RefCell::new(DepTrackingMap::new(graph)),
+ }
+ }
+}
+
+// Implement DepTrackingMapConfig for `trait_cache`
+pub struct TraitSelectionCache<'tcx> {
+ data: PhantomData<&'tcx ()>
+}
+
+impl<'tcx> DepTrackingMapConfig for TraitSelectionCache<'tcx> {
+ type Key = ty::PolyTraitRef<'tcx>;
+ type Value = Vtable<'tcx, ()>;
+ fn to_dep_node(key: &ty::PolyTraitRef<'tcx>) -> DepNode<DefId> {
+ key.to_poly_trait_predicate().dep_node()
+ }
+}
+
+// # Global Cache
+
+pub struct ProjectionCache<'gcx> {
+ data: PhantomData<&'gcx ()>
+}
+
+impl<'gcx> DepTrackingMapConfig for ProjectionCache<'gcx> {
+ type Key = Ty<'gcx>;
+ type Value = Ty<'gcx>;
+ fn to_dep_node(key: &Self::Key) -> DepNode<DefId> {
+ // Ideally, we'd just put `key` into the dep-node, but we
+ // can't put full types in there. So just collect up all the
+ // def-ids of structs/enums as well as any traits that we
+ // project out of. It doesn't matter so much what we do here,
+ // except that if we are too coarse, we'll create overly
+ // coarse edges between impls and the trans. For example, if
+ // we just used the def-id of things we are projecting out of,
+ // then the key for `<Foo as SomeTrait>::T` and `<Bar as
+ // SomeTrait>::T` would both share a dep-node
+ // (`TraitSelect(SomeTrait)`), and hence the impls for both
+ // `Foo` and `Bar` would be considered inputs. So a change to
+ // `Bar` would affect things that just normalized `Foo`.
+ // Anyway, this heuristic is not ideal, but better than
+ // nothing.
+ let def_ids: Vec<DefId> =
+ key.walk()
+ .filter_map(|t| match t.sty {
+ ty::TyAdt(adt_def, _) => Some(adt_def.did),
+ ty::TyProjection(ref proj) => Some(proj.trait_ref.def_id),
+ _ => None,
+ })
+ .collect();
+
+ DepNode::ProjectionCache { def_ids: def_ids }
+ }
+}
+

src/librustc/ty/context.rs

@@ -407,6 +407,8 @@ pub struct GlobalCtxt<'tcx> {
 
  pub specializes_cache: RefCell<traits::SpecializesCache>,
 
+ pub trans_trait_caches: traits::trans::TransTraitCaches<'tcx>,
+
  pub dep_graph: DepGraph,
 
  /// Common types, pre-interned for your convenience.
@@ -689,6 +691,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
  providers[LOCAL_CRATE] = local_providers;
  tls::enter_global(GlobalCtxt {
  sess: s,
+ trans_trait_caches: traits::trans::TransTraitCaches::new(dep_graph.clone()),
  specializes_cache: RefCell::new(traits::SpecializesCache::new()),
  global_arenas: arenas,
  global_interners: interners,

src/librustc/ty/maps.rs

@@ -380,6 +380,9 @@ define_maps! { <'tcx>
  pub adt_destructor: AdtDestructor(DefId) -> Option<ty::Destructor>,
  pub adt_sized_constraint: SizedConstraint(DefId) -> Ty<'tcx>,
 
+ /// True if this is a foreign item (i.e., linked via `extern { ... }`).
+ pub is_foreign_item: IsForeignItem(DefId) -> bool,
+
  /// Maps from def-id of a type or region parameter to its
  /// (inferred) variance.
  pub variances: ItemSignature(DefId) -> Rc<Vec<ty::Variance>>,
@@ -448,7 +451,7 @@ define_maps! { <'tcx>
  /// Performs the privacy check and computes "access levels".
  pub privacy_access_levels: PrivacyAccessLevels(CrateNum) -> Rc<AccessLevels>,
 
- pub reachable_set: reachability_dep_node(CrateNum) -> NodeSet,
+ pub reachable_set: reachability_dep_node(CrateNum) -> Rc<NodeSet>,
 
  pub mir_shims: mir_shim(ty::InstanceDef<'tcx>) -> &'tcx RefCell<mir::Mir<'tcx>>
 }

src/librustc/ty/mod.rs

@@ -115,7 +115,7 @@ mod sty;
 #[derive(Clone)]
 pub struct CrateAnalysis {
  pub access_levels: Rc<AccessLevels>,
- pub reachable: NodeSet,
+ pub reachable: Rc<NodeSet>,
  pub name: String,
  pub glob_map: Option<hir::GlobMap>,
 }

src/librustc_driver/driver.rs

@@ -810,7 +810,7 @@ pub fn phase_2_configure_and_expand<F>(sess: &Session,
  defs: resolver.definitions,
  analysis: ty::CrateAnalysis {
  access_levels: Rc::new(AccessLevels::default()),
- reachable: NodeSet(),
+ reachable: Rc::new(NodeSet()),
  name: crate_name.to_string(),
  glob_map: if resolver.make_glob_map { Some(resolver.glob_map) } else { None },
  },
@@ -889,9 +889,10 @@ pub fn phase_3_run_analysis_passes<'tcx, F, R>(sess: &'tcx Session,
  let index = stability::Index::new(&hir_map);
 
  let mut local_providers = ty::maps::Providers::default();
+ borrowck::provide(&mut local_providers);
  mir::provide(&mut local_providers);
+ reachable::provide(&mut local_providers);
  rustc_privacy::provide(&mut local_providers);
- borrowck::provide(&mut local_providers);
  typeck::provide(&mut local_providers);
  ty::provide(&mut local_providers);
  reachable::provide(&mut local_providers);

src/librustc_metadata/cstore_impl.rs

@@ -111,6 +111,7 @@ provide! { <'tcx> tcx, def_id, cdata
  closure_kind => { cdata.closure_kind(def_id.index) }
  closure_type => { cdata.closure_ty(def_id.index, tcx) }
  inherent_impls => { Rc::new(cdata.get_inherent_implementations_for_type(def_id.index)) }
+ is_foreign_item => { cdata.is_foreign_item(def_id.index) }
 }
 
 impl CrateStore for cstore::CStore {