Remove major version parameter from the interpreter

sdk/canton/community/common/src/main/scala/com/daml/lf/CantonOnly.scala

@@ -41,8 +41,7 @@ object CantonOnly {
   ): PureCompiledPackages = {
     PureCompiledPackages.assertBuild(
       darMap,
-      if (enableLfDev) Compiler.Config.Dev(LanguageMajorVersion.V2)
-      else Compiler.Config.Default(LanguageMajorVersion.V2),
+      if (enableLfDev) Compiler.Config.Dev else Compiler.Config.Default,
     )
   }
 

sdk/canton/community/ledger/ledger-api-core/src/test/scala/com/digitalasset/canton/platform/IndexComponentTest.scala

@@ -148,7 +148,7 @@ trait IndexComponentTest extends PekkoBeforeAndAfterAll with BaseTest {
           metrics = Metrics.ForTesting,
           servicesExecutionContext = ec,
           engine = new Engine(
-            EngineConfig(LanguageVersion.StableVersions(LanguageMajorVersion.V2))
+            EngineConfig(LanguageVersion.StableVersions)
           ),
           inMemoryState = inMemoryState,
           tracer = NoReportingTracerProvider.tracer,

sdk/canton/community/ledger/ledger-api-core/src/test/scala/com/digitalasset/canton/platform/store/dao/JdbcLedgerDaoBackend.scala

@@ -121,7 +121,7 @@ private[dao] trait JdbcLedgerDaoBackend extends PekkoBeforeAndAfterAll with Base
       servicesExecutionContext = ec,
       metrics = metrics,
       engine = Some(
-        new Engine(EngineConfig(LanguageVersion.StableVersions(LanguageMajorVersion.V2)))
+        new Engine(EngineConfig(LanguageVersion.StableVersions))
       ),
       participantId = JdbcLedgerDaoBackend.TestParticipantIdRef,
       ledgerEndCache = ledgerEndCache,

sdk/canton/community/participant/src/main/scala/com/digitalasset/canton/participant/util/DAMLe.scala

@@ -43,11 +43,11 @@ object DAMLe {
       EngineConfig(
         allowedLanguageVersions =
           if (enableLfDev)
-            LanguageVersion.AllVersions(LanguageMajorVersion.V2)
+            LanguageVersion.DevVersions
           else
             VersionRange(
               LanguageVersion.v2_1,
-              LanguageVersion.StableVersions(LanguageMajorVersion.V2).max,
+              LanguageVersion.StableVersions.max,
             ),
         // The package store contains only validated packages, so we can skip validation upon loading
         packageValidation = false,

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

@@ -63,7 +63,7 @@ class Context(
 
   private val compilerConfig =
     Compiler.Config(
-      allowedLanguageVersions = LanguageVersion.AllVersions(languageVersion.major),
+      allowedLanguageVersions = LanguageVersion.DevVersions,
       packageValidation = Compiler.FullPackageValidation,
       profiling = Compiler.NoProfile,
       stacktracing = Compiler.FullStackTrace,

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

@@ -23,7 +23,7 @@ import com.daml.lf.transaction.{
 import java.nio.file.Files
 import com.daml.lf.value.Value
 import com.daml.lf.value.Value.ContractId
-import com.daml.lf.language.{LanguageMajorVersion, LanguageVersion, LookupError, PackageInterface}
+import com.daml.lf.language.{LanguageVersion, LookupError, PackageInterface}
 import com.daml.lf.stablepackages.StablePackages
 import com.daml.lf.validation.Validation
 import com.daml.logging.LoggingContext
@@ -624,7 +624,7 @@ object Engine {
     }
   }
 
-  def DevEngine(majorLanguageVersion: LanguageMajorVersion): Engine = new Engine(
-    EngineConfig(allowedLanguageVersions = LanguageVersion.AllVersions(majorLanguageVersion))
+  def DevEngine: Engine = new Engine(
+    EngineConfig(allowedLanguageVersions = LanguageVersion.DevVersions)
   )
 }

sdk/daml-lf/engine/src/test/scala/com/digitalasset/daml/lf/engine/ApiCommandPreprocessorSpec.scala

@@ -109,7 +109,7 @@ class ApiCommandPreprocessorSpec(majorLanguageVersion: LanguageMajorVersion)
     """
 
   private[this] val compiledPackage = ConcurrentCompiledPackages(
-    Compiler.Config.Default(majorLanguageVersion)
+    Compiler.Config.Default
   )
   assert(compiledPackage.addPackage(defaultPackageId, pkg) == ResultDone.Unit)
 

sdk/daml-lf/engine/src/test/scala/com/digitalasset/daml/lf/engine/AuthPropagationSpec.scala

@@ -107,7 +107,7 @@ class AuthPropagationSpec(majorLanguageVersion: LanguageMajorVersion)
   private val submissionSeed: crypto.Hash = crypto.Hash.hashPrivateKey("submissionSeed")
 
   private val testEngine: Engine =
-    Engine.DevEngine(majorLanguageVersion)
+    Engine.DevEngine
 
   private def go(
       submitters: Set[Party],

sdk/daml-lf/engine/src/test/scala/com/digitalasset/daml/lf/engine/ConcurrentCompiledPackagesTest.scala

@@ -35,14 +35,14 @@ class ConcurrentCompiledPackagesTest(majorLanguageVersion: LanguageMajorVersion)
 
     "load valid package" in {
 
-      new ConcurrentCompiledPackages(Compiler.Config.Dev(majorLanguageVersion))
+      new ConcurrentCompiledPackages(Compiler.Config.Dev)
         .addPackage(parserParameters.defaultPackageId, pkg) shouldBe ResultDone(())
 
     }
 
     "not load of an invalid package" in {
 
-      val packages = new ConcurrentCompiledPackages(Compiler.Config.Dev(majorLanguageVersion))
+      val packages = new ConcurrentCompiledPackages(Compiler.Config.Dev)
 
       val illFormedPackage =
         p"""

sdk/daml-lf/engine/src/test/scala/com/digitalasset/daml/lf/engine/ContractKeySpec.scala

@@ -10,7 +10,6 @@ import com.daml.lf.command.ApiCommand
 import com.daml.lf.data.Ref.{Identifier, Name, PackageId, Party, QualifiedName, TypeConName}
 import com.daml.lf.data.{Bytes, ImmArray, Ref, Time}
 import com.daml.lf.language.Ast.Package
-import com.daml.lf.language.LanguageMajorVersion
 import com.daml.lf.speedy.InitialSeeding
 import com.daml.lf.transaction.test.TransactionBuilder.assertAsVersionedContract
 import com.daml.lf.transaction.{ContractKeyUniquenessMode, GlobalKey, GlobalKeyWithMaintainers}
@@ -35,16 +34,14 @@ import org.scalatest.wordspec.AnyWordSpec
 
 import scala.language.implicitConversions
 
-class ContractKeySpecV2 extends ContractKeySpec(LanguageMajorVersion.V2)
-
 @SuppressWarnings(
   Array(
     "org.wartremover.warts.Any",
     "org.wartremover.warts.Serializable",
     "org.wartremover.warts.Product",
   )
 )
-class ContractKeySpec(majorLanguageVersion: LanguageMajorVersion)
+class ContractKeySpec
     extends AnyWordSpec
     with Matchers
     with TableDrivenPropertyChecks
@@ -55,7 +52,7 @@ class ContractKeySpec(majorLanguageVersion: LanguageMajorVersion)
 
   private[this] implicit def logContext: LoggingContext = LoggingContext.ForTesting
 
-  private[this] val suffixLenientEngine = Engine.DevEngine(majorLanguageVersion)
+  private[this] val suffixLenientEngine = Engine.DevEngine
   private[this] val compiledPackages = ConcurrentCompiledPackages(
     suffixLenientEngine.config.getCompilerConfig
   )
@@ -71,7 +68,7 @@ class ContractKeySpec(majorLanguageVersion: LanguageMajorVersion)
   }
 
   private val (basicTestsPkgId, basicTestsPkg, allPackages) = loadAndAddPackage(
-    s"daml-lf/engine/BasicTests-v${majorLanguageVersion.pretty}dev.dar"
+    s"daml-lf/engine/BasicTests-v2dev.dar"
   )
 
   val basicTestsSignatures = language.PackageInterface(Map(basicTestsPkgId -> basicTestsPkg))
@@ -263,20 +260,20 @@ class ContractKeySpec(majorLanguageVersion: LanguageMajorVersion)
       import com.daml.lf.language.{LanguageVersion => LV}
       val nonUckEngine = new Engine(
         EngineConfig(
-          allowedLanguageVersions = LV.AllVersions(majorLanguageVersion),
+          allowedLanguageVersions = LV.DevVersions,
           contractKeyUniqueness = ContractKeyUniquenessMode.Off,
           requireSuffixedGlobalContractId = true,
         )
       )
       val uckEngine = new Engine(
         EngineConfig(
-          allowedLanguageVersions = LV.AllVersions(majorLanguageVersion),
+          allowedLanguageVersions = LV.DevVersions,
           contractKeyUniqueness = ContractKeyUniquenessMode.Strict,
           requireSuffixedGlobalContractId = true,
         )
       )
       val (multiKeysPkgId, multiKeysPkg, allMultiKeysPkgs) =
-        loadAndAddPackage(s"daml-lf/tests/MultiKeys-v${majorLanguageVersion.pretty}dev.dar")
+        loadAndAddPackage(s"daml-lf/tests/MultiKeys-v2dev.dar")
       val keyedId = Identifier(multiKeysPkgId, "MultiKeys:Keyed")
       val opsId = Identifier(multiKeysPkgId, "MultiKeys:KeyOperations")
       val let = Time.Timestamp.now()

sdk/daml-lf/engine/src/test/scala/com/digitalasset/daml/lf/engine/EngineInfoTest.scala

@@ -3,7 +3,7 @@
 
 package com.daml.lf.engine
 
-import com.daml.lf.language.{LanguageMajorVersion, LanguageVersion}
+import com.daml.lf.language.LanguageVersion
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.wordspec.AnyWordSpec
 
@@ -17,9 +17,9 @@ class EngineInfoTest extends AnyWordSpec with Matchers {
       engineInfoV2,
     ) =
       List(
-        LanguageVersion.StableVersions(LanguageMajorVersion.V2),
-        LanguageVersion.EarlyAccessVersions(LanguageMajorVersion.V2),
-        LanguageVersion.AllVersions(LanguageMajorVersion.V2),
+        LanguageVersion.StableVersions,
+        LanguageVersion.EarlyAccessVersions,
+        LanguageVersion.DevVersions,
       ).map(versions => new EngineInfo(EngineConfig(allowedLanguageVersions = versions)))
 
     "show supported LF, Transaction and Value versions" in {

sdk/daml-lf/engine/src/test/scala/com/digitalasset/daml/lf/engine/EngineTest.scala

@@ -2535,7 +2535,7 @@ class EngineTestHelpers(majorLanguageVersion: LanguageMajorVersion) {
   def newEngine(requireCidSuffixes: Boolean = false) =
     new Engine(
       EngineConfig(
-        allowedLanguageVersions = language.LanguageVersion.AllVersions(majorLanguageVersion),
+        allowedLanguageVersions = language.LanguageVersion.DevVersions,
         requireSuffixedGlobalContractId = requireCidSuffixes,
       )
     )

sdk/daml-lf/engine/src/test/scala/com/digitalasset/daml/lf/engine/EngineValidatePackagesTest.scala

@@ -5,29 +5,24 @@ package com.daml.lf
 package engine
 
 import com.daml.lf.data.Ref
-import com.daml.lf.language.{LanguageMajorVersion, LanguageVersion}
+import com.daml.lf.language.LanguageVersion
 import com.daml.lf.testing.parser
 import com.daml.lf.testing.parser.Implicits.SyntaxHelper
 import org.scalatest.Inside
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.wordspec.AnyWordSpec
 
-class EngineValidatePackagesTestV2 extends EngineValidatePackagesTest(LanguageMajorVersion.V2)
-
-class EngineValidatePackagesTest(majorLanguageVersion: LanguageMajorVersion)
-    extends AnyWordSpec
-    with Matchers
-    with Inside {
+class EngineValidatePackages extends AnyWordSpec with Matchers with Inside {
 
   val pkgId = Ref.PackageId.assertFromString("-pkg-")
 
-  val langVersion = LanguageVersion.defaultOrLatestStable(majorLanguageVersion)
+  val langVersion = LanguageVersion.defaultOrLatestStable
 
   implicit val parserParameters: parser.ParserParameters[this.type] =
     parser.ParserParameters(pkgId, langVersion)
 
   private def newEngine = new Engine(
-    EngineConfig(LanguageVersion.AllVersions(majorLanguageVersion))
+    EngineConfig(LanguageVersion.DevVersions)
   )
 
   "Engine.validatePackages" should {

sdk/daml-lf/engine/src/test/scala/com/digitalasset/daml/lf/engine/InterfaceViewSpec.scala

@@ -54,7 +54,7 @@ class InterfaceViewSpec(majorLanguageVersion: LanguageMajorVersion)
 
   val interfaceviewsSignatures =
     language.PackageInterface(Map(interfaceviewsPkgId -> interfaceviewsPkg))
-  val engine = Engine.DevEngine(majorLanguageVersion)
+  val engine = Engine.DevEngine
 
   private def id(s: String) = Identifier(interfaceviewsPkgId, s"InterfaceViews:$s")
 

sdk/daml-lf/engine/src/test/scala/com/digitalasset/daml/lf/engine/LargeTransactionTest.scala

@@ -109,7 +109,7 @@ class LargeTransactionTest(majorLanguageVersion: LanguageMajorVersion)
   private def report(name: String, quantity: Quantity[Double]): Unit =
     println(s"$name: $quantity")
 
-  private val engine = Engine.DevEngine(majorLanguageVersion)
+  private val engine = Engine.DevEngine
 
   List(5000, 50000, 500000)
     .foreach { txSize =>

sdk/daml-lf/engine/src/test/scala/com/digitalasset/daml/lf/engine/MetaDataTest.scala

@@ -154,7 +154,7 @@ class MetaDataTestHelper(majorLanguageVersion: LanguageMajorVersion) {
       Some(TransactionVersion.assignNodeVersion(langVersion))
   }
 
-  val engine = Engine.DevEngine(majorLanguageVersion)
+  val engine = Engine.DevEngine
 
   def emptyPkg(pkgName: String): language.Ast.Package =
     language.Ast.Package(

sdk/daml-lf/engine/src/test/scala/com/digitalasset/daml/lf/engine/NodeSeedsTest.scala

@@ -36,7 +36,7 @@ class NodeSeedsTest(majorLanguageVersion: LanguageMajorVersion) extends AnyWordS
     (packages.main._1, packages.main._2, packages.all.toMap)
   }
 
-  val engine = Engine.DevEngine(majorLanguageVersion)
+  val engine = Engine.DevEngine
 
   val operator = Ref.Party.assertFromString("operator")
   val investor = Ref.Party.assertFromString("investor")

sdk/daml-lf/engine/src/test/scala/com/digitalasset/daml/lf/engine/PreprocessorSpec.scala

@@ -8,7 +8,7 @@ import com.daml.lf.crypto.Hash
 import com.daml.lf.data.Ref.Party
 import com.daml.lf.data.{Bytes, FrontStack, ImmArray, Ref}
 import com.daml.lf.command.ApiCommand
-import com.daml.lf.language.{Ast, LanguageMajorVersion, LanguageVersion}
+import com.daml.lf.language.{Ast, LanguageVersion}
 import com.daml.lf.speedy.{ArrayList, Command, DisclosedContract, SValue}
 import com.daml.lf.value.Value.{ContractId, ValueInt64, ValueList, ValueParty, ValueRecord}
 import org.scalatest.{Assertion, Inside, Inspectors}
@@ -21,19 +21,16 @@ import com.daml.lf.transaction.test.TransactionBuilder.Implicits.{defaultPackage
 import com.daml.lf.value.Value
 import com.daml.lf.speedy.Compiler
 
-class PreprocessorSpecV2 extends PreprocessorSpec(LanguageMajorVersion.V2)
-
-class PreprocessorSpec(majorLanguageVersion: LanguageMajorVersion)
+class PreprocessorSpec
     extends AnyWordSpec
     with Inside
     with Matchers
     with Inspectors
     with TableDrivenPropertyChecks {
 
-  val helpers = new PreprocessorSpecHelpers(majorLanguageVersion)
-  import helpers._
+  import PreprocessorSpecHelpers._
 
-  val compilerConfig = Compiler.Config.Dev(majorLanguageVersion)
+  val compilerConfig = Compiler.Config.Dev
 
   "preprocessor" should {
     "returns correct result when resuming" in {
@@ -281,12 +278,12 @@ class PreprocessorSpec(majorLanguageVersion: LanguageMajorVersion)
   }
 }
 
-final class PreprocessorSpecHelpers(majorLanguageVersion: LanguageMajorVersion) {
+object PreprocessorSpecHelpers {
 
   implicit val parserParameters: ParserParameters[this.type] =
     ParserParameters(
       defaultPackageId = Ref.PackageId.assertFromString("-pkgId-"),
-      LanguageVersion.defaultOrLatestStable(majorLanguageVersion),
+      LanguageVersion.defaultOrLatestStable,
     )
 
   implicit val defaultPackageId: Ref.PackageId = parserParameters.defaultPackageId

sdk/daml-lf/engine/src/test/scala/com/digitalasset/daml/lf/engine/ReinterpretTest.scala

@@ -64,7 +64,7 @@ class ReinterpretTest(majorLanguageVersion: LanguageMajorVersion)
 
   private val engine = new Engine(
     EngineConfig(
-      allowedLanguageVersions = language.LanguageVersion.AllVersions(majorLanguageVersion),
+      allowedLanguageVersions = language.LanguageVersion.DevVersions,
       requireSuffixedGlobalContractId = true,
     )
   )

sdk/daml-lf/engine/src/test/scala/com/digitalasset/daml/lf/engine/ReplayCommandPreprocessorSpec.scala

@@ -73,7 +73,7 @@ class ReplayCommandPreprocessorSpec(majorLanguageVersion: LanguageMajorVersion)
     """
 
   private[this] val compiledPackage = ConcurrentCompiledPackages(
-    Compiler.Config.Default(majorLanguageVersion)
+    Compiler.Config.Default
   )
   assert(compiledPackage.addPackage(defaultPackageId, pkg) == ResultDone.Unit)
 

sdk/daml-lf/engine/src/test/scala/com/digitalasset/daml/lf/engine/ValueEnricherSpec.scala

@@ -92,7 +92,7 @@ class ValueEnricherSpec(majorLanguageVersion: LanguageMajorVersion)
 
     """
 
-  private[this] val engine = Engine.DevEngine(majorLanguageVersion)
+  private[this] val engine = Engine.DevEngine
 
   engine
     .preloadPackage(defaultPackageId, pkg)

sdk/daml-lf/engine/src/test/scala/com/digitalasset/daml/lf/engine/ValueTranslatorSpec.scala

@@ -68,7 +68,7 @@ class ValueTranslatorSpec(majorLanguageVersion: LanguageMajorVersion)
     """
 
   private[this] val compiledPackage = ConcurrentCompiledPackages(
-    Compiler.Config.Default(majorLanguageVersion)
+    Compiler.Config.Default
   )
   assert(compiledPackage.addPackage(defaultPackageId, pkg) == ResultDone.Unit)
 

sdk/daml-lf/interpreter/perf/src/main/scala/com/daml/lf/explore/Explore.scala

@@ -26,7 +26,7 @@ object PlaySpeedy {
   def main(args: List[String]) = {
     val config: Config = parseArgsOrDie(args)
     val compilerConfig =
-      Compiler.Config.Default(config.majorLfVersion).copy(stacktracing = Compiler.FullStackTrace)
+      Compiler.Config.Default.copy(stacktracing = Compiler.FullStackTrace)
     val compiler: Compiler = new Compiler(PackageInterface.Empty, compilerConfig)
 
     val names: List[String] = config.names match {

sdk/daml-lf/interpreter/perf/src/main/scala/com/daml/lf/explore/ExploreDar.scala

@@ -77,8 +77,7 @@ object PlaySpeedy {
 
     println(s"Compiling packages... ${config.stacktracing}")
     val compilerConfig =
-      Compiler.Config
-        .Default(packages.main._2.languageVersion.major)
+      Compiler.Config.Default
         .copy(stacktracing = config.stacktracing)
     val compiledPackages =
       PureCompiledPackages.build(packages.all.toMap, compilerConfig) match {

sdk/daml-lf/interpreter/perf/src/main/scala/com/daml/lf/explore/LoadDarFunction.scala

@@ -24,9 +24,7 @@ object LoadDarFunction extends App {
     val packages = UniversalArchiveDecoder.assertReadFile(darFile)
 
     val compilerConfig =
-      Compiler.Config
-        .Default(packages.main._2.languageVersion.major)
-        .copy(stacktracing = Compiler.NoStackTrace)
+      Compiler.Config.Default.copy(stacktracing = Compiler.NoStackTrace)
 
     val compiledPackages: CompiledPackages =
       PureCompiledPackages.assertBuild(packages.all.toMap, compilerConfig)

sdk/daml-lf/interpreter/src/bench/com/daml/lf/interpreter/SpeedyCompilationBench.scala

@@ -38,8 +38,7 @@ class SpeedyCompilationBench {
 
   @Benchmark
   def bench(): Unit = {
-    val config = Config
-      .Default(dar.main._2.languageVersion.major)
+    val config = Config.Default
       .copy(packageValidation = NoPackageValidation)
     val res = compilePackages(pkgInterface, darMap, config)
     assert(res.isRight)