[LF] introduce a basic patch mecanism for LF

Author: remyhaemmerle-da

sdk/compiler/daml-lf-proto-encode/src/DA/Daml/LF/Proto3/Encode.hs

@@ -18,4 +18,4 @@ encodePayload :: Package -> ArchivePayload
 encodePayload package = case packageLfVersion package of
     (Version V2 minor) ->
         let payload = ArchivePayloadSumDamlLf2 $ BSL.toStrict $ Proto.toLazyByteString (EncodeV2.encodePackage package)
-        in ArchivePayload (TL.pack $ renderMinorVersion minor) (Just payload)
+        in ArchivePayload (TL.pack $ renderMinorVersion minor) 0 (Just payload)

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

@@ -13,6 +13,7 @@ message ArchivePayload {
   // this is number 3 for historical reasons -- we had
   // Daml-LF v0 and v1 before we had minor versions.
   string minor = 3;
+  int32 patch = 5; // must be empty
   reserved 9999; // for the removed "dev" major version
   reserved 1; // was daml_lf_0
 

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

@@ -15,13 +15,14 @@ object Decode {
       onlySerializableDataDefs: Boolean = false,
   ): Either[Error, (PackageId, Ast.Package)] =
     payload match {
-      case ArchivePayload.Lf2(pkgId, protoPkg, minor)
+      case ArchivePayload.Lf2(pkgId, protoPkg, minor, patch)
           if LanguageMajorVersion.V2.supportedMinorVersions.contains(minor) =>
         new DecodeV2(minor)
           .decodePackage(
             pkgId,
             protoPkg,
             onlySerializableDataDefs,
+            patch,
           )
           .map(payload.pkgId -> _)
       case ArchivePayload.Lf1(pkgId, protoPkg, minor)

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

@@ -31,55 +31,63 @@ private[archive] class DecodeV2(minor: LV.Minor) {
       packageId: PackageId,
       lfPackage: PLF.Package,
       onlySerializableDataDefs: Boolean,
-  ): Either[Error, Package] = attempt(NameOf.qualifiedNameOfCurrentFunc) {
-
-    val internedStrings = lfPackage.getInternedStringsList.asScala.to(ImmArraySeq)
-
-    val internedDottedNames =
-      decodeInternedDottedNames(
-        lfPackage.getInternedDottedNamesList.asScala,
-        internedStrings,
-      )
-
-    val dependencyTracker = new PackageDependencyTracker(packageId)
-
-    val metadata: PackageMetadata = {
-      if (!lfPackage.hasMetadata)
-        throw Error.Parsing(s"Package.metadata is required in Daml-LF 2.$minor")
-      decodePackageMetadata(lfPackage.getMetadata, internedStrings)
-    }
+      patchVersion: Int,
+  ): Either[Error, Package] =
+    if (patchVersion != 0) {
+      if (languageVersion < LV.Features.patchVersion)
+        Left(Error.Parsing(s"Patch version not supported for LF $languageVersion"))
+      else
+        Left(Error.Parsing(s"Unknown patch version $patchVersion for LF $languageVersion"))
+    } else
+      attempt(NameOf.qualifiedNameOfCurrentFunc) {
+
+        val internedStrings = lfPackage.getInternedStringsList.asScala.to(ImmArraySeq)
+
+        val internedDottedNames =
+          decodeInternedDottedNames(
+            lfPackage.getInternedDottedNamesList.asScala,
+            internedStrings,
+          )
 
-    val imports = decodePackageImports(lfPackage)
+        val dependencyTracker = new PackageDependencyTracker(packageId)
 
-    val env0 = Env(
-      packageId = packageId,
-      internedStrings = internedStrings,
-      internedDottedNames = internedDottedNames,
-      optDependencyTracker = Some(dependencyTracker),
-      onlySerializableDataDefs = onlySerializableDataDefs,
-      imports = imports,
-    )
+        val metadata: PackageMetadata = {
+          if (!lfPackage.hasMetadata)
+            throw Error.Parsing(s"Package.metadata is required in Daml-LF 2.$minor")
+          decodePackageMetadata(lfPackage.getMetadata, internedStrings)
+        }
 
-    val internedKinds = decodeKindsTable(env0, lfPackage)
-    val env1 = env0.copy(internedKinds = internedKinds)
-    val internedTypes = decodeTypesTable(env1, lfPackage)
-    val env2 = env1.copy(internedTypes = internedTypes)
-    val internedExprs = lfPackage.getInternedExprsList().asScala.toVector
-    val env = env2.copy(internedExprs = internedExprs)
+        val imports = decodePackageImports(lfPackage)
 
-    val importsSet =
-      imports.map(xs => xs.map(s => eitherToParseError(PackageId.fromString(s))).toSet)
+        val env0 = Env(
+          packageId = packageId,
+          internedStrings = internedStrings,
+          internedDottedNames = internedDottedNames,
+          optDependencyTracker = Some(dependencyTracker),
+          onlySerializableDataDefs = onlySerializableDataDefs,
+          imports = imports,
+        )
 
-    val modules = lfPackage.getModulesList.asScala.map(env.decodeModule(_))
-    Package.build(
-      modules = modules,
-      directDeps = dependencyTracker.getDependencies,
-      languageVersion = languageVersion,
-      metadata = metadata,
-      imports = importsSet,
-    )
+        val internedKinds = decodeKindsTable(env0, lfPackage)
+        val env1 = env0.copy(internedKinds = internedKinds)
+        val internedTypes = decodeTypesTable(env1, lfPackage)
+        val env2 = env1.copy(internedTypes = internedTypes)
+        val internedExprs = lfPackage.getInternedExprsList().asScala.toVector
+        val env = env2.copy(internedExprs = internedExprs)
+
+        val importsSet =
+          imports.map(xs => xs.map(s => eitherToParseError(PackageId.fromString(s))).toSet)
+
+        val modules = lfPackage.getModulesList.asScala.map(env.decodeModule(_))
+        Package.build(
+          modules = modules,
+          directDeps = dependencyTracker.getDependencies,
+          languageVersion = languageVersion,
+          metadata = metadata,
+          imports = importsSet,
+        )
 
-  }
+      }
 
   private[archive] def decodePackageMetadata(
       metadata: PLF.PackageMetadata,

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

@@ -29,6 +29,7 @@ object ArchivePayload {
       pkgId: PackageId,
       proto: DamlLf2.Package,
       minor: language.LanguageMinorVersion,
+      patch: Int,
   ) extends ArchivePayload {
     val version = LanguageVersion(LanguageMajorVersion.V2, minor)
   }
@@ -72,16 +73,19 @@ object Reader {
   ): Either[Error, ArchivePayload] =
     lf.getSumCase match {
       case DamlLf.ArchivePayload.SumCase.DAML_LF_1 =>
-        lf1PackageParser
-          .fromByteString(lf.getDamlLf1)
-          .map(
-            ArchivePayload.Lf1(hash, _, LanguageMinorVersion(lf.getMinor))
-          )
+        if (lf.getPatch != 0)
+          Left(Error.Parsing("Patch version is not supported for LF1"))
+        else
+          lf1PackageParser
+            .fromByteString(lf.getDamlLf1)
+            .map(
+              ArchivePayload.Lf1(hash, _, LanguageMinorVersion(lf.getMinor))
+            )
       case DamlLf.ArchivePayload.SumCase.DAML_LF_2 =>
         val minor = LanguageMinorVersion(lf.getMinor)
         lf2PackageParser(minor)
           .fromByteString(lf.getDamlLf2)
-          .map(ArchivePayload.Lf2(hash, _, LanguageMinorVersion(lf.getMinor)))
+          .map(ArchivePayload.Lf2(hash, _, LanguageMinorVersion(lf.getMinor), lf.getPatch))
       case DamlLf.ArchivePayload.SumCase.SUM_NOT_SET =>
         Left(Error.Parsing("Unrecognized or Unsupported LF version"))
     }

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

@@ -41,8 +41,8 @@ class DarReaderTest
       case ArchivePayload.Lf1(packageId, protoPkg, _) =>
         packageId shouldNot be(Symbol("empty"))
         protoPkg.getModulesCount should be > 0
-      case ArchivePayload.Lf2(_, _, _) =>
-        Assertions.fail("unexpected Lf1 payload")
+      case ArchivePayload.Lf2(_, _, _, _) =>
+        Assertions.fail("unexpected Lf2 payload")
     }
 
     val mainPkg = dar.main.asInstanceOf[ArchivePayload.Lf1].proto
@@ -94,8 +94,8 @@ class DarReaderTest
           "LibraryModules",
           "GHC.Tuple.Check",
         )
-      case ArchivePayload.Lf2(_, _, _) =>
-        Assertions.fail("unexpected Lf2 payload")
+      case ArchivePayload.Lf2(_, _, _, _) =>
+        Assertions.fail("unexpected LF2 payload")
     }
 
     def internedName(
@@ -116,7 +116,7 @@ class DarReaderTest
     forAll(dar.all) {
       case ArchivePayload.Lf1(_, _, _) =>
         Assertions.fail("unexpected Lf1 payload")
-      case ArchivePayload.Lf2(packageId, protoPkg, _) =>
+      case ArchivePayload.Lf2(packageId, protoPkg, _, _) =>
         packageId shouldNot be(Symbol("empty"))
         protoPkg.getModulesCount should be > 0
     }
@@ -150,7 +150,7 @@ class DarReaderTest
     forExactly(1, dar.dependencies) {
       case ArchivePayload.Lf1(_, _, _) =>
         Assertions.fail("unexpected Lf1 payload")
-      case ArchivePayload.Lf2(_, protoPkg, _) =>
+      case ArchivePayload.Lf2(_, protoPkg, _, _) =>
         val archiveModules = protoPkg.getModulesList.asScala
         val archiveInternedDotted = protoPkg.getInternedDottedNamesList.asScala
         val archiveInternedStrings = protoPkg.getInternedStringsList.asScala

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

@@ -4,6 +4,7 @@
 package com.digitalasset.daml.lf.archive
 
 import com.daml.SafeProto
+
 import java.math.BigDecimal
 import java.nio.file.Paths
 import com.daml.bazeltools.BazelRunfiles._
@@ -1501,7 +1502,7 @@ class DecodeV2Spec
 
   "decodeModuleRef" should {
 
-    lazy val Right(ArchivePayload.Lf2(pkgId, pkgProto, minorVersion)) =
+    lazy val Right(ArchivePayload.Lf2(pkgId, pkgProto, minorVersion, _)) =
       ArchiveReader.fromFile(Paths.get(rlocation("daml-lf/archive/DarReaderTest.dalf")))
 
     lazy val extId = {
@@ -1536,7 +1537,7 @@ class DecodeV2Spec
 
     "decode resolving the interned package ID" in {
       val decoder = new DecodeV2(minorVersion)
-      inside(decoder.decodePackage(pkgId, pkgProto, false)) { case Right(pkg) =>
+      inside(decoder.decodePackage(pkgId, pkgProto, false, 0)) { case Right(pkg) =>
         inside(
           pkg
             .modules(Ref.DottedName.assertFromString("DarReaderTest"))
@@ -1657,7 +1658,7 @@ class DecodeV2Spec
         val pkgId = Ref.PackageId.assertFromString(
           "0000000000000000000000000000000000000000000000000000000000000000"
         )
-        inside(decoder.decodePackage(pkgId, DamlLf2.Package.newBuilder().build(), false)) {
+        inside(decoder.decodePackage(pkgId, DamlLf2.Package.newBuilder().build(), false, 0)) {
           case Left(err) => err shouldBe an[Error.Parsing]
         }
       }
@@ -1680,7 +1681,7 @@ class DecodeV2Spec
           .addInternedStrings("0.0.0")
           .setMetadata(metadata)
           .build()
-        inside(decoder.decodePackage(pkgId, pkg, false)) { case Right(pkg) =>
+        inside(decoder.decodePackage(pkgId, pkg, false, 0)) { case Right(pkg) =>
           pkg.metadata shouldBe
             Ast.PackageMetadata(
               Ref.PackageName.assertFromString("foobar"),
@@ -1812,6 +1813,28 @@ class DecodeV2Spec
         Decode.decodeArchive(exprToArch(buildLet(498), "1")) shouldBe a[Right[_, _]]
       }
     }
+
+    "fail for unknown patch versions" in {
+      val pkgId = Ref.PackageId.assertFromString("-pkgId-")
+
+      forEveryVersion { version =>
+        inside(
+          Decode.decodeArchivePayload(
+            ArchivePayload.Lf2(
+              pkgId = pkgId,
+              proto = DamlLf2.Package.getDefaultInstance,
+              minor = version.minor,
+              patch = 1,
+            )
+          )
+        ) { case Left(err) =>
+          if (version < LV.Features.patchVersion)
+            err.msg should include(s"Patch version not supported for LF $version")
+          else
+            err.msg should include(s"Unknown patch version 1 for LF $version")
+        }
+      }
+    }
   }
 
   "decodeChoice" should {

sdk/daml-lf/encoder/src/test/scala/com/digitalasset/daml/lf/testing/archive/DamlLfEncoderTest.scala

@@ -94,7 +94,7 @@ class DamlLfEncoderTest
     for {
       payload <- dar.all
       name <- payload match {
-        case ArchivePayload.Lf2(_, pkg, _) => getNonEmptyModules(pkg)
+        case ArchivePayload.Lf2(_, pkg, _, _) => getNonEmptyModules(pkg)
         case _ => throw new RuntimeException(s"Unsupported language version: ${payload.version}")
       }
     } yield name

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

@@ -85,6 +85,7 @@ object LanguageVersion {
     val default = v2_1
     val exceptions = v2_1
     val packageUpgrades = v2_1
+    val patchVersion = v2_dev
     val persistedPackageVersion = v2_dev
 
     val choiceFuncs = v2_dev