fix: filter out unsupported versions when getting the solar compiler

from the output project parser

Author: 0xrusowsky

crates/cli/src/opts/build/mod.rs

@@ -9,7 +9,7 @@ mod paths;
 pub use self::paths::ProjectPathOpts;
 
 mod utils;
-pub use self::utils::{configure_pcx, configure_pcx_from_compile_output, configure_pcx_from_solc};
+pub use self::utils::*;
 
 // A set of solc compiler settings that can be set via command line arguments, which are intended
 // to be merged into an existing `foundry_config::Config`.

crates/cli/src/opts/build/utils.rs

@@ -83,18 +83,17 @@ pub fn configure_pcx(
     Ok(())
 }
 
-/// Configures a [`ParsingContext`] from a [`ProjectCompileOutput`] and [`SolcVersionedInput`].
+/// Extracts Solar-compatible sources from a [`ProjectCompileOutput`].
 ///
 /// # Note:
 /// uses `output.graph().source_files()` and `output.artifact_ids()` rather than `output.sources()`
 /// because sources aren't populated when build is skipped when there are no changes in the source
 /// code. <https://github.com/foundry-rs/foundry/issues/12018>
-pub fn configure_pcx_from_compile_output(
-    pcx: &mut ParsingContext<'_>,
+pub fn get_solar_sources_from_compile_output(
     config: &Config,
     output: &ProjectCompileOutput,
     target_paths: Option<&[PathBuf]>,
-) -> Result<()> {
+) -> Result<SolcVersionedInput> {
     let is_solidity_file = |path: &Path| -> bool {
         path.extension().and_then(|s| s.to_str()).is_some_and(|ext| SOLC_EXTENSIONS.contains(&ext))
     };
@@ -159,6 +158,17 @@ pub fn configure_pcx_from_compile_output(
         version,
     );
 
+    Ok(solc)
+}
+
+/// Configures a [`ParsingContext`] from a [`ProjectCompileOutput`].
+pub fn configure_pcx_from_compile_output(
+    pcx: &mut ParsingContext<'_>,
+    config: &Config,
+    output: &ProjectCompileOutput,
+    target_paths: Option<&[PathBuf]>,
+) -> Result<()> {
+    let solc = get_solar_sources_from_compile_output(config, output, target_paths)?;
     configure_pcx_from_solc(pcx, &config.project_paths(), &solc, true);
     Ok(())
 }

crates/forge/src/cmd/build.rs

@@ -3,7 +3,7 @@ use clap::Parser;
 use eyre::{Context, Result};
 use forge_lint::{linter::Linter, sol::SolidityLinter};
 use foundry_cli::{
-    opts::BuildOpts,
+    opts::{BuildOpts, configure_pcx_from_solc, get_solar_sources_from_compile_output},
     utils::{LoadConfig, cache_local_signatures},
 };
 use foundry_common::{compile::ProjectCompiler, shell};
@@ -117,7 +117,6 @@ impl BuildArgs {
         if config.lint.lint_on_build && !output.output().errors.iter().any(|e| e.is_error()) {
             self.lint(&project, &config, self.paths.as_deref(), &mut output)
                 .wrap_err("Lint failed")?;
-
         }
 
         Ok(output)
@@ -175,10 +174,24 @@ impl BuildArgs {
                 })
                 .collect::<Vec<_>>();
 
-            if !input_files.is_empty() {
-                let compiler = output.parser_mut().solc_mut().compiler_mut();
-                linter.lint(&input_files, config.deny, compiler)?;
+            let solar_sources =
+                get_solar_sources_from_compile_output(config, output, Some(&input_files))?;
+            if solar_sources.input.sources.is_empty() {
+                if !input_files.is_empty() {
+                    sh_warn!(
+                        "unable to lint. Solar only supports Solidity versions prior to 0.8.0"
+                    )?;
+                }
+                return Ok(());
             }
+
+            let compiler = output.parser_mut().solc_mut().compiler_mut();
+            compiler.enter_mut(|compiler| {
+                compiler.drop_asts();
+                let mut pcx = compiler.parse();
+                configure_pcx_from_solc(&mut pcx, &config.project_paths(), &solar_sources, true);
+            });
+            linter.lint(&input_files, config.deny, compiler)?;
         }
 
         Ok(())

crates/forge/src/cmd/lint.rs

@@ -5,7 +5,7 @@ use forge_lint::{
     sol::{SolLint, SolLintError, SolidityLinter},
 };
 use foundry_cli::{
-    opts::BuildOpts,
+    opts::{BuildOpts, configure_pcx_from_solc, get_solar_sources_from_compile_output},
     utils::{FoundryPathExt, LoadConfig},
 };
 use foundry_common::{compile::ProjectCompiler, shell};
@@ -69,15 +69,15 @@ impl LintArgs {
                     } else if path.is_sol() {
                         inputs.push(path.to_path_buf());
                     } else {
-                        warn!("Cannot process path {}", path.display());
+                        warn!("cannot process path {}", path.display());
                     }
                 }
                 inputs
             }
         };
 
         if input.is_empty() {
-            sh_println!("Nothing to lint")?;
+            sh_println!("nothing to lint")?;
             return Ok(());
         }
 
@@ -95,7 +95,7 @@ impl LintArgs {
         let severity = self.severity.unwrap_or(config.lint.severity.clone());
 
         if project.compiler.solc.is_none() {
-            return Err(eyre!("Linting not supported for this language"));
+            return Err(eyre!("linting not supported for this language"));
         }
 
         let linter = SolidityLinter::new(path_config)
@@ -107,7 +107,19 @@ impl LintArgs {
             .with_mixed_case_exceptions(&config.lint.mixed_case_exceptions);
 
         let mut output = ProjectCompiler::new().files(input.iter().cloned()).compile(&project)?;
+        let solar_sources = get_solar_sources_from_compile_output(&config, &output, Some(&input))?;
+        if solar_sources.input.sources.is_empty() {
+            return Err(eyre!(
+                "unable to lint. Solar only supports Solidity versions prior to 0.8.0"
+            ));
+        }
+
         let compiler = output.parser_mut().solc_mut().compiler_mut();
+        compiler.enter_mut(|compiler| {
+            compiler.drop_asts();
+            let mut pcx = compiler.parse();
+            configure_pcx_from_solc(&mut pcx, &config.project_paths(), &solar_sources, true);
+        });
         linter.lint(&input, config.deny, compiler)?;
 
         Ok(())

crates/forge/tests/cli/lint.rs

@@ -796,23 +796,23 @@ fn ensure_no_privileged_lint_id() {
     }
 }
 
-forgetest!(build_allows_linting_for_old_solidity_versions, |prj, cmd| {
+forgetest!(skips_linting_for_old_solidity_versions, |prj, cmd| {
     prj.wipe_contracts();
-    
+
     // Add a contract with Solidity 0.7.x which has lint issues
     const OLD_CONTRACT: &str = r#"
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.7.0;
 
 contract OldContract {
     uint256 VARIABLE_MIXED_CASE_INFO;
-    
+
     function FUNCTION_MIXED_CASE_INFO() public {}
 }
 "#;
-    
+
     prj.add_source("OldContract", OLD_CONTRACT);
-    
+
     // Configure linter to show all severities
     prj.update_config(|config| {
         config.lint = LinterConfig {
@@ -823,15 +823,15 @@ contract OldContract {
             ..Default::default()
         };
     });
-    
-    // Run forge build - should NOT show linting output because version < 0.8.0
-    // Should show a warning about skipping linting
-    let output = cmd.arg("build").assert_success();
-    let stderr = String::from_utf8_lossy(&output.get_output().stderr);
-    
-    // Should contain warning about skipping linting
-    assert!(stderr.contains("mutable variables should use mixedCase"));
-    
-    // Should NOT contain any lint warnings
-    // assert!(!stderr.contains("mixed-case"));
+
+    // Run forge build - should SUCCEED without linting
+    cmd.arg("build").assert_success().stderr_eq(
+        "Warning: unable to lint. Solar only supports Solidity versions prior to 0.8.0\n",
+    );
+
+    // Run forge lint - should FAIL
+    cmd.forge_fuse()
+        .arg("lint")
+        .assert_failure()
+        .stderr_eq("Error: unable to lint. Solar only supports Solidity versions prior to 0.8.0\n");
 });

crates/lint/src/sol/mod.rs

@@ -8,6 +8,7 @@ use foundry_common::{
         inline_config::{InlineConfig, InlineConfigItem},
     },
     errors::convert_solar_errors,
+    sh_warn,
 };
 use foundry_compilers::{ProjectPathsConfig, solc::SolcLanguage};
 use foundry_config::{DenyLevel, lint::Severity};
@@ -258,7 +259,10 @@ impl<'a> Linter for SolidityLinter<'a> {
             input.par_iter().for_each(|path| {
                 let path = &self.path_config.root.join(path);
                 let Some((_, ast_source)) = gcx.get_ast_source(path) else {
-                    panic!("AST source not found for {}", path.display());
+                    // issue a warning rather than panicking, in case that some (but not all) of the
+                    // input files have old solidity versions which are not supported by solar.
+                    _ = sh_warn!("AST source not found for {}", path.display());
+                    return;
                 };
                 let Some(ast) = &ast_source.ast else {
                     panic!("AST missing for {}", path.display());