Add modifier flags to descriptors

compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java

@@ -61,8 +61,7 @@ import java.util.*;
 
 import static org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget.*;
 import static org.jetbrains.kotlin.diagnostics.Errors.*;
-import static org.jetbrains.kotlin.lexer.JetTokens.OVERRIDE_KEYWORD;
-import static org.jetbrains.kotlin.lexer.JetTokens.VARARG_KEYWORD;
+import static org.jetbrains.kotlin.lexer.JetTokens.*;
 import static org.jetbrains.kotlin.resolve.BindingContext.*;
 import static org.jetbrains.kotlin.resolve.DescriptorUtils.*;
 import static org.jetbrains.kotlin.resolve.ModifiersChecker.resolveModalityFromModifiers;
@@ -278,6 +277,8 @@ public class DescriptorResolver {
                     new ValueParameterDescriptorImpl(functionDescriptor, null, parameter.getIndex(), parameter.getAnnotations(),
                                                      parameter.getName(), parameter.getType(),
                                                      declaresDefaultValue,
+                                                     parameter.isCrossinline(),
+                                                     parameter.isNoinline(),
                                                      parameter.getVarargElementType(), parameter.getSource());
             parameterDescriptors.add(parameterDescriptor);
             if (declaresDefaultValue) {
@@ -366,6 +367,8 @@ public class DescriptorResolver {
                 JetPsiUtil.safeName(valueParameter.getName()),
                 variableType,
                 valueParameter.hasDefaultValue(),
+                valueParameter.hasModifier(CROSSINLINE_KEYWORD),
+                valueParameter.hasModifier(NOINLINE_KEYWORD),
                 varargElementType,
                 KotlinSourceElementKt.toSourceElement(valueParameter)
         );
@@ -1002,7 +1005,7 @@ public class DescriptorResolver {
             setterDescriptor = new PropertySetterDescriptorImpl(propertyDescriptor, annotations,
                                                                 resolveModalityFromModifiers(setter, propertyDescriptor.getModality()),
                                                                 resolveVisibilityFromModifiers(setter, propertyDescriptor.getVisibility()),
-                                                                setter.hasBody(), false,
+                                                                setter.hasBody(), false, setter.hasModifier(EXTERNAL_KEYWORD),
                                                                 CallableMemberDescriptor.Kind.DECLARATION, null, KotlinSourceElementKt
                                                                         .toSourceElement(setter));
             if (parameter != null) {
@@ -1042,7 +1045,8 @@ public class DescriptorResolver {
         }
         else if (property.isVar()) {
             Annotations setterAnnotations = annotationSplitter.getAnnotationsForTarget(PROPERTY_SETTER);
-            setterDescriptor = DescriptorFactory.createSetter(propertyDescriptor, setterAnnotations, !property.hasDelegate());
+            setterDescriptor = DescriptorFactory.createSetter(propertyDescriptor, setterAnnotations, !property.hasDelegate(),
+                                                              /* isExternal = */ false);
         }
 
         if (!property.isVar()) {
@@ -1082,7 +1086,7 @@ public class DescriptorResolver {
             getterDescriptor = new PropertyGetterDescriptorImpl(propertyDescriptor, getterAnnotations,
                                                                 resolveModalityFromModifiers(getter, propertyDescriptor.getModality()),
                                                                 resolveVisibilityFromModifiers(getter, propertyDescriptor.getVisibility()),
-                                                                getter.hasBody(), false,
+                                                                getter.hasBody(), false, getter.hasModifier(EXTERNAL_KEYWORD),
                                                                 CallableMemberDescriptor.Kind.DECLARATION, null, KotlinSourceElementKt
                                                                         .toSourceElement(getter));
             getterDescriptor.initialize(returnType);
@@ -1090,7 +1094,8 @@ public class DescriptorResolver {
         }
         else {
             Annotations getterAnnotations = annotationSplitter.getAnnotationsForTarget(PROPERTY_GETTER);
-            getterDescriptor = DescriptorFactory.createGetter(propertyDescriptor, getterAnnotations, !property.hasDelegate());
+            getterDescriptor = DescriptorFactory.createGetter(propertyDescriptor, getterAnnotations, !property.hasDelegate(),
+                                                              /* isExternal = */ false);
             getterDescriptor.initialize(propertyDescriptor.getType());
         }
         return getterDescriptor;

compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt

@@ -29,7 +29,9 @@ import org.jetbrains.kotlin.diagnostics.Errors.*
 import org.jetbrains.kotlin.lexer.JetTokens
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.resolve.DescriptorResolver.*
+import org.jetbrains.kotlin.resolve.DescriptorResolver.getDefaultModality
+import org.jetbrains.kotlin.resolve.DescriptorResolver.getDefaultVisibility
+import org.jetbrains.kotlin.resolve.DescriptorResolver.transformAnonymousTypeIfNeeded
 import org.jetbrains.kotlin.resolve.DescriptorUtils.getDispatchReceiverParameterIfNeeded
 import org.jetbrains.kotlin.resolve.DescriptorUtils.isFunctionExpression
 import org.jetbrains.kotlin.resolve.DescriptorUtils.isFunctionLiteral
@@ -178,6 +180,9 @@ class FunctionDescriptorResolver(
         )
         functionDescriptor.isOperator = function.hasModifier(JetTokens.OPERATOR_KEYWORD)
         functionDescriptor.isInfix = function.hasModifier(JetTokens.INFIX_KEYWORD)
+        functionDescriptor.isExternal = function.hasModifier(JetTokens.EXTERNAL_KEYWORD)
+        functionDescriptor.isInline = function.hasModifier(JetTokens.INLINE_KEYWORD)
+        functionDescriptor.isTailrec = function.hasModifier(JetTokens.TAILREC_KEYWORD)
         receiverType?.let { ForceResolveUtil.forceResolveAllContents(it.getAnnotations()) }
         for (valueParameterDescriptor in valueParameterDescriptors) {
             ForceResolveUtil.forceResolveAllContents(valueParameterDescriptor.getType().getAnnotations())
@@ -198,6 +203,7 @@ class FunctionDescriptorResolver(
                 val valueParameterDescriptor = expectedValueParameters.first()
                 val it = ValueParameterDescriptorImpl(functionDescriptor, null, 0, Annotations.EMPTY, Name.identifier("it"),
                                                       valueParameterDescriptor.getType(), valueParameterDescriptor.declaresDefaultValue(),
+                                                      valueParameterDescriptor.isCrossinline, valueParameterDescriptor.isNoinline,
                                                       valueParameterDescriptor.getVarargElementType(), SourceElement.NO_SOURCE)
                 trace.record(BindingContext.AUTO_CREATED_IT, it)
                 return listOf(it)

compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorUtil.java

@@ -141,6 +141,8 @@ public class FunctionDescriptorUtil {
                             parameter.getName(),
                             returnType,
                             parameter.declaresDefaultValue(),
+                            parameter.isCrossinline(),
+                            parameter.isNoinline(),
                             parameter.getVarargElementType(),
                             SourceElement.NO_SOURCE
                     )
@@ -158,6 +160,9 @@ public class FunctionDescriptorUtil {
                 function.getVisibility());
         descriptor.setOperator(function.isOperator());
         descriptor.setInfix(function.isInfix());
+        descriptor.setExternal(function.isExternal());
+        descriptor.setInline(function.isInline());
+        descriptor.setTailrec(function.isTailrec());
         return descriptor;
     }
 }

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/dynamicCalls.kt

@@ -24,7 +24,6 @@ import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.lexer.JetTokens
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.DescriptorFactory
 import org.jetbrains.kotlin.resolve.calls.tasks.collectors.CallableDescriptorCollector
 import org.jetbrains.kotlin.resolve.calls.tasks.collectors.CallableDescriptorCollectors
@@ -166,7 +165,9 @@ class DynamicCallableDescriptors(private val builtIns: KotlinBuiltIns) {
                     Annotations.EMPTY,
                     arg.getArgumentName()?.asName ?: Name.identifier("p$index"),
                     outType,
-                    false,
+                    /* declaresDefaultValue = */ false,
+                    /* isCrossinline = */ false,
+                    /* isNoinline = */ false,
                     varargElementType,
                     SourceElement.NO_SOURCE
             ))

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/synthesizedInvokes.kt

@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.types.TypeSubstitutor
 import org.jetbrains.kotlin.util.OperatorNameConventions
-import java.util.ArrayList
+import java.util.*
 
 fun createSynthesizedInvokes(functions: Collection<FunctionDescriptor>): Collection<FunctionDescriptor> {
     val result = ArrayList<FunctionDescriptor>(1)
@@ -75,7 +75,7 @@ private fun createSynthesizedFunctionWithFirstParameterAsReceiver(descriptor: Fu
             original.getValueParameters().drop(1).map { p ->
                 ValueParameterDescriptorImpl(
                         result, null, p.getIndex() - 1, p.getAnnotations(), Name.identifier("p${p.getIndex() + 1}"), p.getType(),
-                        p.declaresDefaultValue(), p.getVarargElementType(), p.getSource()
+                        p.declaresDefaultValue(), p.isCrossinline, p.isNoinline, p.getVarargElementType(), p.getSource()
                 )
             },
             original.getReturnType(),
@@ -84,6 +84,9 @@ private fun createSynthesizedFunctionWithFirstParameterAsReceiver(descriptor: Fu
     )
     result.isOperator = original.isOperator
     result.isInfix = original.isInfix
+    result.isExternal = original.isExternal
+    result.isInline = original.isInline
+    result.isTailrec = original.isTailrec
 
     return result
 }

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptDescriptor.kt

@@ -32,7 +32,8 @@ import org.jetbrains.kotlin.resolve.ScriptBodyResolver
 import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil
 import org.jetbrains.kotlin.resolve.lazy.LazyEntity
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession
-import org.jetbrains.kotlin.resolve.scopes.*
+import org.jetbrains.kotlin.resolve.scopes.LexicalScope
+import org.jetbrains.kotlin.resolve.scopes.LexicalScopeImpl
 import org.jetbrains.kotlin.resolve.scopes.receivers.ScriptReceiver
 import org.jetbrains.kotlin.resolve.source.toSourceElement
 import org.jetbrains.kotlin.types.DeferredType
@@ -78,7 +79,10 @@ public class LazyScriptDescriptor(
                 scriptDefinition.getScriptParameters().mapIndexed { index, scriptParameter ->
                     ValueParameterDescriptorImpl(
                             result, null, index, Annotations.EMPTY, scriptParameter.getName(), scriptParameter.getType(),
-                            false, null, SourceElement.NO_SOURCE
+                            /* declaresDefaultValue = */ false,
+                            /* isCrossinline = */ false,
+                            /* isNoinline = */ false,
+                            null, SourceElement.NO_SOURCE
                     )
                 },
                 DeferredType.create(resolveSession.storageManager, resolveSession.trace) {

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingUtils.java

@@ -118,7 +118,11 @@ public class ControlStructureTypingUtils {
             JetType argumentType = isArgumentNullable.get(i) ? nullableType : type;
             ValueParameterDescriptorImpl valueParameter = new ValueParameterDescriptorImpl(
                     function, null, i, Annotations.Companion.getEMPTY(), Name.identifier(argumentNames.get(i)),
-                    argumentType, false, null, SourceElement.NO_SOURCE
+                    argumentType,
+                    /* declaresDefaultValue = */ false,
+                    /* isCrossinline = */ false,
+                    /* isNoinline = */ false,
+                    null, SourceElement.NO_SOURCE
             );
             valueParameters.add(valueParameter);
         }