Replace early_error and sess.err with bug!, in all cases. If the
compiler we're running with, including plugins, is registering something
twice, that's a (compiler/plugin) programmer error -- we should not try
to be nice at the cost of developer ergononomics (hiding the stacktrace
of the second registration is bad).

This also is basically a static bug in ~all cases so it should not be a
detriment to users, including with plugins.

This is straight up removing dead code, but is a separate commit from
the previous to avoid conflating clean up and important changes.

This extracts the call to get_lints() to callers.

This is in preparation for on-demand constructing passes

This moves from calling get_lints on instantiated pass objects to the
raw object

This stops storing the pass objects and instead stores constructor
functions.

The primary effect is that LintStore no longer has any interior
mutability.

Moves this information to a direct field of Lint, which is where it
belongs.

Avoid querying LintStore when not necessary

Access through tcx is fine -- by that point, the lint store is frozen,
but direct access through Session will go away in future commits, as
lint store is still mutable in early stages of Session, and will be
removed completely.

Remove lint store from Session

Move to using Box<dyn Fn() -> ...> so that we can let plugins register
state.

This also adds a callback that'll get called from plugin registration so
that Clippy and other tools can register lints without using the plugin
API. The plugin API still works, but this new API is more compatible
with drivers other than rustc.

`TokenStream` used to be a complex type, but it is now just a newtype
around a `Lrc<Vec<TreeAndJoint>>`. Currently it uses custom encoding
that discards the `IsJoint` and custom decoding that adds `NonJoint`
back in for every token tree. This requires building intermediate
`Vec<TokenTree>`s.

This commit makes `TokenStream` derive `Rustc{En,De}codable`. This
simplifies the code, and avoids the creation of the intermediate
vectors, saving up to 3% on various benchmarks. It also changes the AST
JSON output in one test.

This avoids the needs for various conversions, and makes the code
slightly faster, because `Symbol` comparisons and hashing is faster.

Its fourth argument is always `Some(pred)`, so the pattern matching is
unnecessary. This commit inlines and removes it.

It's a full conversion, except in `DefKey::compute_stable_hash()` where
a `Symbol` now is converted to an `InternedString` before being hashed.
This was necessary to avoid test failures.

This requires changing the `PartialOrd`/`Ord` implementations to look at
the chars rather than the symbol index.

This is a straightforward replacement except for two places where we
have to convert to `LocalInternedString` to get a stable sort.

By using `LocalInternedString` instead for the few remaining uses.

Change-Id: Ib3a396e7334d209fe6c6ef425bbfc7b2ae471378

Change-Id: Ib3a396e7334d209fe6c6ef425bbfc7b2ae471378

…t have that bound

Add Cow::is_borrowed and Cow::is_owned

Implements rust-lang#65143.

… r=nikomatsakis

Lockless LintStore

This removes mutability from the lint store after registration. Each commit stands alone, for the most part, though they don't make sense out of sequence.

The intent here is to move LintStore to a more parallel-friendly architecture, although also just a cleaner one from an implementation perspective. Specifically, this has the following changes:
 * We no longer implicitly register lints when registering lint passes
    * For the most part this means that registration calls now likely want to call something like:
       `lint_store.register_lints(&Pass::get_lints())` as well as `register_*_pass`.
    * In theory this is a simplification as it's much easier for folks to just register lints and then have passes that implement whichever lint however they want, rather than necessarily tying passes to lints.
 * Lint passes still have a list of associated lints, but a followup PR could plausibly change that
   * This list must be known for a given pass type, not instance, i.e., `fn get_lints()` is the signature instead of `fn get_lints(&self)` as before.
 * We do not store pass objects, instead storing constructor functions. This means we always get new passes when running lints (this happens approximately once though for a given compiler session, so no behavior change is expected).
 * Registration API is _much_ simpler: generally all functions are just taking `Fn() -> PassObject` rather than several different `bool`s.

…ables, r=michaelwoerister

rustc_metadata: use a table for super_predicates, fn_sig, impl_trait_ref.

This is an attempt at a part of rust-lang#65407, i.e. moving parts of cross-crate "metadata" into tables that match queries more closely.

Three new tables should be enough to see some perf/metadata size changes.
(need to do something similar to rust-lang#59953 (comment))

There are other bits of data that could be made into tables, but they can be more compact so the impact would likely be not as bad, and they're also more work to set up.

…dable-Decodable, r=petrochenkov

Derive `Rustc{En,De}codable` for `TokenStream`.

`TokenStream` used to be a complex type, but it is now just a newtype
around a `Lrc<Vec<TreeAndJoint>>`. Currently it uses custom encoding
that discards the `IsJoint` and custom decoding that adds `NonJoint`
back in for every token tree. This requires building intermediate
`Vec<TokenTree>`s.

This commit makes `TokenStream` derive `Rustc{En,De}codable`. This
simplifies the code, and avoids the creation of the intermediate
vectors, saving up to 3% on various benchmarks. It also changes the AST
JSON output in one test.

r? @petrochenkov

…omatsakis

Eliminate `intersect_opt`.

Its fourth argument is always `Some(pred)`, so the pattern matching is
unnecessary. This commit inlines and removes it.

r? @nikomatsakis

…rly, r=eddyb

Remove `InternedString`

This PR removes `InternedString` by converting all occurrences to `Symbol`. There are a handful of places that need to use the symbol chars instead of the symbol index, e.g. for stable sorting; local conversions `LocalInternedString` is used in those places.

r? @eddyb

Deprecated proc_macro doesn't trigger warning on build library

Fix rust-lang#65189

…r=Dylan-DPC

Update E0659 error code long explanation to 2018 edition

Fixes rust-lang#65571

r? @Centril

relax ExactSizeIterator bound on write_bytes

Too many iterators don't have that bound. Instead we do run-time checks.

r? @oli-obk