hacking

Author: Grant Wuerker

Cargo.lock

@@ -105,6 +105,9 @@ pub enum IngotKind {
 
     /// Standard library ingot.
     Std,
+
+    /// Core library ingot.
+    Core,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]

crates/common2/src/input.rs

@@ -2,7 +2,6 @@ pub mod config;
 pub mod diagnostics;
 pub mod indexmap;
 pub mod input;
-pub mod resolver;
 
 pub use input::{InputFile, InputIngot};
 

crates/common2/src/lib.rs

@@ -16,6 +16,7 @@ codespan-reporting = "0.11"
 hir = { path = "../hir", package = "fe-hir" }
 common = { path = "../common2", package = "fe-common2" }
 hir-analysis = { path = "../hir-analysis", package = "fe-hir-analysis" }
+resolver = { path = "../resolver", package = "fe-resolver" }
 camino = "1.1.4"
 clap = { version = "4.3", features = ["derive"] }
 semver = "1.0.23"

crates/driver2/Cargo.toml

@@ -2,14 +2,15 @@ pub mod diagnostics;
 
 use std::path;
 
+use camino::Utf8PathBuf;
 use codespan_reporting::term::{
     self,
     termcolor::{BufferWriter, ColorChoice},
 };
 use common::{
     diagnostics::CompleteDiagnostic,
-    indexmap::IndexSet,
-    input::{IngotKind, Version},
+    indexmap::{IndexMap, IndexSet},
+    input::{IngotDependency, IngotKind, Version},
     InputDb, InputFile, InputIngot,
 };
 use hir::{
@@ -27,6 +28,12 @@ use hir_analysis::{
     },
     HirAnalysisDb,
 };
+use resolver::{
+    ingot::{
+        config::ConfigResolver, dependencies::DependenciesResolver, src_files::SrcFilesResolver,
+    },
+    Resolver,
+};
 
 use crate::diagnostics::ToCsDiag;
 
@@ -91,6 +98,47 @@ impl DriverDataBase {
         DiagnosticsCollection(pass_manager.run_on_module_tree(tree))
     }
 
+    pub fn ingot(&mut self, ingot_path: &path::Path) -> InputIngot {
+        let config_resolver = ConfigResolver;
+        let dep_resolver = DependenciesResolver { config_resolver };
+        let src_files_resolver = SrcFilesResolver;
+
+        let dep_graph = dep_resolver.resolve(ingot_path).unwrap();
+
+        let input_ingots = IndexMap::new();
+
+        for path in dep_graph.reverse_toposort() {
+            let ingot_kind = if path == ingot_path {
+                IngotKind::Local
+            } else {
+                IngotKind::External
+            };
+            let external_ingots =
+                dep_graph
+                    .dependencies(&dep)
+                    .iter()
+                    .map(|(name, _, path)| IngotDependency {
+                        name,
+                        ingot: input_ingots[path],
+                    });
+            input_ingot[ingot_path] =
+                InputIngot::new(self, path, ingot_kind, version, external_ingots);
+        }
+
+        for (ingot_path, input_ingot) in input_ingots {
+            let files = src_files_resolver.resolve(&ingot_path);
+            let input_files = files
+                .into_iter()
+                .map(|(path, content)| InputFile::new(self, input_ingot, file_path, content))
+                .collect();
+            input_ingot.set_files(db, input_files);
+            // match lib.fe and main.fe
+            // input_ingot.set_root_file(db, input_files[0]);
+        }
+
+        input_ingots[ingot_path]
+    }
+
     pub fn standalone(&mut self, file_path: &path::Path, source: &str) -> InputFile {
         let kind = IngotKind::StandAlone;
 

crates/driver2/src/lib.rs

@@ -2,20 +2,41 @@ use serde::Deserialize;
 use smol_str::SmolStr;
 use std::hash::Hash;
 
-use crate::files::AnyFilesDesc;
+use crate::{path::PathDescription, remote::GitDescription};
 
-mod config;
-mod dep_graph;
-mod src_files;
+pub mod config;
+pub mod dependencies;
+pub mod src_files;
 
-#[derive(Deserialize, Hash, Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
-pub struct IngotDesc<FD>
-where
-    FD: Hash,
-{
+#[derive(Deserialize, Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub struct IngotDescription<FD> {
     pub version: Option<SmolStr>,
+    // pub fe_version: SmolStr,
+    // pub features: Vec<SmolStr>,
     #[serde(flatten)]
-    pub files_desc: FD,
+    pub files_description: FD,
 }
 
-pub type AnyIngotDesc = IngotDesc<AnyFilesDesc>;
+#[derive(Deserialize, PartialEq, Debug, Clone, Eq)]
+pub enum AnyIngotDescription {
+    Path(IngotDescription<PathDescription>),
+    Remote(IngotDescription<GitDescription>),
+    Registered(IngotDescription<()>),
+}
+
+// pub struct IngotPathResolver;
+
+// pub enum IngotPathResolutionError {
+//     RemotePathOutOfScope,
+//     LocalPathDoesNotExist,
+// }
+
+// impl Resolver for IngotPathResolver {
+//     type ResourceDesc = Vec<AnyIngotDesc>;
+//     type Resource = Utf8PathBuf;
+//     type ResolutionError = IngotPathResolutionError;
+
+//     fn resolve(&self, desc: &Self::ResourceDesc) -> Result<Self::Resource, Self::ResolutionError> {
+//         todo!()
+//     }
+// }

crates/resolver/src/files.rs

@@ -1,68 +1,48 @@
 use camino::Utf8PathBuf;
-use serde::de::DeserializeOwned;
 use serde::Deserialize;
 use smol_str::SmolStr;
-use std::hash::Hash;
 use std::{collections::HashMap, fs};
 use toml;
 
 use crate::Resolver;
 
-use super::IngotDesc;
+use super::AnyIngotDescription;
 
-#[derive(Deserialize)]
-pub struct Config<FD>
-where
-    FD: Hash,
-{
+#[derive(Deserialize, Debug, Clone, PartialEq, Eq)]
+pub struct Config {
     pub name: SmolStr,
     pub version: SmolStr,
-    pub dependencies: HashMap<SmolStr, IngotDesc<FD>>,
+    pub dependencies: HashMap<SmolStr, AnyIngotDescription>,
+}
+
+pub enum InvalidConfigError {
+    MissingVersion,
+    MissingName,
+    UnrecognizedField(String),
 }
 
 #[derive(Debug)]
 pub enum ConfigResolutionError {
-    FileNotFound,
+    ConfigNotFound,
     FileReadError(std::io::Error),
     TomlParseError(toml::de::Error),
     InvalidConfig(String),
 }
 
-pub struct ConfigResolver<FR> {
-    files_resolver: FR,
-}
+pub struct ConfigResolver;
 
-impl<FR> Resolver for ConfigResolver<FR>
-where
-    FR: Resolver,
-    FR::ResourceDesc: Hash,
-    FR::Resource: AsRef<Utf8PathBuf>,
-    Config<FR::ResourceDesc>: DeserializeOwned,
-{
-    type Config = ();
-    type ResourceDesc = IngotDesc<FR::ResourceDesc>;
-    type Resource = Config<FR::ResourceDesc>;
+impl Resolver for ConfigResolver {
+    type Description = Utf8PathBuf;
+    type Resource = Config;
     type ResolutionError = ConfigResolutionError;
 
-    fn from_config(_config: &Self::Config) -> Self {
-        todo!()
-    }
-
-    fn resolve(
-        &self,
-        desc: &IngotDesc<FR::ResourceDesc>,
-    ) -> Result<Config<FR::ResourceDesc>, ConfigResolutionError> {
-        let config_path = self
-            .files_resolver
-            .resolve(&desc.files_desc)
-            .map_err(|_| ConfigResolutionError::FileNotFound)?
-            .as_ref()
-            .join("fe.toml");
+    fn resolve(&self, desc: &Utf8PathBuf) -> Result<Config, ConfigResolutionError> {
+        let config_path = desc.join("fe.toml");
 
         let file_content =
             fs::read_to_string(&config_path).map_err(ConfigResolutionError::FileReadError)?;
 
-        let config: Config<FR::ResourceDesc> =
+        let config: Config =
             toml::from_str(&file_content).map_err(ConfigResolutionError::TomlParseError)?;
 
         if config.name.is_empty() {