Use OPAQUE pragma on stringToBuiltinByteString and stringToBuiltinStr…

…ing (#6501)

plutus-tx-plugin/src/PlutusTx/Compiler/Expr.hs

@@ -419,7 +419,7 @@ This is very fiddly:
 - Sometimes the selector has been inlined.
  - We can't easily get access to the name of the method definition itself, so instead we mark
  that as INLINE and look for a special function ('stringToBuiltinString') that is in its
- body (which we put inside 'noinline', see Note [noinline hack]).
+ body (and we use the OPAQUE pragma on that function to ensure it isn't inlined).
 - Sometimes our heuristics fail.
  - The actual definition of 'stringToBuiltinString' works, so in the worst case we fall back
  to using it and converting the list of characters into an expression.
@@ -751,11 +751,11 @@ compileExpr e = traceCompilation 2 ("Compiling expr:" GHC.<+> GHC.ppr e) $ do
  Nothing ->
  throwSd UnsupportedError $
  "Use of fromString on type other than builtin strings or bytestrings:" GHC.<+> GHC.ppr ty
- -- 'stringToBuiltinByteString' invocation, will be wrapped in a 'noinline'
+ -- 'stringToBuiltinByteString' invocation
  (strip -> GHC.Var n) `GHC.App` (strip -> stringExprContent -> Just bs)
  | GHC.getName n == sbbsName ->
  pure $ PIR.Constant annMayInline $ PLC.someValue bs
- -- 'stringToBuiltinString' invocation, will be wrapped in a 'noinline'
+ -- 'stringToBuiltinString' invocation
  (strip -> GHC.Var n) `GHC.App` (strip -> stringExprContent -> Just bs) | GHC.getName n == sbsName ->
  case TE.decodeUtf8' bs of
  Right t -> pure $ PIR.Constant annMayInline $ PLC.someValue t
@@ -785,7 +785,7 @@ compileExpr e = traceCompilation 2 ("Compiling expr:" GHC.<+> GHC.ppr e) $ do
  -- Unboxed unit, (##).
  GHC.Var (GHC.idDetails -> GHC.DataConWorkId dc) | dc == GHC.unboxedUnitDataCon -> pure (PIR.mkConstant annMayInline ())
  -- Ignore the magic 'noinline' function, it's the identity but has no unfolding.
- -- See Note [noinline hack]
+ -- See Note [GHC.Magic.noinline]
  GHC.Var n `GHC.App` GHC.Type _ `GHC.App` arg | GHC.getName n == GHC.noinlineIdName -> compileExpr arg
  -- See Note [GHC runtime errors]
  -- <error func> <runtime rep> <overall type> <call stack> <message>

plutus-tx/plutus-tx.cabal

@@ -128,7 +128,6 @@ library
  , deriving-compat
  , extra
  , flat ^>=0.6
- , ghc-prim
  , hashable
  , lens
  , memory

plutus-tx/src/PlutusTx/Builtins/HasOpaque.hs

@@ -2,7 +2,6 @@
 {-# LANGUAGE DefaultSignatures #-}
 {-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE FunctionalDependencies #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE StandaloneKindSignatures #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE TypeOperators #-}
@@ -21,14 +20,13 @@ import PlutusTx.Builtins.Internal
 import Data.Kind qualified as GHC
 import Data.String (IsString (..))
 import Data.Text qualified as Text
-import GHC.Magic qualified as Magic
 import Prelude qualified as Haskell (String)
 #if MIN_VERSION_base(4,20,0)
 import Prelude (type (~))
 #endif
 
 
-{- Note [noinline hack]
+{- Note [GHC.Magic.noinline]
 For some functions we have two conflicting desires:
 - We want to have the unfolding available for the plugin.
 - We don't want the function to *actually* get inlined before the plugin runs, since we rely
@@ -42,42 +40,28 @@ that function is compiled later into the body of another function.
 
 We do therefore need to handle 'noinline' in the plugin, as it itself does not have
 an unfolding.
-
-Another annoying quirk: even if you have 'noinline'd a function call, if the body is
-a single variable, it will still inline! This is the case for the obvious definition
-of 'stringToBuiltinString' (since the newtype constructor vanishes), so we have to add
-some obfuscation to the body to prevent it inlining.
 -}
 
-obfuscatedId :: a -> a
-obfuscatedId a = a
-{-# NOINLINE obfuscatedId #-}
-
 stringToBuiltinByteString :: Haskell.String -> BuiltinByteString
 stringToBuiltinByteString str = encodeUtf8 $ stringToBuiltinString str
-{-# INLINABLE stringToBuiltinByteString #-}
+{-# OPAQUE stringToBuiltinByteString #-}
 
 stringToBuiltinString :: Haskell.String -> BuiltinString
--- To explain why the obfuscatedId is here
--- See Note [noinline hack]
-stringToBuiltinString str = obfuscatedId (BuiltinString $ Text.pack str)
-{-# INLINABLE stringToBuiltinString #-}
+stringToBuiltinString str = BuiltinString (Text.pack str)
+{-# OPAQUE stringToBuiltinString #-}
 
-{- Same noinline hack as with `String` type. -}
 instance IsString BuiltinByteString where
  -- Try and make sure the dictionary selector goes away, it's simpler to match on
  -- the application of 'stringToBuiltinByteString'
- -- See Note [noinline hack]
- fromString = Magic.noinline stringToBuiltinByteString
+ fromString = stringToBuiltinByteString
  {-# INLINE fromString #-}
 
 -- We can't put this in `Builtins.hs`, since that force `O0` deliberately, which prevents
 -- the unfoldings from going in. So we just stick it here. Fiddly.
 instance IsString BuiltinString where
  -- Try and make sure the dictionary selector goes away, it's simpler to match on
  -- the application of 'stringToBuiltinString'
- -- See Note [noinline hack]
- fromString = Magic.noinline stringToBuiltinString
+ fromString = stringToBuiltinString
  {-# INLINE fromString #-}
 
 {- Note [Built-in types and their Haskell counterparts]