interfaces: precondition, scala ast, decoder/encoder

compiler/damlc/daml-lf-conversion/src/DA/Daml/LFConversion.hs

@@ -444,7 +444,7 @@ convertInterfaces env tyThings = interfaceClasses
             intVirtualChoices <- NM.fromList <$> mapM convertVirtualChoice
                 (MS.findWithDefault [] intName (envInterfaceChoiceData env))
             intFixedChoices <- convertChoices env intName emptyTemplateBinds
-            let intPrecondition = EUnit -- TODO (drsk) #11397 Implement interface preconditions
+            let intPrecondition = ETrue -- TODO (drsk) #11397 Implement interface preconditions
             pure DefInterface {..}
 
     convertVirtualChoice :: ChoiceData -> ConvertM InterfaceChoice

daml-lf/archive/src/main/scala/com/digitalasset/daml/lf/archive/DecodeV1.scala

@@ -677,6 +677,7 @@ private[archive] class DecodeV1(minor: LV.Minor) {
         methods = lfInterface.getMethodsList.asScala.view
           .map(decodeInterfaceMethod)
           .map(method => method.name -> method),
+        precond = decodeExpr(lfInterface.getPrecond, s"$id:ensure"),
       )
 
     private[this] def decodeInterfaceChoice(

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

@@ -728,6 +728,7 @@ private[daml] class EncodeV1(minor: LV.Minor) {
       builder.accumulateLeft(interface.virtualChoices.sortByKey)(_ addChoices _)
       builder.accumulateLeft(interface.fixedChoices.sortByKey)(_ addFixedChoices _)
       builder.accumulateLeft(interface.methods.sortByKey)(_ addMethods _)
+      builder.setPrecond(interface.precond)
       builder.build()
     }
 

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

@@ -642,6 +642,7 @@ object Ast {
       virtualChoices: Map[ChoiceName, InterfaceChoice],
       fixedChoices: Map[ChoiceName, GenTemplateChoice[E]],
       methods: Map[MethodName, InterfaceMethod],
+      precond: E, // Interface creation precondition.
   ) {
     virtualChoices.keys.foreach(name =>
       if (fixedChoices.isDefinedAt(name))
@@ -655,6 +656,7 @@ object Ast {
         virtualChoices: Iterable[(ChoiceName, InterfaceChoice)],
         fixedChoices: Iterable[(ChoiceName, GenTemplateChoice[E])],
         methods: Iterable[(MethodName, InterfaceMethod)],
+        precond: E,
     ): GenDefInterface[E] = {
       val virtualChoiceMap = toMapWithoutDuplicate(
         virtualChoices,
@@ -668,17 +670,18 @@ object Ast {
         methods,
         (name: MethodName) => throw PackageError(s"collision on interface method name $name"),
       )
-      GenDefInterface(param, virtualChoiceMap, fixedChoiceMap, methodMap)
+      GenDefInterface(param, virtualChoiceMap, fixedChoiceMap, methodMap, precond)
     }
     def unapply(arg: GenDefInterface[E]): Some[
       (
           ExprVarName,
           Map[ChoiceName, InterfaceChoice],
           Map[ChoiceName, GenTemplateChoice[E]],
           Map[MethodName, InterfaceMethod],
+          E,
       )
     ] =
-      Some((arg.param, arg.virtualChoices, arg.fixedChoices, arg.methods))
+      Some((arg.param, arg.virtualChoices, arg.fixedChoices, arg.methods, arg.precond))
   }
 
   type DefInterface = GenDefInterface[Expr]

daml-lf/language/src/main/scala/com/digitalasset/daml/lf/language/Util.scala

@@ -243,12 +243,13 @@ object Util {
 
   private def toSignature(interface: DefInterface): DefInterfaceSignature =
     interface match {
-      case DefInterface(param, virtualChoices, fixedChoices, methods) =>
+      case DefInterface(param, virtualChoices, fixedChoices, methods, _) =>
         DefInterfaceSignature(
           param,
           virtualChoices,
           fixedChoices.transform((_, choice) => toSignature(choice)),
           methods,
+          (),
         )
     }
 

daml-lf/parser/src/main/scala/com/digitalasset/daml/lf/testing/parser/AstRewriter.scala

@@ -323,12 +323,13 @@ private[daml] class AstRewriter(
 
   def apply(x: DefInterface): DefInterface =
     x match {
-      case DefInterface(param, virtualChoices, fixedChoices, methods) =>
+      case DefInterface(param, virtualChoices, fixedChoices, methods, precond) =>
         DefInterface(
           param,
           virtualChoices.transform((_, v) => apply(v)),
           fixedChoices.transform((_, v) => apply(v)),
           methods.transform((_, v) => apply(v)),
+          apply(precond),
         )
     }
 }

daml-lf/validation/src/main/scala/com/digitalasset/daml/lf/validation/Typing.scala

@@ -455,12 +455,14 @@ private[validation] object Typing {
 
     def checkDefIface(ifaceName: TypeConName, iface: DefInterface): Unit =
       iface match {
-        case DefInterface(param, virtualChoices, fixedChoices, methods) =>
+        case DefInterface(param, virtualChoices, fixedChoices, methods, precond) =>
           fixedChoices.values.foreach(
             introExprVar(param, TTyCon(ifaceName)).checkChoice(ifaceName, _)
           )
           virtualChoices.values.foreach(checkIfaceChoice)
           methods.values.foreach(checkIfaceMethod)
+          val env = introExprVar(param, TTyCon(ifaceName))
+          env.checkExpr(precond, TBool)
       }
 
     def checkIfaceChoice(choice: InterfaceChoice): Unit = {
@@ -477,7 +479,7 @@ private[validation] object Typing {
         AlphaEquiv.alphaEquiv(expandTypeSynonyms(t1), expandTypeSynonyms(t2))
 
     def checkIfaceImplementation(tplTcon: TypeConName, impl: TemplateImplements): Unit = {
-      val DefInterfaceSignature(_, virtualChoices, _, methods) =
+      val DefInterfaceSignature(_, virtualChoices, _, methods, _) =
         handleLookup(ctx, interface.lookupInterface(impl.interface))
       virtualChoices.values.foreach { case InterfaceChoice(name, consuming, argType, returnType) =>
         val tplChoice = handleLookup(ctx, interface.lookupChoice(tplTcon, name))

daml-lf/validation/src/main/scala/com/digitalasset/daml/lf/validation/iterable/ExprIterable.scala

@@ -206,8 +206,9 @@ private[validation] object ExprIterable {
             virtualChoices @ _,
             fixedChoices,
             methods @ _,
+            precond,
           ) =>
-        fixedChoices.values.iterator.flatMap(iterator(_))
+        Iterator(precond) ++ fixedChoices.values.iterator.flatMap(iterator(_))
     }
 
   def apply(expr: Expr): Iterable[Expr] =

daml-lf/validation/src/main/scala/com/digitalasset/daml/lf/validation/iterable/TypeIterable.scala

@@ -238,8 +238,9 @@ private[validation] object TypeIterable {
 
   private[validation] def iterator(interface: DefInterface): Iterator[Type] =
     interface match {
-      case DefInterface(_, virtualChoices, fixedChoice, methods) =>
-        virtualChoices.values.iterator.flatMap(iterator) ++
+      case DefInterface(_, virtualChoices, fixedChoice, methods, precond) =>
+        iterator(precond) ++
+          virtualChoices.values.iterator.flatMap(iterator) ++
           fixedChoice.values.iterator.flatMap(iterator) ++
           methods.values.iterator.flatMap(iterator)
     }