"Forward" cross-crate PDG construction

Makefile.toml

@@ -65,6 +65,8 @@ args = [
     "--test",
     "async_tests",
     "--no-fail-fast",
+    "--test",
+    "cross-crate",
 ]
 
 [tasks.policy-framework-tests]

crates/flowistry_pdg/src/lib.rs

@@ -11,6 +11,11 @@ pub(crate) mod rustc {
     pub use middle::mir;
 }
 
+#[cfg(feature = "rustc")]
+extern crate rustc_macros;
+#[cfg(feature = "rustc")]
+extern crate rustc_serialize;
+
 mod pdg;
 #[cfg(feature = "rustc")]
 mod rustc_impls;

crates/flowistry_pdg/src/pdg.rs

@@ -8,6 +8,10 @@ use serde::{Deserialize, Serialize};
 use crate::rustc_portable::*;
 #[cfg(feature = "rustc")]
 use crate::rustc_proxies;
+#[cfg(feature = "rustc")]
+use rustc_macros::{Decodable, Encodable};
+#[cfg(feature = "rustc")]
+use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
 
 /// Extends a MIR body's `Location` with `Start` (before the first instruction) and `End` (after all returns).
 #[derive(PartialEq, Eq, Hash, Clone, Copy, Debug, Serialize, Deserialize)]
@@ -26,6 +30,35 @@ pub enum RichLocation {
     End,
 }
 
+#[cfg(feature = "rustc")]
+impl<E: Encoder> Encodable<E> for RichLocation {
+    fn encode(&self, s: &mut E) {
+        match self {
+            Self::Location(loc) => s.emit_enum_variant(0, |s| {
+                s.emit_u32(loc.block.as_u32());
+                s.emit_usize(loc.statement_index);
+            }),
+            Self::Start => s.emit_enum_variant(1, |_| ()),
+            Self::End => s.emit_enum_variant(2, |_| ()),
+        }
+    }
+}
+
+#[cfg(feature = "rustc")]
+impl<D: Decoder> Decodable<D> for RichLocation {
+    fn decode(d: &mut D) -> Self {
+        match d.read_usize() {
+            0 => Self::Location(Location {
+                block: d.read_u32().into(),
+                statement_index: d.read_usize(),
+            }),
+            1 => Self::Start,
+            2 => Self::End,
+            v => panic!("Unknown variant index: {v}"),
+        }
+    }
+}
+
 impl RichLocation {
     /// Returns true if this is a `Start` location.
     pub fn is_start(self) -> bool {
@@ -74,17 +107,18 @@ impl From<Location> for RichLocation {
 
 /// A [`RichLocation`] within a specific point in a codebase.
 #[derive(PartialEq, Eq, Hash, Clone, Copy, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "rustc", derive(Encodable, Decodable))]
 pub struct GlobalLocation {
+    // TODO Change to `DefId`
     /// The function containing the location.
-    #[cfg_attr(feature = "rustc", serde(with = "rustc_proxies::LocalDefId"))]
-    pub function: LocalDefId,
+    #[cfg_attr(feature = "rustc", serde(with = "rustc_proxies::DefId"))]
+    pub function: DefId,
 
     /// The location of an instruction in the function, or the function's start.
     pub location: RichLocation,
 }
 
 #[cfg(not(feature = "rustc"))]
-
 impl fmt::Display for GlobalLocation {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{:?}::{}", self.function, self.location)
@@ -103,6 +137,21 @@ impl fmt::Display for GlobalLocation {
 #[derive(PartialEq, Eq, Hash, Copy, Clone, Debug, Serialize, Deserialize)]
 pub struct CallString(Intern<CallStringInner>);
 
+#[cfg(feature = "rustc")]
+impl<S: Encoder> Encodable<S> for CallString {
+    fn encode(&self, s: &mut S) {
+        let inner: &CallStringInner = &self.0;
+        inner.encode(s);
+    }
+}
+
+#[cfg(feature = "rustc")]
+impl<D: Decoder> Decodable<D> for CallString {
+    fn decode(d: &mut D) -> Self {
+        Self(Intern::new(CallStringInner::decode(d)))
+    }
+}
+
 type CallStringInner = Box<[GlobalLocation]>;
 
 impl CallString {
@@ -153,6 +202,10 @@ impl CallString {
         CallString::new(string)
     }
 
+    pub fn push_front(self, loc: GlobalLocation) -> Self {
+        CallString::new([loc].into_iter().chain(self.0.iter().copied()).collect())
+    }
+
     pub fn is_at_root(self) -> bool {
         self.0.len() == 1
     }
@@ -199,13 +252,15 @@ impl fmt::Display for CallString {
 #[derive(
     PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy, Debug, Serialize, Deserialize, strum::EnumIs,
 )]
+#[cfg_attr(feature = "rustc", derive(Decodable, Encodable))]
 pub enum SourceUse {
     Operand,
     Argument(u8),
 }
 
 /// Additional information about this mutation.
 #[derive(PartialEq, Eq, Hash, Clone, Copy, Debug, Serialize, Deserialize, strum::EnumIs)]
+#[cfg_attr(feature = "rustc", derive(Decodable, Encodable))]
 pub enum TargetUse {
     /// A function returned, assigning to it's return destination
     Return,

crates/flowistry_pdg/src/rustc_impls.rs

@@ -77,7 +77,7 @@ impl From<DefIndex> for def_id::DefIndex {
 impl fmt::Display for GlobalLocation {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         tls::with_opt(|opt_tcx| match opt_tcx {
-            Some(tcx) => match tcx.opt_item_name(self.function.to_def_id()) {
+            Some(tcx) => match tcx.opt_item_name(self.function) {
                 Some(name) => name.fmt(f),
                 None => write!(f, "<closure>"),
             },

crates/flowistry_pdg_construction/Cargo.toml

@@ -23,6 +23,8 @@ flowistry_pdg = { version = "0.1.0", path = "../flowistry_pdg", features = [
 ] }
 #flowistry = { path = "../../../flowistry/crates/flowistry", default-features = false }
 flowistry = { workspace = true }
+serde = { workspace = true, features = ["derive"] }
+strum = { workspace = true }
 
 [dev-dependencies]
 rustc_utils = { workspace = true, features = ["indexical", "test"] }

crates/flowistry_pdg_construction/src/async_support.rs

@@ -1,21 +1,40 @@
 use std::rc::Rc;
 
 use either::Either;
+use flowistry_pdg::{CallString, GlobalLocation};
 use itertools::Itertools;
 use rustc_abi::{FieldIdx, VariantIdx};
 use rustc_hir::def_id::{DefId, LocalDefId};
+use rustc_macros::{Decodable, Encodable};
 use rustc_middle::{
     mir::{
         AggregateKind, BasicBlock, Body, Location, Operand, Place, Rvalue, Statement,
         StatementKind, Terminator, TerminatorKind,
     },
-    ty::{GenericArgsRef, TyCtxt},
+    ty::{GenericArgsRef, Instance, TyCtxt},
 };
 
-use crate::construct::{CallKind, PartialGraph};
+use crate::{
+    construct::{push_call_string_root, CallKind, LocalAnalysis},
+    utils, PartialGraph,
+};
+
+/// Describe in which way a function is `async`.
+///
+/// Critically distinguishes between a normal `async fn` and an
+/// `#[async_trait]`.
+#[derive(Debug, Clone, Copy, Decodable, Encodable)]
+pub enum Asyncness {
+    No,
+    AsyncFn,
+    AsyncTrait,
+}
 
-use super::construct::GraphConstructor;
-use super::utils::{self, FnResolution};
+impl Asyncness {
+    pub fn is_async(self) -> bool {
+        !matches!(self, Asyncness::No)
+    }
+}
 
 /// Stores ids that are needed to construct projections around async functions.
 pub(crate) struct AsyncInfo {
@@ -143,20 +162,28 @@ fn get_async_generator<'tcx>(body: &Body<'tcx>) -> (LocalDefId, GenericArgsRef<'
     (def_id.expect_local(), generic_args, location)
 }
 
+/// Try to interpret this function as an async function.
+///
+/// If this is an async function it returns the [`Instance`] of the generator,
+/// the location where the generator is bound and the type of [`Asyncness`]
+/// which in this case is guaranteed to satisfy [`Asyncness::is_async`].
 pub fn determine_async<'tcx>(
     tcx: TyCtxt<'tcx>,
     def_id: LocalDefId,
     body: &Body<'tcx>,
-) -> Option<(FnResolution<'tcx>, Location)> {
-    let (generator_def_id, args, loc) = if tcx.asyncness(def_id).is_async() {
-        get_async_generator(body)
+) -> Option<(Instance<'tcx>, Location, Asyncness)> {
+    let ((generator_def_id, args, loc), asyncness) = if tcx.asyncness(def_id).is_async() {
+        (get_async_generator(body), Asyncness::AsyncFn)
     } else {
-        try_as_async_trait_function(tcx, def_id.to_def_id(), body)?
+        (
+            try_as_async_trait_function(tcx, def_id.to_def_id(), body)?,
+            Asyncness::AsyncTrait,
+        )
     };
     let param_env = tcx.param_env_reveal_all_normalized(def_id);
     let generator_fn =
-        utils::try_resolve_function(tcx, generator_def_id.to_def_id(), param_env, args);
-    Some((generator_fn, loc))
+        utils::try_resolve_function(tcx, generator_def_id.to_def_id(), param_env, args)?;
+    Some((generator_fn, loc, asyncness))
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -166,29 +193,29 @@ pub enum AsyncDeterminationResult<T> {
     NotAsync,
 }
 
-impl<'tcx> GraphConstructor<'tcx> {
+impl<'tcx, 'a> LocalAnalysis<'tcx, 'a> {
     pub(crate) fn try_handle_as_async(&self) -> Option<PartialGraph<'tcx>> {
-        let (generator_fn, location) = determine_async(self.tcx, self.def_id, &self.body)?;
+        let (generator_fn, location, asyncness) =
+            determine_async(self.tcx(), self.def_id, &self.body)?;
 
-        let calling_context = self.calling_context_for(generator_fn.def_id(), location);
-        let params = self.pdg_params_for_call(generator_fn);
-        Some(
-            GraphConstructor::new(
-                params,
-                Some(calling_context),
-                self.async_info.clone(),
-                &self.pdg_cache,
-            )
-            .construct_partial(),
-        )
+        let g = self.memo.construct_for(generator_fn)?;
+        let gloc = GlobalLocation {
+            function: self.def_id.to_def_id(),
+            location: flowistry_pdg::RichLocation::Location(location),
+        };
+        let mut new_g = push_call_string_root(g, gloc);
+        //let g_generics = std::mem::replace(&mut new_g.graph.generics, self.generic_args());
+        new_g.asyncness = asyncness;
+        new_g.monos.insert(CallString::single(gloc), new_g.generics);
+        Some(new_g)
     }
 
-    pub(crate) fn try_poll_call_kind<'a>(
-        &'a self,
+    pub(crate) fn try_poll_call_kind<'b>(
+        &'b self,
         def_id: DefId,
-        original_args: &'a [Operand<'tcx>],
+        original_args: &'b [Operand<'tcx>],
     ) -> AsyncDeterminationResult<CallKind<'tcx>> {
-        let lang_items = self.tcx.lang_items();
+        let lang_items = self.tcx().lang_items();
         if lang_items.future_poll_fn() == Some(def_id) {
             match self.find_async_args(original_args) {
                 Ok((fun, loc, args)) => {
@@ -202,10 +229,10 @@ impl<'tcx> GraphConstructor<'tcx> {
     }
     /// Given the arguments to a `Future::poll` call, walk back through the
     /// body to find the original future being polled, and get the arguments to the future.
-    fn find_async_args<'a>(
-        &'a self,
-        args: &'a [Operand<'tcx>],
-    ) -> Result<(FnResolution<'tcx>, Location, Place<'tcx>), String> {
+    fn find_async_args<'b>(
+        &'b self,
+        args: &'b [Operand<'tcx>],
+    ) -> Result<(Instance<'tcx>, Location, Place<'tcx>), String> {
         macro_rules! let_assert {
             ($p:pat = $e:expr, $($arg:tt)*) => {
                 let $p = $e else {
@@ -241,7 +268,7 @@ impl<'tcx> GraphConstructor<'tcx> {
         debug_assert!(new_pin_args.len() == 1);
 
         let future_aliases = self
-            .aliases(self.tcx.mk_place_deref(new_pin_args[0].place().unwrap()))
+            .aliases(self.tcx().mk_place_deref(new_pin_args[0].place().unwrap()))
             .collect_vec();
         debug_assert!(future_aliases.len() == 1);
         let future = *future_aliases.first().unwrap();
@@ -308,11 +335,12 @@ impl<'tcx> GraphConstructor<'tcx> {
         let (op, generics, calling_convention, async_fn_call_loc) = chase_target.unwrap();
 
         let resolution = utils::try_resolve_function(
-            self.tcx,
+            self.tcx(),
             op,
-            self.tcx.param_env_reveal_all_normalized(self.def_id),
+            self.tcx().param_env_reveal_all_normalized(self.def_id),
             generics,
-        );
+        )
+        .ok_or("Resolving function failed")?;
 
         Ok((resolution, async_fn_call_loc, calling_convention))
     }

crates/flowistry_pdg_construction/src/callback.rs

@@ -1,18 +1,16 @@
 //! CAllbacks to influence graph construction and their supporting types.
 
 use flowistry_pdg::{rustc_portable::Location, CallString};
-
-use crate::FnResolution;
+use rustc_middle::ty::Instance;
 
 pub trait CallChangeCallback<'tcx> {
     fn on_inline(&self, info: CallInfo<'tcx>) -> CallChanges;
 
     fn on_inline_miss(
         &self,
-        _resolution: FnResolution<'tcx>,
+        _resolution: Instance<'tcx>,
         _loc: Location,
-        _under_analysis: FnResolution<'tcx>,
-        _call_string: Option<CallString>,
+        _under_analysis: Instance<'tcx>,
         _reason: InlineMissReason,
     ) {
     }
@@ -50,11 +48,11 @@ impl Default for CallChanges {
 /// Information about the function being called.
 pub struct CallInfo<'tcx> {
     /// The potentially-monomorphized resolution of the callee.
-    pub callee: FnResolution<'tcx>,
+    pub callee: Instance<'tcx>,
 
     /// If the callee is an async closure created by an `async fn`, this is the
     /// `async fn` item.
-    pub async_parent: Option<FnResolution<'tcx>>,
+    pub async_parent: Option<Instance<'tcx>>,
 
     /// The call-stack up to the current call site.
     pub call_string: CallString,