Test: Fix processing of yul object files in equivalence checking

The code was already trying to handle yul files with named object
format, however, the logic was not correct and we ended up trying to
compile empty input, which resulted in error.

There are several fixes:
- `onlyAfter` now returns only lines *after* the matched line.
  Previously, the matched line was returned as well.
- The regex used to check if we have `object` line in the file now no
  longer contains quotes. Previously, this regex never matched because
  of this quotes.
- We now extract the object name in case of an object format. This is
  necessary to pass to the `yul` function. Previously, we always passed
  empty string. However, in case of named objects, the key in json is
  the object name.

Author: blishko

test/EVM/Equivalence/EquivalenceTests.hs

@@ -1,4 +1,5 @@
 {-# LANGUAGE QuasiQuotes #-}
+{-# OPTIONS_GHC -Wno-x-partial #-}
 
 module EVM.Equivalence.EquivalenceTests (tests) where
 
@@ -19,7 +20,7 @@ import Test.Tasty
 import Test.Tasty.ExpectedFailure (ignoreTest)
 import Test.Tasty.HUnit
 import Text.RE.TDFA.String hiding (matches)
-import Text.RE.Replace (replaceAll)
+import Text.RE.Replace (replaceAll, captureText, CaptureOrdinal(..), CaptureID(..))
 
 
 import EVM.Effects qualified as Effects
@@ -492,12 +493,6 @@ yulOptimizationsSolcTests = testCase "eq-all-yul-optimization-tests" $ do
                     , "loadResolver/zero_length_reads_eof.yul"
                     -- Yul subobjects
                     , "fullSuite/sub_objects.yul"
-                    -- Parser errors
-                    , "commonSubexpressionEliminator/long_literals_as_builtin_args.yul"
-                    , "commonSubexpressionEliminator/object_access.yul"
-                    , "disambiguator/string_as_hex_and_hex_as_string.yul"
-                    , "expressionSplitter/object_access.yul"
-                    , "equivalentFunctionCombiner/constant_representation_datasize.yul"
                     ]
 
         solcRepo <- fromMaybe (internalError "cannot find solidity repo") <$> (lookupEnv "HEVM_SOLIDITY_REPO")
@@ -511,7 +506,7 @@ yulOptimizationsSolcTests = testCase "eq-all-yul-optimization-tests" $ do
         forM_ filesFiltered (\f-> do
           origcont <- readFile f
           let
-            onlyAfter pattern (a:ax) = if a =~ pattern then (a:ax) else onlyAfter pattern ax
+            onlyAfter pattern (a:ax) = if a =~ pattern then ax else onlyAfter pattern ax
             onlyAfter _ [] = []
             replaceOnce pat repl inp = go inp [] where
               go (a:ax) b = if a =~ pat then let a2 = replaceAll repl $ a *=~ pat in b ++ a2:ax
@@ -522,15 +517,25 @@ yulOptimizationsSolcTests = testCase "eq-all-yul-optimization-tests" $ do
             -- `calldatacopy(0,0,1024)`. (calldata is symbolic, but memory starts empty).
             -- This forces the exploration of more branches, and makes the test vectors a
             -- little more thorough.
-            symbolicMem (a:ax) = if a =~ [re|"^ *object"|] then
-                                      let a2 = replaceAll "a calldatacopy(0,0,1024)" $ a *=~ [re|code {|]
-                                      in (a2:ax)
-                                    else replaceOnce [re|^ *{|] "{\ncalldatacopy(0,0,1024)" $ onlyAfter [re|^ *{|] (a:ax)
+            symbolicMem program@(a:_) = if a =~ [re|^ *object|] then
+                                      let replacementTemplate = "$0\n    calldatacopy(0,0,1024)"
+                                          replaced = replaceAll replacementTemplate $ (unlines program) *=~ [re|code {|]
+                                      in lines replaced
+                                    else replaceOnce [re|^ *{|] "{\ncalldatacopy(0,0,1024)" program
             symbolicMem _ = internalError "Program too short"
 
             unfiltered = lines origcont
             filteredASym = symbolicMem [ x | x <- unfiltered, (not $ x =~ [re|^//|]) && (not $ x =~ [re|^$|]) ]
-            filteredBSym = symbolicMem [ replaceAll "" $ x *=~[re|^//|] | x <- onlyAfter [re|^// step:|] unfiltered, not $ x =~ [re|^$|] ]
+            filteredBSym = symbolicMem [ cleaned | x <- onlyAfter [re|^// step:|] unfiltered
+                                        , let cleaned = replaceAll "" $ x *=~[re|^//|]
+                                        , not $ null cleaned
+                                       ]
+            contractName = let
+               match = head filteredASym ?=~ [re|^ *object +"([^"]+)"|]
+               success = captureText (IsCaptureOrdinal $ CaptureOrdinal 1) match
+             in T.pack $ case matched match of
+                  False -> ""
+                  True-> success
           start <- getCurrentTime
           let verbosity :: Int = 0
           when (verbosity > 0) $ putStrLn $ "Checking file: " <> f
@@ -542,8 +547,8 @@ yulOptimizationsSolcTests = testCase "eq-all-yul-optimization-tests" $ do
             putStrLn "------------- Filtered B + Symb below-----------------"
             mapM_ putStrLn filteredBSym
             putStrLn "------------- END -----------------"
-          Right aPrgm <- yul "" $ T.pack $ unlines filteredASym
-          Right bPrgm <- yul "" $ T.pack $ unlines filteredBSym
+          Right aPrgm <- yul contractName $ T.pack $ unlines filteredASym
+          Right bPrgm <- yul contractName $ T.pack $ unlines filteredBSym
           eq <- Effects.runApp $ withSolvers Bitwuzla 1 (Just 100) defMemLimit $ \s -> do
             calldata <- mkCalldata Nothing []
             equivalenceCheck s Nothing aPrgm bPrgm opts calldata False