}
impl EdgeFilter {
- pub fn new(test: &str) -> Result<EdgeFilter, Box<Error>> {
+ pub fn new(test: &str) -> Result<EdgeFilter, Box<dyn Error>> {
let parts: Vec<_> = test.split("->").collect();
if parts.len() != 2 {
Err(format!("expected a filter like `a&b -> c&d`, not `{}`", test).into())
// Use to assign ids to hir nodes that do not directly correspond to an ast node
sess: &'a Session,
- cstore: &'a CrateStore,
+ cstore: &'a dyn CrateStore,
// As we walk the AST we must keep track of the current 'parent' def id (in
// the form of a DefIndex) so that if we create a new node which introduces
// a definition, then we can properly create the def id.
parent_def: Option<DefIndex>,
- resolver: &'a mut Resolver,
+ resolver: &'a mut dyn Resolver,
name_map: FxHashMap<Ident, Name>,
/// The items being lowered are collected here.
}
pub fn lower_crate(sess: &Session,
- cstore: &CrateStore,
+ cstore: &dyn CrateStore,
dep_graph: &DepGraph,
krate: &Crate,
- resolver: &mut Resolver)
+ resolver: &mut dyn Resolver)
-> hir::Crate {
// We're constructing the HIR here; we don't care what we will
// read, since we haven't even constructed the *input* to
pub(super) fn finalize_and_compute_crate_hash(self,
crate_disambiguator: CrateDisambiguator,
- cstore: &CrateStore,
+ cstore: &dyn CrateStore,
codemap: &CodeMap,
commandline_args_hash: u64)
-> (Vec<MapEntry<'hir>>, Svh) {
definitions: &'a mut Definitions,
parent_def: Option<DefIndex>,
expansion: Mark,
- pub visit_macro_invoc: Option<&'a mut FnMut(MacroInvocationData)>,
+ pub visit_macro_invoc: Option<&'a mut dyn FnMut(MacroInvocationData)>,
}
pub struct MacroInvocationData {
impl Named for ImplItem { fn name(&self) -> Name { self.name } }
pub fn map_crate<'hir>(sess: &::session::Session,
- cstore: &::middle::cstore::CrateStore,
+ cstore: &dyn ::middle::cstore::CrateStore,
forest: &'hir mut Forest,
definitions: &'hir Definitions)
-> Map<'hir> {
pub struct NoAnn;
impl PpAnn for NoAnn {}
-pub const NO_ANN: &'static PpAnn = &NoAnn;
+pub const NO_ANN: &'static dyn PpAnn = &NoAnn;
impl PpAnn for hir::Crate {
fn nested(&self, state: &mut State, nested: Nested) -> io::Result<()> {
literals: Peekable<vec::IntoIter<comments::Literal>>,
cur_cmnt: usize,
boxes: Vec<pp::Breaks>,
- ann: &'a (PpAnn + 'a),
+ ann: &'a (dyn PpAnn + 'a),
}
impl<'a> PrintState<'a> for State<'a> {
sess: &ParseSess,
krate: &hir::Crate,
filename: FileName,
- input: &mut Read,
- out: Box<Write + 'a>,
- ann: &'a PpAnn,
+ input: &mut dyn Read,
+ out: Box<dyn Write + 'a>,
+ ann: &'a dyn PpAnn,
is_expanded: bool)
-> io::Result<()> {
let mut s = State::new_from_input(cm, sess, filename, input, out, ann, is_expanded);
pub fn new_from_input(cm: &'a CodeMap,
sess: &ParseSess,
filename: FileName,
- input: &mut Read,
- out: Box<Write + 'a>,
- ann: &'a PpAnn,
+ input: &mut dyn Read,
+ out: Box<dyn Write + 'a>,
+ ann: &'a dyn PpAnn,
is_expanded: bool)
-> State<'a> {
let (cmnts, lits) = comments::gather_comments_and_literals(sess, filename, input);
}
pub fn new(cm: &'a CodeMap,
- out: Box<Write + 'a>,
- ann: &'a PpAnn,
+ out: Box<dyn Write + 'a>,
+ ann: &'a dyn PpAnn,
comments: Option<Vec<comments::Comment>>,
literals: Option<Vec<comments::Literal>>)
-> State<'a> {
}
}
-pub fn to_string<F>(ann: &PpAnn, f: F) -> String
+pub fn to_string<F>(ann: &dyn PpAnn, f: F) -> String
where F: FnOnce(&mut State) -> io::Result<()>
{
let mut wr = Vec::new();
pub struct StableHashingContext<'gcx> {
sess: &'gcx Session,
definitions: &'gcx Definitions,
- cstore: &'gcx CrateStore,
+ cstore: &'gcx dyn CrateStore,
body_resolver: BodyResolver<'gcx>,
hash_spans: bool,
hash_bodies: bool,
pub fn new(sess: &'gcx Session,
krate: &'gcx hir::Crate,
definitions: &'gcx Definitions,
- cstore: &'gcx CrateStore)
+ cstore: &'gcx dyn CrateStore)
-> Self {
let hash_spans_initial = !sess.opts.debugging_opts.incremental_ignore_spans;
}
impl<'a, 'gcx, 'tcx> VerifyBound<'tcx> {
- fn for_each_region(&self, f: &mut FnMut(ty::Region<'tcx>)) {
+ fn for_each_region(&self, f: &mut dyn FnMut(ty::Region<'tcx>)) {
match self {
&VerifyBound::AnyRegion(ref rs) | &VerifyBound::AllRegions(ref rs) => for &r in rs {
f(r);
}
/// A lint pass boxed up as a trait object.
-pub type EarlyLintPassObject = Box<EarlyLintPass + 'static>;
-pub type LateLintPassObject = Box<for<'a, 'tcx> LateLintPass<'a, 'tcx> + 'static>;
+pub type EarlyLintPassObject = Box<dyn EarlyLintPass + 'static>;
+pub type LateLintPassObject = Box<dyn for<'a, 'tcx> LateLintPass<'a, 'tcx> + 'static>;
/// Identifies a lint known to the compiler.
#[derive(Clone, Copy, Debug)]
/// (it'd break incremental compilation) and should only be called pre-HIR (e.g.
/// during resolve)
pub trait CrateStore {
- fn crate_data_as_rc_any(&self, krate: CrateNum) -> Lrc<Any>;
+ fn crate_data_as_rc_any(&self, krate: CrateNum) -> Lrc<dyn Any>;
// access to the metadata loader
- fn metadata_loader(&self) -> &MetadataLoader;
+ fn metadata_loader(&self) -> &dyn MetadataLoader;
// resolve
fn def_key(&self, def: DefId) -> DefKey;
#[allow(unused_variables)]
impl CrateStore for DummyCrateStore {
- fn crate_data_as_rc_any(&self, krate: CrateNum) -> Lrc<Any>
+ fn crate_data_as_rc_any(&self, krate: CrateNum) -> Lrc<dyn Any>
{ bug!("crate_data_as_rc_any") }
// item info
fn visibility_untracked(&self, def: DefId) -> ty::Visibility { bug!("visibility") }
fn postorder_cnums_untracked(&self) -> Vec<CrateNum> { bug!("postorder_cnums_untracked") }
// access to the metadata loader
- fn metadata_loader(&self) -> &MetadataLoader { bug!("metadata_loader") }
+ fn metadata_loader(&self) -> &dyn MetadataLoader { bug!("metadata_loader") }
}
pub trait CrateLoader {
// also skip this step entirely.
fn activate_injected_dep(injected: Option<CrateNum>,
list: &mut DependencyList,
- replaces_injected: &Fn(CrateNum) -> bool) {
+ replaces_injected: &dyn Fn(CrateNum) -> bool) {
for (i, slot) in list.iter().enumerate() {
let cnum = CrateNum::new(i + 1);
if !replaces_injected(cnum) {
// This is the code that actually walks the tree.
pub struct ExprUseVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
mc: mc::MemCategorizationContext<'a, 'gcx, 'tcx>,
- delegate: &'a mut Delegate<'tcx>,
+ delegate: &'a mut dyn Delegate<'tcx>,
param_env: ty::ParamEnv<'tcx>,
}
/// `None` means that rvalues will be given more conservative lifetimes.
///
/// See also `with_infer`, which is used *during* typeck.
- pub fn new(delegate: &'a mut (Delegate<'tcx>+'a),
+ pub fn new(delegate: &'a mut (dyn Delegate<'tcx>+'a),
tcx: TyCtxt<'a, 'tcx, 'tcx>,
param_env: ty::ParamEnv<'tcx>,
region_scope_tree: &'a region::ScopeTree,
}
impl<'a, 'gcx, 'tcx> ExprUseVisitor<'a, 'gcx, 'tcx> {
- pub fn with_infer(delegate: &'a mut (Delegate<'tcx>+'a),
+ pub fn with_infer(delegate: &'a mut (dyn Delegate<'tcx>+'a),
infcx: &'a InferCtxt<'a, 'gcx, 'tcx>,
param_env: ty::ParamEnv<'tcx>,
region_scope_tree: &'a region::ScopeTree,
}
fn write_vars<F>(&self,
- wr: &mut Write,
+ wr: &mut dyn Write,
ln: LiveNode,
mut test: F)
-> io::Result<()> where
fn ln_str(&self, ln: LiveNode) -> String {
let mut wr = Vec::new();
{
- let wr = &mut wr as &mut Write;
+ let wr = &mut wr as &mut dyn Write;
write!(wr, "[ln({:?}) of kind {:?} reads", ln.get(), self.ir.lnk(ln));
self.write_vars(wr, ln, |idx| self.users[idx].reader);
write!(wr, " writes");
pub enum EvalErrorKind<'tcx> {
/// This variant is used by machines to signal their own errors that do not
/// match an existing variant
- MachineError(Box<Error>),
+ MachineError(Box<dyn Error>),
FunctionPointerTyMismatch(FnSig<'tcx>, FnSig<'tcx>),
NoMirFor(String),
UnterminatedCString(MemoryPointer),
}
}
- fn cause(&self) -> Option<&Error> {
+ fn cause(&self) -> Option<&dyn Error> {
use self::EvalErrorKind::*;
match self.kind {
MachineError(ref inner) => Some(&**inner),
($opt_name:ident, $opt_expr:expr, $sub_hashes:expr, [UNTRACKED]) => ({});
($opt_name:ident, $opt_expr:expr, $sub_hashes:expr, [TRACKED]) => ({
if $sub_hashes.insert(stringify!($opt_name),
- $opt_expr as &dep_tracking::DepTrackingHash).is_some() {
+ $opt_expr as &dyn dep_tracking::DepTrackingHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHashHash).is_some() {
bug!("Duplicate key in CLI DepTrackingHash: {}", stringify!($opt_name))
}
});
}
pub struct RustcOptGroup {
- pub apply: Box<Fn(&mut getopts::Options) -> &mut getopts::Options>,
+ pub apply: Box<dyn Fn(&mut getopts::Options) -> &mut getopts::Options>,
pub name: &'static str,
pub stability: OptionStability,
}
}
// This is a stable hash because BTreeMap is a sorted container
- pub fn stable_hash(sub_hashes: BTreeMap<&'static str, &DepTrackingHash>,
+ pub fn stable_hash(sub_hashes: BTreeMap<&'static str, &dyn DepTrackingHash>,
hasher: &mut DefaultHasher,
error_format: ErrorOutputType) {
for (key, sub_hash) in sub_hashes {
local_crate_source_file: Option<PathBuf>,
registry: errors::registry::Registry,
codemap: Lrc<codemap::CodeMap>,
- emitter_dest: Option<Box<Write + Send>>)
+ emitter_dest: Option<Box<dyn Write + Send>>)
-> Session {
// FIXME: This is not general enough to make the warning lint completely override
// normal diagnostic warnings, since the warning lint can also be denied and changed
let external_macro_backtrace = sopts.debugging_opts.external_macro_backtrace;
- let emitter: Box<Emitter> = match (sopts.error_format, emitter_dest) {
+ let emitter: Box<dyn Emitter> = match (sopts.error_format, emitter_dest) {
(config::ErrorOutputType::HumanReadable(color_config), None) => {
Box::new(EmitterWriter::stderr(color_config, Some(codemap.clone()),
false, sopts.debugging_opts.teach)
}
pub fn early_error(output: config::ErrorOutputType, msg: &str) -> ! {
- let emitter: Box<Emitter> = match output {
+ let emitter: Box<dyn Emitter> = match output {
config::ErrorOutputType::HumanReadable(color_config) => {
Box::new(EmitterWriter::stderr(color_config, None, false, false))
}
}
pub fn early_warn(output: config::ErrorOutputType, msg: &str) {
- let emitter: Box<Emitter> = match output {
+ let emitter: Box<dyn Emitter> = match output {
config::ErrorOutputType::HumanReadable(color_config) => {
Box::new(EmitterWriter::stderr(color_config, None, false, false))
}
item_name: ast::Name,
_impl_item_def_id: DefId,
trait_item_def_id: DefId,
- requirement: &fmt::Display)
+ requirement: &dyn fmt::Display)
-> DiagnosticBuilder<'tcx>
{
let msg = "impl has stricter requirements than trait";
Ok(Inserted::BecameNewSibling(last_lint))
}
- fn iter_mut(&'a mut self) -> Box<Iterator<Item = &'a mut DefId> + 'a> {
+ fn iter_mut(&'a mut self) -> Box<dyn Iterator<Item = &'a mut DefId> + 'a> {
let nonblanket = self.nonblanket_impls.iter_mut().flat_map(|(_, v)| v.iter_mut());
Box::new(self.blanket_impls.iter_mut().chain(nonblanket))
}
fn filtered_mut(&'a mut self, sty: SimplifiedType)
- -> Box<Iterator<Item = &'a mut DefId> + 'a> {
+ -> Box<dyn Iterator<Item = &'a mut DefId> + 'a> {
let nonblanket = self.nonblanket_impls.entry(sty).or_insert(vec![]).iter_mut();
Box::new(self.blanket_impls.iter_mut().chain(nonblanket))
}
global_arenas: &'tcx GlobalArenas<'tcx>,
global_interners: CtxtInterners<'tcx>,
- cstore: &'tcx CrateStore,
+ cstore: &'tcx dyn CrateStore,
pub sess: &'tcx Session,
/// This is intended to only get used during the trans phase of the compiler
/// when satisfying the query for a particular codegen unit. Internally in
/// the query it'll send data along this channel to get processed later.
- pub tx_to_llvm_workers: mpsc::Sender<Box<Any + Send>>,
+ pub tx_to_llvm_workers: mpsc::Sender<Box<dyn Any + Send>>,
output_filenames: Arc<OutputFilenames>,
}
/// value (types, substs, etc.) can only be used while `ty::tls` has a valid
/// reference to the context, to allow formatting values that need it.
pub fn create_and_enter<F, R>(s: &'tcx Session,
- cstore: &'tcx CrateStore,
+ cstore: &'tcx dyn CrateStore,
local_providers: ty::maps::Providers<'tcx>,
extern_providers: ty::maps::Providers<'tcx>,
arenas: &'tcx AllArenas<'tcx>,
hir: hir_map::Map<'tcx>,
on_disk_query_result_cache: maps::OnDiskCache<'tcx>,
crate_name: &str,
- tx: mpsc::Sender<Box<Any + Send>>,
+ tx: mpsc::Sender<Box<dyn Any + Send>>,
output_filenames: &OutputFilenames,
f: F) -> R
where F: for<'b> FnOnce(TyCtxt<'b, 'tcx, 'tcx>) -> R
// Note that this is *untracked* and should only be used within the query
// system if the result is otherwise tracked through queries
- pub fn crate_data_as_rc_any(self, cnum: CrateNum) -> Lrc<Any> {
+ pub fn crate_data_as_rc_any(self, cnum: CrateNum) -> Lrc<dyn Any> {
self.cstore.crate_data_as_rc_any(cnum)
}
tcx: TyCtxt<'a, 'gcx, 'tcx>,
skipped_regions: &'a mut bool,
current_depth: u32,
- fld_r: &'a mut (FnMut(ty::Region<'tcx>, u32) -> ty::Region<'tcx> + 'a),
+ fld_r: &'a mut (dyn FnMut(ty::Region<'tcx>, u32) -> ty::Region<'tcx> + 'a),
}
impl<'a, 'gcx, 'tcx> RegionFolder<'a, 'gcx, 'tcx> {
struct RegionReplacer<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
tcx: TyCtxt<'a, 'gcx, 'tcx>,
current_depth: u32,
- fld_r: &'a mut (FnMut(ty::BoundRegion) -> ty::Region<'tcx> + 'a),
+ fld_r: &'a mut (dyn FnMut(ty::BoundRegion) -> ty::Region<'tcx> + 'a),
map: BTreeMap<ty::BoundRegion, ty::Region<'tcx>>
}
pub fn calculate_dtor(
self,
adt_did: DefId,
- validate: &mut FnMut(Self, DefId) -> Result<(), ErrorReported>
+ validate: &mut dyn FnMut(Self, DefId) -> Result<(), ErrorReported>
) -> Option<ty::Destructor> {
let drop_trait = if let Some(def_id) = self.lang_items().drop_trait() {
def_id
thread_local!(static TIME_DEPTH: Cell<usize> = Cell::new(0));
lazy_static! {
- static ref DEFAULT_HOOK: Box<Fn(&panic::PanicInfo) + Sync + Send + 'static> = {
+ static ref DEFAULT_HOOK: Box<dyn Fn(&panic::PanicInfo) + Sync + Send + 'static> = {
let hook = panic::take_hook();
panic::set_hook(Box::new(panic_hook));
hook
projects / rust.git / commitdiff