digital-asset · mergify · Sep 20, 2021 · Sep 20, 2021
diff --git a/.../repl-service/server/src/main/scala/com/digitalasset/daml/lf/speedy/ReplServiceMain.scala b/.../repl-service/server/src/main/scala/com/digitalasset/daml/lf/speedy/ReplServiceMain.scala
@@ -227,7 +227,7 @@ class ReplService(
     val (pkgId, pkg) = archive.ArchiveDecoder.assertFromByteString(req.getPackage)
     val newSignatures = signatures.updated(pkgId, AstUtil.toSignature(pkg))
     val newCompiledDefinitions = compiledDefinitions ++
-      new Compiler(new language.Interface(newSignatures), compilerConfig)
+      new Compiler(new language.PackageInterface(newSignatures), compilerConfig)
         .unsafeCompilePackage(pkgId, pkg)
     signatures = newSignatures
     compiledDefinitions = newCompiledDefinitions
@@ -257,7 +257,7 @@ class ReplService(
     }
 
     val signatures = this.signatures.updated(homePackageId, AstUtil.toSignature(pkg))
-    val interface = new language.Interface(signatures)
+    val interface = new language.PackageInterface(signatures)
     val defs =
       new Compiler(interface, compilerConfig).unsafeCompilePackage(homePackageId, pkg)
     val compiledPackages =

diff --git a/...er/scenario-service/server/src/main/scala/com/digitalasset/daml/lf/scenario/Context.scala b/...er/scenario-service/server/src/main/scala/com/digitalasset/daml/lf/scenario/Context.scala
@@ -99,7 +99,7 @@ class Context(val contextId: Context.ContextId, languageVersion: LanguageVersion
       if (unloadPackages.nonEmpty || newPackages.nonEmpty) {
         val invalidPackages = unloadModules ++ newPackages.keys
         val newExtSignature = extSignatures -- unloadPackages ++ AstUtil.toSignatures(newPackages)
-        val interface = new language.Interface(newExtSignature)
+        val interface = new language.PackageInterface(newExtSignature)
         val newExtDefns = extDefns.view.filterKeys(sdef => !invalidPackages(sdef.packageId)) ++
           assertRight(Compiler.compilePackages(interface, newPackages, compilerConfig))
         // we update only if we manage to compile the new packages
@@ -112,7 +112,7 @@ class Context(val contextId: Context.ContextId, languageVersion: LanguageVersion
         newModules
       }
 
-    val interface = new language.Interface(this.allSignatures)
+    val interface = new language.PackageInterface(this.allSignatures)
     val compiler = new Compiler(interface, compilerConfig)
 
     modulesToCompile.foreach { mod =>

diff --git a/daml-lf/encoder/src/main/scala/com/digitalasset/daml/lf/archive/testing/DamlLfEncoder.scala b/daml-lf/encoder/src/main/scala/com/digitalasset/daml/lf/archive/testing/DamlLfEncoder.scala
@@ -9,7 +9,7 @@ import java.nio.file.Paths
 import com.daml.lf.archive.{Dar, DarWriter}
 import com.daml.lf.data.Ref
 import com.daml.lf.data.Ref.PackageId
-import com.daml.lf.language.{Ast, Interface, LanguageVersion}
+import com.daml.lf.language.{Ast, PackageInterface, LanguageVersion}
 import com.daml.lf.testing.parser.{ParserParameters, parseModules}
 import com.daml.lf.validation.Validation
 import com.daml.SdkVersion
@@ -71,7 +71,7 @@ private[daml] object DamlLfEncoder extends App {
 
     val pkg =
       Ast.Package(modules, Set.empty[PackageId], parserParameters.languageVersion, metadata)
-    val pkgs = Interface(Map(pkgId -> pkg))
+    val pkgs = PackageInterface(Map(pkgId -> pkg))
 
     Validation.checkPackage(pkgs, pkgId, pkg).left.foreach(e => error(e.pretty))
 

diff --git a/daml-lf/encoder/src/test/scala/com/digitalasset/daml/lf/archive/testing/EncodeV1Spec.scala b/daml-lf/encoder/src/test/scala/com/digitalasset/daml/lf/archive/testing/EncodeV1Spec.scala
@@ -192,7 +192,7 @@ object EncodeV1Spec {
 
   private def validate(pkgId: PackageId, pkg: Package): Unit =
     Validation
-      .checkPackage(language.Interface(Map(pkgId -> pkg)), pkgId, pkg)
+      .checkPackage(language.PackageInterface(Map(pkgId -> pkg)), pkgId, pkg)
       .left
       .foreach(e => sys.error(e.toString))
 

diff --git a/...lf/engine/src/main/scala/com/digitalasset/daml/lf/engine/ConcurrentCompiledPackages.scala b/...lf/engine/src/main/scala/com/digitalasset/daml/lf/engine/ConcurrentCompiledPackages.scala
@@ -9,7 +9,7 @@ import java.util.concurrent.ConcurrentHashMap
 import com.daml.lf.data.Ref.PackageId
 import com.daml.lf.engine.ConcurrentCompiledPackages.AddPackageState
 import com.daml.lf.language.Ast.{Package, PackageSignature}
-import com.daml.lf.language.{Interface, Util => AstUtil}
+import com.daml.lf.language.{PackageInterface, Util => AstUtil}
 import com.daml.lf.speedy.Compiler
 import com.daml.nameof.NameOf
 
@@ -30,7 +30,7 @@ private[lf] final class ConcurrentCompiledPackages(compilerConfig: Compiler.Conf
     new ConcurrentHashMap()
 
   override def packageIds: scala.collection.Set[PackageId] = signatures.keySet
-  override def interface: Interface = new Interface(signatures)
+  override def interface: PackageInterface = new PackageInterface(signatures)
   override def getDefinition(dref: speedy.SExpr.SDefinitionRef): Option[speedy.SDefinition] =
     Option(definitionsByReference.get(dref))
 
@@ -99,7 +99,7 @@ private[lf] final class ConcurrentCompiledPackages(compilerConfig: Compiler.Conf
           if (!signatures.contains(pkgId)) {
             val pkgSignature = AstUtil.toSignature(pkg)
             val extendedSignatures =
-              new language.Interface(Map(pkgId -> pkgSignature) orElse signatures)
+              new language.PackageInterface(Map(pkgId -> pkgSignature) orElse signatures)
 
             // Compile the speedy definitions for this package.
             val defns =

diff --git a/daml-lf/engine/src/main/scala/com/digitalasset/daml/lf/engine/Engine.scala b/daml-lf/engine/src/main/scala/com/digitalasset/daml/lf/engine/Engine.scala
@@ -15,7 +15,7 @@ import com.daml.lf.transaction.{SubmittedTransaction, Transaction => Tx}
 import com.daml.lf.transaction.Node._
 import java.nio.file.Files
 
-import com.daml.lf.language.{Interface, LanguageVersion, LookupError, StablePackages}
+import com.daml.lf.language.{PackageInterface, LanguageVersion, LookupError, StablePackages}
 import com.daml.lf.validation.Validation
 import com.daml.nameof.NameOf
 
@@ -456,7 +456,7 @@ class Engine(val config: EngineConfig = Engine.StableConfig) {
       pkgIds = pkgs.keySet
       missingDeps = pkgs.valuesIterator.flatMap(_.directDeps).toSet.filterNot(pkgIds)
       _ <- Either.cond(missingDeps.isEmpty, (), Error.Package.SelfConsistency(pkgIds, missingDeps))
-      interface = Interface(pkgs)
+      interface = PackageInterface(pkgs)
       _ <- {
         pkgs.iterator
           // we trust already loaded packages

diff --git a/...ne/src/main/scala/com/digitalasset/daml/lf/engine/preprocessing/CommandPreprocessor.scala b/...ne/src/main/scala/com/digitalasset/daml/lf/engine/preprocessing/CommandPreprocessor.scala
@@ -12,7 +12,7 @@ import com.daml.lf.value.Value
 import scala.annotation.tailrec
 
 private[lf] final class CommandPreprocessor(
-    interface: language.Interface,
+    interface: language.PackageInterface,
     // See Preprocessor scala doc for more details about the following flags.
     forbidV0ContractId: Boolean,
     requireV1ContractIdSuffix: Boolean,

diff --git a/...engine/src/main/scala/com/digitalasset/daml/lf/engine/preprocessing/ValueTranslator.scala b/...engine/src/main/scala/com/digitalasset/daml/lf/engine/preprocessing/ValueTranslator.scala
@@ -15,7 +15,7 @@ import com.daml.lf.value.Value._
 import scala.annotation.tailrec
 
 private[engine] final class ValueTranslator(
-    interface: language.Interface,
+    interface: language.PackageInterface,
     // See Preprocessor scala doc for more details about the following flags.
     forbidV0ContractId: Boolean,
     requireV1ContractIdSuffix: Boolean,

diff --git a/daml-lf/engine/src/test/scala/com/digitalasset/daml/lf/engine/EngineTest.scala b/daml-lf/engine/src/test/scala/com/digitalasset/daml/lf/engine/EngineTest.scala
@@ -69,7 +69,7 @@ class EngineTest
     "daml-lf/tests/BasicTests.dar"
   )
 
-  val basicTestsSignatures = language.Interface(Map(basicTestsPkgId -> basicTestsPkg))
+  val basicTestsSignatures = language.PackageInterface(Map(basicTestsPkgId -> basicTestsPkg))
 
   val withKeyTemplate = "BasicTests:WithKey"
   val BasicTests_WithKey = Identifier(basicTestsPkgId, withKeyTemplate)
@@ -561,7 +561,7 @@ class EngineTest
     }
 
     val let = Time.Timestamp.now()
-    val submissionSeed = hash("multi-party create command")
+    val submissionSeed = hash("multi-party create command2")
 
     def interpretResult(
         templateId: String,

diff --git a/daml-lf/interpreter/perf/src/main/scala/com/daml/lf/explore/Explore.scala b/daml-lf/interpreter/perf/src/main/scala/com/daml/lf/explore/Explore.scala
@@ -5,7 +5,7 @@ package com.daml.lf
 package speedy
 package explore
 
-import com.daml.lf.language.Interface
+import com.daml.lf.language.PackageInterface
 import com.daml.lf.speedy.SExpr._
 import com.daml.lf.speedy.SValue._
 import com.daml.lf.speedy.SResult._
@@ -25,7 +25,7 @@ object PlaySpeedy {
 
   def main(args0: List[String]) = {
     val config: Config = parseArgs(args0)
-    val compiler: Compiler = new Compiler(Interface.Empty, compilerConfig)
+    val compiler: Compiler = new Compiler(PackageInterface.Empty, compilerConfig)
 
     val names: List[String] = config.names match {
       case Nil => examples.toList.map(_._1)

diff --git a/daml-lf/interpreter/src/main/scala/com/digitalasset/daml/lf/CompiledPackages.scala b/daml-lf/interpreter/src/main/scala/com/digitalasset/daml/lf/CompiledPackages.scala
@@ -5,7 +5,7 @@ package com.daml.lf
 
 import com.daml.lf.data.Ref.PackageId
 import com.daml.lf.language.Ast.{Package, PackageSignature}
-import com.daml.lf.language.{Interface, Util}
+import com.daml.lf.language.{PackageInterface, Util}
 import com.daml.lf.speedy.SExpr.SDefinitionRef
 import com.daml.lf.speedy.{Compiler, SDefinition}
 
@@ -17,7 +17,7 @@ private[lf] abstract class CompiledPackages(
 ) {
   def getDefinition(dref: SDefinitionRef): Option[SDefinition]
   def packageIds: scala.collection.Set[PackageId]
-  def interface: Interface
+  def interface: PackageInterface
   def definitions: PartialFunction[SDefinitionRef, SDefinition] =
     Function.unlift(this.getDefinition)
 
@@ -29,7 +29,7 @@ private[lf] abstract class CompiledPackages(
   */
 private[lf] final class PureCompiledPackages(
     val packageIds: Set[PackageId],
-    val interface: Interface,
+    val interface: PackageInterface,
     val defns: Map[SDefinitionRef, SDefinition],
     compilerConfig: Compiler.Config,
 ) extends CompiledPackages(compilerConfig) {
@@ -46,14 +46,14 @@ private[lf] object PureCompiledPackages {
       defns: Map[SDefinitionRef, SDefinition],
       compilerConfig: Compiler.Config,
   ): PureCompiledPackages =
-    new PureCompiledPackages(packages.keySet, new Interface(packages), defns, compilerConfig)
+    new PureCompiledPackages(packages.keySet, new PackageInterface(packages), defns, compilerConfig)
 
   def build(
       packages: Map[PackageId, Package],
       compilerConfig: Compiler.Config = Compiler.Config.Default,
   ): Either[String, PureCompiledPackages] = {
     Compiler
-      .compilePackages(Interface(packages), packages, compilerConfig)
+      .compilePackages(PackageInterface(packages), packages, compilerConfig)
       .map(apply(Util.toSignatures(packages), _, compilerConfig))
   }
 

diff --git a/daml-lf/interpreter/src/main/scala/com/digitalasset/daml/lf/speedy/Compiler.scala b/daml-lf/interpreter/src/main/scala/com/digitalasset/daml/lf/speedy/Compiler.scala
@@ -8,7 +8,7 @@ import java.util
 import com.daml.lf.data.Ref._
 import com.daml.lf.data.{ImmArray, Numeric, Ref, Struct, Time}
 import com.daml.lf.language.Ast._
-import com.daml.lf.language.{LanguageVersion, LookupError, Interface, StablePackages}
+import com.daml.lf.language.{LanguageVersion, LookupError, PackageInterface, StablePackages}
 import com.daml.lf.speedy.Anf.flattenToAnf
 import com.daml.lf.speedy.Profile.LabelModule
 import com.daml.lf.speedy.SBuiltin._
@@ -105,7 +105,7 @@ private[lf] object Compiler {
     * they transitively reference are in the [[packages]] in the compiler.
     */
   def compilePackages(
-      interface: Interface,
+      interface: PackageInterface,
       packages: Map[PackageId, Package],
       compilerConfig: Compiler.Config,
   ): Either[String, Map[SDefinitionRef, SDefinition]] = {
@@ -136,7 +136,7 @@ private[lf] object Compiler {
 }
 
 private[lf] final class Compiler(
-    interface: Interface,
+    interface: PackageInterface,
     config: Compiler.Config,
 ) {
 

diff --git a/daml-lf/interpreter/src/test/scala/com/digitalasset/daml/lf/speedy/ExceptionTest.scala b/daml-lf/interpreter/src/test/scala/com/digitalasset/daml/lf/speedy/ExceptionTest.scala
@@ -8,7 +8,7 @@ import com.daml.lf.data.Ref
 import com.daml.lf.data.Ref.{PackageId, Party}
 import com.daml.lf.interpretation.{Error => IE}
 import com.daml.lf.language.Ast._
-import com.daml.lf.language.{LanguageVersion, Interface}
+import com.daml.lf.language.{LanguageVersion, PackageInterface}
 import com.daml.lf.speedy.Compiler.FullStackTrace
 import com.daml.lf.speedy.SResult.{SResultError, SResultFinalValue}
 import com.daml.lf.speedy.SError.SErrorDamlException
@@ -539,7 +539,7 @@ class ExceptionTest extends AnyWordSpec with Matchers with TableDrivenPropertyCh
   private def typeAndCompile(pkg: Package): PureCompiledPackages = {
     import defaultParserParameters.defaultPackageId
     val rawPkgs = Map(defaultPackageId -> pkg)
-    Validation.checkPackage(Interface(rawPkgs), defaultPackageId, pkg)
+    Validation.checkPackage(PackageInterface(rawPkgs), defaultPackageId, pkg)
     val compilerConfig = Compiler.Config.Dev.copy(stacktracing = FullStackTrace)
     PureCompiledPackages.assertBuild(rawPkgs, compilerConfig)
   }

diff --git a/daml-lf/interpreter/src/test/scala/com/digitalasset/daml/lf/speedy/RollbackTest.scala b/daml-lf/interpreter/src/test/scala/com/digitalasset/daml/lf/speedy/RollbackTest.scala
@@ -8,7 +8,7 @@ import com.daml.lf.data.ImmArray
 import com.daml.lf.data.Ref
 import com.daml.lf.data.Ref.Party
 import com.daml.lf.language.Ast.{Package, Expr, PrimLit, PLParty, EPrimLit, EApp}
-import com.daml.lf.language.{LanguageVersion, Interface}
+import com.daml.lf.language.{LanguageVersion, PackageInterface}
 import com.daml.lf.speedy.Compiler.FullStackTrace
 import com.daml.lf.speedy.PartialTransaction.{CompleteTransaction, IncompleteTransaction, LeafNode}
 import com.daml.lf.speedy.SResult.SResultFinalValue
@@ -38,7 +38,7 @@ class ExceptionTest extends AnyWordSpec with Matchers with TableDrivenPropertyCh
   private def typeAndCompile(pkg: Package): PureCompiledPackages = {
     import defaultParserParameters.defaultPackageId
     val rawPkgs = Map(defaultPackageId -> pkg)
-    Validation.checkPackage(Interface(rawPkgs), defaultPackageId, pkg)
+    Validation.checkPackage(PackageInterface(rawPkgs), defaultPackageId, pkg)
     val compilerConfig = Compiler.Config.Dev.copy(stacktracing = FullStackTrace)
     PureCompiledPackages.assertBuild(rawPkgs, compilerConfig)
   }

diff --git a/daml-lf/interpreter/src/test/scala/com/digitalasset/daml/lf/speedy/SpeedyTest.scala b/daml-lf/interpreter/src/test/scala/com/digitalasset/daml/lf/speedy/SpeedyTest.scala
@@ -517,7 +517,7 @@ object SpeedyTest {
   private def typeAndCompile(pkg: Package): PureCompiledPackages = {
     import defaultParserParameters.defaultPackageId
     val rawPkgs = Map(defaultPackageId -> pkg)
-    Validation.checkPackage(language.Interface(rawPkgs), defaultPackageId, pkg)
+    Validation.checkPackage(language.PackageInterface(rawPkgs), defaultPackageId, pkg)
     val compilerConfig = Compiler.Config.Default.copy(stacktracing = FullStackTrace)
     PureCompiledPackages.assertBuild(rawPkgs, compilerConfig)
   }

diff --git a/daml-lf/interpreter/src/test/scala/com/digitalasset/daml/lf/speedy/TailCallTest.scala b/daml-lf/interpreter/src/test/scala/com/digitalasset/daml/lf/speedy/TailCallTest.scala
@@ -105,7 +105,7 @@ class TailCallTest extends AnyWordSpec with Matchers with TableDrivenPropertyChe
     import defaultParserParameters.defaultPackageId
     val rawPkgs = Map(defaultPackageId -> pkg)
     Validation.checkPackage(
-      language.Interface(rawPkgs),
+      language.PackageInterface(rawPkgs),
       defaultParserParameters.defaultPackageId,
       pkg,
     )

diff --git a/...talasset/daml/lf/language/Interface.scala → ...t/daml/lf/language/PackageInterface.scala b/...talasset/daml/lf/language/Interface.scala → ...t/daml/lf/language/PackageInterface.scala
@@ -7,9 +7,9 @@ package language
 import com.daml.lf.data.Ref._
 import com.daml.lf.language.Ast._
 
-private[lf] class Interface(signatures: PartialFunction[PackageId, PackageSignature]) {
+private[lf] class PackageInterface(signatures: PartialFunction[PackageId, PackageSignature]) {
 
-  import Interface._
+  import PackageInterface._
 
   private[this] def lookupPackage(
       pkgId: PackageId,
@@ -263,12 +263,12 @@ private[lf] class Interface(signatures: PartialFunction[PackageId, PackageSignat
 
 }
 
-object Interface {
+object PackageInterface {
 
-  val Empty = new Interface(PartialFunction.empty)
+  val Empty = new PackageInterface(PartialFunction.empty)
 
-  def apply(packages: Map[PackageId, Package]): Interface =
-    new Interface(Util.toSignatures(packages))
+  def apply(packages: Map[PackageId, Package]): PackageInterface =
+    new PackageInterface(Util.toSignatures(packages))
 
   case class DataRecordInfo(
       dataType: DDataType,

diff --git a/daml-lf/repl/src/main/scala/com/digitalasset/daml/lf/repl/testing/Main.scala b/daml-lf/repl/src/main/scala/com/digitalasset/daml/lf/repl/testing/Main.scala
@@ -16,7 +16,7 @@ import com.daml.lf.speedy.SResult._
 import com.daml.lf.speedy.SExpr.LfDefRef
 import com.daml.lf.validation.Validation
 import com.daml.lf.testing.parser
-import com.daml.lf.language.{Interface, LanguageVersion => LV}
+import com.daml.lf.language.{PackageInterface, LanguageVersion => LV}
 import java.io.{File, PrintWriter, StringWriter}
 import java.nio.file.{Path, Paths}
 import java.io.PrintStream
@@ -156,7 +156,7 @@ object Repl {
 
   def cmdValidate(state: State): (Boolean, State) = {
     val (validationResults, validationTime) = time(state.packages.map { case (pkgId, pkg) =>
-      Validation.checkPackage(Interface(state.packages), pkgId, pkg)
+      Validation.checkPackage(PackageInterface(state.packages), pkgId, pkg)
     })
     System.err.println(s"${state.packages.size} package(s) validated in $validationTime ms.")
     validationResults collectFirst { case Left(e) =>
@@ -428,7 +428,7 @@ object Repl {
   def speedyCompile(state: State, args: Seq[String]): Unit = {
     val defs = assertRight(
       Compiler.compilePackages(
-        Interface(state.packages),
+        PackageInterface(state.packages),
         state.packages,
         state.scenarioRunner.compilerConfig,
       )

diff --git a/...-lf/validation/src/main/scala/com/digitalasset/daml/lf/validation/DependencyVersion.scala b/...-lf/validation/src/main/scala/com/digitalasset/daml/lf/validation/DependencyVersion.scala
@@ -12,7 +12,7 @@ import scala.Ordering.Implicits.infixOrderingOps
 private[validation] object DependencyVersion {
 
   @throws[ValidationError]
-  def checkPackage(interface: language.Interface, pkgId: PackageId, pkg: Package): Unit =
+  def checkPackage(interface: language.PackageInterface, pkgId: PackageId, pkg: Package): Unit =
     for {
       depPkgId <- pkg.directDeps
       depPkg = Util.handleLookup(NoContext, interface.lookupPackage(depPkgId))

diff --git a/daml-lf/validation/src/main/scala/com/digitalasset/daml/lf/validation/PartyLiterals.scala b/daml-lf/validation/src/main/scala/com/digitalasset/daml/lf/validation/PartyLiterals.scala
@@ -5,15 +5,15 @@ package com.daml.lf.validation
 
 import com.daml.lf.data.Ref.PackageId
 import com.daml.lf.language.Ast._
-import com.daml.lf.language.Interface
+import com.daml.lf.language.PackageInterface
 import com.daml.lf.validation.iterable.ExprIterable
 
 private[validation] object PartyLiterals {
 
   import Util.handleLookup
 
   @throws[EForbiddenPartyLiterals]
-  def checkModule(interface: Interface, pkgId: PackageId, module: Module): Unit = {
+  def checkModule(interface: PackageInterface, pkgId: PackageId, module: Module): Unit = {
     module.definitions.foreach {
       case (defName, DValue(typ @ _, noPartyLiterals, body, isTest @ _)) =>
         def context = ContextDefValue(pkgId, module.name, defName)
@@ -29,7 +29,7 @@ private[validation] object PartyLiterals {
     }
   }
 
-  private def checkExpr(interface: Interface, context: => Context, expr: Expr): Unit =
+  private def checkExpr(interface: PackageInterface, context: => Context, expr: Expr): Unit =
     expr match {
       case EPrimLit(party: PLParty) =>
         throw EForbiddenPartyLiterals(context, PartyLiteral(party.value))