forge/cmd/

build.rs

use super::{install, watch::WatchArgs};
use crate::diagnostic::build::SOLC_ERROR;
use clap::Parser;
use eyre::Result;
use forge_lint::{linter::Linter, sol::SolidityLinter};
use foundry_cli::{
    ExitCode,
    json::{JsonEnvelope, JsonMessage, print_json},
    opts::{BuildOpts, configure_pcx_from_solc, get_solar_sources_from_compile_output},
    utils::{Git, LoadConfig, cache_local_signatures},
};
use foundry_common::{
    compile::{ContractSizeLimits, ProjectCompiler},
    shell,
};
use foundry_compilers::{
    CompilationError, FileFilter, Project, ProjectCompileOutput,
    compilers::{Language, multi::MultiCompilerLanguage},
    solc::SolcLanguage,
    utils::source_files_iter,
};
use foundry_config::{
    Config, DenyLevel, SkipBuildFilters,
    figment::{
        self, Metadata, Profile, Provider,
        error::Kind::InvalidType,
        value::{Dict, Map, Value},
    },
    filter::expand_globs,
};
use serde::Serialize;
use solar::{
    interface::{Session, config::Opts},
    sema::Compiler,
};
use std::path::PathBuf;

foundry_config::merge_impl_figment_convert!(BuildArgs, build);

/// CLI arguments for `forge build`.
///
/// CLI arguments take the highest precedence in the Config/Figment hierarchy.
/// In order to override them in the foundry `Config` they need to be merged into an existing
/// `figment::Provider`, like `foundry_config::Config` is.
///
/// `BuildArgs` implements `figment::Provider` in which all config related fields are serialized and
/// then merged into an existing `Config`, effectively overwriting them.
///
/// Some arguments are marked as `#[serde(skip)]` and require manual processing in
/// `figment::Provider` implementation
#[derive(Clone, Debug, Default, Serialize, Parser)]
#[command(next_help_heading = "Build options", about = None, long_about = None)] // override doc
pub struct BuildArgs {
    /// Build source files from specified paths.
    #[serde(skip)]
    pub paths: Option<Vec<PathBuf>>,

    /// Print compiled contract names.
    #[arg(long)]
    #[serde(skip)]
    pub names: bool,

    /// Print compiled contract sizes.
    /// Constructor argument length is not included in the calculation of initcode size.
    #[arg(long)]
    #[serde(skip)]
    pub sizes: bool,

    /// Ignore initcode contract bytecode size limit introduced by EIP-3860.
    #[arg(long, alias = "ignore-initcode-size")]
    #[serde(skip)]
    pub ignore_eip_3860: bool,

    /// Skip the post-build lint step for this invocation.
    ///
    /// Equivalent to setting `lint_on_build = false` under `[lint]` in foundry.toml,
    /// but only for the current command.
    #[arg(long, visible_alias = "skip-lint")]
    #[serde(skip)]
    pub no_lint: bool,

    #[command(flatten)]
    #[serde(flatten)]
    pub build: BuildOpts,

    #[command(flatten)]
    #[serde(skip)]
    pub watch: WatchArgs,
}

impl BuildArgs {
    /// Reject flags whose stdout shape conflicts with the envelope contract.
    /// Must be called before dispatch so `--watch` is caught before the watch
    /// loop short-circuits past `BuildArgs::run`.
    pub fn ensure_machine_compatible(&self) {
        if !foundry_cli::is_machine() {
            return;
        }
        let unsupported =
            [("--watch", self.is_watch()), ("--names", self.names), ("--sizes", self.sizes)]
                .into_iter()
                .filter_map(|(name, on)| on.then_some(name))
                .collect::<Vec<_>>();
        if !unsupported.is_empty() {
            foundry_cli::machine::bail_machine_usage_with_details(
                format!(
                    "`forge build` under `--machine` does not yet support {}; \
                     run without `--machine` or omit those flags.",
                    unsupported.join(", ")
                ),
                serde_json::json!({ "unsupported_flags": unsupported }),
            );
        }
    }

    pub async fn run(self) -> Result<ProjectCompileOutput> {
        self.ensure_machine_compatible();

        let machine_mode = foundry_cli::is_machine();
        let mut config = self.load_config()?;

        // Skip implicit dep install under `--machine`: it writes to stdout and mutates the project
        // behind the agent's back. Missing deps will surface as a typed compile-error envelope.
        if !machine_mode
            && install::install_missing_dependencies(&mut config).await
            && config.auto_detect_remappings
        {
            // need to re-configure here to also catch additional remappings
            config = self.load_config()?;
        }

        // Lock-consistency checks emit `sh_warn!` to stderr; skip under `--machine` to keep
        // the agent channel quiet.
        if !machine_mode {
            self.check_soldeer_lock_consistency(&config).await;
            self.check_foundry_lock_consistency(&config);
        }

        let project = config.project()?;

        // Collect sources to compile if build subdirectories specified.
        let mut files = vec![];
        if let Some(paths) = &self.paths {
            for path in paths {
                let joined = project.root().join(path);
                let path = if joined.exists() { &joined } else { path };
                files.extend(source_files_iter(path, MultiCompilerLanguage::FILE_EXTENSIONS));
            }
            if files.is_empty() {
                eyre::bail!("No source files found in specified build paths.")
            }
        }

        let format_json = shell::is_json();

        // Pre-empt the inner `"Nothing to compile" + exit(0)` path so it can't break the
        // envelope-only stdout contract.
        if machine_mode && !project.paths.has_input_files() && self.paths.is_none() {
            let payload = BuildData { artifacts: 0, errors: 0, warnings: 0, unchanged: false };
            print_json(&JsonEnvelope::success(payload))?;
            std::process::exit(ExitCode::Success.to_i32());
        }

        // Under `--machine`: force quiet (envelope-only stdout) and disable `bail` so we can
        // emit a typed failure envelope instead of a generic eyre error. v1 skips post-build
        // lint (not yet modeled in the envelope schema).
        let mut compiler = ProjectCompiler::new()
            .files(files)
            .dynamic_test_linking(config.dynamic_test_linking)
            .print_names(self.names)
            .print_sizes(self.sizes)
            .ignore_eip_3860(self.ignore_eip_3860)
            .size_limits(
                config
                    .code_size_limit
                    .map(ContractSizeLimits::with_runtime_limit)
                    .unwrap_or_default(),
            )
            .bail(!format_json && !machine_mode);
        if machine_mode {
            compiler = compiler.quiet(true);
        }

        let mut output = compiler.compile(&project)?;

        // Under `--machine`, emit the typed envelope *before* `cache_local_signatures` so a
        // cache-write failure can never mask a compile-error envelope as `cli.unknown`.
        if machine_mode && output.has_compiler_errors() {
            let errors: Vec<JsonMessage> = output
                .output()
                .errors
                .iter()
                .filter(|e| e.is_error())
                .map(|e| JsonMessage::error(SOLC_ERROR, e.to_string()))
                .collect();
            // Best-effort: bubbling via `?` on a broken stdout would demote
            // the canonical `Build (4)` exit to `GenericError (1)`.
            let _ = print_json(&JsonEnvelope::<()>::failure(errors));
            std::process::exit(ExitCode::Build.to_i32());
        }

        // Cache project selectors.
        cache_local_signatures(&output)?;

        if format_json && !self.names && !self.sizes && !machine_mode {
            sh_println!("{}", serde_json::to_string_pretty(&output.output())?)?;
        }

        if machine_mode {
            // Lint output isn't modeled in the v1 envelope; refuse configs that would otherwise
            // diverge human and machine outcomes (deferred until after compile so a failed
            // build still emits `compiler.solc.error` + `Build (4)`).
            if !self.no_lint && config.lint.lint_on_build && config.deny != DenyLevel::Never {
                foundry_cli::machine::bail_machine_usage(
                    "`forge build --machine` does not model lint diagnostics in v1; \
                     `lint_on_build = true` with `deny != never` would diverge human and \
                     machine outcomes. Pass `--no-lint` or set `deny = never`.",
                );
            }

            let payload = BuildData::from_output(&output);
            print_json(&JsonEnvelope::success(payload))?;
            return Ok(output);
        }

        // Only run the `SolidityLinter` if lint on build and no compilation errors.
        if !self.no_lint
            && config.lint.lint_on_build
            && !output.output().errors.iter().any(|e| e.is_error())
            && let Err(err) = self.lint(&project, &config, self.paths.as_deref(), &mut output)
        {
            emit_lint_failure_notice();
            return Err(err.wrap_err("post-build lint step failed"));
        }

        Ok(output)
    }

    fn lint(
        &self,
        project: &Project,
        config: &Config,
        files: Option<&[PathBuf]>,
        output: &mut ProjectCompileOutput,
    ) -> Result<()> {
        let format_json = shell::is_json();
        if project.compiler.solc.is_some() && !shell::is_quiet() {
            let linter = SolidityLinter::new(config.project_paths())
                .with_json_emitter(format_json)
                .with_description(!format_json)
                .with_severity(if config.lint.severity.is_empty() {
                    None
                } else {
                    Some(config.lint.severity.clone())
                })
                .without_lints(if config.lint.exclude_lints.is_empty() {
                    None
                } else {
                    Some(
                        config
                            .lint
                            .exclude_lints
                            .iter()
                            .filter_map(|s| forge_lint::sol::SolLint::try_from(s.as_str()).ok())
                            .collect(),
                    )
                })
                .with_lint_specific(&config.lint.lint_specific);

            // Expand ignore globs and canonicalize from the get go
            let ignored = expand_globs(&config.root, config.lint.ignore.iter())?
                .iter()
                .flat_map(foundry_common::fs::canonicalize_path)
                .collect::<Vec<_>>();

            let skip = SkipBuildFilters::new(config.skip.clone(), config.root.clone());
            let curr_dir = std::env::current_dir()?;
            let input_files = config
                .project_paths::<SolcLanguage>()
                .input_files_iter()
                .filter(|p| {
                    // Lint only specified build files, if any.
                    if let Some(files) = files {
                        return files.iter().any(|file| &curr_dir.join(file) == p);
                    }
                    skip.is_match(p)
                        && !(ignored.contains(p) || ignored.contains(&curr_dir.join(p)))
                })
                .collect::<Vec<_>>();

            let solar_sources =
                get_solar_sources_from_compile_output(config, output, Some(&input_files), None)?;
            if solar_sources.input.sources.is_empty() {
                if !input_files.is_empty() {
                    sh_warn!("unable to lint. Solar only supports Solidity versions >=0.8.0")?;
                }
                return Ok(());
            }

            // NOTE(rusowsky): Once solar can drop unsupported versions, rather than creating a new
            // compiler, we should reuse the parser from the project output.
            let mut opts = Opts::default();
            opts.unstable.typeck = true;
            let mut compiler =
                Compiler::new(Session::builder().opts(opts).with_stderr_emitter().build());

            // Load the solar-compatible sources to the pcx before linting
            compiler.enter_mut(|compiler| {
                let mut pcx = compiler.parse();
                configure_pcx_from_solc(&mut pcx, &config.project_paths(), &solar_sources, true);
                pcx.set_resolve_imports(true);
                pcx.parse();
            });

            linter.lint(&input_files, config.deny, &mut compiler)?;
        }

        Ok(())
    }

    /// Returns the `Project` for the current workspace
    ///
    /// This loads the `foundry_config::Config` for the current workspace (see
    /// [`foundry_config::utils::find_project_root`] and merges the cli `BuildArgs` into it before
    /// returning [`foundry_config::Config::project()`]
    pub fn project(&self) -> Result<Project> {
        self.build.project()
    }

    /// Returns whether `BuildArgs` was configured with `--watch`
    pub const fn is_watch(&self) -> bool {
        self.watch.watch.is_some()
    }

    /// Returns the [`watchexec::Config`] necessary to bootstrap a new watch loop.
    pub(crate) fn watchexec_config(&self) -> Result<watchexec::Config> {
        // Use the path arguments or if none where provided the `src`, `test` and `script`
        // directories as well as the `foundry.toml` configuration file.
        self.watch.watchexec_config(|| {
            let config = self.load_config()?;
            let foundry_toml: PathBuf = config.root.join(Config::FILE_NAME);
            Ok([config.src, config.test, config.script, foundry_toml])
        })
    }

    /// Check soldeer.lock file consistency using soldeer_core APIs
    async fn check_soldeer_lock_consistency(&self, config: &Config) {
        let soldeer_lock_path = config.root.join("soldeer.lock");
        if !soldeer_lock_path.exists() {
            return;
        }

        // Note: read_lockfile returns Ok with empty entries for malformed files
        let Ok(lockfile) = soldeer_core::lock::read_lockfile(&soldeer_lock_path) else {
            return;
        };

        let deps_dir = config.root.join("dependencies");
        for entry in &lockfile.entries {
            let dep_name = entry.name();

            // Use soldeer_core's integrity check
            match soldeer_core::install::check_dependency_integrity(entry, &deps_dir).await {
                Ok(status) => {
                    use soldeer_core::install::DependencyStatus;
                    // Check if status indicates a problem
                    if matches!(
                        status,
                        DependencyStatus::Missing | DependencyStatus::FailedIntegrity
                    ) {
                        sh_warn!("Dependency '{}' integrity check failed: {:?}", dep_name, status)
                            .ok();
                    }
                }
                Err(e) => {
                    sh_warn!("Dependency '{}' integrity check error: {}", dep_name, e).ok();
                }
            }
        }
    }

    /// Check foundry.lock file consistency with git submodules
    fn check_foundry_lock_consistency(&self, config: &Config) {
        use crate::lockfile::{DepIdentifier, FOUNDRY_LOCK, Lockfile};

        let foundry_lock_path = config.root.join(FOUNDRY_LOCK);
        if !foundry_lock_path.exists() {
            return;
        }

        let git = Git::new(&config.root);

        let mut lockfile = Lockfile::new(&config.root).with_git(&git);
        if let Err(e) = lockfile.read() {
            if !e.to_string().contains("Lockfile not found") {
                sh_warn!("Failed to parse foundry.lock: {}", e).ok();
            }
            return;
        }

        for (dep_path, dep_identifier) in lockfile.iter() {
            let full_path = config.root.join(dep_path);

            if !full_path.exists() {
                sh_warn!("Dependency '{}' not found at expected path", dep_path.display()).ok();
                continue;
            }

            let actual_rev = match git.get_rev("HEAD", &full_path) {
                Ok(rev) => rev,
                Err(_) => {
                    sh_warn!("Failed to get git revision for dependency '{}'", dep_path.display())
                        .ok();
                    continue;
                }
            };

            // Compare with the expected revision from lockfile
            let expected_rev = match dep_identifier {
                DepIdentifier::Branch { rev, .. }
                | DepIdentifier::Tag { rev, .. }
                | DepIdentifier::Rev { rev, .. } => rev.clone(),
            };

            if actual_rev != expected_rev {
                sh_warn!(
                    "Dependency '{}' revision mismatch: expected '{}', found '{}'",
                    dep_path.display(),
                    expected_rev,
                    actual_rev
                )
                .ok();
            }
        }
    }
}

/// Stable payload emitted in the `forge build` envelope under `--machine`.
#[derive(Clone, Debug, Serialize)]
pub struct BuildData {
    /// Total number of compiled artifacts in the project.
    pub artifacts: usize,
    /// Number of compiler errors in the output.
    pub errors: usize,
    /// Number of compiler warnings in the output.
    pub warnings: usize,
    /// Whether the build was a no-op (no input files changed since the last
    /// compile). Mirrors `ProjectCompileOutput::is_unchanged`.
    pub unchanged: bool,
}

impl BuildData {
    fn from_output(output: &ProjectCompileOutput) -> Self {
        let artifacts = output.artifact_ids().count();
        let mut errors = 0usize;
        let mut warnings = 0usize;
        for diag in &output.output().errors {
            if diag.is_error() {
                errors += 1;
            } else {
                warnings += 1;
            }
        }
        Self { artifacts, errors, warnings, unchanged: output.is_unchanged() }
    }
}

/// Notice shown on lint-on-build failure; printed separately so it survives single-line
/// cause-chain rendering.
const LINT_FAILURE_NOTICE: &str = "\
note: internal lint engine failure (compilation itself succeeded).
note: please file a bug report at
      https://github.com/foundry-rs/foundry/issues/new?template=BUG-FORM.yml
      and attach the full output above.
help: rerun with `--no-lint` to skip linting for this build, or consider temporarily
      disabling forge lint on build:
      https://getfoundry.sh/forge/linting#disable-linting-on-build
";

fn emit_lint_failure_notice() {
    if shell::is_json() {
        return;
    }
    let _ = sh_eprintln!("\n{LINT_FAILURE_NOTICE}");
}

// Make this args a `figment::Provider` so that it can be merged into the `Config`
impl Provider for BuildArgs {
    fn metadata(&self) -> Metadata {
        Metadata::named("Build Args Provider")
    }

    fn data(&self) -> Result<Map<Profile, Dict>, figment::Error> {
        let value = Value::serialize(self)?;
        let error = InvalidType(value.to_actual(), "map".into());
        let mut dict = value.into_dict().ok_or(error)?;

        if self.names {
            dict.insert("names".to_string(), true.into());
        }

        if self.sizes {
            dict.insert("sizes".to_string(), true.into());
        }

        if self.ignore_eip_3860 {
            dict.insert("ignore_eip_3860".to_string(), true.into());
        }

        Ok(Map::from([(Config::selected_profile(), dict)]))
    }
}