Scala条件编译

我正在编写一个Scala程序，我希望它能与一个大型库的两个版本一起工作

这个大型库的版本2对API的更改非常轻微（只有一个类构造函数签名有一个额外的参数）

//Lib v1
类APIClass（a:字符串，b:整数）{
...
}
//Lib v2
类ApicClass（a:字符串，b:整数，c:字符串）{
...
}
//我的代码扩展了APIClass。。而且我没有IFDEF
类MyClass（）扩展了ApicClass（“x”，1）{/我看到了一些选项，但如果它们是“条件编译”，则没有选项


您可以在构建中创建两个模块-它们将有一个共享的源目录，每个模块都有一个特定于它的代码的源目录。然后您将发布整个库的两个版本
创建3个模块-一个包含库和一个抽象类/trait，它将与之对话/通过，另2个包含trait的特定版本实现

问题是-如果您根据v1和用户提供的v2构建代码会怎么样？或者相反？您发出了字节码，但JVM需要其他东西，所以它会崩溃

事实上，每当你有这种破坏兼容性的更改时，库要么拒绝更新，要么放弃。这不是因为你不能生成两个版本——你会。问题在于下游——你的用户如何处理这种情况。如果你正在编写应用程序，你可以提交其中一个。如果你正在编写libra而且你不想把用户锁定在你的选择上……你必须为每个选择发布单独的版本

理论上，您可以创建一个项目，它有2个模块，它们共享相同的代码，使用Scala宏或ScaleMaA使用C++中的不同代码，如“代码”＞“IFDEF”/Calp[Guangs]，但如果您想使用IDE或井手的发布源代码，这是一个灾难。没有任何来源可以查看。没有跳过定义的SOU的方法。rce。最多是反汇编字节码

因此，对于不匹配的版本，您只需使用单独的源目录，这样的解决方案从长远来看更易于阅读、编写和维护。
我看到了一些选项，但如果它们是“条件编译”，则没有选项


您可以在构建中创建两个模块-它们将有一个共享的源目录，每个模块都有一个特定于它的代码的源目录。然后您将发布整个库的两个版本
创建3个模块-一个包含库和一个抽象类/trait，它将与之对话/通过，另2个包含trait的特定版本实现

问题是-如果您根据v1和用户提供的v2构建代码会怎么样？或者相反？您发出了字节码，但JVM需要其他东西，所以它会崩溃

事实上，每当你有这种破坏兼容性的更改时，库要么拒绝更新，要么放弃。这不是因为你不能生成两个版本——你会。问题在于下游——你的用户如何处理这种情况。如果你正在编写应用程序，你可以提交其中一个。如果你正在编写libra而且你不想把用户锁定在你的选择上……你必须为每个选择发布单独的版本

理论上，您可以创建一个项目，它有2个模块，它们共享相同的代码，使用Scala宏或ScaleMaA使用C++中的不同代码，如“代码”＞“IFDEF”/Calp[Guangs]，但如果您想使用IDE或井手的发布源代码，这是一个灾难。没有任何来源可以查看。没有跳过定义的SOU的方法。rce。最多是反汇编字节码

<> P>这样，对于错误匹配的版本，您只需有不同的源目录，就可以很容易地读、写和维护。在<>代码> javac 或Scalac （也有）之前，如果<>代码> CPP<代码>，可以使用java／Scala。< /P> < P> < C++ > Scala可以使用Java /Scala。

2.如果您真的想在Scala中进行条件编译，您可以使用（在编译时扩展）

宏/src/main/scala/extendsAPIClass.scala

core/src/main/scala/MyClass.scala（如果
LIB\u VERSION=2
）


3.或者，您可以使用它生成代码（在编译时之前）

build.sbt

project/build.sbt

project/Generator.scala

common/src/main/scala/com/api/APIClass.scala

在/src/main/scala/com/example/MyClass.scala中

out/target/scala-2.13/src_managed/main/scala/com/example/MyClass.scala

（如果
LIB_VERSION=2
，则在
sbt out/compile
之后）


<>（强> 1）.<强> C++预处理器可用于java／Scala，如果在<代码> javac 或<代码> Scalac < /C> >之前运行<代码> CPP <代码>（也有）。

2.如果您真的想在Scala中进行条件编译，您可以使用（在编译时扩展）

宏/src/main/scala/extendsAPIClass.scala

core/src/main/scala/MyClass.scala（如果
LIB\u VERSION=2
）


3.或者，您可以使用它生成代码（在编译时之前）

build.sbt

project/build.sbt

project/Generator.scala

common/src/main/scala/com/api/APIClass.scala

在/src/main/scala/com/example/MyClass.scala中

out/target/scala-2.13/src_managed/main/scala/com/example/MyClass.scala

（如果
LIB_VERSION=2
，则在
sbt out/compile
之后）



import scala.annotation.{StaticAnnotation, compileTimeOnly}
import scala.language.experimental.macros
import scala.reflect.macros.blackbox

@compileTimeOnly("enable macro paradise")
class extendsAPIClass extends StaticAnnotation {
  def macroTransform(annottees: Any*): Any = macro ExtendsAPIClassMacro.impl
}

object ExtendsAPIClassMacro {
  def impl(c: blackbox.Context)(annottees: c.Tree*): c.Tree = {
    import c.universe._
    annottees match {
      case q"$mods class $tpname[..$tparams] $ctorMods(...$paramss) extends { ..$earlydefns } with ..$parents { $self => ..$stats }" :: tail => 
        def updateParents(parents: Seq[Tree], args: Seq[Tree]) = 
          q"""${tq"APIClass"}(..$args)""" +: parents.filter { case tq"scala.AnyRef" => false; case _ => true }

        val parents1 = sys.env.get("LIB_VERSION") match {
          case Some("1") => updateParents(parents, Seq(q""" "x" """, q"1"))
          case Some("2") => updateParents(parents, Seq(q""" "x" """, q"1", q""" "y" """))
          case None      => parents
        }

        q"""
          $mods class $tpname[..$tparams] $ctorMods(...$paramss) extends { ..$earlydefns } with ..$parents1 { $self => ..$stats }
          ..$tail
        """
    }
  }
}

@extendsAPIClass
class MyClass

//Warning:scalac: {
//  class MyClass extends APIClass("x", 1, "y") {
//    def <init>() = {
//      super.<init>();
//      ()
//    }
//  };
//  ()
//}

ThisBuild / name := "macrosdemo"

lazy val commonSettings = Seq(
  scalaVersion := "2.13.2",
  organization := "com.example",
  version := "1.0.0",
  scalacOptions ++= Seq(
    "-Ymacro-debug-lite",
    "-Ymacro-annotations",
  ),
)

lazy val macros: Project = (project in file("macros")).settings(
  commonSettings,
  libraryDependencies ++= Seq(
    scalaOrganization.value % "scala-reflect" % scalaVersion.value,
  )
)

lazy val core: Project = (project in file("core")).aggregate(macros).dependsOn(macros).settings(
  commonSettings,
  )
)

ThisBuild / name := "scalametacodegendemo"

lazy val commonSettings = Seq(
  scalaVersion := "2.13.2",
  organization := "com.example",
  version := "1.0.0",
)

lazy val common = project
  .settings(
    commonSettings,
  )

lazy val in = project
  .dependsOn(common)
  .settings(
    commonSettings,
  )

lazy val out = project
  .dependsOn(common)
  .settings(
    sourceGenerators in Compile += Def.task {
      Generator.gen(
        inputDir = sourceDirectory.in(in, Compile).value,
        outputDir = sourceManaged.in(Compile).value
      )
    }.taskValue,
    commonSettings,
  )

libraryDependencies += "org.scalameta" %% "scalameta" % "4.3.10"

import sbt._

object Generator {
  def gen(inputDir: File, outputDir: File): Seq[File] = {
    val finder: PathFinder = inputDir ** "*.scala"

    for(inputFile <- finder.get) yield {
      val inputStr = IO.read(inputFile)
      val outputFile = outputDir / inputFile.toURI.toString.stripPrefix(inputDir.toURI.toString)
      val outputStr = Transformer.transform(inputStr)
      IO.write(outputFile, outputStr)
      outputFile
    }
  }
}

import scala.meta._

object Transformer {
  def transform(input: String): String = {
    val (v1on, v2on) = sys.env.get("LIB_VERSION") match {
      case Some("1") => (true, false)
      case Some("2") => (false, true)
      case None      => (false, false)
    }
    var v1 = false
    var v2 = false
    input.tokenize.get.filter(_.text match {
      case "// Lib v1" =>
        v1 = true
        false
      case "// End Lib v1" =>
        v1 = false
        false
      case "// Lib v2" =>
        v2 = true
        false
      case "// End Lib v2" =>
        v2 = false
        false
      case _ => (v1on && v1) || (v2on && v2) || (!v1 && !v2)
    }).mkString("")
  }
}

package com.api

class APIClass(a: String, b: Integer, c: String)

package com.example

import com.api.APIClass

// Lib v1
class MyClass extends APIClass("x", 1)
// End Lib v1

// Lib v2
class MyClass extends APIClass("x", 1, "y")
// End Lib v2

package com.example

import com.api.APIClass

class MyClass extends APIClass("x", 1, "y")