Update nightly toolchain (#6)

* Update nightly toolchain

* Tree formatter

* Update to nightly-2024-05-20

* Install latest Depot

* Depot setup

* Fix bad merge.

* Disassociate obligations from method calls.

Rustc updates caused more obligations to associate with method call
exprs. This means that no call tables will be built for now but we can
re-establish the functionality once we figure out where the difference
is coming from.

Frontend updates simplify the communication process which should cut
down on syncing issues.

.github/workflows/setup/action.yml

@@ -13,7 +13,7 @@ runs:
       shell: bash
 
     - name: Install Depot
-      run: curl https://raw.githubusercontent.com/cognitive-engineering-lab/depot/main/scripts/install.sh | sh -s e92a63edcb17cf156e399587b79192369911560e
+      run: cargo install --git https://github.com/cognitive-engineering-lab/depot.git depot-js && depot setup
       shell: bash
 
     - name: Install Test Libraries

README.md

@@ -46,7 +46,7 @@ If rustup fails, especially with an error like "could not rename the downloaded
 To solve the issue, go to the command line and run:
 
 ```
-rustup toolchain install nightly-2024-01-24 -c rust-src -c rustc-dev -c llvm-tools-preview
+rustup toolchain install nightly-2024-05-20 -c rust-src -c rustc-dev -c llvm-tools-preview
 ```
 
 Then go back to VSCode and click "Continue" to let Argus continue installing.

crates/argus/Cargo.toml

@@ -14,7 +14,7 @@ testing = ["lazy_static", "ts-rs"]
 doctest = false
 
 [dependencies]
-rustc_utils = { version = "=0.9.0-nightly-2024-01-24", features = ["serde"] }
+rustc_utils = { version = "=0.10.0-nightly-2024-05-20", features = ["serde"] }
 
 log = "0.4"
 index_vec = { version = "0.1.3", features = ["serde"] }
@@ -33,7 +33,7 @@ ts-rs = { version = "7.1.1", features = ["indexmap-impl"], optional = true }
 
 [dev-dependencies]
 argus-lib = { path = ".", features = ["testing"] }
-rustc_utils = { version = "=0.9.0-nightly-2024-01-24", features = ["serde", "ts-rs"] }
+rustc_utils = { version = "=0.10.0-nightly-2024-05-20", features = ["serde", "ts-rs"] }
 test-log = "0.2.11"
 env_logger = "0.9.3"
 text-diff = "0.4"

crates/argus/src/analysis/entry.rs

@@ -5,9 +5,8 @@ use anyhow::{anyhow, bail, Result};
 use fluid_let::fluid_let;
 use rustc_hir::BodyId;
 use rustc_infer::{infer::InferCtxt, traits::PredicateObligation};
-use rustc_middle::ty::{Predicate, TyCtxt, TypeckResults};
+use rustc_middle::ty::{TyCtxt, TypeckResults};
 use rustc_trait_selection::traits::solve::Goal;
-use serde::Serialize;
 
 use crate::{
   analysis::{
@@ -17,7 +16,6 @@ use crate::{
   },
   ext::{EvaluationResultExt, InferCtxtExt},
   proof_tree::{serialize::serialize_proof_tree, SerializedTree},
-  serialize::ty::PredicateDef,
   types::{
     intermediate::{
       ErrorAssemblyCtx, Forgettable, FullData, ObligationQueriesInBody,
@@ -29,6 +27,7 @@ use crate::{
 
 fluid_let! {
   pub static INSPECTING: bool;
+  pub static BODY_ID: BodyId;
 }
 
 macro_rules! guard_inspection {
@@ -43,23 +42,19 @@ macro_rules! guard_inspection {
 // --------------------------------
 // Rustc inspection points
 
-#[derive(Serialize)]
-struct PredWrapper<'a, 'tcx: 'a>(
-  #[serde(with = "PredicateDef")] &'a Predicate<'tcx>,
-);
-
 pub fn process_obligation<'tcx>(
   infcx: &InferCtxt<'tcx>,
   obl: &PredicateObligation<'tcx>,
   result: EvaluationResult,
 ) {
   guard_inspection! {}
 
-  let Some(_ldef_id) = infcx.body_id() else {
-    log::warn!("Skipping obligation unassociated with local body {obl:?}");
+  let Some(body_id) = BODY_ID.copied() else {
     return;
   };
 
+  log::trace!("RECV OBLIGATION {result:?} {obl:?}");
+
   // Use this to get rid of any resolved inference variables,
   // these could have been resolved while trying to solve the obligation
   // and we want to present it as such to the user.
@@ -78,8 +73,6 @@ pub fn process_obligation<'tcx>(
     return;
   }
 
-  log::debug!("Processing obligation {obl:?}");
-
   let necessity = infcx.obligation_necessity(obl);
   let dataid = if matches!(necessity, ObligationNecessity::Yes)
     || (matches!(necessity, ObligationNecessity::OnError) && result.is_no())
@@ -89,7 +82,8 @@ pub fn process_obligation<'tcx>(
     None
   };
 
-  let obligation = transform::compute_provenance(infcx, obl, result, dataid);
+  let obligation =
+    transform::compute_provenance(body_id, infcx, obl, result, dataid);
 
   tls::store_obligation(obligation);
 
@@ -195,11 +189,13 @@ fn generate_tree<'tcx>(
     predicate: obligation.predicate,
     param_env: obligation.param_env,
   };
-  let item_def_id = infcx
-    .body_id()
-    .ok_or(anyhow!("body not local"))?
-    .to_def_id();
-  serialize_proof_tree(goal, infcx, item_def_id)
+
+  let Some(body_id) = BODY_ID.copied() else {
+    bail!("missing body id");
+  };
+
+  let body_owner = infcx.tcx.hir().body_owner_def_id(body_id).to_def_id();
+  serialize_proof_tree(goal, obligation.cause.span, infcx, body_owner)
 }
 
 pub(in crate::analysis) fn build_obligations_in_body<'tcx>(

crates/argus/src/analysis/hir.rs

@@ -94,6 +94,12 @@ impl BinCreator<'_, '_> {
       .collect::<Vec<_>>();
 
     if !obligations.is_empty() {
+      log::debug!(
+        "Associating obligations with {kind:?} {:?}\n{:#?}",
+        self.ctx.tcx.hir().node_to_string(target),
+        obligations
+      );
+
       self.bins.push(Bin {
         hir_id: target,
         obligations,
@@ -104,23 +110,29 @@ impl BinCreator<'_, '_> {
 }
 
 impl<'a, 'tcx: 'a> HirVisitor<'_> for BinCreator<'a, 'tcx> {
+  // FIXME: after updating to nightly-2024-05-20 this binning logic broke slightly.
+  // Obligations associated with parameters are now being assigned to the overall call,
+  // this makes more things use a method call table than necessary.
   fn visit_expr(&mut self, ex: &hir::Expr) {
+    // Drain nested obligations first to match the most specific node possible.
     hir::intravisit::walk_expr(self, ex);
 
     match ex.kind {
       hir::ExprKind::Call(callable, args) => {
-        self.drain_nested(callable.hir_id, BinKind::CallableExpr);
         for arg in args {
           self.drain_nested(arg.hir_id, BinKind::CallArg);
         }
+        self.drain_nested(callable.hir_id, BinKind::CallableExpr);
         self.drain_nested(ex.hir_id, BinKind::Call);
       }
       hir::ExprKind::MethodCall(_, func, args, _) => {
-        self.drain_nested(func.hir_id, BinKind::MethodReceiver);
         for arg in args {
           self.drain_nested(arg.hir_id, BinKind::CallArg);
         }
-        self.drain_nested(ex.hir_id, BinKind::MethodCall);
+        self.drain_nested(func.hir_id, BinKind::MethodReceiver);
+        // [ ] TODO (see above `FIXME`):
+        // self.drain_nested(ex.hir_id, BinKind::MethodCall);
+        self.drain_nested(ex.hir_id, BinKind::Misc);
       }
       _ => {}
     }
@@ -193,14 +205,13 @@ macro_rules! simple_visitors {
 impl HirVisitor<'_> for FindNodeBySpan {
   simple_visitors! {
     [visit_param, walk_param, hir::Param],
-    [visit_local, walk_local, hir::Local],
+    [visit_local, walk_local, hir::LetStmt],
     [visit_block, walk_block, hir::Block],
     [visit_stmt, walk_stmt, hir::Stmt],
     [visit_arm, walk_arm, hir::Arm],
     [visit_pat, walk_pat, hir::Pat],
     [visit_pat_field, walk_pat_field, hir::PatField],
     [visit_expr, walk_expr, hir::Expr],
-    [visit_let_expr, walk_let_expr, hir::Let],
     [visit_expr_field, walk_expr_field, hir::ExprField],
     [visit_ty, walk_ty, hir::Ty],
     [visit_generic_param, walk_generic_param, hir::GenericParam],

crates/argus/src/analysis/mod.rs

@@ -34,7 +34,7 @@ pub fn obligations<'tcx>(
   body_id: BodyId,
 ) -> Result<ObligationsInBody> {
   rustc_middle::ty::print::with_no_trimmed_paths! {{
-    log::info!("Typeck'ing body {body_id:?}");
+    fluid_let::fluid_set!(entry::BODY_ID, body_id);
 
     let typeck_results = tcx.inspect_typeck(body_id, entry::process_obligation);
 
@@ -50,6 +50,8 @@ pub fn tree<'tcx>(
   body_id: BodyId,
 ) -> Result<SerializedTree> {
   rustc_middle::ty::print::with_no_trimmed_paths! {{
+    fluid_let::fluid_set!(entry::BODY_ID, body_id);
+
     let typeck_results =
       tcx.inspect_typeck(body_id, entry::process_obligation_for_tree);
 
@@ -62,6 +64,8 @@ pub fn tree<'tcx>(
 /// NOTE: this requires quite a bit of memory as everything is generated eagerly, favor
 /// using a combination of `obligation` and `tree` analyses for a reduced memory footprint.
 pub fn bundle<'tcx>(tcx: TyCtxt<'tcx>, body_id: BodyId) -> Result<BodyBundle> {
+  fluid_let::fluid_set!(entry::BODY_ID, body_id);
+
   let (full_data, obligations_in_body) = body_data(tcx, body_id)?;
   let t = (&*full_data, &obligations_in_body);
   let thunk = || t;
@@ -82,6 +86,7 @@ pub fn bundle<'tcx>(tcx: TyCtxt<'tcx>, body_id: BodyId) -> Result<BodyBundle> {
     .prefer_local()
     .to_string_lossy()
     .to_string();
+
   Ok(BodyBundle {
     filename,
     body: obligations_in_body,

crates/argus/src/analysis/tls.rs

@@ -119,7 +119,7 @@ pub fn replace_reported_errors(infcx: &InferCtxt) {
       .reported_trait_errors
       .borrow()
       .iter()
-      .map(|(span, predicates)| {
+      .map(|(span, (predicates, _))| {
         (
           *span,
           predicates