interfaces: tests: no interfaces below 1.dev (#13179)

We add a check for the decoder that tests that implementations in
templates are only accepted in 1.dev.

CHANGELOG_BEGIN
CHANGELOG_END

daml-lf/archive/src/main/protobuf/com/daml/daml_lf_dev/daml_lf_1.proto

@@ -1567,7 +1567,7 @@ message DefTemplate {
 
   Location location = 9;
 
-  // They key definition for the template, if present
+  // The key definition for the template, if present
   DefKey key = 10; // optional
 
   // Interfaces that this template implements.

daml-lf/archive/src/test/scala/com/digitalasset/daml/lf/archive/DecodeV1Spec.scala

@@ -15,6 +15,12 @@ import com.daml.lf.language.Ast.{
   EInterfaceTemplateTypeRep,
   EObserverInterface,
   EPrimLit,
+  EPrimCon,
+  PCUnit,
+  GenTemplate,
+  GenModule,
+  GenTemplateImplements,
+  FeatureFlags,
   ESignatoryInterface,
   PLRoundingMode,
 }
@@ -26,6 +32,7 @@ import org.scalatest.wordspec.AnyWordSpec
 import scala.Ordering.Implicits.infixOrderingOps
 import scala.jdk.CollectionConverters._
 import scala.util.{Failure, Success, Try}
+import scala.collection.immutable.VectorMap
 
 class DecodeV1Spec
     extends AnyWordSpec
@@ -916,6 +923,82 @@ class DecodeV1Spec
       }
     }
 
+    s"Reject interface implementations in templates iff version < ${LV.Features.interfaces}" in {
+      val unit = DamlLf1.Unit.newBuilder().build()
+      val pkgRef = DamlLf1.PackageRef.newBuilder().setSelf(unit).build
+      val modRef =
+        DamlLf1.ModuleRef.newBuilder().setPackageRef(pkgRef).setModuleNameInternedDname(0).build()
+      val ifaceTyConName =
+        DamlLf1.TypeConName.newBuilder().setModule(modRef).setNameInternedDname(2)
+
+      val i = DamlLf1.DefTemplate.Implements.newBuilder()
+      i.setInterface(ifaceTyConName)
+
+      val t = DamlLf1.DefTemplate.newBuilder()
+      t.setTyconInternedDname(1)
+      t.setParamInternedStr(0)
+      t.setPrecond(unitExpr)
+      t.setSignatories(unitExpr)
+      t.setAgreement(unitExpr)
+      t.setObservers(unitExpr)
+      t.addImplements(i.build())
+
+      val m = DamlLf1.Module.newBuilder()
+      m.setNameInternedDname(0)
+      m.addTemplates(t.build())
+      m.setFlags(
+        DamlLf1.FeatureFlags
+          .newBuilder()
+          .setForbidPartyLiterals(true)
+          .setDontDivulgeContractIdsInCreateArguments(true)
+          .setDontDiscloseNonConsumingChoicesToObservers(true)
+      )
+
+      val ifaceTemplateScala = GenModule(
+        Ref.DottedName.assertFromString("Mod"),
+        Map(),
+        Map(
+          Ref.DottedName.assertFromString("Mod.T") -> GenTemplate(
+            Ref.IdString.Name.assertFromString("test"),
+            EPrimCon(PCUnit),
+            EPrimCon(PCUnit),
+            EPrimCon(PCUnit),
+            Map(),
+            EPrimCon(PCUnit),
+            None,
+            VectorMap(
+              Ref.TypeConName
+                .assertFromString("noPkgId:Mod:Mod.I") -> GenTemplateImplements[EPrimCon](
+                Ref.TypeConName.assertFromString("noPkgId:Mod:Mod.I"),
+                Map(),
+                Set(),
+              )
+            ),
+          )
+        ),
+        Map(),
+        Map(),
+        FeatureFlags(),
+      )
+
+      val mod = m.build()
+      forEveryVersion { version =>
+        val decoder = moduleDecoder(
+          version,
+          ImmArraySeq("test"),
+          ImmArraySeq("Mod", "Mod.T", "Mod.I").map(Ref.DottedName.assertFromString),
+          typeTable,
+        )
+        val result = Try(decoder.decodeModule(mod))
+        if (version >= LV.Features.interfaces)
+          result shouldBe Success(ifaceTemplateScala)
+        else
+          inside(result) { case Failure(error) =>
+            error shouldBe an[Error.Parsing]
+          }
+      }
+    }
+
     val interfacePrimitivesDottedNameTable =
       ImmArraySeq("Mod", "I").map(Ref.DottedName.assertFromString)