resolc 1.1.0

Solidity frontend for the revive compiler
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

//! The Solidity compiler solJson interface.

use std::collections::HashSet;
use std::path::PathBuf;

use revive_common::deserialize_from_slice;
use revive_solc_json_interface::combined_json::CombinedJson;
use revive_solc_json_interface::CombinedJsonSelector;
use revive_solc_json_interface::SolcStandardJsonInput;
use revive_solc_json_interface::SolcStandardJsonOutput;
use revive_solc_json_interface::SolcStandardJsonOutputError;

use crate::solc::version::Version;
use anyhow::Context;
use std::ffi::{c_char, c_void, CStr, CString};

use super::Compiler;

extern "C" {
    fn soljson_version() -> *const c_char;
    fn soljson_compile(inputPtr: *const c_char, inputLen: usize) -> *const c_char;
}

/// The Solidity compiler.
pub struct SoljsonCompiler;

impl Compiler for SoljsonCompiler {
    /// Compiles the Solidity `--standard-json` input into Yul IR.
    fn standard_json(
        &self,
        input: &mut SolcStandardJsonInput,
        messages: &mut Vec<SolcStandardJsonOutputError>,
        base_path: Option<String>,
        include_paths: Vec<String>,
        allow_paths: Option<String>,
    ) -> anyhow::Result<SolcStandardJsonOutput> {
        if !include_paths.is_empty() {
            anyhow::bail!("configuring include paths is not supported with solJson")
        }
        if base_path.is_some() {
            anyhow::bail!("configuring the base path is not supported with solJson")
        }
        if allow_paths.is_some() {
            anyhow::bail!("configuring allow paths is not supported with solJson")
        }

        let input_json = serde_json::to_string(&input).expect("Always valid");
        let out = Self::compile_standard_json(input_json)?;
        let mut output: SolcStandardJsonOutput =
            deserialize_from_slice(out.as_bytes()).map_err(|error| {
                anyhow::anyhow!(
                    "Soljson output parsing error: {}\n{}",
                    error,
                    deserialize_from_slice::<serde_json::Value>(out.as_bytes())
                        .map(|json| serde_json::to_string_pretty(&json).expect("Always valid"))
                        .unwrap_or_else(|_| String::from_utf8_lossy(out.as_bytes()).to_string()),
                )
            })?;
        output
            .errors
            .retain(|error| match error.error_code.as_deref() {
                Some(code) => !SolcStandardJsonOutputError::IGNORED_WARNING_CODES.contains(&code),
                None => true,
            });
        output.errors.append(messages);

        let mut suppressed_warnings = input.suppressed_warnings.clone();
        suppressed_warnings.extend_from_slice(input.settings.suppressed_warnings.as_slice());

        input.resolve_sources();
        output.preprocess_ast(&input.sources, &suppressed_warnings)?;

        Ok(output)
    }

    fn combined_json(
        &self,
        _paths: &[PathBuf],
        _selector: HashSet<CombinedJsonSelector>,
    ) -> anyhow::Result<CombinedJson> {
        unimplemented!();
    }

    fn version(&self) -> anyhow::Result<Version> {
        let version = Self::get_soljson_version()?;
        let long = version.clone();
        let default: semver::Version = version
            .split('+')
            .next()
            .ok_or_else(|| anyhow::anyhow!("Soljson version parsing: metadata dropping"))?
            .parse()
            .map_err(|error| anyhow::anyhow!("Soljson version parsing: {}", error))?;
        Version::new(long, default).validate()
    }
}

impl SoljsonCompiler {
    fn get_soljson_version() -> anyhow::Result<String> {
        unsafe {
            let version_ptr = soljson_version();
            let version = CStr::from_ptr(version_ptr)
                .to_str()
                .with_context(|| "Failed to convert C string to Rust string")
                .map(str::to_owned);
            libc::free(version_ptr as *mut c_void);
            Ok(version?)
        }
    }

    fn compile_standard_json(input: String) -> anyhow::Result<String> {
        let c_input = CString::new(input).unwrap();
        let c_input_len = c_input.as_bytes().len();

        unsafe {
            let output_ptr = soljson_compile(c_input.as_ptr(), c_input_len);
            let output_json = CStr::from_ptr(output_ptr)
                .to_str()
                .with_context(|| "Failed to convert C string to Rust string")
                .map(str::to_owned);
            libc::free(output_ptr as *mut c_void);
            Ok(output_json?)
        }
    }
}