3: detection of targetplatform(Native/JS/JVM) works, i need to figure out how to get names of the native targets (e.g. "linux_x64") out of the CompilerConfiguration Map

Author: Foso

.gitignore

@@ -8,4 +8,6 @@
 /.gradle/
 /build/
 /mpapt-runtime/build/*
-/kotlin-plugin-shared/build/
+/kotlin-plugin-shared/build/
+/buildSrc/build/
+/buildSrc/.gradle/

kotlin-compiler-native-plugin/src/main/java/de/jensklingenberg/common/NativeTestComponentRegistrar.kt

@@ -18,8 +18,8 @@ import org.jetbrains.kotlin.resolve.extensions.SyntheticResolveExtension
 class NativeTestComponentRegistrar : ComponentRegistrar {
 
     override fun registerProjectComponents(project: MockProject, configuration: CompilerConfiguration) {
-        val generator = MpAptTestProcessor(configuration)
-        val mpapt = MpAptProject(generator)
+        val generator = MpAptTestProcessor()
+        val mpapt = MpAptProject(generator,configuration)
 
         StorageComponentContainerContributor.registerExtension(project,mpapt)
         SyntheticResolveExtension.registerExtension(project, mpapt)

kotlin-plugin-shared/src/main/java/de/jensklingenberg/MpAptTestProcessor.kt

@@ -7,9 +7,10 @@ import de.jensklingenberg.mpapt.common.simpleName
 import de.jensklingenberg.mpapt.model.Element
 import de.jensklingenberg.testAnnotations.*
 import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.resolve.descriptorUtil.module
 
-class MpAptTestProcessor(configuration: CompilerConfiguration) : AbstractProcessor(configuration) {
+class MpAptTestProcessor : AbstractProcessor() {
     val TAG = "MyAnnotationProcessor"
 
     val testFunction = TestFunction::class.java.name
@@ -20,6 +21,19 @@ class MpAptTestProcessor(configuration: CompilerConfiguration) : AbstractProcess
     val testConstructor = TestConstructor::class.java.name
     val testLocalVariable = TestLocalVariable::class.java.name
 
+    override fun isTargetPlatformSupported(platform: TargetPlatform): Boolean {
+        val targetName = platform.first().platformName
+
+       return when(targetName){
+            "JS"->false
+           "JVM"->true
+           else -> {
+               log(targetName)
+               false
+           }
+       }
+
+    }
 
     override fun process(roundEnvironment: RoundEnvironment) {
 

kotlin-plugin/src/main/java/de/jensklingenberg/CommonComponentRegistrar.kt

@@ -20,12 +20,12 @@ open class CommonComponentRegistrar : ComponentRegistrar {
             project: MockProject,
             configuration: CompilerConfiguration
     ) {
-        val processor = MpAptTestProcessor(configuration)
-        val mpapt = MpAptProject(processor)
+        val processor = MpAptTestProcessor()
+        val mpapt = MpAptProject(processor,configuration)
         StorageComponentContainerContributor.registerExtension(project,mpapt)
         SyntheticResolveExtension.registerExtension(project, mpapt)
         ClassBuilderInterceptorExtension.registerExtension(project,mpapt)
         JsSyntheticTranslateExtension.registerExtension(project,mpapt)
+
     }
 }
-

mpapt-runtime/src/main/java/de/jensklingenberg/mpapt/common/ClassParser.kt

@@ -1,7 +1,7 @@
 package de.jensklingenberg.mpapt.common
 
-import de.jensklingenberg.mpapt.model.AbstractProcessor
 import de.jensklingenberg.mpapt.model.Element
+import de.jensklingenberg.mpapt.model.Processor
 import de.jensklingenberg.mpapt.model.RoundEnvironment
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.name.FqName
@@ -15,7 +15,7 @@ class ClassParser() {
 
     companion object {
 
-        fun parse(descriptor: ClassDescriptor, processor: AbstractProcessor, roundEnvironment: RoundEnvironment) {
+        fun parse(descriptor: ClassDescriptor, processor: Processor, roundEnvironment: RoundEnvironment) {
 
             processor.getSupportedAnnotationTypes().forEach { annotation ->
                 if (descriptor.hasAnnotation(annotation)) {
@@ -38,24 +38,24 @@ class ClassParser() {
 
         }
 
-        private fun parseClassConstructor(descriptor: ClassDescriptor, processor: AbstractProcessor, round: RoundEnvironment, annotation: String) {
+        private fun parseClassConstructor(descriptor: ClassDescriptor, processor: Processor, round: RoundEnvironment, annotation: String) {
             try {
                 descriptor.constructors.forEach {
-                    if (checkit(it, annotation)) {
+                    if (hasAnnnotations(it, annotation)) {
                         val annotatedConstructors =
-                            descriptor.constructors.filter { constructor -> constructor.hasAnnotation(annotation) }
+                                descriptor.constructors.filter { constructor -> constructor.hasAnnotation(annotation) }
 
                         annotatedConstructors.forEach { annotatedConstructor ->
 
                             val annotationDesc = annotatedConstructor.annotations.findAnnotation(annotation)
 
                             round.module = descriptor.module
                             round.elements.add(
-                                Element.ClassConstructorElement(
-                                    classConstructorDescriptor = annotatedConstructor,
-                                    annotation = annotationDesc
+                                    Element.ClassConstructorElement(
+                                            classConstructorDescriptor = annotatedConstructor,
+                                            annotation = annotationDesc
 
-                                )
+                                    )
                             )
                             processor.process(round)
                         }
@@ -72,7 +72,7 @@ class ClassParser() {
         fun parseMethod(
                 descriptor: ClassDescriptor,
                 function: FunctionDescriptor,
-                processor: AbstractProcessor,
+                processor: Processor,
                 roundEnvironment: RoundEnvironment
         ) {
 
@@ -108,7 +108,7 @@ class ClassParser() {
 
         }
 
-        private fun checkValueParameter(descriptor: ClassDescriptor, function: FunctionDescriptor, processor: AbstractProcessor, roundEnvironment: RoundEnvironment, annotationNames: String) {
+        private fun checkValueParameter(descriptor: ClassDescriptor, function: FunctionDescriptor, processor: Processor, roundEnvironment: RoundEnvironment, annotationNames: String) {
             function.valueParameters.forEach { parameterDescriptor ->
                 if (parameterDescriptor.annotations.hasAnnotation(FqName(annotationNames))) {
                     val annotation = parameterDescriptor.annotations.findAnnotation(FqName(annotationNames))
@@ -131,7 +131,7 @@ class ClassParser() {
         }
 
 
-        fun parseProperty(propertyDescriptor: PropertyDescriptor, processor: AbstractProcessor, roundEnvironment: RoundEnvironment, isLastClass: Boolean = false) {
+        fun parseProperty(propertyDescriptor: PropertyDescriptor, processor: Processor, roundEnvironment: RoundEnvironment) {
 
             processor.getSupportedAnnotationTypes().forEachIndexed { index, annotationNames ->
 
@@ -159,7 +159,7 @@ class ClassParser() {
 
         }
 
-        private fun checkPropertySetter(propertyDescriptor: PropertyDescriptor, processor: AbstractProcessor, roundEnvironment: RoundEnvironment, annotationNames: String) {
+        private fun checkPropertySetter(propertyDescriptor: PropertyDescriptor, processor: Processor, roundEnvironment: RoundEnvironment, annotationNames: String) {
             propertyDescriptor.setter?.let { setterDesc ->
                 if (setterDesc.annotations.hasAnnotation(annotationNames)) {
                     val annotation = setterDesc.annotations.findAnnotation(annotationNames)
@@ -176,10 +176,9 @@ class ClassParser() {
                     processor.process(roundEnvironment)
                 }
             }
-
         }
 
-        private fun checkPropertyGetter(propertyDescriptor: PropertyDescriptor, processor: AbstractProcessor, roundEnvironment: RoundEnvironment, annotationNames: String) {
+        private fun checkPropertyGetter(propertyDescriptor: PropertyDescriptor, processor: Processor, roundEnvironment: RoundEnvironment, annotationNames: String) {
             propertyDescriptor.getter?.let { setterDesc ->
                 if (setterDesc.annotations.hasAnnotation(annotationNames)) {
                     val annotation = setterDesc.annotations.findAnnotation(annotationNames)
@@ -200,17 +199,8 @@ class ClassParser() {
 
         }
 
-        fun parsePackage(thisDescriptor: PackageFragmentDescriptor, processor: AbstractProcessor, roundEnvironment: RoundEnvironment) {
-
-            processor.getSupportedAnnotationTypes().forEach { annotationNames ->
-
-
-            }
-
-
-        }
 
-        private fun checkit(it: ClassConstructorDescriptor, annotation: String): Boolean {
+        private fun hasAnnnotations(it: ClassConstructorDescriptor, annotation: String): Boolean {
             /**I dont like this approach*/
 
             try {

mpapt-runtime/src/main/java/de/jensklingenberg/mpapt/common/End.kt

@@ -2,23 +2,26 @@ package de.jensklingenberg.mpapt.common
 
 import de.jensklingenberg.mpapt.extension.*
 import de.jensklingenberg.mpapt.extension.js.JsSyntheticTranslateExtensionExt
-import de.jensklingenberg.mpapt.extension.unused.DebugLogClassGenerationInterceptor
+import de.jensklingenberg.mpapt.extension.ClassBuilderInterceptorExtensionImpl
 import de.jensklingenberg.mpapt.model.AbstractProcessor
 import org.jetbrains.kotlin.backend.common.extensions.IrGenerationExtension
 import org.jetbrains.kotlin.codegen.extensions.ClassBuilderInterceptorExtension
-import org.jetbrains.kotlin.codegen.extensions.ExpressionCodegenExtension
-import org.jetbrains.kotlin.extensions.CompilerConfigurationExtension
-import org.jetbrains.kotlin.extensions.PreprocessedVirtualFileFactoryExtension
+import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.extensions.StorageComponentContainerContributor
 import org.jetbrains.kotlin.js.translate.extensions.JsSyntheticTranslateExtension
 import org.jetbrains.kotlin.resolve.extensions.SyntheticResolveExtension
 
-class MpAptProject(abstractProcessor: AbstractProcessor) : SyntheticResolveExtension by SyntheticResolveExtensionImpl(abstractProcessor),
+class MpAptProject(abstractProcessor: AbstractProcessor,configuration: CompilerConfiguration) : SyntheticResolveExtension by SyntheticResolveExtensionImpl(abstractProcessor),
         IrGenerationExtension by NativeIrGenerationExtension(abstractProcessor),
         JsSyntheticTranslateExtension by JsSyntheticTranslateExtensionExt(abstractProcessor),
-        ClassBuilderInterceptorExtension by DebugLogClassGenerationInterceptor(abstractProcessor),
+        ClassBuilderInterceptorExtension by ClassBuilderInterceptorExtensionImpl(abstractProcessor),
         StorageComponentContainerContributor by StorageComponentContainerContributorImpl(abstractProcessor)
        // CompilerConfigurationExtension by CompilerConfigurationExtensionExt(abstractProcessor),
       //  ExpressionCodegenExtension by ExpressionCodegenExtensionImpl(abstractProcessor)
       //  PreprocessedVirtualFileFactoryExtension by MetaPreprocessedVirtualFileFactoryExtension(abstractProcessor)
 //   AnalysisHandlerExtension by AnalysisHandlerExtensionImpl(abstractProcessor),
+{
+    init {
+        abstractProcessor.configuration=(configuration)
+    }
+}

mpapt-runtime/src/main/java/de/jensklingenberg/mpapt/common/MpAptProject.kt

@@ -0,0 +1,29 @@
+package de.jensklingenberg.mpapt.extension
+
+import de.jensklingenberg.mpapt.extension.unused.DelegatingClassBuilderImpl
+import de.jensklingenberg.mpapt.model.Processor
+import org.jetbrains.kotlin.codegen.ClassBuilderFactory
+import org.jetbrains.kotlin.codegen.extensions.ClassBuilderInterceptorExtension
+import org.jetbrains.kotlin.diagnostics.DiagnosticSink
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
+
+
+class ClassBuilderInterceptorExtensionImpl(val processor: Processor) : ClassBuilderInterceptorExtension {
+
+    override fun interceptClassBuilderFactory(
+            interceptedFactory: ClassBuilderFactory,
+            bindingContext: BindingContext,
+            diagnostics: DiagnosticSink
+    ): ClassBuilderFactory = object : ClassBuilderFactory by interceptedFactory {
+
+        override fun newClassBuilder(origin: JvmDeclarationOrigin): DelegatingClassBuilderImpl {
+            processor.processingOver()
+
+            return DelegatingClassBuilderImpl(interceptedFactory.newClassBuilder(origin))
+        }
+    }
+
+
+}
+

mpapt-runtime/src/main/java/de/jensklingenberg/mpapt/extension/ClassBuilderInterceptorExtensionImpl.kt

@@ -1,62 +1,54 @@
 package de.jensklingenberg.mpapt.extension
 
 import de.jensklingenberg.mpapt.common.ClassParser
-import de.jensklingenberg.mpapt.model.AbstractProcessor
-import de.jensklingenberg.mpapt.model.Platform
+import de.jensklingenberg.mpapt.model.Processor
 import de.jensklingenberg.mpapt.model.RoundEnvironment
-import org.jetbrains.kotlin.cli.common.config.kotlinSourceRoots
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.KtClass
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.extensions.SyntheticResolveExtension
 import org.jetbrains.kotlin.resolve.lazy.LazyClassContext
 import org.jetbrains.kotlin.resolve.lazy.declarations.PackageMemberDeclarationProvider
-import org.jetbrains.kotlin.resolve.source.KotlinSourceElement
 import java.util.*
 
-internal class SyntheticResolveExtensionImpl(val abstractProcessor: AbstractProcessor) : SyntheticResolveExtension {
+internal class SyntheticResolveExtensionImpl(val abstractProcessor: Processor) : SyntheticResolveExtension {
 
     override fun generateSyntheticClasses(thisDescriptor: PackageFragmentDescriptor, name: Name, ctx: LazyClassContext, declarationProvider: PackageMemberDeclarationProvider, result: MutableSet<ClassDescriptor>) {
-        ClassParser.parsePackage(thisDescriptor, abstractProcessor, RoundEnvironment())
+        if (!abstractProcessor.isTargetPlatformSupported()) {
+            return
+        }
 
         val roundEnvironment = RoundEnvironment()
-        if (
-                abstractProcessor.supportedTargetPlatform().contains(Platform.ALL)
-        ) {
-
-            result.forEach {
-                if (!it.isCompanionObject && name.identifier != "Companion") {
-                    ClassParser.parse(it, abstractProcessor, roundEnvironment)
-                }
-                //checkiflast(it)
+        result.forEach {
+            if (!it.isCompanionObject && name.identifier != "Companion") {
+                ClassParser.parse(it, abstractProcessor, roundEnvironment)
             }
         }
-    }
 
-    private fun checkiflast(thisDescriptor: ClassDescriptor, state: String): Boolean {
-        ((thisDescriptor.source as KotlinSourceElement).psi as KtClass).getProperties()
-        return false
     }
 
-
     override fun generateSyntheticMethods(
             thisDescriptor: ClassDescriptor,
             name: Name,
             bindingContext: BindingContext,
             fromSupertypes: List<SimpleFunctionDescriptor>,
             result: MutableCollection<SimpleFunctionDescriptor>
     ) {
+        if (!abstractProcessor.isTargetPlatformSupported()) {
+            return
+        }
         result.forEach { function ->
             ClassParser.parseMethod(thisDescriptor, function, abstractProcessor, RoundEnvironment())
         }
     }
 
     override fun generateSyntheticProperties(thisDescriptor: ClassDescriptor, name: Name, bindingContext: BindingContext, fromSupertypes: ArrayList<PropertyDescriptor>, result: MutableSet<PropertyDescriptor>) {
-
+        if (!abstractProcessor.isTargetPlatformSupported()) {
+            return
+        }
         result.forEach {
             ClassParser.parseProperty(it, abstractProcessor, RoundEnvironment())
         }

mpapt-runtime/src/main/java/de/jensklingenberg/mpapt/extension/SyntheticResolveExtensionImpl.kt

@@ -7,10 +7,8 @@ import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
 import org.jetbrains.org.objectweb.asm.FieldVisitor
 import org.jetbrains.org.objectweb.asm.MethodVisitor
 
-class DebugLogClassBuilder(
-        val delegateBuilder: ClassBuilder,
-        val test: AbstractProcessor
-) : org.jetbrains.kotlin.codegen.DelegatingClassBuilder() {
+class DelegatingClassBuilderImpl(
+        val delegateBuilder: ClassBuilder) : org.jetbrains.kotlin.codegen.DelegatingClassBuilder() {
     override fun getDelegate() = delegateBuilder