Add nonexistent variant to ModulePath

Summary: See D68929960 for context. Having a variant for nonexistent path avoids the need of using a faked path.

Reviewed By: ndmitchell

Differential Revision: D68932048

fbshipit-source-id: 1c7e1e64e624e732423838118472c6fe22ebc513

pyre2/pyre2/bin/module/module_path.rs

@@ -13,6 +13,7 @@ use std::sync::Arc;
 use dupe::Dupe;
 
 use crate::dunder;
+use crate::module::module_name::ModuleName;
 
 #[derive(Debug, Clone, Dupe, Copy, PartialEq, Eq, Hash)]
 pub enum ModuleStyle {
@@ -33,6 +34,9 @@ enum ModulePathInner {
     /// The module source comes from typeshed bundled with Pyre (which gets stored in-memory).
     /// The path is relative to the root of the typeshed directory.
     BundledTypeshed(PathBuf),
+    /// Representing the possibility that a module source doesn't exist.
+    /// The module name indicates the module that is looked up but not found.
+    NotFound(ModuleName),
 }
 
 fn is_path_init(path: &Path) -> bool {
@@ -58,6 +62,10 @@ impl ModulePath {
         Self(Arc::new(ModulePathInner::BundledTypeshed(relative_path)))
     }
 
+    pub fn not_found(module_name: ModuleName) -> Self {
+        Self(Arc::new(ModulePathInner::NotFound(module_name)))
+    }
+
     pub fn display(&self) -> String {
         match &*self.0 {
             ModulePathInner::FileSystem(path) => path.display().to_string(),
@@ -67,13 +75,19 @@ impl ModulePath {
                     relative_path.display()
                 )
             }
+            ModulePathInner::NotFound(module_name) => {
+                // This branch is not expected to be reachable since nonexistent module shouldn't have an errors,
+                // but lets make it clear this is a fake path if it ever happens to leak into any output.
+                format!("empty {module_name}")
+            }
         }
     }
 
     pub fn is_init(&self) -> bool {
         match &*self.0 {
             ModulePathInner::FileSystem(path) => is_path_init(path),
             ModulePathInner::BundledTypeshed(relative_path) => is_path_init(relative_path),
+            ModulePathInner::NotFound(_) => false,
         }
     }
 
@@ -82,6 +96,7 @@ impl ModulePath {
         match &*self.0 {
             ModulePathInner::FileSystem(path) => ModuleStyle::of_path(path),
             ModulePathInner::BundledTypeshed(relative_path) => ModuleStyle::of_path(relative_path),
+            ModulePathInner::NotFound(_) => ModuleStyle::Executable,
         }
     }
 
@@ -93,6 +108,7 @@ impl ModulePath {
         match &*self.0 {
             ModulePathInner::FileSystem(path) => Some(path),
             ModulePathInner::BundledTypeshed(_) => None,
+            ModulePathInner::NotFound(_) => None,
         }
     }
 }

pyre2/pyre2/bin/state/loader.rs

@@ -36,12 +36,6 @@ pub struct LoadResultComponents {
 
 static FAKE_MODULE: &str = "";
 
-fn fake_path(module_name: ModuleName) -> PathBuf {
-    // The generated fake module shouldn't have an errors, but lets make it clear
-    // this is a fake path if it ever happens to leak into any output.
-    PathBuf::from(format!("/fake/{module_name}.py"))
-}
-
 impl LoadResult {
     pub fn from_path(path: PathBuf) -> Self {
         match fs_anyhow::read_to_string(&path) {
@@ -65,8 +59,7 @@ impl LoadResult {
                 import_error: None,
             },
             LoadResult::FailedToFind(err) => LoadResultComponents {
-                // TODO(grievejia): Properly model nonexistent paths
-                path: ModulePath::filesystem(fake_path(module_name)),
+                path: ModulePath::not_found(module_name),
                 code: FAKE_MODULE.to_owned(),
                 self_error: None,
                 import_error: Some(err),