chore: bump ethers and solang-parser (foundry-rs#5725)

Cargo.toml

@@ -139,7 +139,7 @@ ethers-solc = { git = "https://github.com/gakonst/ethers-rs", default-features =
 chrono = { version = "0.4", default-features = false, features = ["clock", "std"] }
 hex = { package = "const-hex", version = "1.6", features = ["hex"] }
 itertools = "0.11"
-solang-parser = "=0.3.1"
+solang-parser = "=0.3.2"
 
 #[patch."https://github.com/gakonst/ethers-rs"]
 #ethers = { path = "../ethers-rs/ethers" }

crates/chisel/src/session_source.rs

@@ -513,7 +513,11 @@ contract {} {{
                         pt::Import::Plain(s, _) |
                         pt::Import::Rename(s, _, _) |
                         pt::Import::GlobalSymbol(s, _, _) => {
-                            let path = PathBuf::from(s.string);
+                            let s = match s {
+                                pt::ImportPath::Filename(s) => s.string.clone(),
+                                pt::ImportPath::Path(p) => p.to_string(),
+                            };
+                            let path = PathBuf::from(s);
 
                             match fs::read_to_string(path) {
                                 Ok(source) => {

crates/fmt/src/formatter.rs

@@ -6,6 +6,7 @@ use crate::{
     comments::{
         CommentPosition, CommentState, CommentStringExt, CommentType, CommentWithMetadata, Comments,
     },
+    helpers::import_path_string,
     macros::*,
     solang_ext::{pt::*, *},
     string::{QuoteState, QuotedStringExt},
@@ -15,6 +16,7 @@ use crate::{
 use ethers_core::{types::H160, utils::to_checksum};
 use foundry_config::fmt::{MultilineFuncHeaderStyle, SingleLineBlockStyle};
 use itertools::{Either, Itertools};
+use solang_parser::pt::ImportPath;
 use std::{fmt::Write, str::FromStr};
 use thiserror::Error;
 
@@ -1810,12 +1812,12 @@ impl<'a, W: Write> Visitor for Formatter<'a, W> {
     }
 
     #[instrument(name = "import_plain", skip_all)]
-    fn visit_import_plain(&mut self, loc: Loc, import: &mut StringLiteral) -> Result<()> {
+    fn visit_import_plain(&mut self, loc: Loc, import: &mut ImportPath) -> Result<()> {
         return_source_if_disabled!(self, loc, ';');
 
         self.grouped(|fmt| {
-            write_chunk!(fmt, loc.start(), import.loc.start(), "import")?;
-            fmt.write_quoted_str(import.loc, None, &import.string)?;
+            write_chunk!(fmt, loc.start(), import.loc().start(), "import")?;
+            fmt.write_quoted_str(import.loc(), None, &import_path_string(import))?;
             fmt.write_semicolon()?;
             Ok(())
         })?;
@@ -1826,14 +1828,14 @@ impl<'a, W: Write> Visitor for Formatter<'a, W> {
     fn visit_import_global(
         &mut self,
         loc: Loc,
-        global: &mut StringLiteral,
+        global: &mut ImportPath,
         alias: &mut Identifier,
     ) -> Result<()> {
         return_source_if_disabled!(self, loc, ';');
 
         self.grouped(|fmt| {
-            write_chunk!(fmt, loc.start(), global.loc.start(), "import")?;
-            fmt.write_quoted_str(global.loc, None, &global.string)?;
+            write_chunk!(fmt, loc.start(), global.loc().start(), "import")?;
+            fmt.write_quoted_str(global.loc(), None, &import_path_string(global))?;
             write_chunk!(fmt, loc.start(), alias.loc.start(), "as")?;
             alias.visit(fmt)?;
             fmt.write_semicolon()?;
@@ -1847,16 +1849,16 @@ impl<'a, W: Write> Visitor for Formatter<'a, W> {
         &mut self,
         loc: Loc,
         imports: &mut [(Identifier, Option<Identifier>)],
-        from: &mut StringLiteral,
+        from: &mut ImportPath,
     ) -> Result<()> {
         return_source_if_disabled!(self, loc, ';');
 
         if imports.is_empty() {
             self.grouped(|fmt| {
                 write_chunk!(fmt, loc.start(), "import")?;
                 fmt.write_empty_brackets()?;
-                write_chunk!(fmt, loc.start(), from.loc.start(), "from")?;
-                fmt.write_quoted_str(from.loc, None, &from.string)?;
+                write_chunk!(fmt, loc.start(), from.loc().start(), "from")?;
+                fmt.write_quoted_str(from.loc(), None, &import_path_string(from))?;
                 fmt.write_semicolon()?;
                 Ok(())
             })?;
@@ -1869,7 +1871,7 @@ impl<'a, W: Write> Visitor for Formatter<'a, W> {
 
         self.surrounded(
             SurroundingChunk::new("{", Some(imports_start), None),
-            SurroundingChunk::new("}", None, Some(from.loc.start())),
+            SurroundingChunk::new("}", None, Some(from.loc().start())),
             |fmt, _multiline| {
                 let mut imports = imports.iter_mut().peekable();
                 let mut import_chunks = Vec::new();
@@ -1892,7 +1894,7 @@ impl<'a, W: Write> Visitor for Formatter<'a, W> {
                 }
 
                 let multiline = fmt.are_chunks_separated_multiline(
-                    &format!("{{}} }} from \"{}\";", from.string),
+                    &format!("{{}} }} from \"{}\";", import_path_string(from)),
                     &import_chunks,
                     ",",
                 )?;
@@ -1902,8 +1904,8 @@ impl<'a, W: Write> Visitor for Formatter<'a, W> {
         )?;
 
         self.grouped(|fmt| {
-            write_chunk!(fmt, imports_start, from.loc.start(), "from")?;
-            fmt.write_quoted_str(from.loc, None, &from.string)?;
+            write_chunk!(fmt, imports_start, from.loc().start(), "from")?;
+            fmt.write_quoted_str(from.loc(), None, &import_path_string(from))?;
             fmt.write_semicolon()?;
             Ok(())
         })?;

crates/fmt/src/helpers.rs

@@ -98,3 +98,10 @@ pub fn print_diagnostics_report(
     }
     Ok(())
 }
+
+pub fn import_path_string(path: &ImportPath) -> String {
+    match path {
+        ImportPath::Filename(s) => s.string.clone(),
+        ImportPath::Path(p) => p.to_string(),
+    }
+}

crates/fmt/src/solang_ext/ast_eq.rs

@@ -629,6 +629,12 @@ derive_ast_eq! { enum SourceUnitPart {
     Annotation(annotation),
     _
 }}
+derive_ast_eq! { enum ImportPath {
+    _
+    Filename(lit),
+    Path(path),
+    _
+}}
 derive_ast_eq! { enum Import {
     _
     Plain(string, loc),

crates/fmt/src/solang_ext/loc.rs

@@ -81,6 +81,15 @@ impl CodeLocationExt for pt::SourceUnitPart {
     }
 }
 
+impl CodeLocationExt for pt::ImportPath {
+    fn loc(&self) -> pt::Loc {
+        match self {
+            Self::Filename(s) => s.loc(),
+            Self::Path(i) => i.loc(),
+        }
+    }
+}
+
 macro_rules! impl_delegate {
     ($($t:ty),+ $(,)?) => {$(
         impl CodeLocationExt for $t {

crates/fmt/src/solang_ext/mod.rs

@@ -10,12 +10,12 @@ pub mod pt {
         Annotation, Base, CatchClause, Comment, ContractDefinition, ContractPart, ContractTy,
         EnumDefinition, ErrorDefinition, ErrorParameter, EventDefinition, EventParameter,
         Expression, FunctionAttribute, FunctionDefinition, FunctionTy, HexLiteral, Identifier,
-        IdentifierPath, Import, Loc, Mutability, NamedArgument, OptionalCodeLocation, Parameter,
-        ParameterList, SourceUnit, SourceUnitPart, Statement, StorageLocation, StringLiteral,
-        StructDefinition, Type, TypeDefinition, UserDefinedOperator, Using, UsingFunction,
-        UsingList, VariableAttribute, VariableDeclaration, VariableDefinition, Visibility,
-        YulBlock, YulExpression, YulFor, YulFunctionCall, YulFunctionDefinition, YulStatement,
-        YulSwitch, YulSwitchOptions, YulTypedIdentifier,
+        IdentifierPath, Import, ImportPath, Loc, Mutability, NamedArgument, OptionalCodeLocation,
+        Parameter, ParameterList, SourceUnit, SourceUnitPart, Statement, StorageLocation,
+        StringLiteral, StructDefinition, Type, TypeDefinition, UserDefinedOperator, Using,
+        UsingFunction, UsingList, VariableAttribute, VariableDeclaration, VariableDefinition,
+        Visibility, YulBlock, YulExpression, YulFor, YulFunctionCall, YulFunctionDefinition,
+        YulStatement, YulSwitch, YulSwitchOptions, YulTypedIdentifier,
     };
 }
 

crates/fmt/src/visit.rs

@@ -37,15 +37,15 @@ pub trait Visitor {
     fn visit_import_plain(
         &mut self,
         _loc: Loc,
-        _import: &mut StringLiteral,
+        _import: &mut ImportPath,
     ) -> Result<(), Self::Error> {
         Ok(())
     }
 
     fn visit_import_global(
         &mut self,
         _loc: Loc,
-        _global: &mut StringLiteral,
+        _global: &mut ImportPath,
         _alias: &mut Identifier,
     ) -> Result<(), Self::Error> {
         Ok(())
@@ -55,7 +55,7 @@ pub trait Visitor {
         &mut self,
         _loc: Loc,
         _imports: &mut [(Identifier, Option<Identifier>)],
-        _from: &mut StringLiteral,
+        _from: &mut ImportPath,
     ) -> Result<(), Self::Error> {
         Ok(())
     }