chore: solar-powered fmt rollout

Cargo.toml

@@ -20,7 +20,6 @@ members = [
     "crates/evm/fuzz/",
     "crates/evm/traces/",
     "crates/fmt/",
-    "crates/fmt-2/",
     "crates/forge/",
     "crates/script-sequence/",
     "crates/macros/",

crates/chisel/Cargo.toml

@@ -19,6 +19,7 @@ path = "bin/main.rs"
 
 [dependencies]
 # forge
+forge-doc.workspace = true
 forge-fmt.workspace = true
 foundry-cli.workspace = true
 foundry-common.workspace = true

crates/chisel/src/dispatcher.rs

@@ -9,8 +9,7 @@ use crate::{
 };
 use alloy_primitives::{Address, hex};
 use eyre::{Context, Result};
-use forge_fmt::FormatterConfig;
-use foundry_config::RpcEndpointUrl;
+use foundry_config::{FormatterConfig, RpcEndpointUrl};
 use foundry_evm::{
     decode::decode_console_logs,
     traces::{
@@ -66,18 +65,8 @@ pub struct EtherscanABIResponse {
 
 /// Helper function that formats solidity source with the given [FormatterConfig]
 pub fn format_source(source: &str, config: FormatterConfig) -> eyre::Result<String> {
-    match forge_fmt::parse(source) {
-        Ok(parsed) => {
-            let mut formatted_source = String::default();
-
-            if forge_fmt::format_to(&mut formatted_source, parsed, config).is_err() {
-                eyre::bail!("Could not format source!");
-            }
-
-            Ok(formatted_source)
-        }
-        Err(_) => eyre::bail!("Formatter could not parse source!"),
-    }
+    let formatted = forge_fmt::format(source, config).into_result()?;
+    Ok(formatted)
 }
 
 impl ChiselDispatcher {

crates/chisel/src/source.rs

@@ -5,7 +5,7 @@
 //! execution helpers.
 
 use eyre::Result;
-use forge_fmt::solang_ext::{CodeLocationExt, SafeUnwrap};
+use forge_doc::solang_ext::{CodeLocationExt, SafeUnwrap};
 use foundry_common::fs;
 use foundry_compilers::{
     Artifact, ProjectCompileOutput,

crates/cli/src/utils/mod.rs

@@ -2,6 +2,7 @@ use alloy_json_abi::JsonAbi;
 use alloy_primitives::{U256, map::HashMap};
 use alloy_provider::{Provider, network::AnyNetwork};
 use eyre::{ContextCompat, Result};
+use forge_fmt::FormatterConfig;
 use foundry_common::{
     provider::{ProviderBuilder, RetryProvider},
     shell,
@@ -100,7 +101,7 @@ fn env_filter() -> tracing_subscriber::EnvFilter {
 
 pub fn abi_to_solidity(abi: &JsonAbi, name: &str) -> Result<String> {
     let s = abi.to_sol(name, None);
-    let s = forge_fmt::format(&s)?;
+    let s = forge_fmt::format(&s, FormatterConfig::default()).into_result()?;
     Ok(s)
 }
 

crates/doc/Cargo.toml

@@ -19,6 +19,7 @@ foundry-common.workspace = true
 foundry-compilers.workspace = true
 foundry-config.workspace = true
 
+solar-interface.workspace = true
 alloy-primitives.workspace = true
 
 derive_more.workspace = true

crates/doc/src/builder.rs

@@ -1,12 +1,11 @@
 use crate::{
     AsDoc, BufWriter, Document, ParseItem, ParseSource, Parser, Preprocessor,
-    document::DocumentContent, helpers::merge_toml_table,
+    document::DocumentContent, helpers::merge_toml_table, solang_ext::Visitable,
 };
 use alloy_primitives::map::HashMap;
 use eyre::{Context, Result};
-use forge_fmt::{FormatterConfig, Visitable};
 use foundry_compilers::{compilers::solc::SOLC_EXTENSIONS, utils::source_files_iter};
-use foundry_config::{DocConfig, filter::expand_globs};
+use foundry_config::{DocConfig, FormatterConfig, filter::expand_globs};
 use itertools::Itertools;
 use mdbook::MDBook;
 use rayon::prelude::*;

crates/doc/src/lib.rs

@@ -31,3 +31,6 @@ mod writer;
 pub use writer::{AsDoc, AsDocResult, BufWriter, Markdown};
 
 pub use mdbook;
+
+// old formatter dependencies
+pub mod solang_ext;

crates/doc/src/parser/error.rs

@@ -1,4 +1,4 @@
-use forge_fmt::FormatterError;
+use solar_interface::diagnostics::EmittedDiagnostics;
 use thiserror::Error;
 
 /// The parser error.
@@ -7,7 +7,7 @@ use thiserror::Error;
 pub enum ParserError {
     /// Formatter error.
     #[error(transparent)]
-    Formatter(#[from] FormatterError),
+    Formatter(EmittedDiagnostics),
     /// Internal parser error.
     #[error(transparent)]
     Internal(#[from] eyre::Error),

crates/doc/src/parser/item.rs

@@ -1,8 +1,9 @@
-use crate::{Comments, error::ParserResult};
-use forge_fmt::{
-    Comments as FmtComments, Formatter, FormatterConfig, InlineConfig, Visitor,
+use crate::{
+    Comments,
+    error::{ParserError, ParserResult},
     solang_ext::SafeUnwrap,
 };
+use foundry_config::FormatterConfig;
 use solang_parser::pt::{
     ContractDefinition, ContractTy, EnumDefinition, ErrorDefinition, EventDefinition,
     FunctionDefinition, StructDefinition, TypeDefinition, VariableDefinition,
@@ -82,33 +83,8 @@ impl ParseItem {
 
     /// Set formatted code on the [ParseItem].
     pub fn with_code(mut self, source: &str, config: FormatterConfig) -> ParserResult<Self> {
-        let mut code = String::new();
-        let mut fmt = Formatter::new(
-            &mut code,
-            source,
-            FmtComments::default(),
-            InlineConfig::default(),
-            config,
-        );
-
-        match self.source.clone() {
-            ParseSource::Contract(mut contract) => {
-                contract.parts = vec![];
-                fmt.visit_contract(&mut contract)?
-            }
-            ParseSource::Function(mut func) => {
-                func.body = None;
-                fmt.visit_function(&mut func)?
-            }
-            ParseSource::Variable(mut var) => fmt.visit_var_definition(&mut var)?,
-            ParseSource::Event(mut event) => fmt.visit_event(&mut event)?,
-            ParseSource::Error(mut error) => fmt.visit_error(&mut error)?,
-            ParseSource::Struct(mut structure) => fmt.visit_struct(&mut structure)?,
-            ParseSource::Enum(mut enumeration) => fmt.visit_enum(&mut enumeration)?,
-            ParseSource::Type(mut ty) => fmt.visit_type_definition(&mut ty)?,
-        };
-
-        self.code = code;
+        self.code =
+            forge_fmt::format(source, config).into_result().map_err(ParserError::Formatter)?;
 
         Ok(self)
     }

crates/doc/src/parser/mod.rs

@@ -1,6 +1,7 @@
 //! The parser module.
 
-use forge_fmt::{FormatterConfig, Visitable, Visitor};
+use crate::solang_ext::{Visitable, Visitor};
+use foundry_config::FormatterConfig;
 use itertools::Itertools;
 use solang_parser::{
     doccomment::{DocComment, parse_doccomments},
@@ -295,7 +296,7 @@ mod tests {
                 struct ContractStruct { }
                 enum ContractEnum { }
 
-                uint256 constant CONTRACT_CONSTANT;
+                uint256 constant CONTRACT_CONSTANT = 0;
                 bool contractVar;
 
                 function contractFunction(uint256) external returns (uint256) {
@@ -352,15 +353,15 @@ mod tests {
             pragma solidity ^0.8.19;
             /// @name Test
             ///  no tag
-            ///@notice    Cool contract    
-            ///   @  dev     This is not a dev tag 
+            ///@notice    Cool contract
+            ///   @  dev     This is not a dev tag
             /**
              * @dev line one
              *    line 2
              */
             contract Test {
-                /*** my function    
-                      i like whitespace    
+                /*** my function
+                      i like whitespace
             */
                 function test() {}
             }

crates/doc/src/preprocessor/contract_inheritance.rs

@@ -1,7 +1,8 @@
 use super::{Preprocessor, PreprocessorId};
-use crate::{Document, ParseSource, PreprocessorOutput, document::DocumentContent};
+use crate::{
+    Document, ParseSource, PreprocessorOutput, document::DocumentContent, solang_ext::SafeUnwrap,
+};
 use alloy_primitives::map::HashMap;
-use forge_fmt::solang_ext::SafeUnwrap;
 use std::path::PathBuf;
 
 /// [ContractInheritance] preprocessor id.

crates/doc/src/preprocessor/infer_hyperlinks.rs

@@ -1,6 +1,5 @@
 use super::{Preprocessor, PreprocessorId};
-use crate::{Comments, Document, ParseItem, ParseSource};
-use forge_fmt::solang_ext::SafeUnwrap;
+use crate::{Comments, Document, ParseItem, ParseSource, solang_ext::SafeUnwrap};
 use regex::{Captures, Match, Regex};
 use std::{
     borrow::Cow,

crates/doc/src/preprocessor/inheritdoc.rs

@@ -1,9 +1,9 @@
 use super::{Preprocessor, PreprocessorId};
 use crate::{
     Comments, Document, ParseItem, ParseSource, PreprocessorOutput, document::DocumentContent,
+    solang_ext::SafeUnwrap,
 };
 use alloy_primitives::map::HashMap;
-use forge_fmt::solang_ext::SafeUnwrap;
 
 /// [`Inheritdoc`] preprocessor ID.
 pub const INHERITDOC_ID: PreprocessorId = PreprocessorId("inheritdoc");

crates/fmt/src/solang_ext/mod.rs → crates/doc/src/solang_ext/mod.rs

@@ -23,7 +23,9 @@ pub mod pt {
 mod ast_eq;
 mod loc;
 mod safe_unwrap;
+mod visit;
 
 pub use ast_eq::AstEq;
 pub use loc::CodeLocationExt;
 pub use safe_unwrap::SafeUnwrap;
+pub use visit::{Visitable, Visitor};

crates/fmt/src/visit.rs → crates/doc/src/solang_ext/visit.rs

@@ -287,18 +287,6 @@ pub trait Visitor {
         Ok(())
     }
 
-    fn visit_opening_paren(&mut self) -> Result<(), Self::Error> {
-        Ok(())
-    }
-
-    fn visit_closing_paren(&mut self) -> Result<(), Self::Error> {
-        Ok(())
-    }
-
-    fn visit_newline(&mut self) -> Result<(), Self::Error> {
-        Ok(())
-    }
-
     fn visit_using(&mut self, using: &mut Using) -> Result<(), Self::Error> {
         self.visit_source(using.loc)?;
         self.visit_stray_semicolon()?;

crates/doc/src/writer/as_doc.rs

@@ -3,9 +3,9 @@ use crate::{
     GIT_SOURCE_ID, INHERITDOC_ID, Markdown, PreprocessorOutput,
     document::{DocumentContent, read_context},
     parser::ParseSource,
+    solang_ext::SafeUnwrap,
     writer::BufWriter,
 };
-use forge_fmt::solang_ext::SafeUnwrap;
 use itertools::Itertools;
 use solang_parser::pt::{Base, FunctionDefinition};
 use std::path::{Path, PathBuf};