Improve usability

Author: tschuchortdev

.idea/misc.xml

@@ -0,0 +1,76 @@
+/*
+ * Copyright 2018-present Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License. You may obtain
+ * a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ */
+
+package com.facebook.buck.jvm.java.javax
+
+import com.tschuchort.compiletesting.isJdk9OrLater
+import org.jetbrains.kotlin.com.intellij.util.lang.JavaVersion
+
+import java.lang.reflect.InvocationTargetException
+import java.lang.reflect.Method
+import javax.tools.JavaCompiler
+import javax.tools.ToolProvider
+
+
+/**
+ * ToolProvider has no synchronization internally, so if we don't synchronize from the outside we
+ * could wind up loading the compiler classes multiple times from different class loaders.
+ */
+object SynchronizedToolProvider {
+    private var getPlatformClassLoaderMethod: Method? = null
+
+    val systemJavaCompiler: JavaCompiler
+        get() {
+            val compiler = synchronized(ToolProvider::class.java) {
+                ToolProvider.getSystemJavaCompiler()
+            }
+
+            check(compiler != null) { "System java compiler is null! Are you running without JDK?" }
+            return compiler
+        }
+
+    // The compiler classes are loaded using the platform class loader in Java 9+.
+    val systemToolClassLoader: ClassLoader
+        get() {
+            if (isJdk9OrLater()) {
+                try {
+                    return getPlatformClassLoaderMethod!!.invoke(null) as ClassLoader
+                } catch (e: IllegalAccessException) {
+                    throw RuntimeException(e)
+                } catch (e: InvocationTargetException) {
+                    throw RuntimeException(e)
+                }
+
+            }
+
+            val classLoader: ClassLoader
+            synchronized(ToolProvider::class.java) {
+                classLoader = ToolProvider.getSystemToolClassLoader()
+            }
+            return classLoader
+        }
+
+    init {
+        if (isJdk9OrLater()) {
+            try {
+                getPlatformClassLoaderMethod = ClassLoader::class.java.getMethod("getPlatformClassLoader")
+            } catch (e: NoSuchMethodException) {
+                throw RuntimeException(e)
+            }
+
+        }
+    }
+}

src/main/kotlin/SynchronizedToolProvider.kt

@@ -0,0 +1,33 @@
+package com.tschuchort.compiletesting
+
+import kotlin.properties.ReadWriteProperty
+import kotlin.reflect.KProperty
+
+@Suppress("MemberVisibilityCanBePrivate")
+internal class DefaultPropertyDelegate<R,T>(private val createDefault: () -> T) : ReadWriteProperty<R, T> {
+    val hasDefaultValue
+        @Synchronized get() = (value == DEFAULT)
+
+    private var value: Any? = DEFAULT
+    val defaultValue by lazy { createDefault() }
+
+    @Synchronized
+    override operator fun getValue(thisRef: R, property: KProperty<*>): T {
+        @Suppress("UNCHECKED_CAST")
+        return if(hasDefaultValue)
+            defaultValue
+        else
+            value as T
+    }
+
+    @Synchronized
+    override operator fun setValue(thisRef: R, property: KProperty<*>, value: T) {
+        this.value = value
+    }
+
+    companion object {
+        private object DEFAULT
+    }
+}
+
+internal fun <R,T> default(createDefault: () -> T) = DefaultPropertyDelegate<R,T>(createDefault)

src/main/kotlin/com/tschuchort/compiletesting/DefaultPropertyDelegate.kt

@@ -87,4 +87,8 @@ internal fun isJavac9OrLater(javacVersionString: String): Boolean {
 
     return (majorv.toInt() == 1 && minorv.toInt() >= 9) // old versioning scheme: 1.8.x
             || (majorv.toInt() >= 9) // new versioning scheme: 10.x.x
-}
+}
+
+/** Finds the tools.jar given a path to a JDK 8 or earlier */
+internal fun findToolsJarFromJdk(jdkHome: File): File
+        = File(jdkHome.absolutePath + "/../lib/tools.jar").also { check(it.isFile) }

src/main/kotlin/com/tschuchort/compiletesting/JavacUtils.kt

@@ -48,11 +48,9 @@ import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisHandlerExtension
 import java.io.File
 import javax.annotation.processing.Processor
 
-@Suppress("RemoveEmptyPrimaryConstructor")
-internal class KaptComponentRegistrar() : ComponentRegistrar {
+internal class KaptComponentRegistrar : ComponentRegistrar {
 
     override fun registerProjectComponents(project: MockProject, configuration: CompilerConfiguration) {
-        println("registerProjectComponents called")
         if (threadLocalParameters.get().processors.isEmpty())
             return