FIR Java enhancements: attempt #1

JetBrains · Feb 15, 2019 · 27bb0b4 · 27bb0b4
1 parent c7d211b
commit 27bb0b4
Show file tree

Hide file tree

Showing 3 changed files with 56 additions and 3 deletions.
diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt
@@ -204,7 +204,9 @@ class JavaSymbolProvider(
             val callableSymbols = mutableListOf<ConeCallableSymbol>()
             findClass(classId)?.let { javaClass ->
                 if (firClass.declarations.isEmpty()) {
+                    // TODO: fields
                     for (javaMethod in javaClass.methods) {
+                        if (javaMethod.isStatic) continue // TODO: statics
                         val methodName = javaMethod.name
                         val methodId = CallableId(callableId.packageName, callableId.className, methodName)
                         val methodSymbol = FirFunctionSymbol(methodId)

diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/scopes/java/FirJavaEnhancementScope.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/scopes/java/FirJavaEnhancementScope.kt
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.scopes.java
+
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.scopes.FirScope
+import org.jetbrains.kotlin.fir.scopes.ProcessorAction
+import org.jetbrains.kotlin.fir.scopes.impl.FirAbstractProviderBasedScope
+import org.jetbrains.kotlin.fir.symbols.ConeCallableSymbol
+import org.jetbrains.kotlin.fir.symbols.ConeFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.ConePropertySymbol
+import org.jetbrains.kotlin.name.Name
+
+class FirJavaEnhancementScope(
+    session: FirSession,
+    private val unsubstituted: FirScope
+) : FirAbstractProviderBasedScope(session, lookupInFir = true) {
+
+    private val enhancements = mutableMapOf<ConeCallableSymbol, ConeCallableSymbol>()
+
+    private fun createFunctionEnhancement(original: ConeFunctionSymbol, name: Name): ConeFunctionSymbol {
+        // TODO
+        return original
+    }
+
+    override fun processPropertiesByName(name: Name, processor: (ConePropertySymbol) -> ProcessorAction): ProcessorAction {
+        return unsubstituted.processPropertiesByName(name, processor)
+    }
+
+    override fun processFunctionsByName(name: Name, processor: (ConeFunctionSymbol) -> ProcessorAction): ProcessorAction {
+        unsubstituted.processFunctionsByName(name) { original ->
+            val function = enhancements.getOrPut(original) { createFunctionEnhancement(original, name) }
+            processor(function as ConeFunctionSymbol)
+        }
+
+        return unsubstituted.processFunctionsByName(name, processor)
+    }
+}
diff --git a/.../resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAccessResolveTransformer.kt b/.../resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAccessResolveTransformer.kt
@@ -51,6 +51,14 @@ class FirAccessResolveTransformer : FirAbstractTreeTransformerWithSuperTypes(rev
         return FirClassSubstitutionScope(useSiteSession, unsubstituted, substitution, true)
     }
 
+    private fun FirRegularClass.buildEnhancementScope(
+        session: FirSession,
+        unsubstituted: FirScope
+    ): FirJavaEnhancementScope {
+
+    }
+
+
     private fun FirRegularClass.buildUseSiteScope(useSiteSession: FirSession = session): FirClassUseSiteScope {
         val superTypeScope = FirCompositeScope(mutableListOf())
         val declaredScope = FirClassDeclaredMemberScope(this, useSiteSession)
@@ -59,13 +67,15 @@ class FirAccessResolveTransformer : FirAbstractTreeTransformerWithSuperTypes(rev
                 if (useSiteSuperType is ConeClassErrorType) return@mapNotNullTo null
                 val symbol = useSiteSuperType.symbol
                 if (symbol is FirClassSymbol) {
-                    val scope = symbol.fir.buildUseSiteScope(useSiteSession)
-                    useSiteSuperType.buildSubstitutionScope(useSiteSession, scope, symbol.fir) ?: scope
+                    val superClass = symbol.fir
+                    val useSiteScope = superClass.buildUseSiteScope(useSiteSession)
+                    useSiteSuperType.buildSubstitutionScope(useSiteSession, useSiteScope, superClass) ?: useSiteScope
                 } else {
                     null
                 }
             }
-        return FirClassUseSiteScope(useSiteSession, superTypeScope, declaredScope, true)
+        val useSiteScope = FirClassUseSiteScope(useSiteSession, superTypeScope, declaredScope, lookupInFir = true)
+        return useSiteScope
     }
 
     override fun transformRegularClass(regularClass: FirRegularClass, data: Nothing?): CompositeTransformResult<FirDeclaration> {