make 'isFirstVarBeforeEffects' a pure function to simplify testing.

Author: Unisay

plutus-core/plutus-core.cabal

@@ -458,7 +458,6 @@ test-suite untyped-plutus-core-test
     , hedgehog
     , lens
     , mtl
-    , multiset
     , plutus-core                      ^>=1.44
     , plutus-core:plutus-core-testlib
     , pretty-show

plutus-core/untyped-plutus-core/src/UntypedPlutusCore/Transform/Inline.hs

@@ -40,6 +40,7 @@ import Control.Monad.Reader (ReaderT (runReaderT))
 import Control.Monad.State (StateT, evalStateT, gets, modify')
 import PlutusCore qualified as PLC
 import PlutusCore.Annotation (Inline (AlwaysInline, SafeToInline), InlineHints (..))
+import PlutusCore.Builtin (ToBuiltinMeaning (BuiltinSemanticsVariant))
 import PlutusCore.Builtin qualified as PLC
 import PlutusCore.MkPlc (mkIterApp)
 import PlutusCore.Name.Unique (HasUnique, TermUnique (..), Unique (..))
@@ -399,16 +400,16 @@ nameUsedAtMostOnce n = do
 isFirstVarBeforeEffects
   :: forall name uni fun ann
    . (InliningConstraints name uni fun)
-  => name
+  => BuiltinSemanticsVariant fun
+  -> name
   -> Term name uni fun ann
-  -> InlineM name uni fun ann Bool
-isFirstVarBeforeEffects n t = do
-  builtinSemanticsVariant <- view iiBuiltinSemanticsVariant
+  -> Bool
+isFirstVarBeforeEffects builtinSemanticsVariant n t =
   -- This can in the worst case traverse a lot of the term, which could lead to
   -- us doing ~quadratic work as we process the program. However in practice
   -- most terms have a relatively short evaluation order before we hit Unknown,
   -- so it's not too bad.
-  pure $ go (unEvalOrder (termEvaluationOrder builtinSemanticsVariant t))
+  go (unEvalOrder (termEvaluationOrder builtinSemanticsVariant t))
  where
   -- Found the variable we're looking for!
   go ((EvalTerm _ _ (Var _ n')) : _) | n == n' = True
@@ -471,7 +472,8 @@ effectSafe
   -- ^ is it pure?
   -> InlineM name uni fun a Bool
 effectSafe body n purity = do
-  immediatelyEvaluated <- isFirstVarBeforeEffects n body
+  builtinSemantics <- view iiBuiltinSemanticsVariant
+  let immediatelyEvaluated = isFirstVarBeforeEffects builtinSemantics n body
   pure $ purity || immediatelyEvaluated
 
 {-| Should we inline? Should only inline things that won't duplicate work

plutus-core/untyped-plutus-core/test/Transform/Inline/Spec.hs

@@ -1,35 +1,25 @@
 {-# LANGUAGE BlockArguments      #-}
-{-# LANGUAGE NumericUnderscores  #-}
 {-# LANGUAGE OverloadedStrings   #-}
 {-# LANGUAGE ScopedTypeVariables #-}
 
 module Transform.Inline.Spec where
 
-import Control.Monad.Reader (runReaderT)
-import Control.Monad.State (runStateT)
 import Data.Maybe (fromMaybe, isNothing)
-import Data.MultiSet qualified as MultiSet
-import PlutusCore.Annotation (Inline (MayInline))
-import PlutusCore.Quote (runQuote)
-import PlutusCore.Size (Size (..))
 import PlutusPrelude (def)
 import Test.Tasty (TestTree, testGroup)
 import Test.Tasty.HUnit (Assertion, assertBool, testCase)
 import UntypedPlutusCore (DefaultFun, DefaultUni, Name (..), Term (..))
 import UntypedPlutusCore.Test.Term.Construction (addInteger, app, case_, delay, lam, uniqueNames3,
                                                  uniqueNames4, var)
-import UntypedPlutusCore.Transform.Inline (InlineHints (InlineHints), InlineInfo (..), InlineM,
-                                           S (..), Subst (Subst), TermEnv (TermEnv),
-                                           isFirstVarBeforeEffects, isVarDelayed)
-
---------------------------------------------------------------------------------
--- Tests -----------------------------------------------------------------------
+import UntypedPlutusCore.Transform.Inline (isFirstVarBeforeEffects, isVarDelayed)
 
 test_inline :: TestTree
 test_inline =
   testGroup
     "Inline"
-    [ testCase "var is before or after effects" testVarBeforeAfterEffects
+    [ testCase
+        "var is before or after effects"
+        testVarBeforeAfterEffects
     , testGroup
         "isVarDelayed"
         [ testCase
@@ -47,11 +37,11 @@ test_inline =
 testVarBeforeAfterEffects :: Assertion
 testVarBeforeAfterEffects = do
   assertBool "a is evaluated before effects" do
-    testFirstVarBeforeEffects a term
+    isFirstVarBeforeEffects def a term
   assertBool "b is evaluated before effects" do
-    testFirstVarBeforeEffects b term
+    isFirstVarBeforeEffects def b term
   assertBool "c is not evaluated after effects" $ not do
-    testFirstVarBeforeEffects c term
+    isFirstVarBeforeEffects def c term
  where
   term :: Term Name DefaultUni DefaultFun ()
   term =
@@ -107,28 +97,3 @@ testVarIsDelayedInCaseBranch = do
   term = case_ (var b) [var a, var c]
 
   (a, b, c, d) = uniqueNames4 "a" "b" "c" "d"
-
---------------------------------------------------------------------------------
--- Helper functions: -----------------------------------------------------------
-
-testFirstVarBeforeEffects :: Name -> Term Name DefaultUni DefaultFun () -> Bool
-testFirstVarBeforeEffects name = runInlineM . isFirstVarBeforeEffects name
-
-runInlineM :: InlineM Name DefaultUni DefaultFun () r -> r
-runInlineM m = result
- where
-  (result, _finalState) =
-    runQuote (runStateT (runReaderT m inlineInfo) initialState)
-
-  inlineInfo :: InlineInfo Name DefaultFun ()
-  inlineInfo =
-    InlineInfo
-      { _iiUsages = MultiSet.empty
-      , _iiHints = InlineHints \_ann _name -> MayInline
-      , _iiBuiltinSemanticsVariant = def
-      , _iiInlineConstants = True
-      , _iiInlineCallsiteGrowth = Size 1_000_000
-      }
-
-  initialState :: S Name DefaultUni DefaultFun ()
-  initialState = S{_subst = Subst (TermEnv mempty), _vars = mempty}