Make so that linktime properties parse only booleans

Author: jchyb

README.md

@@ -11,26 +11,8 @@ the dedicated [sbt plugin](https://scala-native.readthedocs.io/en/stable/user/sb
 scala-native-cli --help will bring up possible options and syntax. 
 Since options are dependent on the used version of scala-native-cli, please use it for further instructions.
 
-### Passing link-time resolved properties
-
-Scala Native allows use of link-time properties - values that are used to resolve `if` code blocks on link-time. 
-Their non-standard format requires special care. 
-
-In scala-native-cli their value is defined as follows:
-
-```keystring=[Type]value```
-
-`keystring` is always a string, however value has to have a type specified in the square brackets. It can be one of the following:
-
-* `Short`
-* `Int`
-* `Long`
-* `Float`
-* `Double`
-* `Char`
-* `Boolean`
-* `String`
-
 ## Logging 
 
 For logging purposes, a default Scala Native logger is used. By default it will only show `Error` messages, but its verbosity can be increased with a -v flag.
+
+

cli/version_newer/src/main/scala/scala/scalanative/cli/options/NativeConfigOptions.scala

@@ -39,9 +39,9 @@ case class NativeConfigOptions(
     noOptimize: Boolean = false,
     @Group("Native Config")
     @HelpMessage(
-      "User defined properties resolved at link-time. Multiple can be defined. Example: \"isCli=[Boolean]true\""
+      "User defined properties resolved at link-time. Multiple can be defined. Example: \"isCli=true\""
     )
-    @ValueDescription("<keystring=[type]property>")
+    @ValueDescription("<keystring=boolean>")
     ltp: List[String] = List.empty,
     @Group("Native Config")
     @HelpMessage("Linking options passed to LLVM. Multiple can be defined.")

cli/version_newer/src/main/scala/scala/scalanative/cli/utils/LinktimePropertyParser.scala

@@ -6,31 +6,25 @@ import scala.util.Try
 object LinktimePropertyParser {
 
   val ltpPattern = Pattern.compile("(.*?)=(.*)")
-  val valueTypePattern = Pattern.compile("\\[(.*?)\\](.*)")
 
   @inline
   def getLtpPatternException(incorrectPattern: String) =
     new IllegalArgumentException(
-      s"""|Link-time resolved properties must be of pattern keystring=[Type]value
-              |\"${incorrectPattern}\" is incorrect.""".stripMargin
-    )
-  @inline
-  def getLtpTypeException(incorrectType: String) =
-    new IllegalArgumentException(
-      s"""|Unrecognised link-time property value type:
-          |\"${incorrectType}\" is incorrect.""".stripMargin
+      s"""|Link-time resolved properties must be of pattern keystring=boolean
+          |\"${incorrectPattern}\" is incorrect.""".stripMargin
     )
 
   def toMap(ltpStrings: List[String]): Either[Throwable, Map[String, Any]] = {
     val eitherList =
       ltpStrings
         .map { inputPattern =>
           val matcher = ltpPattern.matcher(inputPattern)
-          if (!matcher.find() || matcher.groupCount() != 2) {
+          if (!matcher.find() || matcher.groupCount() != 2 || matcher.group(1).isEmpty()) {
             Left(getLtpPatternException(inputPattern))
           } else {
-            val (key, typedValue) = (matcher.group(1), matcher.group(2))
-            handleTypedValue(inputPattern, typedValue) match {
+            val (key, booleanString) = (matcher.group(1), matcher.group(2))
+
+            Try(booleanString.toBoolean).toEither match {
               case Right(value) => Right((key, value))
               case Left(value)  => Left(value)
             }
@@ -50,33 +44,4 @@ object LinktimePropertyParser {
       Right(eitherList.collect { case Right(value) => value }.toMap)
     }
   }
-
-  def handleTypedValue(
-      pattern: String,
-      typedValue: String
-  ): Either[Throwable, Any] = {
-    val matcher = valueTypePattern.matcher(typedValue)
-
-    if (!matcher.find() || matcher.groupCount() != 2) {
-      Left(getLtpPatternException(pattern))
-    } else {
-      val valueType = matcher.group(1)
-      val valueContent = matcher.group(2)
-
-      Try {
-        valueType match {
-          case "Boolean" => valueContent.toBoolean
-          case "Byte"    => valueContent.toByte
-          case "Char"    => valueContent.toInt.toChar
-          case "Short"   => valueContent.toShort
-          case "Int"     => valueContent.toInt
-          case "Long"    => valueContent.toLong
-          case "Float"   => valueContent.toFloat
-          case "Double"  => valueContent.toDouble
-          case "String"  => valueContent
-          case _         => throw getLtpTypeException(valueType)
-        }
-      }.toEither
-    }
-  }
 }

cli/version_newer/src/test/scala/scala/scalanative/cli/LinktimePropertyParserTest.scala

@@ -6,97 +6,38 @@ import scala.scalanative.cli.utils.LinktimePropertyParser
 class LinktimePropertyParserTest extends AnyFlatSpec {
 
   "LinktimePropertyParser" should "handle boolean value types correctly" in {
-    val input = List("isTesting=[Boolean]true")
-    val expected = Map[String, Any]("isTesting" -> true)
+    val input = List("isTesting=true", "isNotTesting=False")
+    val expected = Map[String, Any]("isTesting" -> true, "isNotTesting" -> false)
     val obtained = LinktimePropertyParser.toMap(input)
     assert(obtained.right.get == expected)
   }
 
   it should "return error on undefined string patterns" in {
-    val noEquals = List("key-[String]value")
+    val noEquals = List("key-true")
     val obtainedNoEquals = LinktimePropertyParser.toMap(noEquals)
     assert(obtainedNoEquals.isLeft)
 
-    val noType = List("key=value")
-    val obtainedNoType = LinktimePropertyParser.toMap(noEquals)
-    assert(obtainedNoType.isLeft)
-  }
-
-  it should "handle numeric value types correctly" in {
-    val input = List(
-      "testKey0=[Short]1",
-      "testKey1=[Int]10",
-      "testKey2=[Long]10000",
-      "testKey3=[Float]1.20",
-      "testKey4=[Double]20.20",
-      "testKey5=[Char]35"
-    )
-    val expected = Map[String, Any](
-      "testKey0" -> 1.asInstanceOf[Short],
-      "testKey1" -> 10.asInstanceOf[Int],
-      "testKey2" -> 10000.asInstanceOf[Long],
-      "testKey3" -> (1.20).asInstanceOf[Float],
-      "testKey4" -> (20.20).asInstanceOf[Double],
-      "testKey5" -> 35.asInstanceOf[Char]
-    )
-    val obtained = LinktimePropertyParser.toMap(input)
-    assert(obtained.right.get == expected)
-  }
-
-  it should "handle string value types correctly" in {
-    val input = List(
-      "testKey0=[String]1",
-      "testKey1=[String]windows",
-      "testKey2=[String]",
-      "testKey3=[String]with space",
-      "testKey4=[String]20.20"
-    )
-    val expected = Map[String, Any](
-      "testKey0" -> "1",
-      "testKey1" -> "windows",
-      "testKey2" -> "",
-      "testKey3" -> "with space",
-      "testKey4" -> "20.20"
-    )
-    val obtained = LinktimePropertyParser.toMap(input)
-    assert(obtained.right.get == expected)
-  }
-
-  it should "fail on unhandled value types" in {
-    val inputObject = List("testKey=[Object]1")
-    assert(LinktimePropertyParser.toMap(inputObject).isLeft)
-
-    val inputOption = List("testKey=[Option[Int]]Some(1)")
-    assert(LinktimePropertyParser.toMap(inputOption).isLeft)
+    val noKey = List("=true")
+    val obtainedNoKey = LinktimePropertyParser.toMap(noKey)
+    assert(obtainedNoKey.isLeft)
 
-    val inputMessy = List("testKey=[[Int]]1")
-    assert(LinktimePropertyParser.toMap(inputMessy).isLeft)
+    val noBoolean = List("key=")
+    val obtainedNoBoolean = LinktimePropertyParser.toMap(noBoolean)
+    assert(obtainedNoBoolean.isLeft)
   }
 
-  it should "fail on incorect value against their defined types" in {
-    val inputIntString = List("testKey=[Int]stringvalue")
-    assert(LinktimePropertyParser.toMap(inputIntString).isLeft)
+  it should "return error on non boolean values" in {
+    val withString = List("key=string")
+    val obtainedWithString = LinktimePropertyParser.toMap(withString)
+    assert(obtainedWithString.isLeft)
 
-    val inputBooleanNumber = List("testKey=[Boolean]20")
-    assert(LinktimePropertyParser.toMap(inputBooleanNumber).isLeft)
+    val withNull = List("key=null")
+    val obtainedWithNull = LinktimePropertyParser.toMap(withNull)
+    assert(obtainedWithNull.isLeft)
 
-    val inputDoubleEmpty = List("testKey=[Double]")
-    assert(LinktimePropertyParser.toMap(inputDoubleEmpty).isLeft)
+    val withFloat = List("key=1.1")
+    val obtainedWithFloat = LinktimePropertyParser.toMap(withFloat)
+    assert(obtainedWithFloat.isLeft)
   }
 
-  it should "handle square brackets and equals in string value correctly" in {
-    val inputString = List(
-      "testKey0=[String]string[]value",
-      "testKey1=[String][] after brackets",
-      "testKey2=[String]with=equals"
-    )
-
-    val expected = Map[String, Any](
-      "testKey0" -> "string[]value",
-      "testKey1" -> "[] after brackets",
-      "testKey2" -> "with=equals"
-    )
-
-    assert(LinktimePropertyParser.toMap(inputString).right.get == expected)
-  }
 }