LF: Factorize the logic for Ast lookup

compiler/repl-service/server/src/main/scala/com/digitalasset/daml/lf/speedy/ReplServiceMain.scala

@@ -1,7 +1,8 @@
 // Copyright (c) 2021 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-package com.daml.lf.speedy.repl
+package com.daml.lf
+package speedy.repl
 
 import akka.actor.ActorSystem
 import akka.stream._
@@ -223,7 +224,8 @@ class ReplService(
     val (pkgId, pkg) = Decode.decodeArchiveFromInputStream(req.getPackage.newInput)
     val newSignatures = signatures.updated(pkgId, AstUtil.toSignature(pkg))
     val newCompiledDefinitions = compiledDefinitions ++
-      new Compiler(newSignatures, compilerConfig).unsafeCompilePackage(pkgId, pkg)
+      new Compiler(language.Interface(newSignatures), compilerConfig)
+        .unsafeCompilePackage(pkgId, pkg)
     signatures = newSignatures
     compiledDefinitions = newCompiledDefinitions
     respObs.onNext(LoadPackageResponse.newBuilder.build)
@@ -258,12 +260,11 @@ class ReplService(
     }
 
     val signatures = this.signatures.updated(homePackageId, AstUtil.toSignature(pkg))
-    val defs = new Compiler(signatures, compilerConfig).unsafeCompilePackage(homePackageId, pkg)
-    val compiledPackages = new PureCompiledPackages(
-      signatures,
-      compiledDefinitions ++ defs,
-      compilerConfig,
-    )
+    val interface = language.Interface(signatures)
+    val defs =
+      new Compiler(interface, compilerConfig).unsafeCompilePackage(homePackageId, pkg)
+    val compiledPackages =
+      PureCompiledPackages(signatures, compiledDefinitions ++ defs, compilerConfig)
     val runner =
       new Runner(compiledPackages, Script.Action(scriptExpr, ScriptIds(scriptPackageId)), timeMode)
     runner

compiler/scenario-service/server/src/main/scala/com/digitalasset/daml/lf/scenario/Context.scala

@@ -116,8 +116,9 @@ 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 = language.Interface(newExtSignature)
         val newExtDefns = extDefns.view.filterKeys(sdef => !invalidPackages(sdef.packageId)) ++
-          assertRight(Compiler.compilePackages(newExtSignature, newPackages, compilerConfig))
+          assertRight(Compiler.compilePackages(interface, newPackages, compilerConfig))
         // we update only if we manage to compile the new packages
         extSignatures = newExtSignature
         extDefns = newExtDefns.toMap
@@ -128,12 +129,12 @@ class Context(val contextId: Context.ContextId, languageVersion: LanguageVersion
         newModules
       }
 
-    val allSignatures = this.allSignatures
-    val compiler = new Compiler(allSignatures, compilerConfig)
+    val interface = language.Interface(this.allSignatures)
+    val compiler = new Compiler(interface, compilerConfig)
 
     modulesToCompile.foreach { mod =>
       if (!omitValidation)
-        assertRight(Validation.checkModule(allSignatures, homePackageId, mod).left.map(_.pretty))
+        assertRight(Validation.checkModule(interface, homePackageId, mod).left.map(_.pretty))
       modDefns +=
         mod.name -> compiler.unsafeCompileModule(homePackageId, mod).toMap
     }
@@ -156,8 +157,7 @@ class Context(val contextId: Context.ContextId, languageVersion: LanguageVersion
 
   private def buildMachine(identifier: Identifier): Option[Speedy.Machine] = {
     val defns = this.defns
-    val compiledPackages =
-      PureCompiledPackages(allSignatures, defns, compilerConfig)
+    val compiledPackages = PureCompiledPackages(allSignatures, defns, compilerConfig)
     for {
       defn <- defns.get(LfDefRef(identifier))
     } yield Speedy.Machine.fromScenarioSExpr(
@@ -192,8 +192,7 @@ class Context(val contextId: Context.ContextId, languageVersion: LanguageVersion
       mat: Materializer,
   ): Future[Option[(ScenarioLedger, (Speedy.Machine, Speedy.Machine), Either[SError, SValue])]] = {
     val defns = this.defns
-    val compiledPackages =
-      PureCompiledPackages(allSignatures, defns, compilerConfig)
+    val compiledPackages = PureCompiledPackages(allSignatures, defns, compilerConfig)
     val expectedScriptId = DottedName.assertFromString("Daml.Script")
     val Some(scriptPackageId) = allSignatures.collectFirst {
       case (pkgId, pkg) if pkg.modules contains expectedScriptId => pkgId

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

@@ -961,12 +961,10 @@ class DecodeV1Spec
       inside(
         decoder.decoder
           .decodePackage(pkgId, decoder.extract(dalfProto))
-          .lookupDefinition(Ref.QualifiedName assertFromString "DarReaderTest:reverseCopy")
-      ) {
-        case Right(
-              Ast.DValue(_, _, Ast.ELocation(_, Ast.EVal(Ref.Identifier(resolvedExtId, _))), _)
-            ) =>
-          (resolvedExtId: String) should ===(extId: String)
+          .modules(Ref.DottedName.assertFromString("DarReaderTest"))
+          .definitions(Ref.DottedName.assertFromString("reverseCopy"))
+      ) { case Ast.DValue(_, _, Ast.ELocation(_, Ast.EVal(Ref.Identifier(resolvedExtId, _))), _) =>
+        (resolvedExtId: String) should ===(extId: String)
       }
     }
   }

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, LanguageMajorVersion, LanguageVersion}
+import com.daml.lf.language.{Ast, Interface, LanguageMajorVersion, LanguageVersion}
 import com.daml.lf.testing.parser.{ParserParameters, parseModules}
 import com.daml.lf.validation.Validation
 import com.daml.SdkVersion
@@ -70,11 +70,11 @@ private[daml] object DamlLfEncoder extends App {
       } else None
 
     val pkg = Ast.Package(modules, Set.empty[PackageId], parserParameters.languageVersion, metadata)
-    val pkgs = Map(pkgId -> pkg)
+    val pkgs = Interface(Map(pkgId -> pkg))
 
     Validation.checkPackage(pkgs, pkgId, pkg).left.foreach(e => error(e.pretty))
 
-    encodeArchive(pkgId -> pkgs(pkgId), parserParameters.languageVersion)
+    encodeArchive(pkgId -> pkg, parserParameters.languageVersion)
   }
 
   private def makeDar(source: String, file: File)(implicit

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

@@ -1,7 +1,8 @@
 // Copyright (c) 2021 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-package com.daml.lf.testing.archive
+package com.daml.lf
+package testing.archive
 
 import com.daml.lf.archive.Decode
 import com.daml.lf.archive.testing.Encode
@@ -183,7 +184,7 @@ object EncodeV1Spec {
 
   private def validate(pkgId: PackageId, pkg: Package): Unit =
     Validation
-      .checkPackage(Map(pkgId -> pkg), pkgId, pkg)
+      .checkPackage(language.Interface(Map(pkgId -> pkg)), pkgId, pkg)
       .left
       .foreach(e => sys.error(e.toString))
 

daml-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.{Util => AstUtil}
+import com.daml.lf.language.{Interface, Util => AstUtil}
 import com.daml.lf.speedy.Compiler
 import com.daml.lf.speedy.Compiler.CompilationError
 
@@ -21,16 +21,18 @@ import scala.collection.concurrent.{Map => ConcurrentMap}
   */
 private[lf] final class ConcurrentCompiledPackages(compilerConfig: Compiler.Config)
     extends MutableCompiledPackages(compilerConfig) {
-  private[this] val _signatures: ConcurrentMap[PackageId, PackageSignature] =
+  private[this] val signatures: ConcurrentMap[PackageId, PackageSignature] =
     new ConcurrentHashMap().asScala
-  private[this] val _defns: ConcurrentHashMap[speedy.SExpr.SDefinitionRef, speedy.SDefinition] =
+  private[this] val definitions
+      : ConcurrentHashMap[speedy.SExpr.SDefinitionRef, speedy.SDefinition] =
     new ConcurrentHashMap()
-  private[this] val _packageDeps: ConcurrentHashMap[PackageId, Set[PackageId]] =
+  private[this] val packageDeps: ConcurrentHashMap[PackageId, Set[PackageId]] =
     new ConcurrentHashMap()
 
-  override def getSignature(pId: PackageId): Option[PackageSignature] = _signatures.get(pId)
+  override def packageIds: scala.collection.Set[PackageId] = signatures.keySet
+  override def interface: Interface = Interface(signatures)
   override def getDefinition(dref: speedy.SExpr.SDefinitionRef): Option[speedy.SDefinition] =
-    Option(_defns.get(dref))
+    Option(definitions.get(dref))
 
   /** Might ask for a package if the package you're trying to add references it.
     *
@@ -56,7 +58,7 @@ private[lf] final class ConcurrentCompiledPackages(compilerConfig: Compiler.Conf
         val pkgId: PackageId = toCompile.head
         toCompile = toCompile.tail
 
-        if (!_signatures.contains(pkgId)) {
+        if (!signatures.contains(pkgId)) {
 
           val pkg = state.packages.get(pkgId) match {
             case None => return ResultError(Error(s"Could not find package $pkgId"))
@@ -65,7 +67,7 @@ private[lf] final class ConcurrentCompiledPackages(compilerConfig: Compiler.Conf
 
           // Load dependencies of this package and transitively its dependencies.
           for (dependency <- pkg.directDeps) {
-            if (!_signatures.contains(dependency) && !state.seenDependencies.contains(dependency)) {
+            if (!signatures.contains(dependency) && !state.seenDependencies.contains(dependency)) {
               return ResultNeedPackage(
                 dependency,
                 {
@@ -87,33 +89,30 @@ private[lf] final class ConcurrentCompiledPackages(compilerConfig: Compiler.Conf
           // map using 'computeIfAbsent' which will ensure we only compile the
           // package once. Other concurrent calls to add this package will block
           // waiting for the first one to finish.
-          if (!_signatures.contains(pkgId)) {
-            val signature = AstUtil.toSignature(pkg)
-            val signatureLookup: PartialFunction[PackageId, PackageSignature] = { case `pkgId` =>
-              signature
-            }
+          if (!signatures.contains(pkgId)) {
+            val tempSignature = language.Interface(Map(pkgId -> pkg) orElse signatures)
+
             // Compile the speedy definitions for this package.
             val defns =
               try {
-                new speedy.Compiler(signatureLookup orElse _signatures, compilerConfig)
-                  .unsafeCompilePackage(pkgId, pkg)
+                new speedy.Compiler(tempSignature, compilerConfig).unsafeCompilePackage(pkgId, pkg)
               } catch {
                 case CompilationError(msg) =>
                   return ResultError(Error(s"Compilation Error: $msg"))
                 case e: validation.ValidationError =>
                   return ResultError(Error(s"Validation Error: ${e.pretty}"))
               }
             defns.foreach { case (defnId, defn) =>
-              _defns.put(defnId, defn)
+              definitions.put(defnId, defn)
             }
             // Compute the transitive dependencies of the new package. Since we are adding
             // packages in dependency order we can just union the dependencies of the
             // direct dependencies to get the complete transitive dependencies.
             val deps = pkg.directDeps.foldLeft(pkg.directDeps) { case (deps, dependency) =>
-              deps union _packageDeps.get(dependency)
+              deps union packageDeps.get(dependency)
             }
-            _packageDeps.put(pkgId, deps)
-            _signatures.put(pkgId, signature)
+            packageDeps.put(pkgId, deps)
+            signatures.put(pkgId, AstUtil.toSignature(pkg))
           }
         }
       }
@@ -122,16 +121,13 @@ private[lf] final class ConcurrentCompiledPackages(compilerConfig: Compiler.Conf
     }
 
   def clear(): Unit = this.synchronized[Unit] {
-    _signatures.clear()
-    _packageDeps.clear()
-    _defns.clear()
+    signatures.clear()
+    packageDeps.clear()
+    definitions.clear()
   }
 
-  override def packageIds: Set[PackageId] =
-    _signatures.keySet.toSet
-
   def getPackageDependencies(pkgId: PackageId): Option[Set[PackageId]] =
-    Option(_packageDeps.get(pkgId))
+    Option(packageDeps.get(pkgId))
 }
 
 object ConcurrentCompiledPackages {

daml-lf/engine/src/main/scala/com/digitalasset/daml/lf/engine/Engine.scala

@@ -16,7 +16,7 @@ import com.daml.lf.transaction.Node._
 import com.daml.lf.value.Value
 import java.nio.file.Files
 
-import com.daml.lf.language.LanguageVersion
+import com.daml.lf.language.{LanguageVersion, Interface}
 import com.daml.lf.validation.Validation
 import com.daml.lf.value.Value.ContractId
 
@@ -217,7 +217,7 @@ class Engine(val config: EngineConfig = new EngineConfig(LanguageVersion.StableV
   }
 
   private[engine] def loadPackages(pkgIds: List[PackageId]): Result[Unit] =
-    pkgIds.dropWhile(compiledPackages.signatures.isDefinedAt) match {
+    pkgIds.dropWhile(compiledPackages.packageIds.contains) match {
       case pkgId :: rest =>
         ResultNeedPackage(
           pkgId,
@@ -415,7 +415,6 @@ class Engine(val config: EngineConfig = new EngineConfig(LanguageVersion.StableV
       pkgIds: Set[PackageId],
       pkgs: Map[PackageId, Package],
   ): Either[Error, Unit] = {
-    val allSignatures = pkgs orElse compiledPackages().signatures
     for {
       _ <- pkgs
         .collectFirst {
@@ -427,15 +426,15 @@ class Engine(val config: EngineConfig = new EngineConfig(LanguageVersion.StableV
         }
         .toLeft(())
       _ <- {
-        val unknownPackages = pkgIds.filterNot(allSignatures.isDefinedAt)
+        val unknownPackages = pkgIds.filterNot(pkgs.isDefinedAt)
         Either.cond(
           unknownPackages.isEmpty,
           (),
           Error(s"Unknown packages ${unknownPackages.mkString(", ")}"),
         )
       }
       _ <- {
-        val missingDeps = pkgIds.flatMap(pkgId => allSignatures(pkgId).directDeps).filterNot(pkgIds)
+        val missingDeps = pkgs.valuesIterator.flatMap(_.directDeps).toSet.filterNot(pkgIds)
         Either.cond(
           missingDeps.isEmpty,
           (),
@@ -445,12 +444,13 @@ class Engine(val config: EngineConfig = new EngineConfig(LanguageVersion.StableV
           ),
         )
       }
+      interface = Interface(pkgs)
       _ <- {
         pkgs.iterator
           // we trust already loaded packages
           .collect {
-            case (pkgId, pkg) if !compiledPackages.signatures.isDefinedAt(pkgId) =>
-              Validation.checkPackage(allSignatures, pkgId, pkg)
+            case (pkgId, pkg) if !compiledPackages.packageIds.contains(pkgId) =>
+              Validation.checkPackage(interface, pkgId, pkg)
           }
           .collectFirst { case Left(err) => Error(err.pretty) }
       }.toLeft(())