Условная компиляция Scala
Я пишу программу на Scala и хочу, чтобы она работала с двумя версиями большой библиотеки.
Версия 2 этой большой библиотеки изменяет API очень незначительно (только одна сигнатура конструктора класса имеет дополнительный параметр).
// Lib v1
class APIClass(a: String, b:Integer){
...
}
// Lib v2
class APIClass(a: String, b: Integer, c: String){
...
}
// And my code extends APIClass.. And I have no #IFDEF
class MyClass() extends APIClass("x", 1){ // <-- would be APIClass("x", 1, "y") in library v2
...
}
Я действительно не хочу разветвлять свой код. Потому что тогда мне нужно будет поддерживать две ветки, а завтра 3,4,.. ветки для крошечных изменений API:(
В идеале у нас был бы простой препроцессор на Scala, но эта идея была давно отвергнута сообществом Scala.
То, что я действительно не мог понять: может ли Scalameta помочь в моделировании препроцессора в этом случае? Т.е. условный синтаксический анализ двух исходных файлов, скажем, переменной среды, известной во время компиляции?
Если нет, как бы вы подошли к этой реальной жизненной проблеме?
2 ответа
1. Препроцессоры C++ можно использовать с Java/Scala, если вы запуститеcpp перед javac или scalac(также есть Manifold).
2. Если вы действительно хотите иметь условную компиляцию в Scala, вы можете использовать макроаннотацию (расширяемую во время компиляции)
макросы / src / main / scala / extendsAPIClass.scala
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
"""
}
}
}
core / src / main / scala / MyClass.scala (еслиLIB_VERSION=2)
@extendsAPIClass
class MyClass
//Warning:scalac: {
// class MyClass extends APIClass("x", 1, "y") {
// def <init>() = {
// super.<init>();
// ()
// }
// };
// ()
//}
build.sbt
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,
)
)
3. В качестве альтернативы вы можете использовать Scalameta для генерации кода (во время до компиляции)
build.sbt
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,
)
проект / build.sbt
libraryDependencies += "org.scalameta" %% "scalameta" % "4.3.10"
проект /Generator.scala
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
}
}
}
проект /Transformer.scala
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("")
}
}
общий / SRC / основной /scala/com/api/APIClass.scala
package com.api
class APIClass(a: String, b: Integer, c: String)
в /src/main/scala/com/example/MyClass.scala
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
из / цель / scala-2.13 / src_managed / main / scala / com / example / MyClass.scala
(после sbt out/compile если LIB_VERSION=2)
package com.example
import com.api.APIClass
class MyClass extends APIClass("x", 1, "y")
Аннотации макроса для переопределения toString функции Scala
Я вижу несколько вариантов, но их нет, если это "условная компиляция"
- вы можете создать 2 модуля в своей сборке - у них будет общий исходный каталог, и у каждого из них есть исходный каталог для кода, специфичного для него. Затем вы опубликуете 2 версии всей своей библиотеки.
- создать 3 модуля - один с вашей библиотекой и абстрактным классом / признаком, с которым он будет разговаривать / через, и 2 других с конкретной версией реализации признака
Проблема в том, что если вы создадите код для версии v1 и предоставленной пользователем версии 2? Или наоборот? Вы выпустили байт-код, но JVM ожидает чего-то еще, и все происходит сбой.
Практически каждый раз, когда у вас возникают такие нарушения совместимости, библиотека либо отказывается обновляться, либо разветвляется. Не потому, что вы не сможете сгенерировать 2 версии - вы бы это сделали. Проблема в нисходящем направлении - как ваши пользователи справятся с этой ситуацией. Если вы пишете приложение, вы можете выполнить одно из них. Если вы пишете библиотеку и не хотите ограничивать пользователей по своему выбору... вы должны публиковать отдельные версии для каждого выбора.
Теоретически вы можете создать один проект с 2 модулями, которые используют один и тот же код и используют разные ветки, например #ifdefмакросы в C++ с использованием макросов Scala или Scalameta - но это катастрофа, если вы хотите использовать IDE или опубликовать исходный код, который ваши пользователи могут использовать в IDE. Нет источника для просмотра. Невозможно перейти к источнику определения. В лучшем случае разобранный байт-код.
Таким образом, решение, заключающееся в том, что у вас есть отдельные исходные каталоги для несовпадающих версий, намного проще читать, писать и поддерживать в долгосрочной перспективе.