pub fn empty(local_id_root: Option<DefId>) -> TypeckTables<'tcx> {
TypeckTables {
local_id_root,
- type_dependent_defs: ItemLocalMap(),
- field_indices: ItemLocalMap(),
- user_provided_tys: ItemLocalMap(),
+ type_dependent_defs: Default::default(),
+ field_indices: Default::default(),
+ user_provided_tys: Default::default(),
user_provided_sigs: Default::default(),
- node_types: ItemLocalMap(),
- node_substs: ItemLocalMap(),
- user_substs: ItemLocalMap(),
- adjustments: ItemLocalMap(),
- pat_binding_modes: ItemLocalMap(),
- pat_adjustments: ItemLocalMap(),
+ node_types: Default::default(),
+ node_substs: Default::default(),
+ user_substs: Default::default(),
+ adjustments: Default::default(),
+ pat_binding_modes: Default::default(),
+ pat_adjustments: Default::default(),
upvar_capture_map: Default::default(),
- closure_kind_origins: ItemLocalMap(),
- liberated_fn_sigs: ItemLocalMap(),
- fru_field_types: ItemLocalMap(),
- cast_kinds: ItemLocalMap(),
- used_trait_imports: Lrc::new(DefIdSet()),
+ closure_kind_origins: Default::default(),
+ liberated_fn_sigs: Default::default(),
+ fru_field_types: Default::default(),
+ cast_kinds: Default::default(),
+ used_trait_imports: Lrc::new(Default::default()),
tainted_by_errors: false,
free_region_map: Default::default(),
concrete_existential_types: Default::default(),
pat_adjustments.hash_stable(hcx, hasher);
hash_stable_hashmap(hcx, hasher, upvar_capture_map, |up_var_id, hcx| {
let ty::UpvarId {
- var_id,
+ var_path,
closure_expr_id
} = *up_var_id;
let var_owner_def_id = DefId {
krate: local_id_root.krate,
- index: var_id.owner,
+ index: var_path.hir_id.owner,
};
let closure_def_id = DefId {
krate: local_id_root.krate,
index: closure_expr_id.to_def_id().index,
};
(hcx.def_path_hash(var_owner_def_id),
- var_id.local_id,
+ var_path.hir_id.local_id,
hcx.def_path_hash(closure_def_id))
});
/// Allocates a byte or string literal for `mir::interpret`, read-only
pub fn allocate_bytes(self, bytes: &[u8]) -> interpret::AllocId {
// create an allocation that just contains these bytes
- let alloc = interpret::Allocation::from_byte_aligned_bytes(bytes);
+ let alloc = interpret::Allocation::from_byte_aligned_bytes(bytes, ());
let alloc = self.intern_const_alloc(alloc);
self.alloc_map.lock().allocate(alloc)
}
/// done with either: `-Ztwo-phase-borrows`, `#![feature(nll)]`,
/// or by opting into an edition after 2015.
pub fn two_phase_borrows(self) -> bool {
- if self.features().nll || self.sess.opts.debugging_opts.two_phase_borrows {
- return true;
- }
-
- match self.sess.edition() {
- Edition::Edition2015 => false,
- Edition::Edition2018 => true,
- _ => true,
- }
+ self.sess.rust_2018() || self.features().nll ||
+ self.sess.opts.debugging_opts.two_phase_borrows
}
/// What mode(s) of borrowck should we run? AST? MIR? both?
}
}
- /// Should we emit EndRegion MIR statements? These are consumed by
- /// MIR borrowck, but not when NLL is used.
- pub fn emit_end_regions(self) -> bool {
- self.sess.opts.debugging_opts.emit_end_regions ||
- self.use_mir_borrowck()
- }
-
#[inline]
pub fn local_crate_exports_generics(self) -> bool {
debug_assert!(self.sess.opts.share_generics());
pub fn print_debug_stats(self) {
sty_debug_print!(
self,
- Adt, Array, Slice, RawPtr, Ref, FnDef, FnPtr,
+ Adt, Array, Slice, RawPtr, Ref, FnDef, FnPtr, Placeholder,
Generator, GeneratorWitness, Dynamic, Closure, Tuple, Bound,
Param, Infer, UnnormalizedProjection, Projection, Opaque, Foreign);