Refactor to better represent to changes and fix comments

Author: ekrich

tools/src/main/scala/scala/scalanative/build/Filter.scala

@@ -5,7 +5,12 @@ import java.io.File
 import java.nio.file.{Files, Path}
 import java.util.Arrays
 import java.util.regex._
+
 import scala.concurrent._
+import scala.util.Failure
+import scala.util.Success
+
+import scalanative.build.IO.RichPath
 import scala.scalanative.linker.ReachabilityAnalysis
 
 /** Original jar or dir path and generated dir path for native code */
@@ -14,16 +19,18 @@ private[scalanative] case class NativeLib(src: Path, dest: Path)
 /** Utilities for dealing with native library code */
 private[scalanative] object NativeLib {
 
-  /** Name of directory that contains native code: "scala-native"
-   */
+  /** Name of directory that contains native code: "scala-native" */
   val nativeCodeDir = "scala-native"
 
+  /** Project Descriptor properties file: "scala-native.properties" */
+  private val nativeProjectProps = s"${nativeCodeDir}.properties"
+
   /** Compiles the native code from the library
    *
    *  @param config
    *    the configuration options
    *  @param linkerResult
-   *    needed for filtering
+   *    needed for configuration based on NIR
    *  @param nativeLib
    *    the native lib to unpack
    *  @return
@@ -34,11 +41,105 @@ private[scalanative] object NativeLib {
       analysis: ReachabilityAnalysis.Result,
       nativeLib: NativeLib
   )(implicit ec: ExecutionContext): Future[Seq[Path]] = {
-    val destPath = NativeLib.unpackNativeCode(nativeLib)
-    val paths = NativeLib.findNativePaths(config.workDir, destPath)
-    val (projPaths, projConfig) =
-      Filter.filterNativelib(config, analysis, destPath, paths)
-    LLVM.compile(projConfig, projPaths)
+    val destPath = unpackNativeCode(nativeLib)
+    val paths = findNativePaths(config.workDir, destPath)
+    val projConfig = configureNativelib(config, analysis, destPath)
+    LLVM.compile(projConfig, paths)
+  }
+
+  /** Update the project configuration the if a project `Descriptor` is present.
+   *
+   *  @param config
+   *    The configuration of the toolchain.
+   *  @param linkerResult
+   *    The results from the linker.
+   *  @param destPath
+   *    The unpacked location of the Scala Native nativelib.
+   *  @return
+   *    The config for this native library.
+   */
+  private def configureNativelib(
+      config: Config,
+      analysis: ReachabilityAnalysis.Result,
+      destPath: Path
+  ): Config = {
+    val nativeCodePath = destPath.resolve(nativeCodeDir)
+    // check if filtering is needed, o.w. return all paths
+    findDescriptor(nativeCodePath).fold(config) { filepath =>
+
+      val desc =
+        Descriptor.load(filepath) match {
+          case Success(v) => v
+          case Failure(e) =>
+            throw new BuildException(
+              s"Problem reading $nativeProjectProps: ${e.getMessage}"
+            )
+        }
+
+      config.logger.debug(desc.toString())
+
+      val projectConfig = desc match {
+        case Descriptor(Some(groupId), Some(artifactId), _)
+            if (groupId == "org.scala-native" && artifactId == "nativelib") =>
+          createGcConfig(nativeCodePath, config)
+        case Descriptor(_, _, _) =>
+          createLinkConfig(desc, analysis, config)
+      }
+
+      projectConfig
+    }
+  }
+
+  private def createLinkConfig(
+      desc: Descriptor,
+      analysis: ReachabilityAnalysis.Result,
+      config: Config
+  ): Config = {
+    val linkDefines =
+      desc.link
+        .filter(name => analysis.links.exists(_.name == name))
+        .map(name => s"-DSCALANATIVE_LINK_${name.toUpperCase}")
+
+    config.withCompilerConfig(
+      _.withCompileOptions(_ ++ linkDefines)
+    )
+  }
+
+  private def createGcConfig(
+      nativeCodePath: Path,
+      config: Config
+  ): Config = {
+    /* A conditional compilation define is used to compile the
+     * correct garbage collector code because code is shared.
+     * This avoids handling all the paths needed and compiling
+     * all the GC code for a given platform.
+     *
+     * Note: The zone directory is also part of the garbage collection
+     * system and shares code from the gc directory.
+     */
+    val gcFlag = {
+      val gc = config.compilerConfig.gc.toString
+      s"-DSCALANATIVE_GC_${gc.toUpperCase}"
+    }
+
+    val gcPath = nativeCodePath.resolve("gc").abs
+
+    config.withCompilerConfig(
+      _.withCompileOptions(_ :+ ("-I" + gcPath) :+ gcFlag)
+    )
+  }
+
+  /** Check for compile Descriptor in destination native code directory.
+   *
+   *  @param nativeCodePath
+   *    The native code directory
+   *  @return
+   *    The optional path to the file or none
+   */
+  private def findDescriptor(nativeCodePath: Path): Option[Path] = {
+    val file = nativeCodePath.resolve(nativeProjectProps)
+    if (Files.exists(file)) Some(file)
+    else None
   }
 
   /** Finds all the native libs on the classpath.
@@ -103,7 +204,7 @@ private[scalanative] object NativeLib {
    *  @return
    *    All file paths to compile
    */
-  def findNativePaths(workDir: Path, destPath: Path): Seq[Path] = {
+  private def findNativePaths(workDir: Path, destPath: Path): Seq[Path] = {
     val srcPatterns = destSrcPattern(workDir, destPath)
     IO.getAll(workDir, srcPatterns)
   }
@@ -136,7 +237,7 @@ private[scalanative] object NativeLib {
    *  @return
    *    The destination path of the directory
    */
-  def unpackNativeCode(nativelib: NativeLib): Path =
+  private def unpackNativeCode(nativelib: NativeLib): Path =
     if (isJar(nativelib)) unpackNativeJar(nativelib)
     else copyNativeDir(nativelib)