PLT-1552: Better support for Plutus Core language versions (#5150)

* Rename defaultVersion to latestVersion

* Add some more support for versions

* Move Version Pretty instance to its module

* Fixup applyProgram

* Update plutus-ledger-api, update language for CIP-35

* Add version to PIR programs

* Changelogs

* Address some comments

* Fixup plutus-core

* Make applyProgram return a Maybe

* More changelog

* Comment

Author: michaelpj

doc/read-the-docs-site/tutorials/AuctionValidator.hs

@@ -193,5 +193,5 @@ auctionValidatorScript ::
   CompiledCode (BuiltinData -> BuiltinData -> BuiltinData -> ())
 auctionValidatorScript params =
   $$(PlutusTx.compile [||auctionUntypedValidator||])
-    `PlutusTx.applyCode` PlutusTx.liftCode params
+    `PlutusTx.unsafeApplyCode` PlutusTx.liftCode params
 -- BLOCK9

doc/read-the-docs-site/tutorials/BasicPlutusTx.hs

@@ -116,8 +116,8 @@ addOne = $$(compile [|| \(x:: Integer) -> x `addInteger` 1 ||])
 addOneToN :: Integer -> CompiledCode Integer
 addOneToN n =
     addOne
-    -- 'applyCode' applies one 'CompiledCode' to another.
-    `applyCode`
+    -- 'unsafeApplyCode' applies one 'CompiledCode' to another.
+    `unsafeApplyCode`
     -- 'liftCode' lifts the argument 'n' into a
     -- 'CompiledCode Integer'.
     liftCode n
@@ -167,9 +167,9 @@ makeLift ''EndDate
 pastEndAt :: EndDate -> Integer -> CompiledCode Bool
 pastEndAt end current =
     pastEnd
-    `applyCode`
+    `unsafeApplyCode`
     liftCode end
-    `applyCode`
+    `unsafeApplyCode`
     liftCode current
 
 {- |

plutus-benchmark/cek-calibration/Main.hs

@@ -68,7 +68,7 @@ go n = zipl (mkList n) (rev $ mkList n)
 
 
 mkListProg :: Integer -> UPLC.Program NamedDeBruijn DefaultUni DefaultFun ()
-mkListProg n = Tx.getPlcNoAnn $ $$(Tx.compile [|| go ||]) `Tx.applyCode` Tx.liftCode n
+mkListProg n = Tx.getPlcNoAnn $ $$(Tx.compile [|| go ||]) `Tx.unsafeApplyCode` Tx.liftCode n
 
 mkListTerm :: Integer -> UPLC.Term NamedDeBruijn DefaultUni DefaultFun ()
 mkListTerm n =

plutus-benchmark/ed25519-throughput/Main.hs

@@ -170,7 +170,7 @@ verifyInputs hash d =
 -- verification script to that.
 mkSigCheckScript :: Integer -> UProg
 mkSigCheckScript n =
-    Tx.getPlcNoAnn $ $$(Tx.compile [|| verifyInputs builtinHash ||]) `Tx.applyCode` Tx.liftCode (mkInputsAsData n haskellHash)
+    Tx.getPlcNoAnn $ $$(Tx.compile [|| verifyInputs builtinHash ||]) `Tx.unsafeApplyCode` Tx.liftCode (mkInputsAsData n haskellHash)
 
 -- Printing utilities
 percentage :: (Integral a, Integral b) => a -> b -> Double

plutus-benchmark/lists/src/PlutusBenchmark/Lists/Sort/GhcSort.hs

@@ -72,7 +72,7 @@ ghcSortWorstCase = mergeSortWorstCase
 
 mkGhcSortTerm :: [Integer] -> Term
 mkGhcSortTerm l =
-    compiledCodeToTerm $ $$(Tx.compile [|| ghcSort ||]) `Tx.applyCode` Tx.liftCode l
+    compiledCodeToTerm $ $$(Tx.compile [|| ghcSort ||]) `Tx.unsafeApplyCode` Tx.liftCode l
 
 mkWorstCaseGhcSortTerm :: Integer -> Term
 mkWorstCaseGhcSortTerm = mkGhcSortTerm . ghcSortWorstCase

plutus-benchmark/lists/src/PlutusBenchmark/Lists/Sort/InsertionSort.hs

@@ -29,7 +29,7 @@ insertionSortWorstCase n = [1..n]
 
 mkInsertionSortTerm :: [Integer] -> Term
 mkInsertionSortTerm l =
-    compiledCodeToTerm $ $$(Tx.compile [|| insertionSort ||]) `Tx.applyCode` Tx.liftCode l
+    compiledCodeToTerm $ $$(Tx.compile [|| insertionSort ||]) `Tx.unsafeApplyCode` Tx.liftCode l
 
 mkWorstCaseInsertionSortTerm :: Integer -> Term
 mkWorstCaseInsertionSortTerm = mkInsertionSortTerm . insertionSortWorstCase

plutus-benchmark/lists/src/PlutusBenchmark/Lists/Sort/MergeSort.hs

@@ -50,7 +50,7 @@ mergeSortWorstCase n = f [1..n]
 
 mkMergeSortTerm :: [Integer] -> Term
 mkMergeSortTerm l =
-    compiledCodeToTerm $ $$(Tx.compile [|| mergeSort ||]) `Tx.applyCode` Tx.liftCode l
+    compiledCodeToTerm $ $$(Tx.compile [|| mergeSort ||]) `Tx.unsafeApplyCode` Tx.liftCode l
 
 mkWorstCaseMergeSortTerm :: Integer -> Term
 mkWorstCaseMergeSortTerm = mkMergeSortTerm . mergeSortWorstCase

plutus-benchmark/lists/src/PlutusBenchmark/Lists/Sort/QuickSort.hs

@@ -34,7 +34,7 @@ quickSortWorstCase n = reverse [1..n]
 
 mkQuickSortTerm :: [Integer] -> Term
 mkQuickSortTerm l =
-    compiledCodeToTerm $ $$(Tx.compile [|| quickSort ||]) `Tx.applyCode` Tx.liftCode l
+    compiledCodeToTerm $ $$(Tx.compile [|| quickSort ||]) `Tx.unsafeApplyCode` Tx.liftCode l
 
 mkWorstCaseQuickSortTerm :: Integer -> Term
 mkWorstCaseQuickSortTerm = mkQuickSortTerm . quickSortWorstCase

plutus-benchmark/lists/src/PlutusBenchmark/Lists/Sum/Compiled.hs

@@ -37,13 +37,13 @@ sumRightScott l = foldRightScott (+) 0 l
 -- Compiling to PLC terms
 
 mkSumLeftScottCode :: [Integer] -> Tx.CompiledCode Integer
-mkSumLeftScottCode l = $$(Tx.compile [|| sumLeftScott ||]) `Tx.applyCode` Tx.liftCode l
+mkSumLeftScottCode l = $$(Tx.compile [|| sumLeftScott ||]) `Tx.unsafeApplyCode` Tx.liftCode l
 
 mkSumLeftScottTerm  :: [Integer] -> Term
 mkSumLeftScottTerm l = compiledCodeToTerm $ mkSumLeftScottCode l
 
 mkSumRightScottCode :: [Integer] -> Tx.CompiledCode Integer
-mkSumRightScottCode l = $$(Tx.compile [|| sumRightScott ||]) `Tx.applyCode` Tx.liftCode l
+mkSumRightScottCode l = $$(Tx.compile [|| sumRightScott ||]) `Tx.unsafeApplyCode` Tx.liftCode l
 
 mkSumRightScottTerm :: [Integer] -> Term
 mkSumRightScottTerm l = compiledCodeToTerm $ mkSumRightScottCode l
@@ -69,13 +69,13 @@ sumRightBuiltin l = foldRightBuiltin B.addInteger 0 l
 -- Compiling to PLC terms
 
 mkSumRightBuiltinCode :: [Integer] -> Tx.CompiledCode Integer
-mkSumRightBuiltinCode l = $$(Tx.compile [|| sumRightBuiltin ||]) `Tx.applyCode` Tx.liftCode (BI.BuiltinList l)
+mkSumRightBuiltinCode l = $$(Tx.compile [|| sumRightBuiltin ||]) `Tx.unsafeApplyCode` Tx.liftCode (BI.BuiltinList l)
 
 mkSumRightBuiltinTerm :: [Integer] -> Term
 mkSumRightBuiltinTerm l = compiledCodeToTerm $ mkSumRightBuiltinCode l
 
 mkSumLeftBuiltinCode :: [Integer] -> Tx.CompiledCode Integer
-mkSumLeftBuiltinCode l = $$(Tx.compile [|| sumLeftBuiltin ||]) `Tx.applyCode` Tx.liftCode (BI.BuiltinList l)
+mkSumLeftBuiltinCode l = $$(Tx.compile [|| sumLeftBuiltin ||]) `Tx.unsafeApplyCode` Tx.liftCode (BI.BuiltinList l)
 
 mkSumLeftBuiltinTerm :: [Integer] -> Term
 mkSumLeftBuiltinTerm l = compiledCodeToTerm $ mkSumLeftBuiltinCode l
@@ -137,13 +137,13 @@ listToDataList l = Tx.dataToBuiltinData (go l)
     go (x:xs) = Tx.Constr 1 [Tx.I x, go xs]
 
 mkSumRightDataCode :: [Integer] -> Tx.CompiledCode Integer
-mkSumRightDataCode l = $$(Tx.compile [|| sumRightData ||]) `Tx.applyCode` Tx.liftCode (listToDataList l)
+mkSumRightDataCode l = $$(Tx.compile [|| sumRightData ||]) `Tx.unsafeApplyCode` Tx.liftCode (listToDataList l)
 
 mkSumRightDataTerm :: [Integer] -> Term
 mkSumRightDataTerm l = compiledCodeToTerm $ mkSumRightDataCode l
 
 mkSumLeftDataCode :: [Integer] -> Tx.CompiledCode Integer
-mkSumLeftDataCode l = $$(Tx.compile [|| sumLeftData ||]) `Tx.applyCode` Tx.liftCode (listToDataList l)
+mkSumLeftDataCode l = $$(Tx.compile [|| sumLeftData ||]) `Tx.unsafeApplyCode` Tx.liftCode (listToDataList l)
 
 mkSumLeftDataTerm :: [Integer] -> Term
 mkSumLeftDataTerm l = compiledCodeToTerm $ mkSumLeftDataCode l

plutus-benchmark/nofib/exe/Main.hs

@@ -315,12 +315,12 @@ main = do
           Primetest n             -> if n<0 then Hs.error "Positive number expected"
                                      else print $ Prime.runPrimalityTest n
     DumpPLC pa ->
-        traverse_ putStrLn $ unindent . prettyPlcClassicDebug . UPLC.mkDefaultProg . getTerm $ pa
+        traverse_ putStrLn $ unindent . prettyPlcClassicDebug . UPLC.Program () PLC.latestVersion . getTerm $ pa
             where unindent d = map (dropWhile isSpace) $ (Hs.lines . Hs.show $ d)
     DumpFlatNamed pa ->
-        writeFlatNamed . UPLC.mkDefaultProg . getTerm $ pa
+        writeFlatNamed . UPLC.Program () PLC.latestVersion . getTerm $ pa
     DumpFlatDeBruijn pa ->
-        writeFlatDeBruijn . UPLC.mkDefaultProg . toAnonDeBruijnTerm . getTerm $ pa
+        writeFlatDeBruijn . UPLC.Program () PLC.latestVersion . toAnonDeBruijnTerm . getTerm $ pa
     SizesAndBudgets
         -> printSizesAndBudgets
     -- Write the output to stdout and let the user deal with redirecting it.