ExternalDeclarationsProvider introduced

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/JetCoreEnvironment.java

@@ -56,6 +56,7 @@ import kotlin.Function1;
 import kotlin.Unit;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.TestOnly;
+import org.jetbrains.jet.extensions.ExternalDeclarationsProvider;
 import org.jetbrains.kotlin.asJava.JavaElementFinder;
 import org.jetbrains.kotlin.asJava.KotlinLightClassForPackage;
 import org.jetbrains.kotlin.asJava.LightClassGenerationSupport;
@@ -298,8 +299,9 @@ public class JetCoreEnvironment {
 
         for (ComponentRegistrar registrar : configuration.getList(ComponentRegistrar.PLUGIN_COMPONENT_REGISTRARS)) {
             registrar.registerProjectComponents(project, configuration);
-
         }
+
+        ExternalDeclarationsProvider.OBJECT$.registerExtensionPoint(project);
     }
 
     private static void registerProjectExtensionPoints(ExtensionsArea area) {

compiler/frontend.java/frontend.java.iml

@@ -14,6 +14,5 @@
     <orderEntry type="module" module-name="serialization.jvm" />
     <orderEntry type="module" module-name="descriptor.loader.java" exported="" />
     <orderEntry type="module" module-name="util" />
-    <orderEntry type="module" module-name="android-compiler-plugin" />
   </component>
 </module>

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmAnalyzerFacade.kt

@@ -35,10 +35,9 @@ import org.jetbrains.kotlin.di.InjectorForLazyResolveWithJava
 import org.jetbrains.kotlin.resolve.CodeAnalyzerInitializer
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.jet.lang.psi.JetFile
-import com.intellij.openapi.components.ServiceManager
-import org.jetbrains.jet.lang.resolve.android.AndroidUIXmlProcessor
 import java.util.ArrayList
-import org.jetbrains.jet.lang.resolve.android.searchAndAddAndroidDeclarations
+import org.jetbrains.jet.extensions.ExternalDeclarationsProvider
+import kotlin.platform.platformStatic
 
 public class JvmResolverForModule(
         override val lazyResolveSession: ResolveSession,
@@ -61,7 +60,7 @@ public object JvmAnalyzerFacade : AnalyzerFacade<JvmResolverForModule, JvmPlatfo
             resolverForProject: ResolverForProject<M, JvmResolverForModule>
     ): JvmResolverForModule {
         val (syntheticFiles, moduleContentScope) = moduleContent
-        val filesToAnalyze = searchAndAddAndroidDeclarations(project, syntheticFiles)
+        val filesToAnalyze = getAllFilesToAnalyze(project, syntheticFiles)
         val declarationProviderFactory = DeclarationProviderFactoryService.createDeclarationProviderFactory(
                 project, globalContext.storageManager, filesToAnalyze,
                 if (moduleInfo.isLibrary) GlobalSearchScope.EMPTY_SCOPE else moduleContentScope
@@ -88,4 +87,12 @@ public object JvmAnalyzerFacade : AnalyzerFacade<JvmResolverForModule, JvmPlatfo
     override val defaultImports = TopDownAnalyzerFacadeForJVM.DEFAULT_IMPORTS
     override val platformToKotlinClassMap = JavaToKotlinClassMap.INSTANCE
 
+    public platformStatic fun getAllFilesToAnalyze(project: Project, baseFiles: Collection<JetFile>): List<JetFile> {
+        val allFiles = ArrayList(baseFiles)
+        for (externalDeclarationsProvider in ExternalDeclarationsProvider.getInstances(project)) {
+            allFiles.addAll(externalDeclarationsProvider.getExternalDeclarations())
+        }
+        return allFiles
+    }
+
 }

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/TopDownAnalyzerFacadeForJVM.java

@@ -116,11 +116,10 @@ public enum TopDownAnalyzerFacadeForJVM {
             @Nullable List<String> moduleIds,
             @Nullable IncrementalCacheProvider incrementalCacheProvider
     ) {
-        List<JetFile> filesToAnalyze = new ArrayList<JetFile>(files);
+        List<JetFile> allFiles = JvmAnalyzerFacade.getAllFilesToAnalyze(project, files);
-        searchAndAddAndroidDeclarations(project, filesToAnalyze);
 
         FileBasedDeclarationProviderFactory providerFactory =
-                new FileBasedDeclarationProviderFactory(topDownAnalysisParameters.getStorageManager(), filesToAnalyze);
+                new FileBasedDeclarationProviderFactory(topDownAnalysisParameters.getStorageManager(), allFiles);
 
         InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm(
                 project,
@@ -149,7 +148,7 @@ public enum TopDownAnalyzerFacadeForJVM {
             }
             additionalProviders.add(injector.getJavaDescriptorResolver().getPackageFragmentProvider());
 
-            injector.getLazyTopDownAnalyzerForTopLevel().analyzeFiles(topDownAnalysisParameters, filesToAnalyze, additionalProviders);
+            injector.getLazyTopDownAnalyzerForTopLevel().analyzeFiles(topDownAnalysisParameters, allFiles, additionalProviders);
             return AnalysisResult.success(trace.getBindingContext(), module);
         }
         finally {

compiler/frontend/src/org/jetbrains/jet/extensions/ExternalDeclarationsProvider.kt

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2010-2014 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.jet.extensions
+
+import org.jetbrains.jet.lang.psi.JetFile
+
+public trait ExternalDeclarationsProvider {
+    class object : ProjectExtensionDescriptor<ExternalDeclarationsProvider>(
+            "org.jetbrains.kotlin.externalDeclarationsProvider",
+            javaClass<ExternalDeclarationsProvider>()
+    )
+
+    public fun getExternalDeclarations(): Collection<JetFile>
+}

compiler/frontend/src/org/jetbrains/jet/extensions/ProjectExtensionDescriptor.kt

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2010-2014 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.jet.extensions
+
+import com.intellij.openapi.extensions.ExtensionPointName
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.extensions.Extensions
+import com.intellij.openapi.extensions.ExtensionPoint
+
+public open class ProjectExtensionDescriptor<T>(name: String, private val extensionClass: Class<T>) {
+    public val extensionPointName: ExtensionPointName<T> = ExtensionPointName.create(name)!!
+
+    public fun registerExtensionPoint(project: Project) {
+        Extensions.getArea(project).registerExtensionPoint(
+                extensionPointName.getName()!!,
+                extensionClass.getName(),
+                ExtensionPoint.Kind.INTERFACE
+        )
+    }
+
+    public fun registerExtension(project: Project, extension: T) {
+        Extensions.getArea(project).getExtensionPoint(extensionPointName).registerExtension(extension)
+    }
+
+    public fun getInstances(project: Project): Collection<T> {
+        val projectArea = Extensions.getArea(project)
+        if (!projectArea.hasExtensionPoint(extensionPointName.getName()!!)) return listOf()
+
+        return projectArea.getExtensionPoint(extensionPointName).getExtensions().toList()
+    }
+}
+

plugins/android-compiler-plugin/android-compiler-plugin.iml

@@ -11,6 +11,7 @@
     <orderEntry type="module" module-name="frontend" />
     <orderEntry type="library" name="kotlin-runtime" level="project" />
     <orderEntry type="module" module-name="cli" />
+    <orderEntry type="module" module-name="util" />
   </component>
 </module>
 

plugins/android-compiler-plugin/src/AndroidComponentRegistrar.kt

@@ -17,14 +17,18 @@
 package org.jetbrains.kotlin.android
 
 import org.jetbrains.kotlin.compiler.plugin.ComponentRegistrar
-import org.jetbrains.jet.lang.resolve.android.CliAndroidUIXmlProcessor
 import org.jetbrains.jet.config.CompilerConfiguration
-import org.jetbrains.jet.lang.resolve.android.AndroidUIXmlProcessor
 import com.intellij.mock.MockProject
 import org.jetbrains.jet.config.CompilerConfigurationKey
 import org.jetbrains.kotlin.compiler.plugin.CommandLineProcessor
 import org.jetbrains.kotlin.compiler.plugin.CliOption
 import org.jetbrains.kotlin.compiler.plugin.CliOptionProcessingException
+import org.jetbrains.jet.extensions.ExternalDeclarationsProvider
+import org.jetbrains.jet.lang.psi.JetFile
+import org.jetbrains.jet.lang.resolve.android.*
+import com.intellij.openapi.components.ServiceManager
+import org.jetbrains.jet.utils.emptyOrSingletonList
+import com.intellij.openapi.project.Project
 
 public object AndroidConfigurationKeys {
 
@@ -54,11 +58,20 @@ public class AndroidCommandLineProcessor : CommandLineProcessor {
     }
 }
 
+public class AndroidDeclarationsProvider(private val project: Project) : ExternalDeclarationsProvider {
+    override fun getExternalDeclarations(): Collection<JetFile> {
+        val parser = ServiceManager.getService<AndroidUIXmlProcessor>(project, javaClass<AndroidUIXmlProcessor>())
+        return emptyOrSingletonList(parser?.parseToPsi(project))
+    }
+}
+
 public class AndroidComponentRegistrar : ComponentRegistrar {
 
     public override fun registerProjectComponents(project: MockProject, configuration: CompilerConfiguration) {
         val androidResPath = configuration.get(AndroidConfigurationKeys.ANDROID_RES_PATH)
         val androidManifest = configuration.get(AndroidConfigurationKeys.ANDROID_MANIFEST)
         project.registerService(javaClass<AndroidUIXmlProcessor>(), CliAndroidUIXmlProcessor(project, androidResPath, androidManifest))
+
+        ExternalDeclarationsProvider.registerExtension(project, AndroidDeclarationsProvider(project))
     }
 }

plugins/android-compiler-plugin/src/org/jetbrains/jet/lang/resolve/android/AndroidUtil.kt

@@ -21,9 +21,9 @@ import com.intellij.psi.PsiElement
 import com.intellij.openapi.project.Project
 import org.jetbrains.jet.lang.psi.JetFile
 import com.intellij.openapi.components.ServiceManager
-import java.util.ArrayList
 import com.intellij.psi.PsiField
 import com.intellij.psi.PsiClass
+import org.jetbrains.jet.utils.emptyOrSingletonList
 
 trait AndroidResource
 
@@ -52,14 +52,6 @@ public fun isAndroidSyntheticElement(element: PsiElement?): Boolean {
     return isAndroidSyntheticFile(element?.getContainingFile())
 }
 
-public fun searchAndAddAndroidDeclarations(project: Project, originalFiles: Collection<JetFile>): Collection<JetFile> {
-    val parser = ServiceManager.getService<AndroidUIXmlProcessor>(project, javaClass<AndroidUIXmlProcessor>())
-    val file = parser?.parseToPsi(project)
-    val files = ArrayList(originalFiles)
-    if (file != null) files.add(file)
-    return files
-}
-
 public fun isRClassField(element: PsiElement): Boolean {
     return if (element is PsiField) {
         val outerClass = element.getParent()?.getParent()

plugins/android-idea-plugin/src/META-INF/plugin.xml

@@ -15,4 +15,8 @@
       <projectService serviceInterface="org.jetbrains.jet.lang.resolve.android.AndroidUIXmlProcessor"
                       serviceImplementation="org.jetbrains.jet.plugin.android.IDEAndroidUIXmlProcessor"/>
   </extensions>
+
+  <extensions defaultExtensionNs="org.jetbrains.kotlin">
+      <externalDeclarationsProvider implementation="org.jetbrains.kotlin.android.AndroidDeclarationsProvider"/>
+  </extensions>
 </idea-plugin>