416399dc10
`Decoder` has two impls: - opaque: this impl is already partly infallible, i.e. in some places it currently panics on failure (e.g. if the input is too short, or on a bad `Result` discriminant), and in some places it returns an error (e.g. on a bad `Option` discriminant). The number of places where either happens is surprisingly small, just because the binary representation has very little redundancy and a lot of input reading can occur even on malformed data. - json: this impl is fully fallible, but it's only used (a) for the `.rlink` file production, and there's a `FIXME` comment suggesting it should change to a binary format, and (b) in a few tests in non-fundamental ways. Indeed #85993 is open to remove it entirely. And the top-level places in the compiler that call into decoding just abort on error anyway. So the fallibility is providing little value, and getting rid of it leads to some non-trivial performance improvements. Much of this commit is pretty boring and mechanical. Some notes about a few interesting parts: - The commit removes `Decoder::{Error,error}`. - `InternIteratorElement::intern_with`: the impl for `T` now has the same optimization for small counts that the impl for `Result<T, E>` has, because it's now much hotter. - Decodable impls for SmallVec, LinkedList, VecDeque now all use `collect`, which is nice; the one for `Vec` uses unsafe code, because that gave better perf on some benchmarks.
63 lines
1.9 KiB
Rust
63 lines
1.9 KiB
Rust
use rustc_data_structures::graph::{
|
|
self, DirectedGraph, WithNumNodes, WithStartNode, WithSuccessors,
|
|
};
|
|
use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
|
|
use rustc_data_structures::sync::OnceCell;
|
|
use rustc_serialize as serialize;
|
|
|
|
/// Helper type to cache the result of `graph::is_cyclic`.
|
|
#[derive(Clone, Debug)]
|
|
pub(super) struct GraphIsCyclicCache {
|
|
cache: OnceCell<bool>,
|
|
}
|
|
|
|
impl GraphIsCyclicCache {
|
|
#[inline]
|
|
pub(super) fn new() -> Self {
|
|
GraphIsCyclicCache { cache: OnceCell::new() }
|
|
}
|
|
|
|
pub(super) fn is_cyclic<G>(&self, graph: &G) -> bool
|
|
where
|
|
G: ?Sized + DirectedGraph + WithStartNode + WithSuccessors + WithNumNodes,
|
|
{
|
|
*self.cache.get_or_init(|| graph::is_cyclic(graph))
|
|
}
|
|
|
|
/// Invalidates the cache.
|
|
#[inline]
|
|
pub(super) fn invalidate(&mut self) {
|
|
// Invalidating the cache requires mutating the MIR, which in turn requires a unique
|
|
// reference (`&mut`) to the `mir::Body`. Because of this, we can assume that all
|
|
// callers of `invalidate` have a unique reference to the MIR and thus to the
|
|
// cache. This means we never need to do synchronization when `invalidate` is called,
|
|
// we can simply reinitialize the `OnceCell`.
|
|
self.cache = OnceCell::new();
|
|
}
|
|
}
|
|
|
|
impl<S: serialize::Encoder> serialize::Encodable<S> for GraphIsCyclicCache {
|
|
#[inline]
|
|
fn encode(&self, s: &mut S) -> Result<(), S::Error> {
|
|
serialize::Encodable::encode(&(), s)
|
|
}
|
|
}
|
|
|
|
impl<D: serialize::Decoder> serialize::Decodable<D> for GraphIsCyclicCache {
|
|
#[inline]
|
|
fn decode(d: &mut D) -> Self {
|
|
let () = serialize::Decodable::decode(d);
|
|
Self::new()
|
|
}
|
|
}
|
|
|
|
impl<CTX> HashStable<CTX> for GraphIsCyclicCache {
|
|
#[inline]
|
|
fn hash_stable(&self, _: &mut CTX, _: &mut StableHasher) {
|
|
// do nothing
|
|
}
|
|
}
|
|
|
|
TrivialTypeFoldableAndLiftImpls! {
|
|
GraphIsCyclicCache,
|
|
}
|