[Speedy] Drop SoftFetch and SoftExercise (#21408)

Soft operations are not produce by the compiler since Feb 2024.
@meiersi-da gave is green light to go with this changes together with #21403

Author: remyhaemmerle-da

sdk/compiler/daml-lf-proto-decode/src/DA/Daml/LF/Proto3/DecodeV2.hs

@@ -607,8 +607,6 @@ decodeUpdate LF2.Update{..} = mayDecode "updateSum" updateSum $ \case
       <*> decodeNameId ChoiceName update_ExerciseChoiceInternedStr
       <*> mayDecode "update_ExerciseCid" update_ExerciseCid decodeExpr
       <*> mayDecode "update_ExerciseArg" update_ExerciseArg decodeExpr
-  LF2.UpdateSumSoftExercise LF2.Update_SoftExercise{} ->
-    throwError (ParseError "Update.Sum.soft_exercise is no longer supported")
   LF2.UpdateSumExerciseInterface LF2.Update_ExerciseInterface{..} ->
     fmap EUpdate $ UExerciseInterface
       <$> mayDecode "update_ExerciseInterfaceInterface" update_ExerciseInterfaceInterface decodeTypeConId
@@ -626,8 +624,6 @@ decodeUpdate LF2.Update{..} = mayDecode "updateSum" updateSum $ \case
     fmap EUpdate $ UFetch
       <$> mayDecode "update_FetchTemplate" update_FetchTemplate decodeTypeConId
       <*> mayDecode "update_FetchCid" update_FetchCid decodeExpr
-  LF2.UpdateSumSoftFetch LF2.Update_SoftFetch{} ->
-    throwError (ParseError "Update.Sum.soft_fetch is no longer supported")
   LF2.UpdateSumFetchInterface LF2.Update_FetchInterface{..} ->
     fmap EUpdate $ UFetchInterface
       <$> mayDecode "update_FetchInterfaceInterface" update_FetchInterfaceInterface decodeTypeConId

sdk/daml-lf/archive/src/main/protobuf/com/digitalasset/daml/lf/archive/daml_lf2.proto

@@ -1005,20 +1005,6 @@ message Update {
     Expr arg = 5;
   }
 
-  // Soft Exercise Update
-  // Exercises a contract of the given template type OR a predecessor.
-  // *Available in versions >= 2.dev*
-  message SoftExercise {
-    // Template type
-    TypeConId template = 1;
-    // *Must be a valid interned identifier*
-    int32 choice_interned_str = 2;
-    // contract id
-    Expr cid = 3;
-    // argument
-    Expr arg = 4;
-  }
-
   // Interface Exercise Update
   message ExerciseInterface {
     // Interface type
@@ -1057,16 +1043,6 @@ message Update {
     Expr cid = 2;
   }
 
-  // Soft Fetch Update
-  // Fetches a contract of the given template type OR a predecessor.
-  // *Available in versions >= 2.dev*
-  message SoftFetch {
-    // Template type
-    TypeConId template = 1;
-    // contract id
-    Expr cid = 2;
-  }
-
   // Interface Fetch Update
   message FetchInterface {
     // Interface type
@@ -1118,9 +1094,6 @@ message Update {
     FetchInterface fetch_interface = 14;
 
     Expr ledger_time_lt = 15;
-
-    SoftFetch soft_fetch = 1002; // *Available in versions >= 2.dev*
-    SoftExercise soft_exercise = 1003; // *Available in versions >= 2.dev*
   }
 }
 

sdk/daml-lf/archive/src/main/scala/com/digitalasset/daml/lf/archive/DecodeV2.scala

@@ -1278,18 +1278,6 @@ private[archive] class DecodeV2(minor: LV.Minor) {
             }
           }
 
-        case PLF.Update.SumCase.SOFT_EXERCISE =>
-          val exercise = lfUpdate.getSoftExercise
-          val templateId = decodeTypeConId(exercise.getTemplate)
-          val choice = internedName(exercise.getChoiceInternedStr)
-          decodeExpr(exercise.getCid, definition) { cidE =>
-            decodeExpr(exercise.getArg, definition) { argE =>
-              Ret(
-                UpdateSoftExercise(templateId, choice, cidE, argE)
-              )
-            }
-          }
-
         case PLF.Update.SumCase.EXERCISE_INTERFACE =>
           val exercise = lfUpdate.getExerciseInterface
           decodeExpr(exercise.getCid, definition) { cidE =>
@@ -1336,17 +1324,6 @@ private[archive] class DecodeV2(minor: LV.Minor) {
             Ret(UpdateFetchTemplate(templateId = decodeTypeConId(fetch.getTemplate), contractId))
           }
 
-        case PLF.Update.SumCase.SOFT_FETCH =>
-          val softFetch = lfUpdate.getSoftFetch
-          decodeExpr(softFetch.getCid, definition) { contractId =>
-            Ret(
-              UpdateSoftFetchTemplate(
-                templateId = decodeTypeConId(softFetch.getTemplate),
-                contractId,
-              )
-            )
-          }
-
         case PLF.Update.SumCase.FETCH_INTERFACE =>
           val fetch = lfUpdate.getFetchInterface
           decodeExpr(fetch.getCid, definition) { contractId =>

sdk/daml-lf/archive/src/test/scala/com/digitalasset/daml/lf/archive/DecodeV2Spec.scala

@@ -880,37 +880,6 @@ class DecodeV2Spec
         decoder.decodeExprForTest(proto, "test") shouldBe Ast.EUpdate(exerciseInterfaceScala)
       }
     }
-
-    s"decode softFetch" in {
-      val dottedNameTable = ImmArraySeq("Mod", "T").map(Ref.DottedName.assertFromString)
-      val unit = DamlLf2.Unit.newBuilder().build()
-      val pkgRef = DamlLf2.SelfOrImportedPackageId.newBuilder().setSelfPackageId(unit).build
-      val modRef =
-        DamlLf2.ModuleId.newBuilder().setPackageId(pkgRef).setModuleNameInternedDname(0).build()
-      val templateTyConName =
-        DamlLf2.TypeConId.newBuilder().setModule(modRef).setNameInternedDname(1)
-
-      val softFetchProto = {
-        val exe = DamlLf2.Update.SoftFetch
-          .newBuilder()
-          .setTemplate(templateTyConName)
-          .setCid(unitExpr)
-          .build()
-        DamlLf2.Update.newBuilder().setSoftFetch(exe).build()
-      }
-
-      val softFetchScala = Ast.UpdateSoftFetchTemplate(
-        Ref.Identifier.assertFromString("noPkgId:Mod:T"),
-        EUnit,
-      )
-
-      forEveryVersion { version =>
-        val decoder = moduleDecoder(version, ImmArraySeq.empty, dottedNameTable, typeTable)
-        val proto = DamlLf2.Expr.newBuilder().setUpdate(softFetchProto).build()
-        val result = Try(decoder.decodeExprForTest(proto, "test"))
-        result shouldBe Success(Ast.EUpdate(softFetchScala))
-      }
-    }
   }
 
   "decodeModule" should {

sdk/daml-lf/encoder/src/main/scala/com/digitalasset/daml/lf/archive/testing/EncodeV2.scala

@@ -361,10 +361,6 @@ private[daml] class EncodeV2(minorLanguageVersion: LV.Minor) {
           )
         case UpdateFetchTemplate(templateId, contractId) =>
           builder.setFetch(PLF.Update.Fetch.newBuilder().setTemplate(templateId).setCid(contractId))
-        case UpdateSoftFetchTemplate(templateId, contractId) =>
-          builder.setSoftFetch(
-            PLF.Update.SoftFetch.newBuilder().setTemplate(templateId).setCid(contractId)
-          )
         case UpdateFetchInterface(interface, contractId) =>
           builder.setFetchInterface(
             PLF.Update.FetchInterface.newBuilder().setInterface(interface).setCid(contractId)
@@ -376,13 +372,6 @@ private[daml] class EncodeV2(minorLanguageVersion: LV.Minor) {
           b.setCid(cid)
           b.setArg(arg)
           builder.setExercise(b)
-        case UpdateSoftExercise(templateId, choice, cid, arg) =>
-          val b = PLF.Update.SoftExercise.newBuilder()
-          b.setTemplate(templateId)
-          setString(choice, b.setChoiceInternedStr)
-          b.setCid(cid)
-          b.setArg(arg)
-          builder.setSoftExercise(b)
         case UpdateExerciseInterface(interface, choice, cid, arg, guard) =>
           val b = PLF.Update.ExerciseInterface.newBuilder()
           b.setInterface(interface)

sdk/daml-lf/interpreter/src/main/scala/com/digitalasset/daml/lf/speedy/PartialTransaction.scala

@@ -484,7 +484,7 @@ private[speedy] case class PartialTransaction(
         ExercisesContextInfo(
           targetId = targetId,
           packageName = packageName,
-          templateId = templateId, // may differ from contract.templateId during soft-exercise
+          templateId = templateId, // may differ from contract.templateId
           interfaceId = interfaceId,
           contractKey =
             // We need to renormalize the key

sdk/daml-lf/interpreter/src/main/scala/com/digitalasset/daml/lf/speedy/PhaseOne.scala

@@ -667,12 +667,6 @@ private[lf] final class PhaseOne(
         compileExp(env, coid) { coid =>
           Return(t.FetchTemplateDefRef(tmplId)(coid))
         }
-      // TODO: https://github.com/digital-asset/daml/issues/17082
-      // - Soft fetch now has identical behavior to normal fetch, and could be removed
-      case UpdateSoftFetchTemplate(tmplId, coid) =>
-        compileExp(env, coid) { coid =>
-          Return(t.FetchTemplateDefRef(tmplId)(coid))
-        }
       case UpdateFetchInterface(ifaceId, coid) =>
         compileExp(env, coid) { coid =>
           Return(t.FetchInterfaceDefRef(ifaceId)(coid))
@@ -702,14 +696,6 @@ private[lf] final class PhaseOne(
             Return(t.TemplateChoiceDefRef(tmplId, chId)(cid, arg))
           }
         }
-      // TODO: https://github.com/digital-asset/daml/issues/17082
-      // - Soft exercise now has identical behavior to normal exercise, and could be removed
-      case UpdateSoftExercise(tmplId, chId, cid, arg) =>
-        compileExp(env, cid) { cid =>
-          compileExp(env, arg) { arg =>
-            Return(t.TemplateChoiceDefRef(tmplId, chId)(cid, arg))
-          }
-        }
       case UpdateExerciseInterface(ifaceId, chId, cid, arg, maybeGuard) =>
         compileExp(env, cid) { cid =>
           compileExp(env, arg) { arg =>

sdk/daml-lf/language/src/main/scala/com/digitalasset/daml/lf/language/Ast.scala

@@ -586,7 +586,6 @@ object Ast {
   final case class UpdateCreate(templateId: TypeConId, arg: Expr) extends Update
   final case class UpdateCreateInterface(interfaceId: TypeConId, arg: Expr) extends Update
   final case class UpdateFetchTemplate(templateId: TypeConId, contractId: Expr) extends Update
-  final case class UpdateSoftFetchTemplate(templateId: TypeConId, contractId: Expr) extends Update
   final case class UpdateFetchInterface(interfaceId: TypeConId, contractId: Expr) extends Update
 
   final case class UpdateExercise(
@@ -595,12 +594,6 @@ object Ast {
       cidE: Expr,
       argE: Expr,
   ) extends Update
-  final case class UpdateSoftExercise(
-      templateId: TypeConId,
-      choice: ChoiceName,
-      cidE: Expr,
-      argE: Expr,
-  ) extends Update
   final case class UpdateExerciseInterface(
       interfaceId: TypeConId,
       choice: ChoiceName,

sdk/daml-lf/language/src/main/scala/com/digitalasset/daml/lf/language/util/iterable/ExprIterable.scala

@@ -102,14 +102,10 @@ private[lf] object ExprIterable {
         Iterator(arg)
       case UpdateFetchTemplate(templateId @ _, contractId) =>
         Iterator(contractId)
-      case UpdateSoftFetchTemplate(templateId @ _, contractId) =>
-        Iterator(contractId)
       case UpdateFetchInterface(interface @ _, contractId) =>
         Iterator(contractId)
       case UpdateExercise(templateId @ _, choice @ _, cid, arg) =>
         Iterator(cid, arg)
-      case UpdateSoftExercise(templateId @ _, choice @ _, cid, arg) =>
-        Iterator(cid, arg)
       case UpdateExerciseInterface(interface @ _, choice @ _, cid, arg, guard) =>
         Iterator(cid, arg) ++ guard.iterator
       case UpdateExerciseByKey(templateId @ _, choice @ _, key, arg) =>

sdk/daml-lf/language/src/main/scala/com/digitalasset/daml/lf/language/util/iterable/TypeIterable.scala

@@ -130,20 +130,13 @@ private[lf] object TypeIterable {
       case UpdateFetchTemplate(templateId, contractId) =>
         Iterator(TTyCon(templateId)) ++
           iterator(contractId)
-      case UpdateSoftFetchTemplate(templateId, contractId) =>
-        Iterator(TTyCon(templateId)) ++
-          iterator(contractId)
       case UpdateFetchInterface(interface, contractId) =>
         Iterator(TTyCon(interface)) ++
           iterator(contractId)
       case UpdateExercise(templateId, choice @ _, cid, arg) =>
         Iterator(TTyCon(templateId)) ++
           iterator(cid) ++
           iterator(arg)
-      case UpdateSoftExercise(templateId, choice @ _, cid, arg) =>
-        Iterator(TTyCon(templateId)) ++
-          iterator(cid) ++
-          iterator(arg)
       case UpdateExerciseInterface(interface, choice @ _, cid, arg, guard) =>
         Iterator(TTyCon(interface)) ++
           iterator(cid) ++