Minor, rename InlineUtil.getInlineType -> getInlineStrategy

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.java

@@ -113,7 +113,7 @@ public class InlineCodegen extends CallGenerator {
         jvmSignature = typeMapper.mapSignature(functionDescriptor, context.getContextKind());
 
         // TODO: implement AS_FUNCTION inline strategy
-        InlineStrategy inlineStrategy = InlineUtil.getInlineType(functionDescriptor);
+        InlineStrategy inlineStrategy = InlineUtil.getInlineStrategy(functionDescriptor);
         this.asFunctionInline = false;
 
         isSameModule = JvmCodegenUtil.isCallInsideSameModuleAsDeclared(functionDescriptor, codegen.getContext(), state.getOutDirectory());

core/descriptors/src/org/jetbrains/kotlin/builtins/InlineUtil.java

@@ -16,11 +16,9 @@
 
 package org.jetbrains.kotlin.builtins;
 
-import kotlin.KotlinPackage;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.*;
-import org.jetbrains.kotlin.descriptors.annotations.Annotated;
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.constants.ArrayValue;
@@ -28,7 +26,7 @@ import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
 import org.jetbrains.kotlin.resolve.constants.EnumValue;
 import org.jetbrains.kotlin.types.JetType;
 
-import java.util.List;
+import static kotlin.KotlinPackage.firstOrNull;
 
 public class InlineUtil {
 
@@ -44,23 +42,22 @@ public class InlineUtil {
     }
 
     public static boolean isInline(@Nullable DeclarationDescriptor descriptor) {
-        return descriptor instanceof SimpleFunctionDescriptor && getInlineType(descriptor).isInline();
+        return descriptor instanceof SimpleFunctionDescriptor && getInlineStrategy(descriptor).isInline();
     }
 
     @NotNull
-    public static InlineStrategy getInlineType(@NotNull DeclarationDescriptor descriptor) {
+    public static InlineStrategy getInlineStrategy(@NotNull DeclarationDescriptor descriptor) {
         ClassDescriptor inlineAnnotation = KotlinBuiltIns.getInstance().getInlineClassAnnotation();
         AnnotationDescriptor annotation = descriptor.getAnnotations().findAnnotation(DescriptorUtils.getFqNameSafe(inlineAnnotation));
         if (annotation == null) {
             return InlineStrategy.NOT_INLINE;
         }
-        CompileTimeConstant<?> argument = getAnnotationSingleArgument(descriptor, inlineAnnotation);
+        CompileTimeConstant<?> argument = firstOrNull(annotation.getAllValueArguments().values());
         if (argument == null) {
             return InlineStrategy.AS_FUNCTION;
         }
         assert argument instanceof EnumValue : "Inline annotation parameter should be enum entry but was: " + argument;
-        String name = ((EnumValue) argument).getValue().getName().asString();
+        return InlineStrategy.valueOf(((EnumValue) argument).getValue().getName().asString());
-        return name.equals(InlineStrategy.IN_PLACE.name()) ? InlineStrategy.IN_PLACE : InlineStrategy.AS_FUNCTION;
     }
 
     public static boolean hasOnlyLocalContinueAndBreak(@NotNull ValueParameterDescriptor descriptor) {
@@ -72,15 +69,14 @@ public class InlineUtil {
     }
 
     private static boolean hasInlineOption(@NotNull ValueParameterDescriptor descriptor, @NotNull InlineOption option) {
-        CompileTimeConstant<?> argument =
+        AnnotationDescriptor annotation = descriptor.getAnnotations().findAnnotation(
-                getAnnotationSingleArgument(descriptor, KotlinBuiltIns.getInstance().getInlineOptionsClassAnnotation());
+                DescriptorUtils.getFqNameSafe(KotlinBuiltIns.getInstance().getInlineOptionsClassAnnotation())
-
+        );
-        if (argument instanceof ArrayValue) {
+        if (annotation != null) {
-            List<CompileTimeConstant<?>> values = ((ArrayValue) argument).getValue();
+            CompileTimeConstant<?> argument = firstOrNull(annotation.getAllValueArguments().values());
-
+            if (argument instanceof ArrayValue) {
-            for (CompileTimeConstant<?> value : values) {
+                for (CompileTimeConstant<?> value : ((ArrayValue) argument).getValue()) {
-                if (value instanceof EnumValue) {
+                    if (value instanceof EnumValue && ((EnumValue) value).getValue().getName().asString().equals(option.name())) {
-                    if (((EnumValue) value).getValue().getName().asString().equals(option.name())) {
                         return true;
                     }
                 }
@@ -89,16 +85,4 @@ public class InlineUtil {
 
         return false;
     }
-
-    @Nullable
-    private static CompileTimeConstant<?> getAnnotationSingleArgument(
-            @NotNull Annotated annotated,
-            @NotNull ClassDescriptor annotationClass
-    ) {
-        AnnotationDescriptor annotation = annotated.getAnnotations().findAnnotation(DescriptorUtils.getFqNameSafe(annotationClass));
-        if (annotation != null) {
-            return KotlinPackage.firstOrNull(annotation.getAllValueArguments().values());
-        }
-        return null;
-    }
 }

idea/src/org/jetbrains/kotlin/idea/debugger/JetPositionManager.kt

@@ -408,14 +408,15 @@ public class JetPositionManager(private val myDebugProcess: DebugProcess) : Mult
             val call = (parent as JetElement).getResolvedCall(context)
             if (call == null) return false
 
-            val inlineType = InlineUtil.getInlineType(call.getResultingDescriptor())
+            if (!InlineUtil.isInline(call.getResultingDescriptor())) return false
-            if (!inlineType.isInline()) return false
 
             for ((valueParameterDescriptor, resolvedValueArgument) in call.getValueArguments()) {
                 for (next in resolvedValueArgument.getArguments()) {
                     val expression = next.getArgumentExpression()
                     if (valueArgument == expression) {
-                        return InlineAnalyzerExtension.checkInlinableParameter(valueParameterDescriptor, expression, call.getResultingDescriptor(), null)
+                        return InlineAnalyzerExtension.checkInlinableParameter(
+                                valueParameterDescriptor, expression, call.getResultingDescriptor(), null
+                        )
                     }
                 }
             }

js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/ExpressionVisitor.java

@@ -419,7 +419,7 @@ public final class ExpressionVisitor extends TranslatorVisitor<JsNode> {
 
         FunctionDescriptor descriptor = getFunctionDescriptor(context.bindingContext(), expression);
         JsName name = context.getNameForDescriptor(descriptor);
-        if (InlineUtil.getInlineType(descriptor).isInline()) {
+        if (InlineUtil.isInline(descriptor)) {
             MetadataPackage.setStaticRef(name, alias);
         }
 

js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/LiteralFunctionTranslator.kt

@@ -17,22 +17,21 @@
 package org.jetbrains.kotlin.js.translate.expression
 
 import com.google.dart.compiler.backend.js.ast.*
-import com.google.dart.compiler.backend.js.ast.metadata.staticRef
 import com.google.dart.compiler.backend.js.ast.metadata.isLocal
-import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import com.google.dart.compiler.backend.js.ast.metadata.staticRef
-import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor
+import org.jetbrains.kotlin.builtins.InlineUtil
-import org.jetbrains.kotlin.psi.JetDeclarationWithBody
+import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.js.translate.context.*
+import org.jetbrains.kotlin.js.inline.util.getInnerFunction
+import org.jetbrains.kotlin.js.translate.context.TranslationContext
+import org.jetbrains.kotlin.js.translate.context.getNameForCapturedDescriptor
+import org.jetbrains.kotlin.js.translate.context.hasCapturedExceptContaining
+import org.jetbrains.kotlin.js.translate.context.isCaptured
 import org.jetbrains.kotlin.js.translate.general.AbstractTranslator
 import org.jetbrains.kotlin.js.translate.utils.BindingUtils.getFunctionDescriptor
 import org.jetbrains.kotlin.js.translate.utils.FunctionBodyTranslator.translateFunctionBody
-import org.jetbrains.kotlin.js.translate.utils.TranslationUtils.simpleReturnFunction
-import org.jetbrains.kotlin.descriptors.MemberDescriptor
-import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.js.translate.utils.JsAstUtils
-import org.jetbrains.kotlin.js.inline.util.getInnerFunction
+import org.jetbrains.kotlin.js.translate.utils.TranslationUtils.simpleReturnFunction
-import org.jetbrains.kotlin.builtins.InlineUtil
+import org.jetbrains.kotlin.psi.JetDeclarationWithBody
-import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 
 class LiteralFunctionTranslator(context: TranslationContext) : AbstractTranslator(context) {
     fun translate(declaration: JetDeclarationWithBody): JsExpression {
@@ -196,5 +195,5 @@ private fun HasName.getStaticRef(): JsNode? {
 private fun isLocalInlineDeclaration(descriptor: CallableDescriptor): Boolean {
     return descriptor is FunctionDescriptor
            && descriptor.getVisibility() == Visibilities.LOCAL
-           && InlineUtil.getInlineType(descriptor).isInline()
+           && InlineUtil.isInline(descriptor)
 }

js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallExpressionTranslator.java

@@ -22,7 +22,10 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.builtins.InlineUtil;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.descriptors.*;
+import org.jetbrains.kotlin.descriptors.CallableDescriptor;
+import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
+import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor;
+import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor;
 import org.jetbrains.kotlin.js.parser.ParserPackage;
 import org.jetbrains.kotlin.js.translate.callTranslator.CallTranslator;
 import org.jetbrains.kotlin.js.translate.context.TranslationContext;
@@ -80,9 +83,7 @@ public final class CallExpressionTranslator extends AbstractCallExpressionTransl
         }
 
         if (descriptor instanceof ValueParameterDescriptor) {
-            DeclarationDescriptor containingDescriptor = descriptor.getContainingDeclaration();
+            return InlineUtil.isInline(descriptor.getContainingDeclaration()) && InlineUtil.isInlineLambdaParameter(descriptor);
-            return InlineUtil.getInlineType(containingDescriptor).isInline()
-                   && InlineUtil.isInlineLambdaParameter(descriptor);
         }
 
         return false;