Remove obsolete InlineStrategy

Replace corresponding metadata property in js.ast with Boolean. This
allows to get rid of dependency of 'js.ast' on 'frontend'.

compiler/frontend/src/org/jetbrains/kotlin/resolve/inline/InlineStrategy.java

@@ -1,27 +0,0 @@
-/*
- * Copyright 2010-2015 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.resolve.inline;
-
-public enum InlineStrategy {
-    AS_FUNCTION,
-    IN_PLACE,
-    NOT_INLINE;
-
-    public boolean isInline() {
-        return this != NOT_INLINE;
-    }
-}

compiler/frontend/src/org/jetbrains/kotlin/resolve/inline/InlineUtil.java

@@ -45,7 +45,7 @@ public class InlineUtil {
     }
 
     public static boolean isInline(@Nullable DeclarationDescriptor descriptor) {
-        return descriptor instanceof FunctionDescriptor && getInlineStrategy((FunctionDescriptor) descriptor).isInline();
+        return descriptor instanceof FunctionDescriptor && ((FunctionDescriptor) descriptor).isInline();
     }
 
     public static boolean hasInlineAccessors(@NotNull PropertyDescriptor propertyDescriptor) {
@@ -74,15 +74,6 @@ public class InlineUtil {
         return isInlineOrContainingInline(descriptor.getContainingDeclaration());
     }
 
-    @NotNull
-    private static InlineStrategy getInlineStrategy(@NotNull FunctionDescriptor descriptor) {
-        if (descriptor.isInline()) {
-            return InlineStrategy.AS_FUNCTION;
-        }
-
-        return InlineStrategy.NOT_INLINE;
-    }
-
     public static boolean checkNonLocalReturnUsage(
             @NotNull DeclarationDescriptor fromFunction,
             @NotNull KtExpression startExpression,

js/js.ast/build.gradle.kts

@@ -1,12 +1,10 @@
-
 plugins {
     kotlin("jvm")
     id("jps-compatible")
 }
 
 dependencies {
-    compile(project(":compiler:util"))
-    compile(project(":compiler:frontend"))
+    compile(project(":core:descriptors"))
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
     compileOnly(intellijDep()) { includeJars("trove4j") }
 }
@@ -15,4 +13,3 @@ sourceSets {
     "main" { projectDefault() }
     "test" {}
 }
-

js/js.ast/src/org/jetbrains/kotlin/js/backend/ast/metadata/metadataProperties.kt

@@ -23,7 +23,6 @@ import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.js.backend.ast.*
-import org.jetbrains.kotlin.resolve.inline.InlineStrategy
 import org.jetbrains.kotlin.types.KotlinType
 
 var JsName.staticRef: JsNode? by MetadataProperty(default = null)
@@ -38,8 +37,7 @@ var JsName.specialFunction: SpecialFunction? by MetadataProperty(default = null)
 
 var JsExpression.localAlias: JsImportedModule? by MetadataProperty(default = null)
 
-// TODO: move this to module 'js.inliner' and change dependency on 'frontend' to dependency on 'descriptors'
-var JsInvocation.inlineStrategy: InlineStrategy? by MetadataProperty(default = null)
+var JsInvocation.isInline: Boolean? by MetadataProperty(default = null)
 
 var JsInvocation.isCallableReference by MetadataProperty(default = false)
 
@@ -51,7 +49,7 @@ var JsInvocation.psiElement: PsiElement? by MetadataProperty(default = null)
 
 var JsNameRef.isJsCall: Boolean by MetadataProperty(default = false)
 
-var JsNameRef.inlineStrategy: InlineStrategy? by MetadataProperty(default = null)
+var JsNameRef.isInline: Boolean? by MetadataProperty(default = null)
 
 var JsNameRef.descriptor: CallableDescriptor? by MetadataProperty(default = null)
 

js/js.inliner/src/org/jetbrains/kotlin/js/inline/FunctionReader.kt

@@ -34,10 +34,8 @@ import org.jetbrains.kotlin.js.translate.expression.InlineMetadata
 import org.jetbrains.kotlin.js.translate.utils.JsAstUtils
 import org.jetbrains.kotlin.js.translate.utils.JsDescriptorUtils.getModuleName
 import org.jetbrains.kotlin.resolve.descriptorUtil.isExtension
-import org.jetbrains.kotlin.resolve.inline.InlineStrategy
 import org.jetbrains.kotlin.utils.JsLibraryUtils
 import java.io.File
-import java.io.StringReader
 
 // TODO: add hash checksum to defineModule?
 /**
@@ -401,7 +399,7 @@ private fun JsFunction.markInlineArguments(descriptor: CallableDescriptor) {
 
             (qualifier as? JsNameRef)?.name?.let { name ->
                 if (name in inlineFuns) {
-                    x.inlineStrategy = InlineStrategy.IN_PLACE
+                    x.isInline = true
                 }
             }
         }
@@ -434,4 +432,4 @@ private class ShallowSubSequence(private val underlying: CharSequence, private v
 
     override fun subSequence(startIndex: Int, endIndex: Int): CharSequence =
         ShallowSubSequence(underlying, start + startIndex, start + endIndex)
-}
+}

js/js.inliner/src/org/jetbrains/kotlin/js/inline/InlineAstVisitor.kt

@@ -10,12 +10,11 @@ import org.jetbrains.kotlin.descriptors.PropertySetterDescriptor
 import org.jetbrains.kotlin.js.backend.ast.*
 import org.jetbrains.kotlin.js.backend.ast.metadata.descriptor
 import org.jetbrains.kotlin.js.backend.ast.metadata.forcedReturnVariable
-import org.jetbrains.kotlin.js.backend.ast.metadata.inlineStrategy
+import org.jetbrains.kotlin.js.backend.ast.metadata.isInline
 import org.jetbrains.kotlin.js.backend.ast.metadata.psiElement
 import org.jetbrains.kotlin.js.inline.clean.FunctionPostProcessor
 import org.jetbrains.kotlin.js.inline.clean.removeUnusedLocalFunctionDeclarations
 import org.jetbrains.kotlin.js.inline.clean.substituteKTypes
-import org.jetbrains.kotlin.js.inline.util.extractFunction
 import org.jetbrains.kotlin.js.inline.util.refreshLabelNames
 import org.jetbrains.kotlin.js.translate.expression.InlineMetadata
 import org.jetbrains.kotlin.js.translate.utils.JsAstUtils
@@ -99,18 +98,16 @@ class InlineAstVisitor(
     private fun hasToBeInlined(node: JsNode): Boolean {
         return when (node) {
             is JsInvocation -> hasToBeInlined(node)
-            is JsNameRef -> node.inlineStrategy != null && tryCreatePropertyGetterInvocation(node)?.let { hasToBeInlined(it) } ?: false
+            is JsNameRef -> node.isInline != null && tryCreatePropertyGetterInvocation(node)?.let { hasToBeInlined(it) } ?: false
             is JsBinaryOperation -> node.operator.isAssignment && node.arg1?.let { left ->
-                left is JsNameRef && left.inlineStrategy != null && tryCreatePropertySetterInvocation(node)?.let { hasToBeInlined(it) } ?: false
+                left is JsNameRef && left.isInline != null && tryCreatePropertySetterInvocation(node)?.let { hasToBeInlined(it) } ?: false
             } ?: false
             else -> false
         }
     }
 
-    private fun hasToBeInlined(call: JsInvocation): Boolean {
-        val strategy = call.inlineStrategy
-        return if (strategy == null || !strategy.isInline) false else jsInliner.functionDefinitionLoader.hasFunctionDefinition(call, scope)
-    }
+    private fun hasToBeInlined(call: JsInvocation): Boolean =
+        call.isInline == true && jsInliner.functionDefinitionLoader.hasFunctionDefinition(call, scope)
 
     private fun patchReturnsFromSecondaryConstructor(function: JsFunction) {
         // Support non-local return from secondary constructor
@@ -125,7 +122,7 @@ class InlineAstVisitor(
     }
 
     private fun tryCreatePropertyGetterInvocation(x: JsNameRef): JsInvocation? {
-        if (x.inlineStrategy != null && x.descriptor is PropertyGetterDescriptor) {
+        if (x.isInline != null && x.descriptor is PropertyGetterDescriptor) {
             val dummyInvocation = JsInvocation(x)
             copyInlineMetadata(x, dummyInvocation)
             return dummyInvocation
@@ -136,7 +133,7 @@ class InlineAstVisitor(
     private fun tryCreatePropertySetterInvocation(x: JsBinaryOperation): JsInvocation? {
         if (!x.operator.isAssignment || x.arg1 !is JsNameRef) return null
         val name = x.arg1 as JsNameRef
-        if (name.inlineStrategy != null && name.descriptor is PropertySetterDescriptor) {
+        if (name.isInline != null && name.descriptor is PropertySetterDescriptor) {
             val dummyInvocation = JsInvocation(name, x.arg2)
             copyInlineMetadata(name, dummyInvocation)
             return dummyInvocation
@@ -145,8 +142,8 @@ class InlineAstVisitor(
     }
 
     private fun copyInlineMetadata(from: JsNameRef, to: JsInvocation) {
-        to.inlineStrategy = from.inlineStrategy
+        to.isInline = from.isInline
         to.descriptor = from.descriptor
         to.psiElement = from.psiElement
     }
-}
+}

js/js.inliner/src/org/jetbrains/kotlin/js/inline/InlinerCycleReporter.kt

@@ -10,11 +10,10 @@ import org.jetbrains.kotlin.diagnostics.Errors
 import org.jetbrains.kotlin.js.backend.ast.JsFunction
 import org.jetbrains.kotlin.js.backend.ast.JsInvocation
 import org.jetbrains.kotlin.js.backend.ast.metadata.descriptor
-import org.jetbrains.kotlin.js.backend.ast.metadata.inlineStrategy
+import org.jetbrains.kotlin.js.backend.ast.metadata.isInline
 import org.jetbrains.kotlin.js.backend.ast.metadata.psiElement
 import org.jetbrains.kotlin.js.inline.context.FunctionDefinitionLoader
 import org.jetbrains.kotlin.js.inline.util.FunctionWithWrapper
-import org.jetbrains.kotlin.resolve.inline.InlineStrategy
 import java.util.*
 
 /**
@@ -90,7 +89,7 @@ class InlinerCycleReporter(
     }
 
     private fun reportInlineCycle(call: JsInvocation?, calledFunction: JsFunction) {
-        call?.inlineStrategy = InlineStrategy.NOT_INLINE
+        call?.isInline = false
         val it = inlineCallInfos.descendingIterator()
 
         while (it.hasNext()) {
@@ -109,4 +108,4 @@ class InlinerCycleReporter(
     }
 }
 
-private class JsCallInfo(val call: JsInvocation, val containingFunction: JsFunction)
+private class JsCallInfo(val call: JsInvocation, val containingFunction: JsFunction)

js/js.serializer/src/org/jetbrains/kotlin/serialization/js/ast/JsAstDeserializer.kt

@@ -30,7 +30,6 @@ import java.io.FileInputStream
 import java.io.InputStream
 import java.io.InputStreamReader
 import java.util.*
-import org.jetbrains.kotlin.resolve.inline.InlineStrategy as KotlinInlineStrategy
 
 class JsAstDeserializer(program: JsProgram, private val sourceRoots: Iterable<File>) {
     private val scope = JsRootScope(program)
@@ -386,7 +385,7 @@ class JsAstDeserializer(program: JsProgram, private val sourceRoots: Iterable<Fi
             val qualifier = if (nameRefProto.hasQualifier()) deserialize(nameRefProto.qualifier) else null
             JsNameRef(deserializeName(nameRefProto.nameId), qualifier).apply {
                 if (nameRefProto.hasInlineStrategy()) {
-                    inlineStrategy = map(nameRefProto.inlineStrategy)
+                    isInline = map(nameRefProto.inlineStrategy)
                 }
             }
         }
@@ -396,7 +395,7 @@ class JsAstDeserializer(program: JsProgram, private val sourceRoots: Iterable<Fi
             val qualifier = if (propertyRefProto.hasQualifier()) deserialize(propertyRefProto.qualifier) else null
             JsNameRef(deserializeString(propertyRefProto.stringId), qualifier).apply {
                 if (propertyRefProto.hasInlineStrategy()) {
-                    inlineStrategy = map(propertyRefProto.inlineStrategy)
+                    isInline = map(propertyRefProto.inlineStrategy)
                 }
             }
         }
@@ -408,7 +407,7 @@ class JsAstDeserializer(program: JsProgram, private val sourceRoots: Iterable<Fi
                     invocationProto.argumentList.map { deserialize(it) }
             ).apply {
                 if (invocationProto.hasInlineStrategy()) {
-                    inlineStrategy = map(invocationProto.inlineStrategy)
+                    isInline = map(invocationProto.inlineStrategy)
                 }
             }
         }
@@ -541,11 +540,8 @@ class JsAstDeserializer(program: JsProgram, private val sourceRoots: Iterable<Fi
         SideEffects.PURE -> SideEffectKind.PURE
     }
 
-    private fun map(inlineStrategy: InlineStrategy) = when(inlineStrategy) {
-        InlineStrategy.AS_FUNCTION -> KotlinInlineStrategy.AS_FUNCTION
-        InlineStrategy.IN_PLACE -> KotlinInlineStrategy.IN_PLACE
-        InlineStrategy.NOT_INLINE -> KotlinInlineStrategy.NOT_INLINE
-    }
+    private fun map(inlineStrategy: InlineStrategy) =
+        inlineStrategy == InlineStrategy.AS_FUNCTION || inlineStrategy == InlineStrategy.IN_PLACE
 
     private fun map(specialFunction: JsAstProtoBuf.SpecialFunction) = when(specialFunction) {
         JsAstProtoBuf.SpecialFunction.DEFINE_INLINE_FUNCTION -> SpecialFunction.DEFINE_INLINE_FUNCTION

js/js.serializer/src/org/jetbrains/kotlin/serialization/js/ast/JsAstSerializer.kt

@@ -29,7 +29,6 @@ import org.jetbrains.kotlin.serialization.js.ast.JsAstProtoBuf.UnaryOperation.Ty
 import java.io.File
 import java.io.OutputStream
 import java.util.*
-import org.jetbrains.kotlin.resolve.inline.InlineStrategy as KotlinInlineStrategy
 
 class JsAstSerializer(private val jsAstValidator: ((JsProgramFragment, Set<JsName>) -> Unit)?,
                       private val pathResolver: (File) -> String) {
@@ -418,13 +417,15 @@ class JsAstSerializer(private val jsAstValidator: ((JsProgramFragment, Set<JsNam
                 val name = nameRef.name
                 val qualifier = nameRef.qualifier
                 if (name != null) {
-                    if (qualifier != null || nameRef.inlineStrategy?.isInline == true) {
+                    if (qualifier != null || nameRef.isInline == true) {
                         val nameRefBuilder = NameReference.newBuilder()
                         nameRefBuilder.nameId = serialize(name)
                         if (qualifier != null) {
                             nameRefBuilder.qualifier = serialize(qualifier)
                         }
-                        nameRef.inlineStrategy?.let { nameRefBuilder.inlineStrategy = map(it) }
+                        nameRef.isInline?.let {
+                            nameRefBuilder.inlineStrategy = if (it) InlineStrategy.IN_PLACE else InlineStrategy.NOT_INLINE
+                        }
                         builder.nameReference = nameRefBuilder.build()
                     }
                     else {
@@ -435,7 +436,9 @@ class JsAstSerializer(private val jsAstValidator: ((JsProgramFragment, Set<JsNam
                     val propertyRefBuilder = PropertyReference.newBuilder()
                     propertyRefBuilder.stringId = serialize(nameRef.ident)
                     qualifier?.let { propertyRefBuilder.qualifier = serialize(it) }
-                    nameRef.inlineStrategy?.let { propertyRefBuilder.inlineStrategy = map(it) }
+                    nameRef.isInline?.let {
+                        propertyRefBuilder.inlineStrategy = if (it) InlineStrategy.IN_PLACE else InlineStrategy.NOT_INLINE
+                    }
                     builder.propertyReference = propertyRefBuilder.build()
                 }
             }
@@ -444,10 +447,8 @@ class JsAstSerializer(private val jsAstValidator: ((JsProgramFragment, Set<JsNam
                 val invocationBuilder = Invocation.newBuilder()
                 invocationBuilder.qualifier = serialize(invocation.qualifier)
                 invocation.arguments.forEach { invocationBuilder.addArgument(serialize(it)) }
-                invocation.inlineStrategy?.let { inlineStrategy ->
-                    if (inlineStrategy != KotlinInlineStrategy.NOT_INLINE) {
-                        invocationBuilder.inlineStrategy = map(inlineStrategy)
-                    }
+                if (invocation.isInline == true) {
+                    invocationBuilder.inlineStrategy = InlineStrategy.IN_PLACE
                 }
                 builder.invocation = invocationBuilder.build()
             }
@@ -584,12 +585,6 @@ class JsAstSerializer(private val jsAstValidator: ((JsProgramFragment, Set<JsNam
         SideEffectKind.PURE -> SideEffects.PURE
     }
 
-    private fun map(inlineStrategy: KotlinInlineStrategy) = when (inlineStrategy) {
-        KotlinInlineStrategy.AS_FUNCTION -> InlineStrategy.AS_FUNCTION
-        KotlinInlineStrategy.IN_PLACE -> InlineStrategy.IN_PLACE
-        KotlinInlineStrategy.NOT_INLINE -> InlineStrategy.NOT_INLINE
-    }
-
     private fun map(specialFunction: SpecialFunction) = when (specialFunction) {
         SpecialFunction.DEFINE_INLINE_FUNCTION -> JsAstProtoBuf.SpecialFunction.DEFINE_INLINE_FUNCTION
         SpecialFunction.WRAP_FUNCTION -> JsAstProtoBuf.SpecialFunction.WRAP_FUNCTION
@@ -685,4 +680,4 @@ class JsAstSerializer(private val jsAstValidator: ((JsProgramFragment, Set<JsNam
 
         return JsLocation(path, startLine, startChar)
     }
-}
+}

js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/functions/factories/ArrayFIF.kt

@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.descriptors.ConstructorDescriptor
 import org.jetbrains.kotlin.descriptors.impl.TypeAliasConstructorDescriptor
 import org.jetbrains.kotlin.js.backend.ast.*
 import org.jetbrains.kotlin.js.backend.ast.metadata.descriptor
-import org.jetbrains.kotlin.js.backend.ast.metadata.inlineStrategy
+import org.jetbrains.kotlin.js.backend.ast.metadata.isInline
 import org.jetbrains.kotlin.js.config.JSConfigurationKeys
 import org.jetbrains.kotlin.js.config.JsConfig
 import org.jetbrains.kotlin.js.patterns.NamePredicate
@@ -39,7 +39,6 @@ import org.jetbrains.kotlin.js.translate.intrinsic.functions.basic.BuiltInProper
 import org.jetbrains.kotlin.js.translate.intrinsic.functions.basic.FunctionIntrinsic
 import org.jetbrains.kotlin.js.translate.utils.JsAstUtils
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.resolve.inline.InlineStrategy
 import org.jetbrains.kotlin.resolve.isInlineClassType
 import org.jetbrains.kotlin.types.KotlinType
 import java.util.*
@@ -217,7 +216,7 @@ object ArrayFIF : CompositeFIF() {
             else {
                 JsAstUtils.invokeKotlinFunction(if (type == CHAR) "untypedCharArrayF" else "newArrayF", size, fn)
             }
-            invocation.inlineStrategy = InlineStrategy.IN_PLACE
+            invocation.isInline = true
             val descriptor = callInfo.resolvedCall.resultingDescriptor.original
             val resolvedDescriptor = when (descriptor) {
                 is TypeAliasConstructorDescriptor -> descriptor.underlyingConstructorDescriptor
@@ -235,4 +234,4 @@ object ArrayFIF : CompositeFIF() {
             return f(callInfo, arguments, context)
         }
     }
-}
+}

js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/functions/factories/CoroutineContextFIF.kt

@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.js.backend.ast.JsExpression
 import org.jetbrains.kotlin.js.backend.ast.JsNameRef
-import org.jetbrains.kotlin.js.backend.ast.metadata.inlineStrategy
+import org.jetbrains.kotlin.js.backend.ast.metadata.isInline
 import org.jetbrains.kotlin.js.descriptorUtils.isCoroutineLambda
 import org.jetbrains.kotlin.js.translate.callTranslator.CallInfo
 import org.jetbrains.kotlin.js.translate.context.TranslationContext
@@ -30,7 +30,6 @@ import org.jetbrains.kotlin.js.translate.utils.TranslationUtils
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.calls.checkers.isBuiltInCoroutineContext
-import org.jetbrains.kotlin.resolve.inline.InlineStrategy
 
 object CoroutineContextFIF : FunctionIntrinsicFactory {
     override fun getIntrinsic(descriptor: FunctionDescriptor, context: TranslationContext): FunctionIntrinsic? {
@@ -48,7 +47,7 @@ object CoroutineContextFIF : FunctionIntrinsicFactory {
                 if (context.declarationDescriptor?.isCoroutineLambda == true) JsAstUtils.stateMachineReceiver()
                 else TranslationUtils.translateContinuationArgument(context)
             )
-            res.inlineStrategy = InlineStrategy.NOT_INLINE
+            res.isInline = false
             return res
         }
     }

js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/inlineUtils.kt

@@ -20,13 +20,14 @@ package org.jetbrains.kotlin.js.translate.utils
 
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.js.backend.ast.*
-import org.jetbrains.kotlin.js.backend.ast.metadata.*
+import org.jetbrains.kotlin.js.backend.ast.metadata.descriptor
+import org.jetbrains.kotlin.js.backend.ast.metadata.isInline
+import org.jetbrains.kotlin.js.backend.ast.metadata.psiElement
 import org.jetbrains.kotlin.js.inline.util.isCallInvocation
 import org.jetbrains.kotlin.js.translate.context.TranslationContext
 import org.jetbrains.kotlin.js.translate.reference.CallExpressionTranslator
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
-import org.jetbrains.kotlin.resolve.inline.InlineStrategy
 
 /**
  * Recursively walks expression and sets metadata for all invocations of descriptor.
@@ -57,7 +58,7 @@ fun setInlineCallMetadata(
 
             if (invocation.name in candidateNames || invocation.name?.descriptor?.original == descriptor.original) {
                 invocation.descriptor = descriptor
-                invocation.inlineStrategy = InlineStrategy.IN_PLACE
+                invocation.isInline = true
                 invocation.psiElement = psiElement
             }
         }
@@ -81,9 +82,9 @@ fun setInlineCallMetadata(
         descriptor: CallableDescriptor,
         context: TranslationContext
 ) {
-    if (nameRef.inlineStrategy != null) return
+    if (nameRef.isInline != null) return
     nameRef.descriptor = descriptor
-    nameRef.inlineStrategy = InlineStrategy.IN_PLACE
+    nameRef.isInline = true
     nameRef.psiElement = psiElement
 
     context.addInlineCall(descriptor)