Android Extensions: put new functionality under the flag

2017-07-14 18:55:55 +03:00
parent 77eafb9716
commit 4851a83a83
21 changed files with 358 additions and 30 deletions
@@ -3,5 +3,6 @@ error: required plugin option not present: org.jetbrains.kotlin.android:variant
 Plugin "org.jetbrains.kotlin.android" usage:
  variant <name;path>        Android build variant (required, multiple)
  package <fq name>          Application package (required)
+  experimental true/false    Enable experimental features

 COMPILATION_ERROR
@@ -66,14 +66,19 @@
        <externalProjectDataService implementation="org.jetbrains.kotlin.android.configure.KotlinAndroidGradleLibraryDataService"/>
    </extensions>

+    <extensions defaultExtensionNs="org.jetbrains.plugins.gradle">
+        <projectResolve implementation="org.jetbrains.kotlin.android.synthetic.idea.AndroidExtensionsProjectResolverExtension"/>
+    </extensions>
+
    <extensions defaultExtensionNs="org.jetbrains.kotlin">
-        <expressionCodegenExtension implementation="org.jetbrains.kotlin.android.synthetic.codegen.AndroidExpressionCodegenExtension"/>
+        <expressionCodegenExtension implementation="org.jetbrains.kotlin.android.synthetic.idea.IDEAndroidExtensionsExpressionCodegenExtension"/>
        <defaultErrorMessages implementation="org.jetbrains.kotlin.android.synthetic.diagnostic.DefaultErrorMessagesAndroid"/>
        <storageComponentContainerContributor implementation="org.jetbrains.kotlin.android.synthetic.AndroidExtensionPropertiesComponentContainerContributor"/>
        <classBuilderFactoryInterceptorExtension implementation="org.jetbrains.kotlin.android.synthetic.codegen.AndroidOnDestroyClassBuilderInterceptorExtension"/>
        <packageFragmentProviderExtension implementation="org.jetbrains.kotlin.android.synthetic.idea.res.IDEAndroidPackageFragmentProviderExtension"/>
        <simpleNameReferenceExtension implementation="org.jetbrains.kotlin.android.synthetic.idea.AndroidSimpleNameReferenceExtension"/>
        <kotlinIndicesHelperExtension implementation="org.jetbrains.kotlin.android.synthetic.idea.AndroidIndicesHelperExtension"/>
+        <gradleProjectImportHandler implementation="org.jetbrains.kotlin.android.synthetic.idea.AndroidExtensionsGradleImportHandler"/>

        <quickFixContributor implementation="org.jetbrains.kotlin.android.quickfix.AndroidQuickFixRegistrar"/>
        <projectConfigurator implementation="org.jetbrains.kotlin.android.configure.KotlinAndroidGradleModuleConfigurator"/>
@@ -0,0 +1,21 @@
+/*
+ * Copyright 2010-2017 JetBrains s.r.o.
+ *
+ * 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 org.jetbrains.kotlin.gradle.internal
+
+open class AndroidExtensionsExtension {
+    open var isExperimental: Boolean = false
+}
@@ -29,15 +29,17 @@ import org.gradle.api.tasks.SourceSet
 import org.gradle.api.tasks.compile.AbstractCompile
 import org.jetbrains.kotlin.com.intellij.openapi.util.text.StringUtil.*
 import org.jetbrains.kotlin.gradle.plugin.*
+import org.jetbrains.kotlin.gradle.plugin.android.AndroidGradleWrapper
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 import org.w3c.dom.Document
 import java.io.File
 import javax.xml.parsers.DocumentBuilderFactory

 // Use apply plugin: 'kotlin-android-extensions' to enable Android Extensions in an Android project.
-// Just a marker plugin.
 class AndroidExtensionsSubpluginIndicator : Plugin<Project> {
    override fun apply(project: Project) {
+        project.extensions.create("androidExtensions", AndroidExtensionsExtension::class.java)
+
        val kotlinPluginWrapper = project.plugins.findPlugin(KotlinAndroidPluginWrapper::class.java) ?: run {
            project.logger.error("'kotlin-android' plugin should be enabled before 'kotlin-android-extensions'")
            return
@@ -83,13 +85,55 @@ class AndroidSubplugin : KotlinGradleSubplugin<KotlinCompile> {
            variantData: Any?,
            androidProjectHandler: Any?,
            javaSourceSet: SourceSet?
+    ): List<SubpluginOption> {
+        val androidExtension = project.extensions.getByName("android") as? BaseExtension ?: return emptyList()
+        val androidExtensionsExtension = project.extensions.getByType(AndroidExtensionsExtension::class.java)
+
+        if (androidExtensionsExtension.isExperimental) {
+            return applyExperimental(androidExtension, project, variantData, androidProjectHandler)
+        }
+
+        val sourceSets = androidExtension.sourceSets
+
+        val pluginOptions = arrayListOf<SubpluginOption>()
+
+        val mainSourceSet = sourceSets.getByName("main")
+        val manifestFile = mainSourceSet.manifest.srcFile
+        val applicationPackage = getApplicationPackageFromManifest(manifestFile) ?: run {
+            project.logger.warn(
+                    "Application package name is not present in the manifest file (${manifestFile.absolutePath})")
+            ""
+        }
+        pluginOptions += SubpluginOption("package", applicationPackage)
+
+        fun addVariant(sourceSet: AndroidSourceSet) {
+            pluginOptions += SubpluginOption("variant", sourceSet.name + ';' +
+                    sourceSet.res.srcDirs.joinToString(";") { it.absolutePath })
+        }
+
+        addVariant(mainSourceSet)
+
+        val flavorSourceSets = AndroidGradleWrapper.getProductFlavorsSourceSets(androidExtension).filterNotNull()
+        for (sourceSet in flavorSourceSets) {
+            addVariant(sourceSet)
+        }
+
+        return pluginOptions
+    }
+
+    private fun applyExperimental(
+            androidExtension: BaseExtension,
+            project: Project,
+            variantData: Any?,
+            androidProjectHandler: Any?
    ): List<SubpluginOption> {
        @Suppress("UNCHECKED_CAST")
        androidProjectHandler as? AbstractAndroidProjectHandler<Any?> ?: return emptyList()

-        val androidExtension = project.extensions.getByName("android") as? BaseExtension ?: return emptyList()
        val pluginOptions = arrayListOf<SubpluginOption>()

+        pluginOptions += SubpluginOption("experimental", "true")
+
        val mainSourceSet = androidExtension.sourceSets.getByName("main")
        pluginOptions += SubpluginOption("package", getApplicationPackage(project, mainSourceSet))

@@ -18,8 +18,8 @@ package org.jetbrains.kotlin.android.synthetic

 import com.intellij.mock.MockProject
 import com.intellij.openapi.extensions.Extensions
-import org.jetbrains.kotlin.android.synthetic.codegen.AndroidExpressionCodegenExtension
 import org.jetbrains.kotlin.android.synthetic.codegen.AndroidOnDestroyClassBuilderInterceptorExtension
+import org.jetbrains.kotlin.android.synthetic.codegen.CliAndroidExtensionsExpressionCodegenExtension
 import org.jetbrains.kotlin.android.synthetic.diagnostic.AndroidExtensionPropertiesCallChecker
 import org.jetbrains.kotlin.android.synthetic.diagnostic.DefaultErrorMessagesAndroid
 import org.jetbrains.kotlin.android.synthetic.res.AndroidLayoutXmlFileManager
@@ -45,6 +45,7 @@ import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
 object AndroidConfigurationKeys {
    val VARIANT: CompilerConfigurationKey<List<String>> = CompilerConfigurationKey.create<List<String>>("Android build variant")
    val PACKAGE: CompilerConfigurationKey<String> = CompilerConfigurationKey.create<String>("application package fq name")
+    val EXPERIMENTAL: CompilerConfigurationKey<String> = CompilerConfigurationKey.create<String>("enable experimental features")
 }

 class AndroidCommandLineProcessor : CommandLineProcessor {
@@ -53,36 +54,41 @@ class AndroidCommandLineProcessor : CommandLineProcessor {

        val VARIANT_OPTION: CliOption = CliOption("variant", "<name;path>", "Android build variant", allowMultipleOccurrences = true)
        val PACKAGE_OPTION: CliOption = CliOption("package", "<fq name>", "Application package")
+        val EXPERIMENTAL_OPTION: CliOption = CliOption("experimental", "true/false", "Enable experimental features", required = false)
+
+        /* This option is just for saving Android Extensions status in Kotlin facet. It should not be supported from CLI. */
+        val ENABLED_OPTION: CliOption = CliOption("enabled", "true/false", "Enable Android Extensions", required = false)
    }

    override val pluginId: String = ANDROID_COMPILER_PLUGIN_ID

-    override val pluginOptions: Collection<CliOption> = listOf(VARIANT_OPTION, PACKAGE_OPTION)
+    override val pluginOptions: Collection<CliOption> = listOf(VARIANT_OPTION, PACKAGE_OPTION, EXPERIMENTAL_OPTION)

    override fun processOption(option: CliOption, value: String, configuration: CompilerConfiguration) {
        when (option) {
            VARIANT_OPTION -> configuration.appendList(AndroidConfigurationKeys.VARIANT, value)
            PACKAGE_OPTION -> configuration.put(AndroidConfigurationKeys.PACKAGE, value)
+            EXPERIMENTAL_OPTION -> configuration.put(AndroidConfigurationKeys.EXPERIMENTAL, value)
            else -> throw CliOptionProcessingException("Unknown option: ${option.name}")
        }
    }
 }

 class AndroidComponentRegistrar : ComponentRegistrar {
-
    override fun registerProjectComponents(project: MockProject, configuration: CompilerConfiguration) {
        val applicationPackage = configuration.get(AndroidConfigurationKeys.PACKAGE)
        val variants = configuration.get(AndroidConfigurationKeys.VARIANT)?.mapNotNull { parseVariant(it) } ?: emptyList()
+        val isExperimental = configuration.get(AndroidConfigurationKeys.EXPERIMENTAL) == "true"

        if (variants.isNotEmpty() && !applicationPackage.isNullOrBlank()) {
            val layoutXmlFileManager = CliAndroidLayoutXmlFileManager(project, applicationPackage!!, variants)
            project.registerService(AndroidLayoutXmlFileManager::class.java, layoutXmlFileManager)

-            ExpressionCodegenExtension.registerExtension(project, AndroidExpressionCodegenExtension())
+            ExpressionCodegenExtension.registerExtension(project, CliAndroidExtensionsExpressionCodegenExtension(isExperimental))
            StorageComponentContainerContributor.registerExtension(project, AndroidExtensionPropertiesComponentContainerContributor())
            Extensions.getRootArea().getExtensionPoint(DefaultErrorMessages.Extension.EP_NAME).registerExtension(DefaultErrorMessagesAndroid())
            ClassBuilderInterceptorExtension.registerExtension(project, AndroidOnDestroyClassBuilderInterceptorExtension())
-            PackageFragmentProviderExtension.registerExtension(project, CliAndroidPackageFragmentProviderExtension())
+            PackageFragmentProviderExtension.registerExtension(project, CliAndroidPackageFragmentProviderExtension(isExperimental))
        }
    }

@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.android.synthetic.codegen

 import kotlinx.android.extensions.CacheImplementation.NO_CACHE
 import org.jetbrains.kotlin.android.synthetic.AndroidConst
+import org.jetbrains.kotlin.android.synthetic.codegen.AndroidContainerType.LAYOUT_CONTAINER
 import org.jetbrains.kotlin.android.synthetic.descriptors.ContainerOptionsProxy
 import org.jetbrains.kotlin.android.synthetic.descriptors.AndroidSyntheticPackageFragmentDescriptor
 import org.jetbrains.kotlin.android.synthetic.res.AndroidSyntheticFunction
@@ -29,6 +30,7 @@ import org.jetbrains.kotlin.codegen.StackValue
 import org.jetbrains.kotlin.codegen.extensions.ExpressionCodegenExtension
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.psi.KtClass
 import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
@@ -42,7 +44,7 @@ import org.jetbrains.org.objectweb.asm.Opcodes.ACC_SYNTHETIC
 import org.jetbrains.org.objectweb.asm.Type
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter

-class AndroidExpressionCodegenExtension : ExpressionCodegenExtension {
+abstract class AbstractAndroidExtensionsExpressionCodegenExtension : ExpressionCodegenExtension {
    companion object {
        val PROPERTY_NAME = "_\$_findViewCache"
        val CACHED_FIND_VIEW_BY_ID_METHOD_NAME = "_\$_findCachedViewById"
@@ -61,6 +63,8 @@ class AndroidExpressionCodegenExtension : ExpressionCodegenExtension {
            val classOrObject: KtClassOrObject,
            val containerOptions: ContainerOptionsProxy)

+    protected abstract fun isExperimental(clazz: KtClassOrObject): Boolean
+
    override fun applyProperty(receiver: StackValue, resolvedCall: ResolvedCall<*>, c: ExpressionCodegenExtension.Context): StackValue? {
        val resultingDescriptor = resolvedCall.resultingDescriptor
        return if (resultingDescriptor is PropertyDescriptor) {
@@ -124,7 +128,7 @@ class AndroidExpressionCodegenExtension : ExpressionCodegenExtension {

    override fun generateClassSyntheticParts(codegen: ImplementationBodyCodegen) {
        val classBuilder = codegen.v
-        val targetClass = codegen.myClass as? KtClassOrObject ?: return
+        val targetClass = codegen.myClass as? KtClass ?: return

        val container = codegen.descriptor
        if (container.kind != ClassKind.CLASS || container.isInner || DescriptorUtils.isLocal(container)) return
@@ -132,6 +136,10 @@ class AndroidExpressionCodegenExtension : ExpressionCodegenExtension {
        val containerOptions = ContainerOptionsProxy.create(container)
        if (containerOptions.cache == NO_CACHE) return

+        if (containerOptions.containerType == LAYOUT_CONTAINER && !isExperimental(targetClass)) {
+            return
+        }
+
        val context = SyntheticPartsGenerateContext(classBuilder, codegen.state, container, targetClass, containerOptions)
        context.generateCachedFindViewByIdFunction()
        context.generateClearCacheFunction()
@@ -239,8 +247,8 @@ class AndroidExpressionCodegenExtension : ExpressionCodegenExtension {
                loadId()
                iv.invokevirtual(containerType.internalClassName, "findViewById", "(I)Landroid/view/View;", false)
            }
-            AndroidContainerType.FRAGMENT, AndroidContainerType.SUPPORT_FRAGMENT, AndroidContainerType.LAYOUT_CONTAINER -> {
-                if (containerType == AndroidContainerType.LAYOUT_CONTAINER) {
+            AndroidContainerType.FRAGMENT, AndroidContainerType.SUPPORT_FRAGMENT, LAYOUT_CONTAINER -> {
+                if (containerType == LAYOUT_CONTAINER) {
                    iv.invokeinterface(containerType.internalClassName, "getContainerView", "()Landroid/view/View;")
                } else {
                    iv.invokevirtual(containerType.internalClassName, "getView", "()Landroid/view/View;", false)
@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.android.synthetic.codegen

 import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.android.synthetic.codegen.AbstractAndroidExtensionsExpressionCodegenExtension.Companion.ON_DESTROY_METHOD_NAME
 import org.jetbrains.kotlin.android.synthetic.descriptors.ContainerOptionsProxy
 import org.jetbrains.kotlin.codegen.ClassBuilder
 import org.jetbrains.kotlin.codegen.ClassBuilderFactory
@@ -28,6 +29,7 @@ import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
 import org.jetbrains.org.objectweb.asm.*
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
+import org.jetbrains.kotlin.android.synthetic.codegen.AbstractAndroidExtensionsExpressionCodegenExtension.Companion.CLEAR_CACHE_METHOD_NAME

 class AndroidOnDestroyClassBuilderInterceptorExtension : ClassBuilderInterceptorExtension {

@@ -106,7 +108,7 @@ class AndroidOnDestroyClassBuilderInterceptorExtension : ClassBuilderInterceptor
                }

                private fun generateClearCacheMethodCall() {
-                    if (name != AndroidExpressionCodegenExtension.ON_DESTROY_METHOD_NAME || currentClass == null) return
+                    if (name != ON_DESTROY_METHOD_NAME || currentClass == null) return
                    if (Type.getArgumentTypes(desc).isNotEmpty()) return
                    if (Type.getReturnType(desc) != Type.VOID_TYPE) return

@@ -118,7 +120,7 @@ class AndroidOnDestroyClassBuilderInterceptorExtension : ClassBuilderInterceptor

                    val iv = InstructionAdapter(this)
                    iv.load(0, containerType)
-                    iv.invokevirtual(currentClassName, AndroidExpressionCodegenExtension.CLEAR_CACHE_METHOD_NAME, "()V", false)
+                    iv.invokevirtual(currentClassName, CLEAR_CACHE_METHOD_NAME, "()V", false)
                }
            }
        }
@@ -20,6 +20,7 @@ import kotlinx.android.extensions.CacheImplementation
 import org.jetbrains.kotlin.android.synthetic.descriptors.ContainerOptionsProxy
 import org.jetbrains.org.objectweb.asm.Type
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
+import org.jetbrains.kotlin.android.synthetic.codegen.AbstractAndroidExtensionsExpressionCodegenExtension.Companion.PROPERTY_NAME

 interface CacheMechanism {
    /** Push the cache object onto the stack. */
@@ -62,7 +63,7 @@ internal class HashMapCacheMechanism(
 ) : CacheMechanism {
    override fun loadCache() {
        iv.load(0, containerType)
-        iv.getfield(containerType.internalName, AndroidExpressionCodegenExtension.PROPERTY_NAME, "Ljava/util/HashMap;")
+        iv.getfield(containerType.internalName, PROPERTY_NAME, "Ljava/util/HashMap;")
    }

    override fun initCache() {
@@ -70,7 +71,7 @@ internal class HashMapCacheMechanism(
        iv.anew(Type.getType("Ljava/util/HashMap;"))
        iv.dup()
        iv.invokespecial("java/util/HashMap", "<init>", "()V", false)
-        iv.putfield(containerType.internalName, AndroidExpressionCodegenExtension.PROPERTY_NAME, "Ljava/util/HashMap;")
+        iv.putfield(containerType.internalName, PROPERTY_NAME, "Ljava/util/HashMap;")
    }

    override fun clearCache() {
@@ -96,7 +97,7 @@ internal class SparseArrayCacheMechanism(
 ) : CacheMechanism {
    override fun loadCache() {
        iv.load(0, containerType)
-        iv.getfield(containerType.internalName, AndroidExpressionCodegenExtension.PROPERTY_NAME, "Landroid/util/SparseArray;")
+        iv.getfield(containerType.internalName, PROPERTY_NAME, "Landroid/util/SparseArray;")
    }

    override fun initCache() {
@@ -104,7 +105,7 @@ internal class SparseArrayCacheMechanism(
        iv.anew(Type.getType("Landroid/util/SparseArray;"))
        iv.dup()
        iv.invokespecial("android/util/SparseArray", "<init>", "()V", false)
-        iv.putfield(containerType.internalName, AndroidExpressionCodegenExtension.PROPERTY_NAME, "Landroid/util/SparseArray;")
+        iv.putfield(containerType.internalName, PROPERTY_NAME, "Landroid/util/SparseArray;")
    }

    override fun clearCache() {
@@ -0,0 +1,23 @@
+/*
+ * Copyright 2010-2017 JetBrains s.r.o.
+ *
+ * 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 org.jetbrains.kotlin.android.synthetic.codegen
+
+import org.jetbrains.kotlin.psi.KtClassOrObject
+
+class CliAndroidExtensionsExpressionCodegenExtension(val isExperimental: Boolean) : AbstractAndroidExtensionsExpressionCodegenExtension() {
+    override fun isExperimental(clazz: KtClassOrObject) = isExperimental
+}
@@ -17,7 +17,8 @@
 package org.jetbrains.kotlin.android.synthetic.codegen

 import org.jetbrains.kotlin.android.synthetic.AndroidConst
-import org.jetbrains.kotlin.android.synthetic.codegen.AndroidExpressionCodegenExtension.Companion.shouldCacheResource
+import org.jetbrains.kotlin.android.synthetic.codegen.AbstractAndroidExtensionsExpressionCodegenExtension.Companion.shouldCacheResource
+import org.jetbrains.kotlin.android.synthetic.codegen.AbstractAndroidExtensionsExpressionCodegenExtension.Companion.CACHED_FIND_VIEW_BY_ID_METHOD_NAME
 import org.jetbrains.kotlin.android.synthetic.descriptors.ContainerOptionsProxy
 import org.jetbrains.kotlin.android.synthetic.res.AndroidSyntheticProperty
 import org.jetbrains.kotlin.codegen.StackValue
@@ -58,7 +59,7 @@ class ResourcePropertyStackValue(
            val packageName = resourceId.packageName ?: androidPackage
            v.getstatic(packageName.replace(".", "/") + "/R\$id", resourceId.name, "I")

-            v.invokevirtual(declarationDescriptorType.internalName, AndroidExpressionCodegenExtension.CACHED_FIND_VIEW_BY_ID_METHOD_NAME, "(I)Landroid/view/View;", false)
+            v.invokevirtual(declarationDescriptorType.internalName, CACHED_FIND_VIEW_BY_ID_METHOD_NAME, "(I)Landroid/view/View;", false)
        }
        else {
            when (containerType) {
@@ -42,7 +42,8 @@ class AndroidSyntheticPackageFragmentDescriptor(
        fqName: FqName,
        val packageData: AndroidSyntheticPackageData,
        private val lazyContext: LazySyntheticElementResolveContext,
-        private val storageManager: StorageManager
+        private val storageManager: StorageManager,
+        private val isExperimental: Boolean
 ) : PackageFragmentDescriptorImpl(module, fqName) {
    private val scope = AndroidExtensionPropertiesScope()
    override fun getMemberScope(): MemberScope = scope
@@ -52,7 +53,7 @@ class AndroidSyntheticPackageFragmentDescriptor(
            val packageFragmentDescriptor = this@AndroidSyntheticPackageFragmentDescriptor

            val context = lazyContext()
-            val widgetReceivers = context.getWidgetReceivers(packageData.forView)
+            val widgetReceivers = context.getWidgetReceivers(packageData.forView, isExperimental)
            val fragmentTypes = context.fragmentTypes

            val properties = ArrayList<PropertyDescriptor>(0)
@@ -77,6 +77,11 @@ internal class SyntheticElementResolveContext(
        receivers += WidgetReceiver(dialog, mayHaveCache = false)
        fragment?.let { receivers += WidgetReceiver(it, mayHaveCache = true) }
        supportFragment?.let { receivers += WidgetReceiver(it, mayHaveCache = true) }
+        receivers
+    }
+
+    private val experimentalWidgetReceivers by lazy {
+        val receivers = widgetReceivers.toMutableList()
        layoutContainer?.let { receivers += WidgetReceiver(it, mayHaveCache = true) }
        receivers
    }
@@ -97,9 +102,9 @@ internal class SyntheticElementResolveContext(
        }
    }

-    fun getWidgetReceivers(forView: Boolean): List<WidgetReceiver> {
+    fun getWidgetReceivers(forView: Boolean, isExperimental: Boolean): List<WidgetReceiver> {
        if (forView) return listOf(WidgetReceiver(view, mayHaveCache = true))
-        return widgetReceivers
+        return if (isExperimental) experimentalWidgetReceivers else widgetReceivers
    }

 }
@@ -31,6 +31,8 @@ import org.jetbrains.kotlin.storage.StorageManager
 abstract class AndroidPackageFragmentProviderExtension : PackageFragmentProviderExtension {
    protected abstract fun getLayoutXmlFileManager(project: Project, moduleInfo: ModuleInfo?): AndroidLayoutXmlFileManager?

+    protected abstract fun isExperimental(moduleInfo: ModuleInfo?): Boolean
+
    override fun getPackageFragmentProvider(
            project: Project,
            module: ModuleDescriptor,
@@ -38,6 +40,8 @@ abstract class AndroidPackageFragmentProviderExtension : PackageFragmentProvider
            trace: BindingTrace,
            moduleInfo: ModuleInfo?
    ): PackageFragmentProvider? {
+        val isExperimental = isExperimental(moduleInfo)
+
        val layoutXmlFileManager = getLayoutXmlFileManager(project, moduleInfo) ?: return null

        val moduleData = layoutXmlFileManager.getModuleData()
@@ -54,7 +58,7 @@ abstract class AndroidPackageFragmentProviderExtension : PackageFragmentProvider
                    val resources = layoutXmlFileManager.extractResources(AndroidLayoutGroupData(layoutName, layouts), module)
                    val packageData = AndroidSyntheticPackageData(moduleData, forView, isDeprecated, resources)
                    val packageDescriptor = AndroidSyntheticPackageFragmentDescriptor(
-                            module, FqName(fqName), packageData, lazyContext, storageManager)
+                            module, FqName(fqName), packageData, lazyContext, storageManager, isExperimental)
                    packagesToLookupInCompletion += packageDescriptor
                    allPackageDescriptors += packageDescriptor
                }
@@ -79,7 +83,10 @@ abstract class AndroidPackageFragmentProviderExtension : PackageFragmentProvider
        // Package with clearFindViewByIdCache()
        AndroidConst.SYNTHETIC_SUBPACKAGES.last().let { s ->
            val packageDescriptor = PredefinedPackageFragmentDescriptor(s, module, storageManager, packagesToLookupInCompletion) { descriptor ->
-                (lazyContext().getWidgetReceivers(forView = false) + lazyContext().getWidgetReceivers(forView = true))
+                val widgetReceivers = lazyContext().getWidgetReceivers(forView = false, isExperimental = isExperimental) +
+                                      lazyContext().getWidgetReceivers(forView = true, isExperimental = isExperimental)
+
+                widgetReceivers
                        .filter { it.mayHaveCache }
                        .map { genClearCacheFunction(descriptor, it.type) }
            }
@@ -17,10 +17,13 @@
 package org.jetbrains.kotlin.android.synthetic.res

 import com.intellij.openapi.components.ServiceManager
+import com.intellij.openapi.module.Module
 import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.analyzer.ModuleInfo

-class CliAndroidPackageFragmentProviderExtension : AndroidPackageFragmentProviderExtension() {
+class CliAndroidPackageFragmentProviderExtension(private val isExperimental: Boolean) : AndroidPackageFragmentProviderExtension() {
+    override fun isExperimental(moduleInfo: ModuleInfo?): Boolean = isExperimental
+
    override fun getLayoutXmlFileManager(project: Project, moduleInfo: ModuleInfo?): AndroidLayoutXmlFileManager? {
        return ServiceManager.getService(project, AndroidLayoutXmlFileManager::class.java)
    }
@@ -22,5 +22,8 @@
    <orderEntry type="module" module-name="frontend.java" scope="TEST" />
    <orderEntry type="module" module-name="idea-live-templates" scope="TEST" />
    <orderEntry type="library" name="gradle-and-groovy-plugin" level="project" />
+    <orderEntry type="module" module-name="idea-jps-common" />
+    <orderEntry type="module" module-name="cli-common" />
+    <orderEntry type="module" module-name="backend" />
  </component>
 </module>
@@ -0,0 +1 @@
+org.jetbrains.kotlin.android.synthetic.idea.AndroidExtensionsModelBuilderService
@@ -0,0 +1,121 @@
+/*
+ * Copyright 2010-2017 JetBrains s.r.o.
+ *
+ * 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 org.jetbrains.kotlin.android.synthetic.idea
+
+import com.intellij.openapi.externalSystem.model.DataNode
+import com.intellij.openapi.externalSystem.model.ProjectKeys
+import com.intellij.openapi.externalSystem.model.project.ModuleData
+import com.intellij.openapi.externalSystem.model.project.ProjectData
+import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil
+import com.intellij.openapi.util.Key
+import org.gradle.api.Project
+import org.gradle.tooling.model.idea.IdeaModule
+import org.gradle.tooling.model.idea.IdeaProject
+import org.jetbrains.kotlin.android.synthetic.AndroidCommandLineProcessor
+import org.jetbrains.kotlin.android.synthetic.AndroidCommandLineProcessor.Companion.ANDROID_COMPILER_PLUGIN_ID
+import org.jetbrains.kotlin.android.synthetic.AndroidCommandLineProcessor.Companion.EXPERIMENTAL_OPTION
+import org.jetbrains.kotlin.android.synthetic.AndroidCommandLineProcessor.Companion.ENABLED_OPTION
+import org.jetbrains.kotlin.cli.common.arguments.CommonCompilerArguments
+import org.jetbrains.kotlin.idea.configuration.GradleProjectImportHandler
+import org.jetbrains.kotlin.idea.facet.KotlinFacet
+import org.jetbrains.kotlin.psi.NotNullableUserDataProperty
+import org.jetbrains.plugins.gradle.model.data.GradleSourceSetData
+import org.jetbrains.plugins.gradle.service.project.AbstractProjectResolverExtension
+import org.jetbrains.plugins.gradle.tooling.ErrorMessageBuilder
+import org.jetbrains.plugins.gradle.tooling.ModelBuilderService
+import java.io.Serializable
+import java.lang.Exception
+
+var DataNode<ModuleData>.hasAndroidExtensionsPlugin: Boolean
+        by NotNullableUserDataProperty(Key.create<Boolean>("HAS_ANDROID_EXTENSIONS_PLUGIN"), false)
+
+var DataNode<ModuleData>.isExperimental: Boolean
+        by NotNullableUserDataProperty(Key.create<Boolean>("ANDROID_EXTENSIONS_IS_EXPERIMENTAL"), false)
+
+interface AndroidExtensionsGradleModel : Serializable {
+    val hasAndroidExtensionsPlugin: Boolean
+    val isExperimental: Boolean
+}
+
+class AndroidExtensionsGradleModelImpl(
+        override val hasAndroidExtensionsPlugin: Boolean,
+        override val isExperimental: Boolean
+) : AndroidExtensionsGradleModel
+
+@Suppress("unused")
+class AndroidExtensionsProjectResolverExtension : AbstractProjectResolverExtension() {
+    override fun getExtraProjectModelClasses() = setOf(AndroidExtensionsGradleModel::class.java)
+    override fun getToolingExtensionsClasses() = setOf(AndroidExtensionsModelBuilderService::class.java)
+
+    override fun populateModuleExtraModels(gradleModule: IdeaModule, ideModule: DataNode<ModuleData>) {
+        val androidExtensionsModel = resolverCtx.getExtraProject(gradleModule, AndroidExtensionsGradleModel::class.java) ?: return
+
+        ideModule.hasAndroidExtensionsPlugin = androidExtensionsModel.hasAndroidExtensionsPlugin
+        ideModule.isExperimental = androidExtensionsModel.isExperimental
+
+        super.populateModuleExtraModels(gradleModule, ideModule)
+    }
+}
+
+class AndroidExtensionsModelBuilderService : ModelBuilderService {
+    override fun getErrorMessageBuilder(project: Project, e: Exception): ErrorMessageBuilder {
+        return ErrorMessageBuilder.create(project, e, "Gradle import errors")
+                .withDescription("Unable to build Android Extensions plugin configuration")
+    }
+
+    override fun canBuild(modelName: String?): Boolean = modelName == AndroidExtensionsGradleModel::class.java.name
+
+    override fun buildAll(modelName: String?, project: Project): Any {
+        val androidExtensionsPlugin = project.plugins.findPlugin("kotlin-android-extensions")
+
+        val isExperimental = project.extensions.findByName("androidExtensions")?.let { ext ->
+            val isExperimentalMethod = ext::class.java.methods
+                    .firstOrNull { it.name == "isExperimental" && it.parameterCount == 0 }
+                    ?: return@let false
+
+            isExperimentalMethod.invoke(ext) as? Boolean
+        } ?: false
+
+        return AndroidExtensionsGradleModelImpl(androidExtensionsPlugin != null, isExperimental)
+    }
+}
+
+@Suppress("unused")
+class AndroidExtensionsGradleImportHandler : GradleProjectImportHandler {
+    override fun importBySourceSet(facet: KotlinFacet, sourceSetNode: DataNode<GradleSourceSetData>) {
+        val module = ExternalSystemApiUtil.findParent(sourceSetNode, ProjectKeys.MODULE) ?: return
+        importByModule(facet, module)
+    }
+
+    override fun importByModule(facet: KotlinFacet, moduleNode: DataNode<ModuleData>) {
+        val facetSettings = facet.configuration.settings
+        val commonArguments = facetSettings.compilerArguments ?: CommonCompilerArguments.DummyImpl()
+
+        fun makePluginOption(key: String, value: String) = "plugin:$ANDROID_COMPILER_PLUGIN_ID:$key=$value"
+
+        val newPluginOptions = (commonArguments.pluginOptions ?: emptyArray())
+                .filterTo(mutableListOf()) { !it.startsWith("plugin:$ANDROID_COMPILER_PLUGIN_ID:") } // Filter out old options
+
+        if (moduleNode.hasAndroidExtensionsPlugin) {
+            newPluginOptions += makePluginOption(EXPERIMENTAL_OPTION.name, moduleNode.isExperimental.toString())
+            newPluginOptions += makePluginOption(ENABLED_OPTION.name, moduleNode.hasAndroidExtensionsPlugin.toString())
+        }
+
+        commonArguments.pluginOptions = newPluginOptions.toTypedArray()
+        facetSettings.compilerArguments = commonArguments
+    }
+}
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2010-2017 JetBrains s.r.o.
+ *
+ * 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 org.jetbrains.kotlin.android.synthetic.idea
+
+import org.jetbrains.kotlin.analyzer.ModuleInfo
+import org.jetbrains.kotlin.android.synthetic.AndroidCommandLineProcessor.Companion.ANDROID_COMPILER_PLUGIN_ID
+import org.jetbrains.kotlin.android.synthetic.AndroidCommandLineProcessor.Companion.EXPERIMENTAL_OPTION
+import org.jetbrains.kotlin.idea.caches.resolve.ModuleSourceInfo
+import org.jetbrains.kotlin.idea.facet.KotlinFacet
+
+private val ANNOTATION_OPTION_PREFIX = "plugin:$ANDROID_COMPILER_PLUGIN_ID:${EXPERIMENTAL_OPTION.name}="
+
+internal val ModuleInfo.androidExtensionsIsExperimental: Boolean
+    get() {
+        val module = (this as? ModuleSourceInfo)?.module ?: return false
+        val kotlinFacet = KotlinFacet.get(module) ?: return false
+        val commonArgs = kotlinFacet.configuration.settings.compilerArguments ?: return false
+
+        val isExperimentalString = commonArgs.pluginOptions
+                ?.firstOrNull { it.startsWith(ANNOTATION_OPTION_PREFIX) }
+                ?.substring(ANNOTATION_OPTION_PREFIX.length)
+
+        return isExperimentalString == "true"
+    }
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2010-2017 JetBrains s.r.o.
+ *
+ * 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 org.jetbrains.kotlin.android.synthetic.idea
+
+import org.jetbrains.kotlin.android.synthetic.codegen.AbstractAndroidExtensionsExpressionCodegenExtension
+import org.jetbrains.kotlin.idea.caches.resolve.getModuleInfo
+import org.jetbrains.kotlin.psi.KtClassOrObject
+
+class IDEAndroidExtensionsExpressionCodegenExtension : AbstractAndroidExtensionsExpressionCodegenExtension() {
+    override fun isExperimental(clazz: KtClassOrObject): Boolean {
+        val moduleInfo = clazz.getModuleInfo() ?: return false
+        return moduleInfo.androidExtensionsIsExperimental
+    }
+}
@@ -25,14 +25,23 @@ import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiManager
 import org.jetbrains.android.facet.AndroidFacet
 import org.jetbrains.kotlin.analyzer.ModuleInfo
+import org.jetbrains.kotlin.android.synthetic.AndroidCommandLineProcessor.Companion.ANDROID_COMPILER_PLUGIN_ID
+import org.jetbrains.kotlin.android.synthetic.AndroidCommandLineProcessor.Companion.EXPERIMENTAL_OPTION
+import org.jetbrains.kotlin.android.synthetic.idea.androidExtensionsIsExperimental
+import org.jetbrains.kotlin.android.synthetic.idea.isExperimental
 import org.jetbrains.kotlin.android.synthetic.res.AndroidLayoutXmlFileManager
 import org.jetbrains.kotlin.android.synthetic.res.AndroidPackageFragmentProviderExtension
 import org.jetbrains.kotlin.idea.caches.resolve.ModuleSourceInfo
+import org.jetbrains.kotlin.idea.facet.KotlinFacet
 import org.jetbrains.plugins.groovy.lang.psi.GroovyFile

 class IDEAndroidPackageFragmentProviderExtension(val project: Project) : AndroidPackageFragmentProviderExtension() {
    private val psiManager = PsiManager.getInstance(project)

+    override fun isExperimental(moduleInfo: ModuleInfo?): Boolean {
+        return moduleInfo?.androidExtensionsIsExperimental ?: false
+    }
+
    override fun getLayoutXmlFileManager(project: Project, moduleInfo: ModuleInfo?): AndroidLayoutXmlFileManager? {
        val moduleSourceInfo = moduleInfo as? ModuleSourceInfo ?: return null
        val module = moduleSourceInfo.module
@@ -19,8 +19,8 @@ package org.jetbrains.kotlin.android.synthetic.test
 import com.intellij.testFramework.registerServiceInstance
 import org.jetbrains.kotlin.android.synthetic.AndroidConfigurationKeys
 import org.jetbrains.kotlin.android.synthetic.AndroidExtensionPropertiesComponentContainerContributor
-import org.jetbrains.kotlin.android.synthetic.codegen.AndroidExpressionCodegenExtension
 import org.jetbrains.kotlin.android.synthetic.codegen.AndroidOnDestroyClassBuilderInterceptorExtension
+import org.jetbrains.kotlin.android.synthetic.codegen.CliAndroidExtensionsExpressionCodegenExtension
 import org.jetbrains.kotlin.android.synthetic.res.AndroidLayoutXmlFileManager
 import org.jetbrains.kotlin.android.synthetic.res.AndroidVariant
 import org.jetbrains.kotlin.android.synthetic.res.CliAndroidLayoutXmlFileManager
@@ -46,10 +46,10 @@ fun KtUsefulTestCase.createTestEnvironment(configuration: CompilerConfiguration,
    val variants = listOf(AndroidVariant.createMainVariant(resDirectories))
    project.registerServiceInstance(AndroidLayoutXmlFileManager::class.java, CliAndroidLayoutXmlFileManager(project, "test", variants))

-    ExpressionCodegenExtension.registerExtension(project, AndroidExpressionCodegenExtension())
+    ExpressionCodegenExtension.registerExtension(project, CliAndroidExtensionsExpressionCodegenExtension(true))
    StorageComponentContainerContributor.registerExtension(project, AndroidExtensionPropertiesComponentContainerContributor())
    ClassBuilderInterceptorExtension.registerExtension(project, AndroidOnDestroyClassBuilderInterceptorExtension())
-    PackageFragmentProviderExtension.registerExtension(project, CliAndroidPackageFragmentProviderExtension())
+    PackageFragmentProviderExtension.registerExtension(project, CliAndroidPackageFragmentProviderExtension(true))

    addAndroidExtensionsRuntimeLibrary(myEnvironment)
				`@@ -0,0 +1 @@`
				`org.jetbrains.kotlin.android.synthetic.idea.AndroidExtensionsModelBuilderService`