Update to nightly-2024-12-01 (#32)

* Update README

* Update to nightly-2024-12-01

* Fix various lints

* More lints

Author: willcrichton

.github/workflows/release.yaml

@@ -14,6 +14,7 @@ jobs:
         uses: baptiste0928/cargo-install@v2
         with:
           crate: cargo-workspaces
+          version: 0.2.44
       - name: Run tests
         run: cargo test --all-features -- --test-threads=1
       - name: Generate documentation

README.md

@@ -11,7 +11,7 @@
 The Rust compiler's interface is not stable, so the only sensible way to develop a Rust compiler plugin is by pinning to a specific nightly. Each version of `rustc_plugin` is pinned to one nightly, and you *have* to use the same nightly version that we do. Therefore each release of `rustc_plugin` has a semantic version number (e.g. `0.1.0`) and the nightly version is added as a prerelease label (e.g. `-nightly-2023-08-25`). You can add a dependency to your `Cargo.toml` like this:
 
 ```toml
-rustc_plugin = "=0.10.0-nightly-2024-05-20"
+rustc_plugin = "=0.11.0-nightly-2024-12-01"
 ```
 
 We will treat a change to the nightly version as a breaking change, so the semantic version will be correspondingly updated as a breaking update.
@@ -55,7 +55,7 @@ Normally, Rust libraries have a [minimum supported Rust version][msrv] because t
 [Aquascope]: https://github.com/cognitive-engineering-lab/aquascope
 [Clippy]: https://github.com/rust-lang/rust-clippy
 [example]: https://github.com/cognitive-engineering-lab/rustc_plugin/tree/main/crates/rustc_plugin/examples/print-all-items
-[docs]: https://cognitive-engineering-lab.github.io/rustc_plugin/v0.10.0-nightly-2024-05-20/rustc_plugin/
-[docs-utils]: https://cognitive-engineering-lab.github.io/rustc_plugin/v0.10.0-nightly-2024-05-20/rustc_utils/
+[docs]: https://cognitive-engineering-lab.github.io/rustc_plugin/v0.11.0-nightly-2024-12-01/rustc_plugin/
+[docs-utils]: https://cognitive-engineering-lab.github.io/rustc_plugin/v0.11.0-nightly-2024-12-01/rustc_utils/
 [msrv]: https://doc.rust-lang.org/cargo/reference/manifest.html#the-rust-version-field
 

crates/rustc_plugin/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rustc_plugin"
-version = "0.10.0-nightly-2024-05-20"
+version = "0.11.0-nightly-2024-12-01"
 edition = "2021"
 authors = ["Will Crichton <crichton.will@gmail.com>"]
 description = "A framework for writing plugins that integrate with the Rust compiler"

crates/rustc_plugin/examples/print-all-items/src/bin/cargo-print-all-items.rs

@@ -1,3 +1,5 @@
+#![feature(rustc_private)]
+
 fn main() {
   env_logger::init();
   rustc_plugin::cli_main(print_all_items::PrintAllItemsPlugin);

crates/rustc_plugin/examples/print-all-items/src/bin/print-all-items-driver.rs

@@ -1,3 +1,5 @@
+#![feature(rustc_private)]
+
 fn main() {
   env_logger::init();
   rustc_plugin::driver_main(print_all_items::PrintAllItemsPlugin);

crates/rustc_plugin/examples/print-all-items/src/lib.rs

@@ -78,14 +78,10 @@ impl rustc_driver::Callbacks for PrintAllItemsCallbacks {
   fn after_analysis<'tcx>(
     &mut self,
     _compiler: &rustc_interface::interface::Compiler,
-    queries: &'tcx rustc_interface::Queries<'tcx>,
+    tcx: TyCtxt<'tcx>,
   ) -> rustc_driver::Compilation {
-    // We extract a key data structure, the `TyCtxt`, which is all we need
-    // for our simple task of printing out item names.
-    queries
-      .global_ctxt()
-      .unwrap()
-      .enter(|tcx| print_all_items(tcx, &self.args));
+    // We call our top-level function with access to the type context `tcx` and the CLI arguments.
+    print_all_items(tcx, &self.args);
 
     // Note that you should generally allow compilation to continue. If
     // your plugin is being invoked on a dependency, then you need to ensure

crates/rustc_plugin/src/cli.rs

@@ -209,7 +209,7 @@ fn only_run_on_file(
     CompileKind::ProcMacro => {}
   }
 
-  cmd.env(SPECIFIC_CRATE, &pkg.name.replace('-', "_"));
+  cmd.env(SPECIFIC_CRATE, pkg.name.replace('-', "_"));
   cmd.env(SPECIFIC_TARGET, kind_str);
 
   log::debug!(

crates/rustc_utils/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rustc_utils"
-version = "0.10.0-nightly-2024-05-20"
+version = "0.11.0-nightly-2024-12-01"
 edition = "2021"
 authors = ["Will Crichton <crichton.will@gmail.com>"]
 description = "Utilities for working with the Rust compiler"

crates/rustc_utils/src/cache.rs

@@ -79,7 +79,7 @@ where
   /// # Panics
   ///
   /// If this is a recursive invocation for this key.
-  pub fn get(&self, key: In, compute: impl FnOnce(In) -> Out) -> &Out {
+  pub fn get(&self, key: &In, compute: impl FnOnce(In) -> Out) -> &Out {
     self
       .get_maybe_recursive(key, compute)
       .unwrap_or_else(recursion_panic)
@@ -90,10 +90,10 @@ where
   /// Returns `None` if this is a recursive invocation of `get` for key `key`.
   pub fn get_maybe_recursive<'a>(
     &'a self,
-    key: In,
+    key: &In,
     compute: impl FnOnce(In) -> Out,
   ) -> Option<&'a Out> {
-    if !self.0.borrow().contains_key(&key) {
+    if !self.0.borrow().contains_key(key) {
       self.0.borrow_mut().insert(key.clone(), None);
       let out = Box::pin(compute(key.clone()));
       self.0.borrow_mut().insert(key.clone(), Some(out));
@@ -102,7 +102,7 @@ where
     let cache = self.0.borrow();
     // Important here to first `unwrap` the `Option` created by `get`, then
     // propagate the potential option stored in the map.
-    let entry = cache.get(&key).expect("invariant broken").as_ref()?;
+    let entry = cache.get(key).expect("invariant broken").as_ref()?;
 
     // SAFETY: because the entry is pinned, it cannot move and this pointer will
     // only be invalidated if Cache is dropped. The returned reference has a lifetime
@@ -139,7 +139,7 @@ where
   /// # Panics
   ///
   /// If this is a recursive invocation for this key.
-  pub fn get(&self, key: In, compute: impl FnOnce(In) -> Out) -> Out {
+  pub fn get(&self, key: &In, compute: impl FnOnce(In) -> Out) -> Out {
     self
       .get_maybe_recursive(key, compute)
       .unwrap_or_else(recursion_panic)
@@ -151,16 +151,16 @@ where
   /// Returns `None` if this is a recursive invocation of `get` for key `key`.
   pub fn get_maybe_recursive(
     &self,
-    key: In,
+    key: &In,
     compute: impl FnOnce(In) -> Out,
   ) -> Option<Out> {
-    if !self.0.borrow().contains_key(&key) {
+    if !self.0.borrow().contains_key(key) {
       self.0.borrow_mut().insert(key.clone(), None);
       let out = compute(key.clone());
       self.0.borrow_mut().insert(key.clone(), Some(out));
     }
 
-    *self.0.borrow_mut().get(&key).expect("invariant broken")
+    *self.0.borrow_mut().get(key).expect("invariant broken")
   }
 }
 
@@ -177,9 +177,9 @@ mod test {
   #[test]
   fn test_cached() {
     let cache: Cache<usize, usize> = Cache::default();
-    let x = cache.get(0, |_| 0);
-    let y = cache.get(1, |_| 1);
-    let z = cache.get(0, |_| 2);
+    let x = cache.get(&0, |_| 0);
+    let y = cache.get(&1, |_| 1);
+    let z = cache.get(&0, |_| 2);
     assert_eq!(*x, 0);
     assert_eq!(*y, 1);
     assert_eq!(*z, 0);
@@ -193,12 +193,12 @@ mod test {
       fn get_infinite_recursion(&self, i: i32) -> i32 {
         self
           .0
-          .get_maybe_recursive(i, |_| i + self.get_infinite_recursion(i))
+          .get_maybe_recursive(&i, |_| i + self.get_infinite_recursion(i))
           .copied()
           .unwrap_or(-18)
       }
       fn get_safe_recursion(&self, i: i32) -> i32 {
-        *self.0.get(i, |_| {
+        *self.0.get(&i, |_| {
           if i == 0 {
             0
           } else {
@@ -208,7 +208,7 @@ mod test {
       }
     }
 
-    let cache = RecursiveUse(Default::default());
+    let cache = RecursiveUse(Cache::default());
 
     assert_eq!(cache.get_infinite_recursion(60), 42);
     assert_eq!(cache.get_safe_recursion(5), 15);

crates/rustc_utils/src/hir/ty.rs

@@ -1,80 +1,74 @@
 //! Utilities for [`Ty`].
 
-use rustc_data_structures::captures::Captures;
 use rustc_hir::def_id::DefId;
 use rustc_infer::infer::TyCtxtInferExt;
-use rustc_middle::ty::{GenericArgKind, ParamEnv, Region, Ty, TyCtxt};
+use rustc_middle::ty::{GenericArgKind, ParamEnv, Region, Ty, TyCtxt, TypingEnv};
 use rustc_trait_selection::infer::InferCtxtExt;
+use rustc_type_ir::TypingMode;
 
 /// Extension trait for [`Ty`].
 pub trait TyExt<'tcx> {
-  type AllRegionsIter<'a>: Iterator<Item = Region<'tcx>>
-  where
-    Self: 'a;
-
   /// Returns an iterator over the regions appearing within a type.
-  fn inner_regions(&self) -> Self::AllRegionsIter<'_>;
+  fn inner_regions(self) -> impl Iterator<Item = Region<'tcx>>;
 
   /// Returns true if a type implements a given trait.
   fn does_implement_trait(
-    &self,
+    self,
     tcx: TyCtxt<'tcx>,
     param_env: ParamEnv<'tcx>,
     trait_def_id: DefId,
   ) -> bool;
 
+  #[allow(clippy::wrong_self_convention)]
   /// Returns true if a type implements `Copy`.
-  fn is_copyable(&self, tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>) -> bool;
+  fn is_copyable(self, tcx: TyCtxt<'tcx>, typing_env: TypingEnv<'tcx>) -> bool;
 }
 
 impl<'tcx> TyExt<'tcx> for Ty<'tcx> {
-  type AllRegionsIter<'a> = impl Iterator<Item = Region<'tcx>> + Captures<'tcx> + 'a
-    where Self: 'a;
-
-  fn inner_regions(&self) -> Self::AllRegionsIter<'_> {
+  fn inner_regions(self) -> impl Iterator<Item = Region<'tcx>> {
     self.walk().filter_map(|part| match part.unpack() {
       GenericArgKind::Lifetime(region) => Some(region),
       _ => None,
     })
   }
 
   fn does_implement_trait(
-    &self,
+    self,
     tcx: TyCtxt<'tcx>,
     param_env: ParamEnv<'tcx>,
     trait_def_id: DefId,
   ) -> bool {
     use rustc_infer::traits::EvaluationResult;
 
-    let infcx = tcx.infer_ctxt().build();
-    let ty = tcx.erase_regions(*self);
+    let infcx = tcx.infer_ctxt().build(TypingMode::non_body_analysis());
+    let ty = tcx.erase_regions(self);
     let result = infcx.type_implements_trait(trait_def_id, [ty], param_env);
     matches!(
       result,
       EvaluationResult::EvaluatedToOk | EvaluationResult::EvaluatedToOkModuloRegions
     )
   }
 
-  fn is_copyable(&self, tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>) -> bool {
-    let ty = tcx.erase_regions(*self);
-    ty.is_copy_modulo_regions(tcx, param_env)
+  fn is_copyable(self, tcx: TyCtxt<'tcx>, typing_env: TypingEnv<'tcx>) -> bool {
+    let ty = tcx.erase_regions(self);
+    ty.is_copy_modulo_regions(tcx, typing_env)
   }
 }
 
 #[cfg(test)]
 mod test {
-  use rustc_middle::ty::ParamEnv;
+  use rustc_middle::ty::TypingEnv;
 
   use super::TyExt;
   use crate::{test_utils, BodyExt};
 
   #[test]
   fn test_ty_ext() {
-    let input = r#"
+    let input = r"
 fn main() {
   let x = &mut 0;
   let y = 0;
-}"#;
+}";
 
     test_utils::compile_body(input, |tcx, _, body| {
       let body = &body.body;
@@ -84,8 +78,8 @@ fn main() {
       assert_eq!(x.ty.inner_regions().count(), 1);
       assert_eq!(y.ty.inner_regions().count(), 0);
 
-      assert!(!x.ty.is_copyable(tcx, ParamEnv::empty()));
-      assert!(y.ty.is_copyable(tcx, ParamEnv::empty()));
+      assert!(!x.ty.is_copyable(tcx, TypingEnv::fully_monomorphized()));
+      assert!(y.ty.is_copyable(tcx, TypingEnv::fully_monomorphized()));
     });
   }
 }