poc: remove Rc Cell from parser2 parse scope structs

crates/analyzer/src/db/queries/ingots.rs

@@ -1,5 +1,7 @@
-use crate::namespace::items::{IngotId, IngotMode, ModuleId, ModuleSource};
-use crate::AnalyzerDb;
+use crate::{
+    namespace::items::{IngotId, IngotMode, ModuleId, ModuleSource},
+    AnalyzerDb,
+};
 use fe_common::files::{SourceFileId, Utf8Path, Utf8PathBuf};
 use indexmap::IndexSet;
 use std::rc::Rc;

crates/analyzer/src/db/queries/module.rs

@@ -1,20 +1,25 @@
-use crate::context::{Analysis, AnalyzerContext, Constant, NamedThing};
-use crate::display::Displayable;
-use crate::errors::{self, ConstEvalError, TypeError};
-use crate::namespace::items::{
-    Contract, ContractId, Enum, Function, Impl, ImplId, Item, ModuleConstant, ModuleConstantId,
-    ModuleId, ModuleSource, Struct, StructId, Trait, TraitId, TypeAlias, TypeDef,
+use crate::{
+    context::{Analysis, AnalyzerContext, Constant, NamedThing},
+    display::Displayable,
+    errors::{self, ConstEvalError, TypeError},
+    namespace::{
+        items::{
+            Contract, ContractId, Enum, Function, Impl, ImplId, Item, ModuleConstant,
+            ModuleConstantId, ModuleId, ModuleSource, Struct, StructId, Trait, TraitId, TypeAlias,
+            TypeDef,
+        },
+        scopes::ItemScope,
+        types::{self, TypeId},
+    },
+    traversal::{const_expr, expressions, types::type_desc},
+    AnalyzerDb,
 };
-use crate::namespace::scopes::ItemScope;
-use crate::namespace::types::{self, TypeId};
-use crate::traversal::{const_expr, expressions, types::type_desc};
-use crate::AnalyzerDb;
-use fe_common::diagnostics::Label;
-use fe_common::files::Utf8Path;
-use fe_common::Span;
+use fe_common::{diagnostics::Label, files::Utf8Path, Span};
 use fe_parser::{ast, node::Node};
-use indexmap::indexmap;
-use indexmap::map::{Entry, IndexMap};
+use indexmap::{
+    indexmap,
+    map::{Entry, IndexMap},
+};
 use smol_str::SmolStr;
 use std::rc::Rc;
 
@@ -293,13 +298,7 @@ pub fn module_structs(db: &dyn AnalyzerDb, module: ModuleId) -> Rc<[StructId]> {
     module
         .all_items(db)
         .iter()
-        .chain(
-            module
-                .used_items(db)
-                .values()
-                .into_iter()
-                .map(|(_, item)| item),
-        )
+        .chain(module.used_items(db).values().map(|(_, item)| item))
         .filter_map(|item| match item {
             Item::Type(TypeDef::Struct(id)) => Some(*id),
             _ => None,

crates/codegen/src/yul/runtime/data.rs

@@ -238,11 +238,7 @@ pub(super) fn make_aggregate_init(
     let ptr = YulVariable::new("ptr");
     let field_num = inner_ty.aggregate_field_num(db.upcast());
 
-    let iter_field_args = || {
-        (0..field_num)
-            .into_iter()
-            .map(|i| YulVariable::new(format! {"arg{i}"}))
-    };
+    let iter_field_args = || (0..field_num).map(|i| YulVariable::new(format! {"arg{i}"}));
 
     let mut body = vec![];
     for (idx, field_arg) in iter_field_args().enumerate() {
@@ -303,11 +299,7 @@ pub(super) fn make_enum_init(
     let ptr = YulVariable::new("ptr");
     let disc = YulVariable::new("disc");
     let disc_ty = arg_tys[0];
-    let enum_data = || {
-        (0..arg_tys.len() - 1)
-            .into_iter()
-            .map(|i| YulVariable::new(format! {"arg{i}"}))
-    };
+    let enum_data = || (0..arg_tys.len() - 1).map(|i| YulVariable::new(format! {"arg{i}"}));
 
     let tuple_def = TupleDef {
         items: arg_tys

crates/common2/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "fe-common2"
+version = "0.20.0-alpha"
+authors = ["The Fe Developers <snakecharmers@ethereum.org>"]
+edition = "2021"
+license = "Apache-2.0"
+repository = "https://github.com/ethereum/fe"
+description = "Provides HIR definition and lowering for Fe lang."
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+semver = "1.0.17"
+camino = "1.1.4"
+smol_str = "0.1.24"
+salsa = { git = "https://github.com/salsa-rs/salsa", package = "salsa-2022" }
+parser = { path = "../parser2", package = "fe-parser2" }

crates/common2/src/diagnostics.rs

@@ -0,0 +1,105 @@
+use parser::TextRange;
+
+use crate::InputFile;
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct CompleteDiagnostic {
+    pub severity: Severity,
+    pub message: String,
+    pub span: Span,
+    pub sub_diagnostics: Vec<SubDiagnostic>,
+    pub error_code: GlobalErrorCode,
+}
+
+impl CompleteDiagnostic {
+    pub fn new(
+        severity: Severity,
+        message: String,
+        span: Span,
+        sub_diagnostics: Vec<SubDiagnostic>,
+        error_code: GlobalErrorCode,
+    ) -> Self {
+        Self {
+            severity,
+            message,
+            span,
+            sub_diagnostics,
+            error_code,
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct GlobalErrorCode {
+    pub pass: AnalysisPass,
+    pub local_code: u16,
+}
+
+impl GlobalErrorCode {
+    pub fn new(pass: AnalysisPass, local_code: u16) -> Self {
+        Self { pass, local_code }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct SubDiagnostic {
+    pub severity: Severity,
+    pub message: String,
+    pub span: Span,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Span {
+    pub file: InputFile,
+    pub range: TextRange,
+    pub kind: SpanKind,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum SpanKind {
+    /// A node corresponding is originally written in the source code.
+    Original,
+
+    /// A node corresponding to the span is generated by macro expansion.
+    Expanded,
+
+    /// No span information was found.
+    /// This happens if analysis code tries to get a span for a node that is
+    /// generated in lowering phase.
+    ///
+    /// If span has this kind, it means there is a bug in the analysis code.
+    /// The reason not to panic is that LSP should continue working even if
+    /// there are bugs in the span generation(This also makes easier to identify
+    /// the cause of the bug)
+    ///
+    /// Range is always the first character of the file in this case.
+    NotFound,
+}
+
+impl Span {
+    pub fn new(file: InputFile, range: TextRange, kind: SpanKind) -> Self {
+        Self { file, range, kind }
+    }
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub enum Severity {
+    Error,
+    Warning,
+    Note,
+}
+
+#[repr(u16)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum AnalysisPass {
+    Parse = 1,
+    NameResolution,
+    TyCheck,
+
+    ExternalAnalysis(ExternalAnalysisKey) = u16::MAX,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ExternalAnalysisKey {
+    name: String,
+}

crates/common2/src/input.rs

@@ -0,0 +1,139 @@
+use std::collections::BTreeSet;
+
+use camino::Utf8PathBuf;
+use smol_str::SmolStr;
+
+use crate::InputDb;
+
+/// An ingot is a collection of files which are compiled together.
+/// Ingot can depend on other ingots.
+#[salsa::input(constructor = __new_impl)]
+pub struct InputIngot {
+    /// An absolute path to the ingot root directory.
+    /// The all files in the ingot should be located under this directory.
+    #[return_ref]
+    pub path: Utf8PathBuf,
+
+    /// Specifies the kind of the ingot.
+    pub kind: IngotKind,
+
+    /// A version of the ingot.
+    #[return_ref]
+    pub version: Version,
+
+    /// A list of ingots which the current ingot depends on.
+    #[return_ref]
+    pub dependency: BTreeSet<IngotDependency>,
+
+    /// A list of files which the current ingot contains.
+    #[return_ref]
+    #[set(__set_files_impl)]
+    pub files: BTreeSet<InputFile>,
+
+    #[set(__set_root_file_impl)]
+    #[get(__get_root_file_impl)]
+    root_file: Option<InputFile>,
+}
+impl InputIngot {
+    pub fn new(
+        db: &dyn InputDb,
+        path: &str,
+        kind: IngotKind,
+        version: Version,
+        dependency: BTreeSet<IngotDependency>,
+    ) -> InputIngot {
+        let path = Utf8PathBuf::from(path);
+        let root_file = None;
+        Self::__new_impl(
+            db,
+            path,
+            kind,
+            version,
+            dependency,
+            BTreeSet::default(),
+            root_file,
+        )
+    }
+
+    /// Set the root file of the ingot.
+    /// The root file must be set before the ingot is used.
+    pub fn set_root_file(self, db: &mut dyn InputDb, file: InputFile) {
+        self.__set_root_file_impl(db).to(Some(file));
+    }
+
+    /// Set the list of files which the ingot contains.
+    /// All files must bee set before the ingot is used.
+    pub fn set_files(self, db: &mut dyn InputDb, files: BTreeSet<InputFile>) {
+        self.__set_files_impl(db).to(files);
+    }
+
+    /// Returns the root file of the ingot.
+    /// Panics if the root file is not set.
+    pub fn root_file(&self, db: &dyn InputDb) -> InputFile {
+        self.__get_root_file_impl(db).unwrap()
+    }
+}
+
+#[salsa::input]
+pub struct InputFile {
+    /// A ingot id which the file belongs to.
+    pub ingot: InputIngot,
+
+    /// A path to the file from the ingot root directory.
+    #[return_ref]
+    pub path: Utf8PathBuf,
+
+    #[return_ref]
+    pub text: String,
+}
+
+impl InputFile {
+    pub fn abs_path(&self, db: &dyn InputDb) -> Utf8PathBuf {
+        self.ingot(db).path(db).join(self.path(db))
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum IngotKind {
+    /// A standalone ingot is a dummy ingot when the compiler is invoked
+    /// directly on a file.
+    StandAlone,
+
+    /// A local ingot which is the current ingot being compiled.
+    Local,
+
+    /// An external ingot which is depended on by the current ingot.
+    External,
+
+    /// Standard library ingot.
+    Std,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct IngotDependency {
+    /// The ingot may have a alias name from the original ingot name.
+    pub name: SmolStr,
+    /// An ingot which the current ingot depends on.
+    pub ingot: InputIngot,
+}
+impl IngotDependency {
+    pub fn new(name: &str, ingot: InputIngot) -> Self {
+        Self {
+            name: SmolStr::new(name),
+            ingot,
+        }
+    }
+}
+
+impl PartialOrd for IngotDependency {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.ingot.cmp(&other.ingot))
+    }
+}
+impl Ord for IngotDependency {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.ingot.cmp(&other.ingot)
+    }
+}
+
+pub type Version = semver::Version;

crates/common2/src/lib.rs

@@ -0,0 +1,14 @@
+pub mod diagnostics;
+pub mod input;
+
+pub use input::{InputFile, InputIngot};
+
+#[salsa::jar(db = InputDb)]
+pub struct Jar(InputIngot, InputFile);
+
+pub trait InputDb: salsa::DbWithJar<Jar> {}
+impl<DB> InputDb for DB where DB: ?Sized + salsa::DbWithJar<Jar> {}
+
+pub trait Upcast<T: ?Sized> {
+    fn upcast(&self) -> &T;
+}

crates/hir/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "fe-hir"
+version = "0.20.0-alpha"
+authors = ["The Fe Developers <snakecharmers@ethereum.org>"]
+edition = "2021"
+license = "Apache-2.0"
+repository = "https://github.com/ethereum/fe"
+description = "Provides HIR definition and lowering for Fe lang"
+
+[dependencies]
+# We may need to fix this to a specific version, 
+# but I want to keep up with the latest version until the new Fe implemeentation is merged into the master.
+salsa = { git = "https://github.com/salsa-rs/salsa", package = "salsa-2022" }
+derive_more = "0.99"
+cranelift-entity = "0.91"
+num-bigint = "0.4.3"
+num-traits = "0.2.15"
+camino = "1.1.4"
+rustc-hash = "1.1.0"
+
+parser = { path = "../parser2", package = "fe-parser2" }
+common = { path = "../common2", package = "fe-common2" }
+smallvec = "1.10.0"