diff --git a/src/main/kotlin/io/bazel/kotlin/plugin/jdeps/JdepsGenExtension.kt b/src/main/kotlin/io/bazel/kotlin/plugin/jdeps/JdepsGenExtension.kt index b6343d3ee..890a99050 100644 --- a/src/main/kotlin/io/bazel/kotlin/plugin/jdeps/JdepsGenExtension.kt +++ b/src/main/kotlin/io/bazel/kotlin/plugin/jdeps/JdepsGenExtension.kt @@ -8,21 +8,22 @@ import org.jetbrains.kotlin.analyzer.AnalysisResult import org.jetbrains.kotlin.config.CompilerConfiguration import org.jetbrains.kotlin.container.StorageComponentContainer import org.jetbrains.kotlin.container.useInstance +import org.jetbrains.kotlin.descriptors.CallableDescriptor import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.DeclarationDescriptor import org.jetbrains.kotlin.descriptors.DeclarationDescriptorWithSource import org.jetbrains.kotlin.descriptors.FunctionDescriptor import org.jetbrains.kotlin.descriptors.ModuleDescriptor -import org.jetbrains.kotlin.descriptors.ParameterDescriptor import org.jetbrains.kotlin.descriptors.PropertyDescriptor import org.jetbrains.kotlin.descriptors.SourceElement +import org.jetbrains.kotlin.descriptors.ValueDescriptor import org.jetbrains.kotlin.descriptors.impl.LocalVariableDescriptor import org.jetbrains.kotlin.extensions.StorageComponentContainerContributor -import org.jetbrains.kotlin.load.java.descriptors.JavaMethodDescriptor -import org.jetbrains.kotlin.load.java.descriptors.JavaPropertyDescriptor +import org.jetbrains.kotlin.load.java.descriptors.JavaClassConstructorDescriptor import org.jetbrains.kotlin.load.java.sources.JavaSourceElement import org.jetbrains.kotlin.load.java.structure.impl.classFiles.BinaryJavaClass import org.jetbrains.kotlin.load.java.structure.impl.classFiles.BinaryJavaField +import org.jetbrains.kotlin.load.kotlin.JvmPackagePartSource import org.jetbrains.kotlin.load.kotlin.KotlinJvmBinarySourceElement import org.jetbrains.kotlin.load.kotlin.VirtualFileKotlinClass import org.jetbrains.kotlin.load.kotlin.getContainingKotlinJvmBinaryClass @@ -30,17 +31,22 @@ import org.jetbrains.kotlin.platform.TargetPlatform import org.jetbrains.kotlin.psi.KtDeclaration import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.resolve.BindingTrace -import org.jetbrains.kotlin.resolve.FunctionImportedFromObject -import org.jetbrains.kotlin.resolve.PropertyImportedFromObject +import org.jetbrains.kotlin.resolve.ImportedFromObjectCallableDescriptor import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker import org.jetbrains.kotlin.resolve.calls.checkers.CallCheckerContext +import org.jetbrains.kotlin.resolve.calls.model.ExpressionKotlinCallArgument import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall -import org.jetbrains.kotlin.resolve.calls.util.FakeCallableDescriptorForObject +import org.jetbrains.kotlin.resolve.calls.tower.NewAbstractResolvedCall +import org.jetbrains.kotlin.resolve.calls.tower.PSIKotlinCallArgument import org.jetbrains.kotlin.resolve.checkers.DeclarationChecker import org.jetbrains.kotlin.resolve.checkers.DeclarationCheckerContext +import org.jetbrains.kotlin.resolve.descriptorUtil.getImportableDescriptor import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisHandlerExtension +import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedTypeAliasDescriptor +import org.jetbrains.kotlin.synthetic.SyntheticJavaPropertyDescriptor import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.kotlin.types.TypeConstructor +import org.jetbrains.kotlin.types.getAbbreviation import org.jetbrains.kotlin.types.typeUtil.supertypes import java.io.BufferedOutputStream import java.io.File @@ -77,7 +83,22 @@ class JdepsGenExtension( * @return the path corresponding to the JAR where this class was loaded from, or null. */ fun getClassCanonicalPath(descriptor: DeclarationDescriptorWithSource): String? { - return when (val sourceElement: SourceElement = descriptor.source) { + // Get the descriptor's source element which may be a type alias + val sourceElement = if (descriptor.source != SourceElement.NO_SOURCE) { + descriptor.source + } else { + when (val declarationDescriptor = descriptor.getImportableDescriptor()) { + is DeserializedTypeAliasDescriptor -> { + declarationDescriptor.containerSource + } + + else -> { + null + } + } + } + + return when (sourceElement) { is JavaSourceElement -> if (sourceElement.javaElement is BinaryJavaClass) { (sourceElement.javaElement as BinaryJavaClass).virtualFile.canonicalPath @@ -92,13 +113,21 @@ class JdepsGenExtension( // Ignore Java source local to this module. null } + is KotlinJvmBinarySourceElement -> (sourceElement.binaryClass as VirtualFileKotlinClass).file.canonicalPath - else -> null + + is JvmPackagePartSource -> { // This case is needed to collect type aliases + ((sourceElement.knownJvmBinaryClass) as VirtualFileKotlinClass).file.canonicalPath + } + + else -> { + null + } } } - fun getClassCanonicalPath(typeConstructor: TypeConstructor): String? { + private fun getClassCanonicalPath(typeConstructor: TypeConstructor): String? { return (typeConstructor.declarationDescriptor as? DeclarationDescriptorWithSource)?.let { getClassCanonicalPath( it, @@ -130,54 +159,88 @@ class JdepsGenExtension( reportOn: PsiElement, context: CallCheckerContext, ) { - when (val resultingDescriptor = resolvedCall.resultingDescriptor) { - is FunctionImportedFromObject -> { - collectTypeReferences(resultingDescriptor.containingObject.defaultType) - } - is PropertyImportedFromObject -> { - collectTypeReferences(resultingDescriptor.containingObject.defaultType) + // First collect type from the Resolved Call + collectExplicitTypes(resolvedCall) + + resolvedCall.valueArguments.keys.forEach { valueArgument -> + collectTypeReferences(valueArgument.type, isExplicit = false) + } + + // And then collect types from any ResultingDescriptor + val resultingDescriptor = resolvedCall.resultingDescriptor + collectExplicitTypes(resultingDescriptor) + + val isExplicitReturnType = resultingDescriptor is JavaClassConstructorDescriptor + resultingDescriptor.returnType?.let { + collectTypeReferences(it, isExplicit = isExplicitReturnType, collectTypeArguments = false) + } + + resultingDescriptor.valueParameters.forEach { valueParameter -> + collectTypeReferences(valueParameter.type, isExplicit = false) + } + + // Finally, collect types that depend on the type of the ResultingDescriptor and note that + // these descriptors may be composed of multiple classes that we need to extract types from + if (resultingDescriptor is DeclarationDescriptor) { + val containingDeclaration = resultingDescriptor.containingDeclaration + if (containingDeclaration is ClassDescriptor) { + collectTypeReferences(containingDeclaration.defaultType) } - is JavaMethodDescriptor -> { - getClassCanonicalPath( - (resultingDescriptor.containingDeclaration as ClassDescriptor).typeConstructor, - )?.let { explicitClassesCanonicalPaths.add(it) } + + if (resultingDescriptor is PropertyDescriptor) { + ( + resultingDescriptor.getter + ?.correspondingProperty as? SyntheticJavaPropertyDescriptor + ) + ?.let { syntheticJavaPropertyDescriptor -> + collectTypeReferences(syntheticJavaPropertyDescriptor.type, isExplicit = false) + + val functionDescriptor = syntheticJavaPropertyDescriptor.getMethod + functionDescriptor.dispatchReceiverParameter?.type?.let { dispatchReceiverType -> + collectTypeReferences(dispatchReceiverType, isExplicit = false) + } + } } - is FunctionDescriptor -> { - resultingDescriptor.returnType?.let { - collectTypeReferences(it, isExplicit = false, collectTypeArguments = false) - } - resultingDescriptor.valueParameters.forEach { valueParameter -> - collectTypeReferences(valueParameter.type, isExplicit = false) + } + + if (resultingDescriptor is ImportedFromObjectCallableDescriptor<*>) { + collectTypeReferences(resultingDescriptor.containingObject.defaultType, isExplicit = false) + } + + if (resultingDescriptor is ValueDescriptor) { + collectTypeReferences(resultingDescriptor.type, isExplicit = false) + } + } + + private fun collectExplicitTypes(resultingDescriptor: CallableDescriptor) { + val kotlinJvmBinaryClass = resultingDescriptor.getContainingKotlinJvmBinaryClass() + if (kotlinJvmBinaryClass is VirtualFileKotlinClass) { + explicitClassesCanonicalPaths.add(kotlinJvmBinaryClass.file.path) + } + } + + private fun collectExplicitTypes(resolvedCall: ResolvedCall<*>) { + val kotlinCallArguments = (resolvedCall as? NewAbstractResolvedCall) + ?.resolvedCallAtom?.atom?.argumentsInParenthesis + + // note that callArgument can be both a PSIKotlinCallArgument and an ExpressionKotlinCallArgument + kotlinCallArguments?.forEach { callArgument -> + if (callArgument is PSIKotlinCallArgument) { + val dataFlowInfos = listOf(callArgument.dataFlowInfoBeforeThisArgument) + + callArgument.dataFlowInfoAfterThisArgument + + dataFlowInfos.forEach { dataFlowInfo -> + dataFlowInfo.completeTypeInfo.values().flatten().forEach { kotlinType -> + collectTypeReferences(kotlinType, isExplicit = true) + } } - val virtualFileClass = - resultingDescriptor.getContainingKotlinJvmBinaryClass() as? VirtualFileKotlinClass - ?: return - explicitClassesCanonicalPaths.add(virtualFileClass.file.path) - } - is ParameterDescriptor -> { - getClassCanonicalPath(resultingDescriptor)?.let { explicitClassesCanonicalPaths.add(it) } - } - is FakeCallableDescriptorForObject -> { - collectTypeReferences(resultingDescriptor.type) } - is JavaPropertyDescriptor -> { - getClassCanonicalPath(resultingDescriptor)?.let { explicitClassesCanonicalPaths.add(it) } - } - is PropertyDescriptor -> { - when (resultingDescriptor.containingDeclaration) { - is ClassDescriptor -> collectTypeReferences( - (resultingDescriptor.containingDeclaration as ClassDescriptor).defaultType, - ) - else -> { - val virtualFileClass = - (resultingDescriptor).getContainingKotlinJvmBinaryClass() as? VirtualFileKotlinClass - ?: return - explicitClassesCanonicalPaths.add(virtualFileClass.file.path) - } + + if (callArgument is ExpressionKotlinCallArgument) { + callArgument.receiver.allOriginalTypes.forEach { kotlinType -> + collectTypeReferences(kotlinType, isExplicit = true) } - collectTypeReferences(resultingDescriptor.type, isExplicit = false) } - else -> return } } @@ -192,8 +255,9 @@ class JdepsGenExtension( collectTypeReferences(it) } } + is FunctionDescriptor -> { - descriptor.returnType?.let { collectTypeReferences(it) } + descriptor.returnType?.let { collectTypeReferences(it, collectTypeArguments = false) } descriptor.valueParameters.forEach { valueParameter -> collectTypeReferences(valueParameter.type) } @@ -204,6 +268,7 @@ class JdepsGenExtension( collectTypeReferences(it) } } + is PropertyDescriptor -> { collectTypeReferences(descriptor.type) descriptor.annotations.forEach { annotation -> @@ -213,6 +278,7 @@ class JdepsGenExtension( collectTypeReferences(annotation.type) } } + is LocalVariableDescriptor -> { collectTypeReferences(descriptor.type) } @@ -245,6 +311,17 @@ class JdepsGenExtension( } } + // Collect type aliases aka abbreviations + // See: https://github.com/Kotlin/KEEP/blob/master/proposals/type-aliases.md#type-alias-expansion + kotlinType.getAbbreviation()?.let { abbreviationType -> + collectTypeReferences( + abbreviationType, + isExplicit = isExplicit, + collectTypeArguments = collectTypeArguments, + visitedKotlinTypes = visitedKotlinTypes, + ) + } + kotlinType.supertypes().forEach { supertype -> collectTypeReferences( supertype, diff --git a/src/test/kotlin/io/bazel/kotlin/builder/tasks/BUILD.bazel b/src/test/kotlin/io/bazel/kotlin/builder/tasks/BUILD.bazel index e0857d93a..fb51348e7 100644 --- a/src/test/kotlin/io/bazel/kotlin/builder/tasks/BUILD.bazel +++ b/src/test/kotlin/io/bazel/kotlin/builder/tasks/BUILD.bazel @@ -19,6 +19,15 @@ java_library( name = "JdepsParserTestFixtures", testonly = True, srcs = glob(["testFixtures/*.java"]), + deps = [ + ":JdepsParserTestFixtures2", + ], +) + +java_library( + name = "JdepsParserTestFixtures2", + testonly = True, + srcs = glob(["testFixtures2/*.java"]), ) kt_rules_test( @@ -44,7 +53,10 @@ kt_rules_test( name = "KotlinBuilderJvmJdepsTest", size = "large", srcs = ["jvm/KotlinBuilderJvmJdepsTest.kt"], - data = [":JdepsParserTestFixtures"], + data = [ + ":JdepsParserTestFixtures", + ":JdepsParserTestFixtures2", + ], ) kt_rules_test( diff --git a/src/test/kotlin/io/bazel/kotlin/builder/tasks/jvm/KotlinBuilderJvmJdepsTest.kt b/src/test/kotlin/io/bazel/kotlin/builder/tasks/jvm/KotlinBuilderJvmJdepsTest.kt index 659ea3801..30a1dcea8 100644 --- a/src/test/kotlin/io/bazel/kotlin/builder/tasks/jvm/KotlinBuilderJvmJdepsTest.kt +++ b/src/test/kotlin/io/bazel/kotlin/builder/tasks/jvm/KotlinBuilderJvmJdepsTest.kt @@ -46,6 +46,7 @@ class KotlinBuilderJvmJdepsTest(private val enableK2Compiler: Boolean) { val ctx = KotlinJvmTestBuilder() val TEST_FIXTURES_DEP = Dep.fromLabel(":JdepsParserTestFixtures") + val TEST_FIXTURES2_DEP = Dep.fromLabel(":JdepsParserTestFixtures2") val KOTLIN_STDLIB_DEP = Dep.fromLabel("//kotlin/compiler:kotlin-stdlib") @Test @@ -159,12 +160,64 @@ class KotlinBuilderJvmJdepsTest(private val enableK2Compiler: Boolean) { val expected = Deps.Dependencies.newBuilder() .setRuleLabel("//:dependingTarget") .setSuccess(true) - .addExplicitDep(KOTLIN_STDLIB_DEP.singleCompileJar()) .addExplicitDep(TEST_FIXTURES_DEP.singleCompileJar()) + .addExplicitDep(KOTLIN_STDLIB_DEP.singleCompileJar()) .build() assertThat(jdeps).isEqualTo(expected) } + @Test + fun `find explicit exception and its supertypes from throws annotation`() { + val baseExceptionTarget = runJdepsCompileTask { c: KotlinJvmTestBuilder.TaskBuilder -> + c.addSource( + "BaseException.kt", + """ + package something + + open class BaseException : Exception() + """ + ) + } + + val exceptionTarget = runJdepsCompileTask { c: KotlinJvmTestBuilder.TaskBuilder -> + c.addSource( + "MyException.kt", + """ + package something + + class MyException : something.BaseException() + """ + ) + c.addDirectDependencies(baseExceptionTarget) + } + + val dependingTarget = runJdepsCompileTask { c: KotlinJvmTestBuilder.TaskBuilder -> + c.addSource( + "AnotherClass.kt", + """ + package something + + import something.MyException + + class AnotherClass { + @Throws(MyException::class) + fun hasAnnotation() {} + } + """ + ) + c.addDirectDependencies(exceptionTarget) + c.addTransitiveDependencies(baseExceptionTarget) + } + val jdeps = depsProto(dependingTarget) + val expected = Deps.Dependencies.newBuilder() + .setRuleLabel(dependingTarget.label()) + .setSuccess(true) + .addExplicitDep(exceptionTarget.singleCompileJar()) + .addExplicitDep(KOTLIN_STDLIB_DEP.singleCompileJar()) + .addImplicitDep(baseExceptionTarget.singleCompileJar()) + .build() + assertThat(jdeps).isEqualTo(expected) + } @Test fun `annotation on class is an explict dep`() { @@ -368,6 +421,46 @@ class KotlinBuilderJvmJdepsTest(private val enableK2Compiler: Boolean) { assertThat(jdeps).isEqualTo(expected) } + @Test + fun `pattern match exception`() { + val connectionNotFoundExceptionDep = runJdepsCompileTask { c: KotlinJvmTestBuilder.TaskBuilder -> + c.addSource( + "ConnectionNotFoundException.kt", + """ + package something2 + + class ConnectionNotFoundException : Exception() + """ + ) + } + + val dependingTarget = runJdepsCompileTask { c: KotlinJvmTestBuilder.TaskBuilder -> + c.addSource( + "PatternMatchException.kt", + """ + package something + import something2.ConnectionNotFoundException + + fun isRetryable(e: Exception): Boolean { + return when (e) { + is ConnectionNotFoundException -> false + else -> true + } + } + """ + ) + c.addDirectDependencies(connectionNotFoundExceptionDep) + } + val jdeps = depsProto(dependingTarget) + val expected = Deps.Dependencies.newBuilder() + .setRuleLabel(dependingTarget.label()) + .setSuccess(true) + .addExplicitDep(connectionNotFoundExceptionDep.singleCompileJar()) + .addExplicitDep(KOTLIN_STDLIB_DEP.singleCompileJar()) + .build() + assertThat(jdeps).isEqualTo(expected) + } + @Test fun `kotlin property reference`() { val dependentTarget = runJdepsCompileTask { c: KotlinJvmTestBuilder.TaskBuilder -> @@ -653,6 +746,91 @@ class KotlinBuilderJvmJdepsTest(private val enableK2Compiler: Boolean) { assertThat(jdeps).isEqualTo(expected) } + @Test + fun `java static repro`() { + val dependingTarget = runJdepsCompileTask { c: KotlinJvmTestBuilder.TaskBuilder -> + c.addSource( + "HasPropertyDefinition.kt", + """ + package something + + class HasPropertyDefinition { + fun provideMyHttpClient(): MyHttpClient { + return MyHttpClient.builder() + .name("ApiClient") + .circuitBreakerStrategy(CircuitBreakerStrategies.alwaysClosed()) + .build() + } + } + """ + ) + c.addDirectDependencies(TEST_FIXTURES_DEP) + } + val jdeps = depsProto(dependingTarget) + val expected = Deps.Dependencies.newBuilder() + .setRuleLabel(dependingTarget.label()) + .setSuccess(true) + .addExplicitDep(TEST_FIXTURES_DEP.singleCompileJar()) + .build() + assertThat(jdeps).isEqualTo(expected) + } + + @Test + fun `java static repro 2`() { + val dependingTarget = runJdepsCompileTask { c: KotlinJvmTestBuilder.TaskBuilder -> + c.addSource( + "Repro.kt", + """ + package something + + class Repro { + fun hi() { + (GlobalTracer.get()?.activeSpan() as? MySpan)?.report(RuntimeException(), false) + } + } + """ + ) + c.addDirectDependencies(TEST_FIXTURES_DEP) + c.addTransitiveDependencies(TEST_FIXTURES2_DEP) + } + val jdeps = depsProto(dependingTarget) + val expected = Deps.Dependencies.newBuilder() + .setRuleLabel(dependingTarget.label()) + .setSuccess(true) + .addExplicitDep(TEST_FIXTURES_DEP.singleCompileJar()) + .addExplicitDep(KOTLIN_STDLIB_DEP.singleCompileJar()) + .addImplicitDep(TEST_FIXTURES2_DEP.singleCompileJar()) + .build() + assertThat(jdeps).isEqualTo(expected) + } + + @Test + fun `test client1 and client2 are explicit jdeps`() { + val dependingTarget = runJdepsCompileTask { c: KotlinJvmTestBuilder.TaskBuilder -> + c.addSource( + "AClass.kt", + """ + package something + import something.JavaBaseWithTypeParam + + class AClass: JavaBaseWithTypeParam() { + val client1Instance = JavaWidgetFactory.create(client1, client2) + } + """ + ) + c.addDirectDependencies(TEST_FIXTURES_DEP, TEST_FIXTURES2_DEP) + } + + val jdeps = depsProto(dependingTarget) + val expected = Deps.Dependencies.newBuilder() + .setRuleLabel(dependingTarget.label()) + .setSuccess(true) + .addExplicitDep(TEST_FIXTURES_DEP.singleCompileJar()) + .addExplicitDep(TEST_FIXTURES2_DEP.singleCompileJar()) + .build() + assertThat(jdeps).isEqualTo(expected) + } + @Test fun `java enum reference`() { val dependingTarget = runJdepsCompileTask { c: KotlinJvmTestBuilder.TaskBuilder -> @@ -751,6 +929,75 @@ class KotlinBuilderJvmJdepsTest(private val enableK2Compiler: Boolean) { assertThat(jdeps).isEqualTo(expected) } + @Test + fun `inline reified test`() { + val objectMapperTarget = runJdepsCompileTask { c: KotlinJvmTestBuilder.TaskBuilder -> + c.addSource( + "ObjectMapper.kt", + """ + package something + + class ObjectMapper { + } + + object Mappers { + val TEST_MAPPER = ObjectMapper() + } + """ + ) + } + + val dependentTarget = runJdepsCompileTask { c: KotlinJvmTestBuilder.TaskBuilder -> + c.addSource( + "ArgumentMatchers.kt", + """ + package something + import something.Mappers.TEST_MAPPER + + object ArgumentMatchers { + inline fun argThatMatchesJson( + expected: String, + policies: List = listOf(), + mapper: ObjectMapper = TEST_MAPPER + ): T = T::class.java.newInstance() + } + """ + ) + c.addDirectDependencies(objectMapperTarget) + } + + val dependingTarget = runJdepsCompileTask { c: KotlinJvmTestBuilder.TaskBuilder -> + c.addSource( + "HasGenericTypeDependency.kt", + """ + package something + + import something.ArgumentMatchers.argThatMatchesJson + + fun hi(msg: String): String { + return msg + } + + fun something() { + hi(argThatMatchesJson(""${'"'}{"userIds": [123]}""${'"'})) + } + """ + ) + c.addDirectDependencies(dependentTarget) + c.addTransitiveDependencies(objectMapperTarget) + } + + val jdeps = depsProto(dependingTarget) + val expected = Deps.Dependencies.newBuilder() + .setRuleLabel(dependingTarget.label()) + .setSuccess(true) + .addExplicitDep(dependentTarget.singleCompileJar()) + .addExplicitDep(KOTLIN_STDLIB_DEP.singleCompileJar()) + .addImplicitDep(objectMapperTarget.singleCompileJar()) + .build() + assertThat(jdeps).isEqualTo(expected) + } + @Test fun `inlined constant dependency recorded`() { val dependentTarget = runJdepsCompileTask { c: KotlinJvmTestBuilder.TaskBuilder -> @@ -1725,6 +1972,38 @@ class KotlinBuilderJvmJdepsTest(private val enableK2Compiler: Boolean) { assertThat(jdeps).isEqualTo(expected) } + @Test + fun `string interpolation`() { + val dependingTarget = runJdepsCompileTask { c: KotlinJvmTestBuilder.TaskBuilder -> + c.addSource( + "ReferencesConsumerConfig.kt", + """ + package something + + private val log = Log() + fun doit(consumerConfig: ConsumerConfig?) { + log.info("busConfig: ${'$'}{consumerConfig?.busConfig}") + } + + class Log { + fun info(message: String) {} + } + """ + ) + c.addDirectDependencies(TEST_FIXTURES_DEP) + c.setLabel("dependingTarget") + } + + val jdeps = depsProto(dependingTarget) + val expected = Deps.Dependencies.newBuilder() + .setRuleLabel(dependingTarget.label()) + .setSuccess(true) + .addExplicitDep(KOTLIN_STDLIB_DEP.singleCompileJar()) + .addExplicitDep(TEST_FIXTURES_DEP.singleCompileJar()) + .build() + assertThat(jdeps).isEqualTo(expected) + } + private fun depsProto(jdeps: Dep) = Deps.Dependencies.parseFrom(BufferedInputStream(Files.newInputStream(Paths.get(jdeps.jdeps()!!)))) diff --git a/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/AlwaysClosedStrategy.java b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/AlwaysClosedStrategy.java new file mode 100644 index 000000000..aac65385c --- /dev/null +++ b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/AlwaysClosedStrategy.java @@ -0,0 +1,5 @@ +package something; + +public class AlwaysClosedStrategy implements CircuitBreakerStrategy { + public static final AlwaysClosedStrategy INSTANCE = new AlwaysClosedStrategy(); +} diff --git a/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/BusConfig.java b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/BusConfig.java new file mode 100644 index 000000000..a828e9641 --- /dev/null +++ b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/BusConfig.java @@ -0,0 +1,4 @@ +package something; + +public class BusConfig { +} diff --git a/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/CircuitBreakerStrategies.java b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/CircuitBreakerStrategies.java new file mode 100644 index 000000000..cb0d8808d --- /dev/null +++ b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/CircuitBreakerStrategies.java @@ -0,0 +1,8 @@ +package something; + +public class CircuitBreakerStrategies { + public static CircuitBreakerStrategy alwaysClosed() { + return AlwaysClosedStrategy.INSTANCE; + } +} + diff --git a/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/CircuitBreakerStrategy.java b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/CircuitBreakerStrategy.java new file mode 100644 index 000000000..80f182046 --- /dev/null +++ b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/CircuitBreakerStrategy.java @@ -0,0 +1,4 @@ +package something; + +public interface CircuitBreakerStrategy { +} diff --git a/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/Client1.java b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/Client1.java new file mode 100644 index 000000000..cae487bc4 --- /dev/null +++ b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/Client1.java @@ -0,0 +1,4 @@ +package something; + +public class Client1 { +} diff --git a/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/ConsumerConfig.java b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/ConsumerConfig.java new file mode 100644 index 000000000..808d37a16 --- /dev/null +++ b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/ConsumerConfig.java @@ -0,0 +1,7 @@ +package something; + +public class ConsumerConfig { + public BusConfig getBusConfig() { + return new BusConfig(); + } +} \ No newline at end of file diff --git a/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/GlobalTracer.java b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/GlobalTracer.java new file mode 100644 index 000000000..2d50786e1 --- /dev/null +++ b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/GlobalTracer.java @@ -0,0 +1,7 @@ +package something; + +public final class GlobalTracer { + public static Tracer get() { + return null; + } +} diff --git a/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/JavaBaseWithTypeParam.java b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/JavaBaseWithTypeParam.java index 21c77da36..852b279d7 100644 --- a/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/JavaBaseWithTypeParam.java +++ b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/JavaBaseWithTypeParam.java @@ -4,4 +4,6 @@ public class JavaBaseWithTypeParam { public T passthru(T t) { return t; } + protected Client1 client1 = new Client1(); + protected TestClient2 client2 = new TestClient2(); } diff --git a/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/JavaClass.java b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/JavaClass.java index b2af3509b..aac2362f0 100644 --- a/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/JavaClass.java +++ b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/JavaClass.java @@ -8,4 +8,8 @@ public interface InnerJavaClass { public static boolean staticMethod() { return true; } + + public static boolean staticMethod2() { + return true; + } } \ No newline at end of file diff --git a/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/JavaException.java b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/JavaException.java new file mode 100644 index 000000000..f8d9c909a --- /dev/null +++ b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/JavaException.java @@ -0,0 +1,4 @@ +package something; + +public class JavaException extends BaseException { +} diff --git a/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/JavaWidgetFactory.java b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/JavaWidgetFactory.java new file mode 100644 index 000000000..8b8785b0c --- /dev/null +++ b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/JavaWidgetFactory.java @@ -0,0 +1,7 @@ +package something; + +public class JavaWidgetFactory { + public static Widget create(Client1 client1, Client2 client2) { + return new Widget(); + } +} diff --git a/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/MyHttpClient.java b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/MyHttpClient.java new file mode 100644 index 000000000..216a3ac4f --- /dev/null +++ b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/MyHttpClient.java @@ -0,0 +1,7 @@ +package something; + +public class MyHttpClient { + public static MyHttpClientBuilder builder() { + return new MyHttpClientBuilder(); + } +} diff --git a/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/MyHttpClientBuilder.java b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/MyHttpClientBuilder.java new file mode 100644 index 000000000..6f1adb1fb --- /dev/null +++ b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/MyHttpClientBuilder.java @@ -0,0 +1,16 @@ +package something; + + +public class MyHttpClientBuilder { + public MyHttpClientBuilder name(String name) { + return this; + } + + public MyHttpClientBuilder circuitBreakerStrategy(CircuitBreakerStrategy strategy) { + return this; + } + + public something.MyHttpClient build() { + return new MyHttpClient(); + } +} diff --git a/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/MySpan.java b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/MySpan.java new file mode 100644 index 000000000..e2b907e32 --- /dev/null +++ b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/MySpan.java @@ -0,0 +1,8 @@ +package something; + +public class MySpan implements Span, MyErrorReporter { + @Override + public void report(Throwable e, boolean fatal) { + System.out.println("Error: " + e); + } +} diff --git a/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/Span.java b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/Span.java new file mode 100644 index 000000000..f14ec2c1e --- /dev/null +++ b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/Span.java @@ -0,0 +1,4 @@ +package something; + +public interface Span { +} diff --git a/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/Tracer.java b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/Tracer.java new file mode 100644 index 000000000..357a37463 --- /dev/null +++ b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/Tracer.java @@ -0,0 +1,5 @@ +package something; + +interface Tracer { + Span activeSpan(); +} diff --git a/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/Widget.java b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/Widget.java new file mode 100644 index 000000000..644ef308d --- /dev/null +++ b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures/Widget.java @@ -0,0 +1,4 @@ +package something; + +public class Widget { +} diff --git a/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures2/BaseException.java b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures2/BaseException.java new file mode 100644 index 000000000..96ed166b0 --- /dev/null +++ b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures2/BaseException.java @@ -0,0 +1,4 @@ +package something; + +public class BaseException extends Exception { +} diff --git a/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures2/Client2.java b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures2/Client2.java new file mode 100644 index 000000000..4906d4c51 --- /dev/null +++ b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures2/Client2.java @@ -0,0 +1,4 @@ +package something; + +public class Client2 { +} diff --git a/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures2/MyErrorReporter.java b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures2/MyErrorReporter.java new file mode 100644 index 000000000..0cb2bcfa2 --- /dev/null +++ b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures2/MyErrorReporter.java @@ -0,0 +1,5 @@ +package something; + +public interface MyErrorReporter { + public void report(Throwable e, boolean fatal); +} diff --git a/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures2/TestClient2.java b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures2/TestClient2.java new file mode 100644 index 000000000..ec638d5a6 --- /dev/null +++ b/src/test/kotlin/io/bazel/kotlin/builder/tasks/testFixtures2/TestClient2.java @@ -0,0 +1,4 @@ +package something; + +public class TestClient2 extends Client2 { +}