Move inference parameter type in FunctionDescriptorResolver

2015-03-05 12:56:50 +03:00
parent 0c74675e6e
commit d9882a6d0b
13 changed files with 294 additions and 267 deletions
@@ -171,8 +171,7 @@ public class DefaultErrorMessages {
        MAP.put(CONFLICTING_IMPORT, "Conflicting import, imported name ''{0}'' is ambiguous", STRING);
        MAP.put(PLATFORM_CLASS_MAPPED_TO_KOTLIN, "This class shouldn''t be used in Kotlin. Use {0} instead.", CLASSES_OR_SEPARATED);

-        MAP.put(CANNOT_INFER_PARAMETER_TYPE,
-                "Cannot infer a type for this parameter. To specify it explicitly use the {(p : Type) -> ...} notation");
+        MAP.put(CANNOT_INFER_PARAMETER_TYPE, "Cannot infer a type for this parameter. Please specify it explicitly.");

        MAP.put(NO_BACKING_FIELD_ABSTRACT_PROPERTY, "This property doesn't have a backing field, because it's abstract");
        MAP.put(NO_BACKING_FIELD_CUSTOM_ACCESSORS,
@@ -17,13 +17,15 @@
 package org.jetbrains.kotlin.resolve

 import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.builtins
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns.*
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.descriptors.impl.ConstructorDescriptorImpl
-import org.jetbrains.kotlin.descriptors.impl.FunctionExpressionDescriptor
-import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl
+import org.jetbrains.kotlin.descriptors.annotations.Annotations
+import org.jetbrains.kotlin.descriptors.impl.*
 import org.jetbrains.kotlin.diagnostics.DiagnosticUtils
 import org.jetbrains.kotlin.diagnostics.Errors.*
+import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.scopes.JetScope
 import org.jetbrains.kotlin.resolve.ModifiersChecker.*
@@ -37,7 +39,10 @@ import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.types.DeferredType
 import org.jetbrains.kotlin.types.ErrorUtils
 import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.TypeUtils
+import org.jetbrains.kotlin.types.checker.JetTypeChecker
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices
+import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils
 import java.util.ArrayList

 class FunctionDescriptorResolver(
@@ -65,7 +70,7 @@ class FunctionDescriptorResolver(
                CallableMemberDescriptor.Kind.DECLARATION,
                function.toSourceElement()
        )
-        initializeFunctionDescriptorAndExplicitReturnType(containingDescriptor, scope, function, functionDescriptor, trace)
+        initializeFunctionDescriptorAndExplicitReturnType(containingDescriptor, scope, function, functionDescriptor, trace, null)
        initializeFunctionReturnTypeBasedOnFunctionBody(scope, function, functionDescriptor, trace, dataFlowInfo)
        BindingContextUtils.recordFunctionDeclarationToDescriptor(trace, function, functionDescriptor)
        return functionDescriptor
@@ -85,7 +90,7 @@ class FunctionDescriptorResolver(
                CallableMemberDescriptor.Kind.DECLARATION,
                function.toSourceElement()
        )
-        initializeFunctionDescriptorAndExplicitReturnType(containingDescriptor, scope, function, functionDescriptor, trace)
+        initializeFunctionDescriptorAndExplicitReturnType(containingDescriptor, scope, function, functionDescriptor, trace, null)
        initializeFunctionReturnTypeBasedOnFunctionBody(scope, function, functionDescriptor, trace, dataFlowInfo)
        BindingContextUtils.recordFunctionDeclarationToDescriptor(trace, function, functionDescriptor)
        return functionDescriptor
@@ -117,12 +122,13 @@ class FunctionDescriptorResolver(
        functionDescriptor.setReturnType(returnType)
    }

-    private fun initializeFunctionDescriptorAndExplicitReturnType(
+    fun initializeFunctionDescriptorAndExplicitReturnType(
            containingDescriptor: DeclarationDescriptor,
            scope: JetScope,
            function: JetFunction,
            functionDescriptor: SimpleFunctionDescriptorImpl,
-            trace: BindingTrace
+            trace: BindingTrace,
+            expectedFunctionType: JetType?
    ) {
        val innerScope = WritableScopeImpl(scope, functionDescriptor, TraceBasedRedeclarationHandler(trace), "Function descriptor header scope")
        innerScope.addLabeledDeclaration(functionDescriptor)
@@ -133,18 +139,18 @@ class FunctionDescriptorResolver(
        descriptorResolver.resolveGenericBounds(function, functionDescriptor, innerScope, typeParameterDescriptors, trace)

        val receiverTypeRef = function.getReceiverTypeReference()
-        val receiverType =  if (receiverTypeRef != null) {
-            typeResolver.resolveType(innerScope, receiverTypeRef, trace, true)
-        } else null
+        val receiverType =
+                if (receiverTypeRef != null)
+                    typeResolver.resolveType(innerScope, receiverTypeRef, trace, true)
+                else
+                    expectedFunctionType.getReceiverType()

-        val valueParameterDescriptors = resolveValueParameters(functionDescriptor, innerScope, function.getValueParameters(), trace)
+
+        val valueParameterDescriptors = createValueParameterDescriptors(function, functionDescriptor, innerScope, trace, expectedFunctionType)

        innerScope.changeLockLevel(WritableScope.LockLevel.READING)

-        val returnTypeRef = function.getTypeReference()
-        val returnType = if (returnTypeRef != null) {
-            typeResolver.resolveType(innerScope, returnTypeRef, trace, true)
-        } else null
+        val returnType = function.getTypeReference()?.let { typeResolver.resolveType(innerScope, it, trace, true) }

        val modality = resolveModalityFromModifiers(function, getDefaultModality(containingDescriptor, function.hasBody()))
        val visibility = resolveVisibilityFromModifiers(function, getDefaultVisibility(function, containingDescriptor))
@@ -159,6 +165,45 @@ class FunctionDescriptorResolver(
        )
    }

+    private fun createValueParameterDescriptors(
+            function: JetFunction,
+            functionDescriptor: SimpleFunctionDescriptorImpl,
+            innerScope: WritableScopeImpl,
+            trace: BindingTrace,
+            expectedFunctionType: JetType?
+    ): List<ValueParameterDescriptor> {
+        val expectedValueParameters = expectedFunctionType.getValueParameters(functionDescriptor)
+        if (expectedValueParameters != null) {
+            if (expectedValueParameters.size() == 1 && function is JetFunctionLiteral && function.getValueParameterList() == null) {
+                // it parameter for lambda
+                val valueParameterDescriptor = expectedValueParameters.first()
+                val it = ValueParameterDescriptorImpl(functionDescriptor, null, 0, Annotations.EMPTY, Name.identifier("it"),
+                                                      valueParameterDescriptor.getType(), valueParameterDescriptor.hasDefaultValue(),
+                                                      valueParameterDescriptor.getVarargElementType(), SourceElement.NO_SOURCE)
+                trace.record(BindingContext.AUTO_CREATED_IT, it)
+                return listOf(it)
+            }
+            if (function.getValueParameters().size() != expectedValueParameters.size()) {
+                val expectedParameterTypes = ExpressionTypingUtils.getValueParametersTypes(expectedValueParameters)
+                trace.report(EXPECTED_PARAMETERS_NUMBER_MISMATCH.on(function, expectedParameterTypes.size(), expectedParameterTypes))
+            }
+        }
+        return resolveValueParameters(
+                functionDescriptor,
+                innerScope,
+                function.getValueParameters(),
+                trace,
+                expectedValueParameters
+        )
+    }
+
+    private fun JetType.functionTypeExpected() = !TypeUtils.noExpectedType(this) && KotlinBuiltIns.isFunctionOrExtensionFunctionType(this)
+    private fun JetType?.getReceiverType(): JetType? =
+            if (this != null && functionTypeExpected()) getReceiverType(this) else null
+
+    private fun JetType?.getValueParameters(owner: FunctionDescriptor): List<ValueParameterDescriptor>? =
+            if (this != null && functionTypeExpected()) getValueParameters(owner, this) else null
+
    public fun resolvePrimaryConstructorDescriptor(
            scope: JetScope,
            classDescriptor: ClassDescriptor,
@@ -222,7 +267,7 @@ class FunctionDescriptorResolver(
        parameterScope.changeLockLevel(WritableScope.LockLevel.BOTH)
        val constructor = constructorDescriptor.initialize(
                typeParameters,
-                resolveValueParameters(constructorDescriptor, parameterScope, valueParameters, trace),
+                resolveValueParameters(constructorDescriptor, parameterScope, valueParameters, trace, null),
                resolveVisibilityFromModifiers(
                        modifierList,
                        DescriptorUtils.getDefaultConstructorVisibility(classDescriptor)
@@ -238,20 +283,43 @@ class FunctionDescriptorResolver(
            functionDescriptor: FunctionDescriptor,
            parameterScope: WritableScope,
            valueParameters: List<JetParameter>,
-            trace: BindingTrace
+            trace: BindingTrace,
+            expectedValueParameters: List<ValueParameterDescriptor>?
    ): List<ValueParameterDescriptor> {
        val result = ArrayList<ValueParameterDescriptor>()
+
        for (i in valueParameters.indices) {
            val valueParameter = valueParameters.get(i)
            val typeReference = valueParameter.getTypeReference()
+            val expectedType = expectedValueParameters?.let { if (i < it.size()) it[i].getType() else null }

            val type: JetType
-            if (typeReference == null) {
-                trace.report(VALUE_PARAMETER_WITH_NO_TYPE_ANNOTATION.on(valueParameter))
-                type = ErrorUtils.createErrorType("Type annotation was missing")
+            if (typeReference != null) {
+                type = typeResolver.resolveType(parameterScope, typeReference, trace, true)
+                if (expectedType != null) {
+                    if (!JetTypeChecker.DEFAULT.isSubtypeOf(expectedType, type)) {
+                        trace.report(EXPECTED_PARAMETER_TYPE_MISMATCH.on(valueParameter, expectedType))
+                    }
+                }
            }
            else {
-                type = typeResolver.resolveType(parameterScope, typeReference, trace, true)
+                if (isFunctionLiteral(functionDescriptor) || isFunctionExpression(functionDescriptor)) {
+                    val containsUninferredParameter = TypeUtils.containsSpecialType(expectedType) {
+                        TypeUtils.isDontCarePlaceholder(it) || ErrorUtils.isUninferredParameter(it)
+                    }
+                    if (expectedType == null || containsUninferredParameter) {
+                        trace.report(CANNOT_INFER_PARAMETER_TYPE.on(valueParameter))
+                    }
+                    if (expectedType != null) {
+                        type = expectedType
+                    }
+                    else {
+                        type = TypeUtils.CANT_INFER_FUNCTION_PARAM_TYPE
+                    }
+                } else {
+                    trace.report(VALUE_PARAMETER_WITH_NO_TYPE_ANNOTATION.on(valueParameter))
+                    type = ErrorUtils.createErrorType("Type annotation was missing for parameter ${valueParameter.getNameAsSafeName()}")
+                }
            }

            if (functionDescriptor !is ConstructorDescriptor) {
@@ -262,7 +330,7 @@ class FunctionDescriptorResolver(
                checkConstructorParameterHasNoModifier(trace, valueParameter)
            }

-            val valueParameterDescriptor = descriptorResolver.resolveValueParameterDescriptor(parameterScope, functionDescriptor,
+            val valueParameterDescriptor = descriptorResolver.resolveValueParameterDescriptorWithAnnotationArguments(parameterScope, functionDescriptor,
                                                                                              valueParameter, i, type, trace)
            parameterScope.addVariableDescriptor(valueParameterDescriptor)
            result.add(valueParameterDescriptor)
@@ -36,7 +36,7 @@ import org.jetbrains.kotlin.resolve.calls.context.ResolutionContext
 import org.jetbrains.kotlin.resolve.scopes.WritableScope
 import org.jetbrains.kotlin.resolve.source.toSourceElement
 import org.jetbrains.kotlin.types.*
-import org.jetbrains.kotlin.types.TypeUtils.CANT_INFER_LAMBDA_PARAM_TYPE
+import org.jetbrains.kotlin.types.TypeUtils.CANT_INFER_FUNCTION_PARAM_TYPE
 import org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE
 import org.jetbrains.kotlin.types.TypeUtils.noExpectedType
 import org.jetbrains.kotlin.types.checker.JetTypeChecker
@@ -127,12 +127,12 @@ public class FunctionsTypingVisitor(facade: ExpressionTypingInternals) : Express
        val expectedType = context.expectedType
        val functionTypeExpected = !noExpectedType(expectedType) && KotlinBuiltIns.isFunctionOrExtensionFunctionType(expectedType)

-        val functionDescriptor = createFunctionDescriptor(expression, context, functionTypeExpected)
+        val functionDescriptor = createFunctionDescriptor(expression, context)
        val safeReturnType = computeReturnType(expression, context, functionDescriptor, functionTypeExpected)
        functionDescriptor.setReturnType(safeReturnType)

        val resultType = createFunctionType(functionDescriptor)!!
-        if (!noExpectedType(expectedType) && KotlinBuiltIns.isFunctionOrExtensionFunctionType(expectedType)) {
+        if (functionTypeExpected) {
            // all checks were done before
            return JetTypeInfo.create(resultType, context.dataFlowInfo)
        }
@@ -142,115 +142,18 @@ public class FunctionsTypingVisitor(facade: ExpressionTypingInternals) : Express

    private fun createFunctionDescriptor(
            expression: JetFunctionLiteralExpression,
-            context: ExpressionTypingContext,
-            functionTypeExpected: Boolean
+            context: ExpressionTypingContext
    ): AnonymousFunctionDescriptor {
        val functionLiteral = expression.getFunctionLiteral()
-        val receiverTypeRef = functionLiteral.getReceiverTypeReference()
        val functionDescriptor = AnonymousFunctionDescriptor(context.scope.getContainingDeclaration(), Annotations.EMPTY,
                                                             CallableMemberDescriptor.Kind.DECLARATION, functionLiteral.toSourceElement())
-
-        val valueParameterDescriptors = createValueParameterDescriptors(context, functionLiteral, functionDescriptor, functionTypeExpected)
-
-        val effectiveReceiverType: JetType?
-        if (receiverTypeRef == null) {
-            if (functionTypeExpected) {
-                effectiveReceiverType = KotlinBuiltIns.getReceiverType(context.expectedType)
-            }
-            else {
-                effectiveReceiverType = null
-            }
-        }
-        else {
-            effectiveReceiverType = components.expressionTypingServices.getTypeResolver().resolveType(context.scope, receiverTypeRef,
-                                                                                                      context.trace, true)
-        }
-        functionDescriptor.initialize(effectiveReceiverType, ReceiverParameterDescriptor.NO_RECEIVER_PARAMETER, listOf(),
-                                      valueParameterDescriptors, /*unsubstitutedReturnType = */ null, Modality.FINAL, Visibilities.LOCAL)
+        components.expressionTypingServices.getFunctionDescriptorResolver().
+                initializeFunctionDescriptorAndExplicitReturnType(context.scope.getContainingDeclaration(), context.scope, functionLiteral,
+                                                                  functionDescriptor, context.trace, context.expectedType)
        BindingContextUtils.recordFunctionDeclarationToDescriptor(context.trace, functionLiteral, functionDescriptor)
        return functionDescriptor
    }

-    private fun createValueParameterDescriptors(
-            context: ExpressionTypingContext,
-            functionLiteral: JetFunctionLiteral,
-            functionDescriptor: FunctionDescriptorImpl,
-            functionTypeExpected: Boolean
-    ): List<ValueParameterDescriptor> {
-        val valueParameterDescriptors = Lists.newArrayList<ValueParameterDescriptor>()
-        val declaredValueParameters = functionLiteral.getValueParameters()
-
-        val expectedValueParameters = if (functionTypeExpected) KotlinBuiltIns.getValueParameters(functionDescriptor, context.expectedType)
-        else null
-
-        val valueParameterList = functionLiteral.getValueParameterList()
-        val hasDeclaredValueParameters = valueParameterList != null
-        if (functionTypeExpected && !hasDeclaredValueParameters && expectedValueParameters!!.size() == 1) {
-            val valueParameterDescriptor = expectedValueParameters!!.get(0)
-            val it = ValueParameterDescriptorImpl(functionDescriptor, null, 0, Annotations.EMPTY, Name.identifier("it"),
-                                                  valueParameterDescriptor.getType(), valueParameterDescriptor.hasDefaultValue(),
-                                                  valueParameterDescriptor.getVarargElementType(), SourceElement.NO_SOURCE)
-            valueParameterDescriptors.add(it)
-            context.trace.record<ValueParameterDescriptor>(AUTO_CREATED_IT, it)
-        }
-        else {
-            if (expectedValueParameters != null && declaredValueParameters.size() != expectedValueParameters.size()) {
-                val expectedParameterTypes = ExpressionTypingUtils.getValueParametersTypes(expectedValueParameters)
-                context.trace.report(EXPECTED_PARAMETERS_NUMBER_MISMATCH.on(functionLiteral, expectedParameterTypes.size(), expectedParameterTypes))
-            }
-            for (i in declaredValueParameters.indices) {
-                val valueParameterDescriptor = createValueParameterDescriptor(context, functionDescriptor, declaredValueParameters, expectedValueParameters, i)
-                valueParameterDescriptors.add(valueParameterDescriptor)
-            }
-        }
-        return valueParameterDescriptors
-    }
-
-    private fun createValueParameterDescriptor(
-            context: ExpressionTypingContext,
-            functionDescriptor: FunctionDescriptorImpl,
-            declaredValueParameters: List<JetParameter>,
-            expectedValueParameters: List<ValueParameterDescriptor>?,
-            index: Int
-    ): ValueParameterDescriptor {
-        val declaredParameter = declaredValueParameters.get(index)
-        val typeReference = declaredParameter.getTypeReference()
-
-        val expectedType: JetType?
-        if (expectedValueParameters != null && index < expectedValueParameters.size()) {
-            expectedType = expectedValueParameters.get(index).getType()
-        }
-        else {
-            expectedType = null
-        }
-        val type: JetType
-        if (typeReference != null) {
-            type = components.expressionTypingServices.getTypeResolver().resolveType(context.scope, typeReference, context.trace, true)
-            if (expectedType != null) {
-                if (!JetTypeChecker.DEFAULT.isSubtypeOf(expectedType, type)) {
-                    context.trace.report(EXPECTED_PARAMETER_TYPE_MISMATCH.on(declaredParameter, expectedType))
-                }
-            }
-        }
-        else {
-            val containsUninferredParameter = TypeUtils.containsSpecialType(expectedType) {
-                    TypeUtils.isDontCarePlaceholder(it) || ErrorUtils.isUninferredParameter(it)
-                }
-            if (expectedType == null || containsUninferredParameter) {
-                context.trace.report(CANNOT_INFER_PARAMETER_TYPE.on(declaredParameter))
-            }
-            if (expectedType != null) {
-                type = expectedType
-            }
-            else {
-                type = CANT_INFER_LAMBDA_PARAM_TYPE
-            }
-        }
-        return components.expressionTypingServices.getDescriptorResolver()
-                .resolveValueParameterDescriptorWithAnnotationArguments(context.scope, functionDescriptor, declaredParameter,
-                                                                        index, type, context.trace)
-    }
-
    private fun computeReturnType(
            expression: JetFunctionLiteralExpression,
            context: ExpressionTypingContext,
@@ -265,10 +168,9 @@ public class FunctionsTypingVisitor(facade: ExpressionTypingInternals) : Express
                return components.builtIns.getUnitType()
            }
        }
-        return returnType ?: CANT_INFER_LAMBDA_PARAM_TYPE
+        return returnType ?: CANT_INFER_FUNCTION_PARAM_TYPE
    }

-
    private fun computeUnsafeReturnType(
            expression: JetFunctionLiteralExpression,
            context: ExpressionTypingContext,
@@ -50,137 +50,137 @@ public open class JetKeywordCompletionContributor() {
    }
 }
 ---------------------
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   <v1>: {<: JetKeywordCompletionContributor}                     NEW: magic[IMPLICIT_RECEIVER](BunchKeywordRegister()) -> <v1>                                                                           
-1.0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <v0>: Double                                                   NEW: r(1.0) -> <v0>                                                                                                                     
-BunchKeywordRegister()                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             <v2>: JetKeywordCompletionContributor.BunchKeywordRegister     NEW: call(BunchKeywordRegister(), <init>|<v1>) -> <v2>                                                                                  
-ABSTRACT_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   <v3>: {<: [ERROR : Type annotation was missing]}               NEW: r(ABSTRACT_KEYWORD) -> <v3>                                                                                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v4>: Double                                                   NEW: r(inTopLevel) -> <v4>                                                                                                              
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v5>: Double                                                   NEW: r(inTopLevel) -> <v5>                                                                                                              
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v6>: Double                                                   NEW: r(inTopLevel) -> <v6>                                                                                                              
-add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          <v7>: JetKeywordCompletionContributor.BunchKeywordRegister     NEW: call(add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel), add|<v2>, <v3>, <v4>, <v5>, <v6>) -> <v7>                          
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  <v7>: JetKeywordCompletionContributor.BunchKeywordRegister     COPY                                                                                                                                    
-FINAL_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <v8>: {<: [ERROR : Type annotation was missing]}               NEW: r(FINAL_KEYWORD) -> <v8>                                                                                                           
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v9>: Double                                                   NEW: r(inTopLevel) -> <v9>                                                                                                              
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v10>: Double                                                  NEW: r(inTopLevel) -> <v10>                                                                                                             
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v11>: Double                                                  NEW: r(inTopLevel) -> <v11>                                                                                                             
-add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             <v12>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW: call(add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel), add|<v7>, <v8>, <v9>, <v10>, <v11>) -> <v12>                          
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          <v12>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                                                                                                                    
-OPEN_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       <v13>: {<: [ERROR : Type annotation was missing]}              NEW: r(OPEN_KEYWORD) -> <v13>                                                                                                           
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v14>: Double                                                  NEW: r(inTopLevel) -> <v14>                                                                                                             
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v15>: Double                                                  NEW: r(inTopLevel) -> <v15>                                                                                                             
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v16>: Double                                                  NEW: r(inTopLevel) -> <v16>                                                                                                             
-add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <v17>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW: call(add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel), add|<v12>, <v13>, <v14>, <v15>, <v16>) -> <v17>                        
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   <v17>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                                                                                                                    
-INTERNAL_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   <v18>: {<: [ERROR : Type annotation was missing]}              NEW: r(INTERNAL_KEYWORD) -> <v18>                                                                                                       
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v19>: Double                                                  NEW: r(inTopLevel) -> <v19>                                                                                                             
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v20>: Double                                                  NEW: r(inTopLevel) -> <v20>                                                                                                             
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v21>: Double                                                  NEW: r(inTopLevel) -> <v21>                                                                                                             
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v22>: Double                                                  NEW: r(inTopLevel) -> <v22>                                                                                                             
-add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <v23>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW: call(add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel), add|<v17>, <v18>, <v19>, <v20>, <v21>, <v22>) -> <v23> 
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <v23>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                                                                                                                    
-PRIVATE_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <v24>: {<: [ERROR : Type annotation was missing]}              NEW: r(PRIVATE_KEYWORD) -> <v24>                                                                                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v25>: Double                                                  NEW: r(inTopLevel) -> <v25>                                                                                                             
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v26>: Double                                                  NEW: r(inTopLevel) -> <v26>                                                                                                             
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v27>: Double                                                  NEW: r(inTopLevel) -> <v27>                                                                                                             
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v28>: Double                                                  NEW: r(inTopLevel) -> <v28>                                                                                                             
-add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               <v29>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW: call(add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel), add|<v23>, <v24>, <v25>, <v26>, <v27>, <v28>) -> <v29>  
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <v29>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                                                                                                                    
-PROTECTED_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  <v30>: {<: [ERROR : Type annotation was missing]}              NEW: r(PROTECTED_KEYWORD) -> <v30>                                                                                                      
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v31>: Double                                                  NEW: r(inTopLevel) -> <v31>                                                                                                             
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v32>: Double                                                  NEW: r(inTopLevel) -> <v32>                                                                                                             
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v33>: Double                                                  NEW: r(inTopLevel) -> <v33>                                                                                                             
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v34>: Double                                                  NEW: r(inTopLevel) -> <v34>                                                                                                             
-add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             <v35>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW: call(add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel), add|<v29>, <v30>, <v31>, <v32>, <v33>, <v34>) -> <v35>
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <v35>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                                                                                                                    
-PUBLIC_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     <v36>: {<: [ERROR : Type annotation was missing]}              NEW: r(PUBLIC_KEYWORD) -> <v36>                                                                                                         
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v37>: Double                                                  NEW: r(inTopLevel) -> <v37>                                                                                                             
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v38>: Double                                                  NEW: r(inTopLevel) -> <v38>                                                                                                             
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v39>: Double                                                  NEW: r(inTopLevel) -> <v39>                                                                                                             
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v40>: Double                                                  NEW: r(inTopLevel) -> <v40>                                                                                                             
-add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <v41>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW: call(add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel), add|<v35>, <v36>, <v37>, <v38>, <v39>, <v40>) -> <v41>   
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v41>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                                                                                                                    
-CLASS_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <v42>: {<: [ERROR : Type annotation was missing]}              NEW: r(CLASS_KEYWORD) -> <v42>                                                                                                          
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v43>: Double                                                  NEW: r(inTopLevel) -> <v43>                                                                                                             
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v44>: Double                                                  NEW: r(inTopLevel) -> <v44>                                                                                                             
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v45>: Double                                                  NEW: r(inTopLevel) -> <v45>                                                                                                             
-add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             <v46>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW: call(add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel), add|<v41>, <v42>, <v43>, <v44>, <v45>) -> <v46>                       
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 <v46>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                                                                                                                    
-ENUM_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       <v47>: {<: [ERROR : Type annotation was missing]}              NEW: r(ENUM_KEYWORD) -> <v47>                                                                                                           
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v48>: Double                                                  NEW: r(inTopLevel) -> <v48>                                                                                                             
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v49>: Double                                                  NEW: r(inTopLevel) -> <v49>                                                                                                             
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v50>: Double                                                  NEW: r(inTopLevel) -> <v50>                                                                                                             
-add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <v51>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW: call(add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel), add|<v46>, <v47>, <v48>, <v49>, <v50>) -> <v51>                        
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          <v51>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                                                                                                                    
-FUN_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <v52>: {<: [ERROR : Type annotation was missing]}              NEW: r(FUN_KEYWORD) -> <v52>                                                                                                            
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v53>: Double                                                  NEW: r(inTopLevel) -> <v53>                                                                                                             
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v54>: Double                                                  NEW: r(inTopLevel) -> <v54>                                                                                                             
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v55>: Double                                                  NEW: r(inTopLevel) -> <v55>                                                                                                             
-add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               <v56>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW: call(add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel), add|<v51>, <v52>, <v53>, <v54>, <v55>) -> <v56>                         
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <v56>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                                                                                                                    
-GET_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <v57>: {<: [ERROR : Type annotation was missing]}              NEW: r(GET_KEYWORD) -> <v57>                                                                                                            
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v58>: Double                                                  NEW: r(inTopLevel) -> <v58>                                                                                                             
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v59>: Double                                                  NEW: r(inTopLevel) -> <v59>                                                                                                             
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v60>: Double                                                  NEW: r(inTopLevel) -> <v60>                                                                                                             
-add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               <v61>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW: call(add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel), add|<v56>, <v57>, <v58>, <v59>, <v60>) -> <v61>                         
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <v61>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                                                                                                                    
-SET_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <v62>: {<: [ERROR : Type annotation was missing]}              NEW: r(SET_KEYWORD) -> <v62>                                                                                                            
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v63>: Double                                                  NEW: r(inTopLevel) -> <v63>                                                                                                             
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v64>: Double                                                  NEW: r(inTopLevel) -> <v64>                                                                                                             
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v65>: Double                                                  NEW: r(inTopLevel) -> <v65>                                                                                                             
-add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               <v66>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW: call(add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel), add|<v61>, <v62>, <v63>, <v64>, <v65>) -> <v66>                         
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <v66>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                                                                                                                    
-TRAIT_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <v67>: {<: [ERROR : Type annotation was missing]}              NEW: r(TRAIT_KEYWORD) -> <v67>                                                                                                          
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v68>: Double                                                  NEW: r(inTopLevel) -> <v68>                                                                                                             
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v69>: Double                                                  NEW: r(inTopLevel) -> <v69>                                                                                                             
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v70>: Double                                                  NEW: r(inTopLevel) -> <v70>                                                                                                             
-add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             <v71>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW: call(add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel), add|<v66>, <v67>, <v68>, <v69>, <v70>) -> <v71>                       
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                <v71>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                                                                                                                    
-VAL_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <v72>: {<: [ERROR : Type annotation was missing]}              NEW: r(VAL_KEYWORD) -> <v72>                                                                                                            
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v73>: Double                                                  NEW: r(inTopLevel) -> <v73>                                                                                                             
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v74>: Double                                                  NEW: r(inTopLevel) -> <v74>                                                                                                             
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v75>: Double                                                  NEW: r(inTopLevel) -> <v75>                                                                                                             
-add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               <v76>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW: call(add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel), add|<v71>, <v72>, <v73>, <v74>, <v75>) -> <v76>                         
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                          <v76>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                                                                                                                    
-VAR_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <v77>: {<: [ERROR : Type annotation was missing]}              NEW: r(VAR_KEYWORD) -> <v77>                                                                                                            
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v78>: Double                                                  NEW: r(inTopLevel) -> <v78>                                                                                                             
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v79>: Double                                                  NEW: r(inTopLevel) -> <v79>                                                                                                             
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v80>: Double                                                  NEW: r(inTopLevel) -> <v80>                                                                                                             
-add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               <v81>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW: call(add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel), add|<v76>, <v77>, <v78>, <v79>, <v80>) -> <v81>                         
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                    <v81>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                                                                                                                    
-TYPE_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       <v82>: {<: [ERROR : Type annotation was missing]}              NEW: r(TYPE_KEYWORD) -> <v82>                                                                                                           
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v83>: Double                                                  NEW: r(inTopLevel) -> <v83>                                                                                                             
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v84>: Double                                                  NEW: r(inTopLevel) -> <v84>                                                                                                             
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v85>: Double                                                  NEW: r(inTopLevel) -> <v85>                                                                                                             
-add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <v86>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW: call(add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel), add|<v81>, <v82>, <v83>, <v84>, <v85>) -> <v86>                        
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                             <v86>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                                                                                                                    
-IMPORT_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     <v87>: {<: [ERROR : Type annotation was missing]}              NEW: r(IMPORT_KEYWORD) -> <v87>                                                                                                         
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v88>: Double                                                  NEW: r(inTopLevel) -> <v88>                                                                                                             
-add(IMPORT_KEYWORD, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <v89>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW: call(add(IMPORT_KEYWORD, inTopLevel), add|<v86>, <v87>, <v88>) -> <v89>                                                            
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel)                                                                                                                                                                                                                            <v89>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                                                                                                                    
-PACKAGE_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <v90>: {<: [ERROR : Type annotation was missing]}              NEW: r(PACKAGE_KEYWORD) -> <v90>                                                                                                        
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v91>: Double                                                  NEW: r(inTopLevel) -> <v91>                                                                                                             
-add(PACKAGE_KEYWORD, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   <v92>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW: call(add(PACKAGE_KEYWORD, inTopLevel), add|<v89>, <v90>, <v91>) -> <v92>                                                           
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel)                                                                                                                                                                                          <v92>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                                                                                                                    
-OVERRIDE_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   <v93>: {<: [ERROR : Type annotation was missing]}              NEW: r(OVERRIDE_KEYWORD) -> <v93>                                                                                                       
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v94>: Double                                                  NEW: r(inTopLevel) -> <v94>                                                                                                             
-add(OVERRIDE_KEYWORD, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  <v95>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW: call(add(OVERRIDE_KEYWORD, inTopLevel), add|<v92>, <v93>, <v94>) -> <v95>                                                          
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel) .add(OVERRIDE_KEYWORD, inTopLevel)                                                                                                                                                       <v95>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                                                                                                                    
-IN_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v96>: {<: [ERROR : Type annotation was missing]}              NEW: r(IN_KEYWORD) -> <v96>                                                                                                             
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v97>: Double                                                  NEW: r(inTopLevel) -> <v97>                                                                                                             
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v98>: Double                                                  NEW: r(inTopLevel) -> <v98>                                                                                                             
-add(IN_KEYWORD, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <v99>: JetKeywordCompletionContributor.BunchKeywordRegister    NEW: call(add(IN_KEYWORD, inTopLevel, inTopLevel), add|<v95>, <v96>, <v97>, <v98>) -> <v99>                                             
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel) .add(OVERRIDE_KEYWORD, inTopLevel) .add(IN_KEYWORD, inTopLevel, inTopLevel)                                                                                                              <v99>: JetKeywordCompletionContributor.BunchKeywordRegister    COPY                                                                                                                                    
-OUT_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <v100>: {<: [ERROR : Type annotation was missing]}             NEW: r(OUT_KEYWORD) -> <v100>                                                                                                           
-inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v101>: Double                                                 NEW: r(inTopLevel) -> <v101>                                                                                                            
-add(OUT_KEYWORD, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       <v102>: JetKeywordCompletionContributor.BunchKeywordRegister   NEW: call(add(OUT_KEYWORD, inTopLevel), add|<v99>, <v100>, <v101>) -> <v102>                                                            
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel) .add(OVERRIDE_KEYWORD, inTopLevel) .add(IN_KEYWORD, inTopLevel, inTopLevel) .add(OUT_KEYWORD, inTopLevel)                                                                                <v102>: JetKeywordCompletionContributor.BunchKeywordRegister   COPY                                                                                                                                    
-OBJECT_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     <v103>: {<: [ERROR : Type annotation was missing]}             NEW: r(OBJECT_KEYWORD) -> <v103>                                                                                                        
-unresolvedCode                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     <v104>: Double                                                 NEW: magic[UNRESOLVED_CALL](unresolvedCode) -> <v104>                                                                                   
-add(OBJECT_KEYWORD, unresolvedCode)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <v105>: JetKeywordCompletionContributor.BunchKeywordRegister   NEW: call(add(OBJECT_KEYWORD, unresolvedCode), add|<v102>, <v103>, <v104>) -> <v105>                                                    
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel) .add(OVERRIDE_KEYWORD, inTopLevel) .add(IN_KEYWORD, inTopLevel, inTopLevel) .add(OUT_KEYWORD, inTopLevel) .add(OBJECT_KEYWORD, unresolvedCode)                                           <v105>: JetKeywordCompletionContributor.BunchKeywordRegister   COPY                                                                                                                                    
-registerAll()                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <v106>: *                                                      NEW: call(registerAll(), registerAll|<v105>) -> <v106>                                                                                  
-BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel) .add(OVERRIDE_KEYWORD, inTopLevel) .add(IN_KEYWORD, inTopLevel, inTopLevel) .add(OUT_KEYWORD, inTopLevel) .add(OBJECT_KEYWORD, unresolvedCode) .registerAll()                            <v106>: *                                                      COPY                                                                                                                                    
-{ val inTopLevel = 1.0 BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel) .add(OVERRIDE_KEYWORD, inTopLevel) .add(IN_KEYWORD, inTopLevel, inTopLevel) .add(OUT_KEYWORD, inTopLevel) .add(OBJECT_KEYWORD, unresolvedCode) .registerAll() }   <v106>: *                                                      COPY                                                                                                                                    
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   <v1>: {<: JetKeywordCompletionContributor}                                            NEW: magic[IMPLICIT_RECEIVER](BunchKeywordRegister()) -> <v1>
+1.0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <v0>: Double                                                                          NEW: r(1.0) -> <v0>
+BunchKeywordRegister()                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             <v2>: JetKeywordCompletionContributor.BunchKeywordRegister                            NEW: call(BunchKeywordRegister(), <init>|<v1>) -> <v2>
+ABSTRACT_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   <v3>: {<: [ERROR : Type annotation was missing for parameter <no name provided>]}     NEW: r(ABSTRACT_KEYWORD) -> <v3>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v4>: Double                                                                          NEW: r(inTopLevel) -> <v4>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v5>: Double                                                                          NEW: r(inTopLevel) -> <v5>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v6>: Double                                                                          NEW: r(inTopLevel) -> <v6>
+add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          <v7>: JetKeywordCompletionContributor.BunchKeywordRegister                            NEW: call(add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel), add|<v2>, <v3>, <v4>, <v5>, <v6>) -> <v7>
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  <v7>: JetKeywordCompletionContributor.BunchKeywordRegister                            COPY
+FINAL_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <v8>: {<: [ERROR : Type annotation was missing for parameter <no name provided>]}     NEW: r(FINAL_KEYWORD) -> <v8>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v9>: Double                                                                          NEW: r(inTopLevel) -> <v9>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v10>: Double                                                                         NEW: r(inTopLevel) -> <v10>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v11>: Double                                                                         NEW: r(inTopLevel) -> <v11>
+add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             <v12>: JetKeywordCompletionContributor.BunchKeywordRegister                           NEW: call(add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel), add|<v7>, <v8>, <v9>, <v10>, <v11>) -> <v12>
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          <v12>: JetKeywordCompletionContributor.BunchKeywordRegister                           COPY
+OPEN_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       <v13>: {<: [ERROR : Type annotation was missing for parameter <no name provided>]}    NEW: r(OPEN_KEYWORD) -> <v13>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v14>: Double                                                                         NEW: r(inTopLevel) -> <v14>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v15>: Double                                                                         NEW: r(inTopLevel) -> <v15>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v16>: Double                                                                         NEW: r(inTopLevel) -> <v16>
+add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <v17>: JetKeywordCompletionContributor.BunchKeywordRegister                           NEW: call(add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel), add|<v12>, <v13>, <v14>, <v15>, <v16>) -> <v17>
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   <v17>: JetKeywordCompletionContributor.BunchKeywordRegister                           COPY
+INTERNAL_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   <v18>: {<: [ERROR : Type annotation was missing for parameter <no name provided>]}    NEW: r(INTERNAL_KEYWORD) -> <v18>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v19>: Double                                                                         NEW: r(inTopLevel) -> <v19>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v20>: Double                                                                         NEW: r(inTopLevel) -> <v20>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v21>: Double                                                                         NEW: r(inTopLevel) -> <v21>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v22>: Double                                                                         NEW: r(inTopLevel) -> <v22>
+add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <v23>: JetKeywordCompletionContributor.BunchKeywordRegister                           NEW: call(add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel), add|<v17>, <v18>, <v19>, <v20>, <v21>, <v22>) -> <v23>
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <v23>: JetKeywordCompletionContributor.BunchKeywordRegister                           COPY
+PRIVATE_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <v24>: {<: [ERROR : Type annotation was missing for parameter <no name provided>]}    NEW: r(PRIVATE_KEYWORD) -> <v24>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v25>: Double                                                                         NEW: r(inTopLevel) -> <v25>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v26>: Double                                                                         NEW: r(inTopLevel) -> <v26>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v27>: Double                                                                         NEW: r(inTopLevel) -> <v27>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v28>: Double                                                                         NEW: r(inTopLevel) -> <v28>
+add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               <v29>: JetKeywordCompletionContributor.BunchKeywordRegister                           NEW: call(add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel), add|<v23>, <v24>, <v25>, <v26>, <v27>, <v28>) -> <v29>
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <v29>: JetKeywordCompletionContributor.BunchKeywordRegister                           COPY
+PROTECTED_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  <v30>: {<: [ERROR : Type annotation was missing for parameter <no name provided>]}    NEW: r(PROTECTED_KEYWORD) -> <v30>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v31>: Double                                                                         NEW: r(inTopLevel) -> <v31>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v32>: Double                                                                         NEW: r(inTopLevel) -> <v32>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v33>: Double                                                                         NEW: r(inTopLevel) -> <v33>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v34>: Double                                                                         NEW: r(inTopLevel) -> <v34>
+add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             <v35>: JetKeywordCompletionContributor.BunchKeywordRegister                           NEW: call(add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel), add|<v29>, <v30>, <v31>, <v32>, <v33>, <v34>) -> <v35>
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <v35>: JetKeywordCompletionContributor.BunchKeywordRegister                           COPY
+PUBLIC_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     <v36>: {<: [ERROR : Type annotation was missing for parameter <no name provided>]}    NEW: r(PUBLIC_KEYWORD) -> <v36>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v37>: Double                                                                         NEW: r(inTopLevel) -> <v37>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v38>: Double                                                                         NEW: r(inTopLevel) -> <v38>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v39>: Double                                                                         NEW: r(inTopLevel) -> <v39>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v40>: Double                                                                         NEW: r(inTopLevel) -> <v40>
+add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <v41>: JetKeywordCompletionContributor.BunchKeywordRegister                           NEW: call(add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel), add|<v35>, <v36>, <v37>, <v38>, <v39>, <v40>) -> <v41>
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v41>: JetKeywordCompletionContributor.BunchKeywordRegister                           COPY
+CLASS_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <v42>: {<: [ERROR : Type annotation was missing for parameter <no name provided>]}    NEW: r(CLASS_KEYWORD) -> <v42>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v43>: Double                                                                         NEW: r(inTopLevel) -> <v43>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v44>: Double                                                                         NEW: r(inTopLevel) -> <v44>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v45>: Double                                                                         NEW: r(inTopLevel) -> <v45>
+add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             <v46>: JetKeywordCompletionContributor.BunchKeywordRegister                           NEW: call(add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel), add|<v41>, <v42>, <v43>, <v44>, <v45>) -> <v46>
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 <v46>: JetKeywordCompletionContributor.BunchKeywordRegister                           COPY
+ENUM_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       <v47>: {<: [ERROR : Type annotation was missing for parameter <no name provided>]}    NEW: r(ENUM_KEYWORD) -> <v47>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v48>: Double                                                                         NEW: r(inTopLevel) -> <v48>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v49>: Double                                                                         NEW: r(inTopLevel) -> <v49>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v50>: Double                                                                         NEW: r(inTopLevel) -> <v50>
+add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <v51>: JetKeywordCompletionContributor.BunchKeywordRegister                           NEW: call(add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel), add|<v46>, <v47>, <v48>, <v49>, <v50>) -> <v51>
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          <v51>: JetKeywordCompletionContributor.BunchKeywordRegister                           COPY
+FUN_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <v52>: {<: [ERROR : Type annotation was missing for parameter <no name provided>]}    NEW: r(FUN_KEYWORD) -> <v52>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v53>: Double                                                                         NEW: r(inTopLevel) -> <v53>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v54>: Double                                                                         NEW: r(inTopLevel) -> <v54>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v55>: Double                                                                         NEW: r(inTopLevel) -> <v55>
+add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               <v56>: JetKeywordCompletionContributor.BunchKeywordRegister                           NEW: call(add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel), add|<v51>, <v52>, <v53>, <v54>, <v55>) -> <v56>
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <v56>: JetKeywordCompletionContributor.BunchKeywordRegister                           COPY
+GET_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <v57>: {<: [ERROR : Type annotation was missing for parameter <no name provided>]}    NEW: r(GET_KEYWORD) -> <v57>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v58>: Double                                                                         NEW: r(inTopLevel) -> <v58>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v59>: Double                                                                         NEW: r(inTopLevel) -> <v59>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v60>: Double                                                                         NEW: r(inTopLevel) -> <v60>
+add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               <v61>: JetKeywordCompletionContributor.BunchKeywordRegister                           NEW: call(add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel), add|<v56>, <v57>, <v58>, <v59>, <v60>) -> <v61>
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <v61>: JetKeywordCompletionContributor.BunchKeywordRegister                           COPY
+SET_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <v62>: {<: [ERROR : Type annotation was missing for parameter <no name provided>]}    NEW: r(SET_KEYWORD) -> <v62>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v63>: Double                                                                         NEW: r(inTopLevel) -> <v63>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v64>: Double                                                                         NEW: r(inTopLevel) -> <v64>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v65>: Double                                                                         NEW: r(inTopLevel) -> <v65>
+add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               <v66>: JetKeywordCompletionContributor.BunchKeywordRegister                           NEW: call(add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel), add|<v61>, <v62>, <v63>, <v64>, <v65>) -> <v66>
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <v66>: JetKeywordCompletionContributor.BunchKeywordRegister                           COPY
+TRAIT_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <v67>: {<: [ERROR : Type annotation was missing for parameter <no name provided>]}    NEW: r(TRAIT_KEYWORD) -> <v67>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v68>: Double                                                                         NEW: r(inTopLevel) -> <v68>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v69>: Double                                                                         NEW: r(inTopLevel) -> <v69>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v70>: Double                                                                         NEW: r(inTopLevel) -> <v70>
+add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             <v71>: JetKeywordCompletionContributor.BunchKeywordRegister                           NEW: call(add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel), add|<v66>, <v67>, <v68>, <v69>, <v70>) -> <v71>
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                <v71>: JetKeywordCompletionContributor.BunchKeywordRegister                           COPY
+VAL_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <v72>: {<: [ERROR : Type annotation was missing for parameter <no name provided>]}    NEW: r(VAL_KEYWORD) -> <v72>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v73>: Double                                                                         NEW: r(inTopLevel) -> <v73>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v74>: Double                                                                         NEW: r(inTopLevel) -> <v74>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v75>: Double                                                                         NEW: r(inTopLevel) -> <v75>
+add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               <v76>: JetKeywordCompletionContributor.BunchKeywordRegister                           NEW: call(add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel), add|<v71>, <v72>, <v73>, <v74>, <v75>) -> <v76>
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                          <v76>: JetKeywordCompletionContributor.BunchKeywordRegister                           COPY
+VAR_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <v77>: {<: [ERROR : Type annotation was missing for parameter <no name provided>]}    NEW: r(VAR_KEYWORD) -> <v77>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v78>: Double                                                                         NEW: r(inTopLevel) -> <v78>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v79>: Double                                                                         NEW: r(inTopLevel) -> <v79>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v80>: Double                                                                         NEW: r(inTopLevel) -> <v80>
+add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               <v81>: JetKeywordCompletionContributor.BunchKeywordRegister                           NEW: call(add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel), add|<v76>, <v77>, <v78>, <v79>, <v80>) -> <v81>
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                    <v81>: JetKeywordCompletionContributor.BunchKeywordRegister                           COPY
+TYPE_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       <v82>: {<: [ERROR : Type annotation was missing for parameter <no name provided>]}    NEW: r(TYPE_KEYWORD) -> <v82>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v83>: Double                                                                         NEW: r(inTopLevel) -> <v83>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v84>: Double                                                                         NEW: r(inTopLevel) -> <v84>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v85>: Double                                                                         NEW: r(inTopLevel) -> <v85>
+add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <v86>: JetKeywordCompletionContributor.BunchKeywordRegister                           NEW: call(add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel), add|<v81>, <v82>, <v83>, <v84>, <v85>) -> <v86>
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                             <v86>: JetKeywordCompletionContributor.BunchKeywordRegister                           COPY
+IMPORT_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     <v87>: {<: [ERROR : Type annotation was missing for parameter <no name provided>]}    NEW: r(IMPORT_KEYWORD) -> <v87>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v88>: Double                                                                         NEW: r(inTopLevel) -> <v88>
+add(IMPORT_KEYWORD, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <v89>: JetKeywordCompletionContributor.BunchKeywordRegister                           NEW: call(add(IMPORT_KEYWORD, inTopLevel), add|<v86>, <v87>, <v88>) -> <v89>
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel)                                                                                                                                                                                                                            <v89>: JetKeywordCompletionContributor.BunchKeywordRegister                           COPY
+PACKAGE_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <v90>: {<: [ERROR : Type annotation was missing for parameter <no name provided>]}    NEW: r(PACKAGE_KEYWORD) -> <v90>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v91>: Double                                                                         NEW: r(inTopLevel) -> <v91>
+add(PACKAGE_KEYWORD, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   <v92>: JetKeywordCompletionContributor.BunchKeywordRegister                           NEW: call(add(PACKAGE_KEYWORD, inTopLevel), add|<v89>, <v90>, <v91>) -> <v92>
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel)                                                                                                                                                                                          <v92>: JetKeywordCompletionContributor.BunchKeywordRegister                           COPY
+OVERRIDE_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   <v93>: {<: [ERROR : Type annotation was missing for parameter <no name provided>]}    NEW: r(OVERRIDE_KEYWORD) -> <v93>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v94>: Double                                                                         NEW: r(inTopLevel) -> <v94>
+add(OVERRIDE_KEYWORD, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  <v95>: JetKeywordCompletionContributor.BunchKeywordRegister                           NEW: call(add(OVERRIDE_KEYWORD, inTopLevel), add|<v92>, <v93>, <v94>) -> <v95>
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel) .add(OVERRIDE_KEYWORD, inTopLevel)                                                                                                                                                       <v95>: JetKeywordCompletionContributor.BunchKeywordRegister                           COPY
+IN_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v96>: {<: [ERROR : Type annotation was missing for parameter <no name provided>]}    NEW: r(IN_KEYWORD) -> <v96>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v97>: Double                                                                         NEW: r(inTopLevel) -> <v97>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v98>: Double                                                                         NEW: r(inTopLevel) -> <v98>
+add(IN_KEYWORD, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <v99>: JetKeywordCompletionContributor.BunchKeywordRegister                           NEW: call(add(IN_KEYWORD, inTopLevel, inTopLevel), add|<v95>, <v96>, <v97>, <v98>) -> <v99>
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel) .add(OVERRIDE_KEYWORD, inTopLevel) .add(IN_KEYWORD, inTopLevel, inTopLevel)                                                                                                              <v99>: JetKeywordCompletionContributor.BunchKeywordRegister                           COPY
+OUT_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <v100>: {<: [ERROR : Type annotation was missing for parameter <no name provided>]}   NEW: r(OUT_KEYWORD) -> <v100>
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v101>: Double                                                                        NEW: r(inTopLevel) -> <v101>
+add(OUT_KEYWORD, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       <v102>: JetKeywordCompletionContributor.BunchKeywordRegister                          NEW: call(add(OUT_KEYWORD, inTopLevel), add|<v99>, <v100>, <v101>) -> <v102>
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel) .add(OVERRIDE_KEYWORD, inTopLevel) .add(IN_KEYWORD, inTopLevel, inTopLevel) .add(OUT_KEYWORD, inTopLevel)                                                                                <v102>: JetKeywordCompletionContributor.BunchKeywordRegister                          COPY
+OBJECT_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     <v103>: {<: [ERROR : Type annotation was missing for parameter <no name provided>]}   NEW: r(OBJECT_KEYWORD) -> <v103>
+unresolvedCode                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     <v104>: Double                                                                        NEW: magic[UNRESOLVED_CALL](unresolvedCode) -> <v104>
+add(OBJECT_KEYWORD, unresolvedCode)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <v105>: JetKeywordCompletionContributor.BunchKeywordRegister                          NEW: call(add(OBJECT_KEYWORD, unresolvedCode), add|<v102>, <v103>, <v104>) -> <v105>
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel) .add(OVERRIDE_KEYWORD, inTopLevel) .add(IN_KEYWORD, inTopLevel, inTopLevel) .add(OUT_KEYWORD, inTopLevel) .add(OBJECT_KEYWORD, unresolvedCode)                                           <v105>: JetKeywordCompletionContributor.BunchKeywordRegister                          COPY
+registerAll()                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <v106>: *                                                                             NEW: call(registerAll(), registerAll|<v105>) -> <v106>
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel) .add(OVERRIDE_KEYWORD, inTopLevel) .add(IN_KEYWORD, inTopLevel, inTopLevel) .add(OUT_KEYWORD, inTopLevel) .add(OBJECT_KEYWORD, unresolvedCode) .registerAll()                            <v106>: *                                                                             COPY
+{ val inTopLevel = 1.0 BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel) .add(OVERRIDE_KEYWORD, inTopLevel) .add(IN_KEYWORD, inTopLevel, inTopLevel) .add(OUT_KEYWORD, inTopLevel) .add(OBJECT_KEYWORD, unresolvedCode) .registerAll() }   <v106>: *                                                                             COPY
 =====================
 == ABSTRACT_KEYWORD ==
 val ABSTRACT_KEYWORD = JetToken()
@@ -0,0 +1,12 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
+
+fun test(a<!SYNTAX!><!>) {
+
+}
+
+class A(a<!SYNTAX!><!>)
+
+val bar = fun test(a<!SYNTAX!><!>){}
+
+val la = { (<!CANNOT_INFER_PARAMETER_TYPE!>a<!>) -> }
+val las = { (a: Int) -> }
@@ -0,0 +1,13 @@
+package
+
+internal val bar: (???) -> kotlin.Unit
+internal val la: (???) -> kotlin.Unit
+internal val las: (kotlin.Int) -> kotlin.Unit
+internal fun test(/*0*/ a: [ERROR : Type annotation was missing for parameter a]): kotlin.Unit
+
+internal final class A {
+    public constructor A(/*0*/ a: [ERROR : Type annotation was missing for parameter a])
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
@@ -0,0 +1,9 @@
+annotation class ann
+
+fun test([ann] <!UNUSED_PARAMETER!>p<!>: Int) {
+
+}
+
+val bar = fun test([ann] <!UNUSED_PARAMETER!>g<!>: Int) {}
+
+val bas = { ([ann] t: Int) -> }
@@ -0,0 +1,12 @@
+package
+
+internal val bar: (kotlin.Int) -> kotlin.Unit
+internal val bas: (kotlin.Int) -> kotlin.Unit
+internal fun test(/*0*/ ann() p: kotlin.Int): kotlin.Unit
+
+internal final annotation class ann : kotlin.Annotation {
+    public constructor ann()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
@@ -38,7 +38,7 @@ internal final class C1</*0*/ in <no name provided>> {
 }

 internal final class C2 {
-    public constructor C2(/*0*/ <no name provided>: [ERROR : Type annotation was missing])
+    public constructor C2(/*0*/ <no name provided>: [ERROR : Type annotation was missing for parameter <no name provided>])
    internal final val <no name provided>: [ERROR : Annotation is absent]
    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
@@ -288,6 +288,12 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
            doTest(fileName);
        }

+        @TestMetadata("FunctionParameterWithoutType.kt")
+        public void testFunctionParameterWithoutType() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/FunctionParameterWithoutType.kt");
+            doTest(fileName);
+        }
+
        @TestMetadata("FunctionReturnTypes.kt")
        public void testFunctionReturnTypes() throws Exception {
            String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/FunctionReturnTypes.kt");
@@ -791,6 +797,12 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
                doTest(fileName);
            }

+            @TestMetadata("onFunctionParameter.kt")
+            public void testOnFunctionParameter() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/onFunctionParameter.kt");
+                doTest(fileName);
+            }
+
            @TestMetadata("onInitializer.kt")
            public void testOnInitializer() throws Exception {
                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/onInitializer.kt");
@@ -43,7 +43,7 @@ import org.jetbrains.kotlin.utils.UtilsPackage;
 import java.util.*;

 import static org.jetbrains.kotlin.resolve.DescriptorUtils.isDefaultObject;
-import static org.jetbrains.kotlin.types.TypeUtils.CANT_INFER_LAMBDA_PARAM_TYPE;
+import static org.jetbrains.kotlin.types.TypeUtils.CANT_INFER_FUNCTION_PARAM_TYPE;

 public class DescriptorRendererImpl implements DescriptorRenderer {

@@ -350,7 +350,7 @@ public class DescriptorRendererImpl implements DescriptorRenderer {
    private String renderInflexibleType(@NotNull JetType type) {
        assert !TypesPackage.isFlexible(type) : "Flexible types not allowed here: " + renderNormalizedType(type);

-        if (type == CANT_INFER_LAMBDA_PARAM_TYPE || TypeUtils.isDontCarePlaceholder(type)) {
+        if (type == CANT_INFER_FUNCTION_PARAM_TYPE || TypeUtils.isDontCarePlaceholder(type)) {
            return "???";
        }
        if (ErrorUtils.isUninferredParameter(type)) {
@@ -43,7 +43,7 @@ public class TypeUtils {
    public static final JetType DONT_CARE = ErrorUtils.createErrorTypeWithCustomDebugName("DONT_CARE");
    public static final JetType PLACEHOLDER_FUNCTION_TYPE = ErrorUtils.createErrorTypeWithCustomDebugName("PLACEHOLDER_FUNCTION_TYPE");

-    public static final JetType CANT_INFER_LAMBDA_PARAM_TYPE = ErrorUtils.createErrorType("Cannot be inferred");
+    public static final JetType CANT_INFER_FUNCTION_PARAM_TYPE = ErrorUtils.createErrorType("Cannot be inferred");

    public static class SpecialType implements JetType {
        private final String name;
@@ -1,6 +1,6 @@
 // IS_APPLICABLE: false
-// ERROR: Cannot infer a type for this parameter. To specify it explicitly use the {(p : Type) -> ...} notation
-// ERROR: Cannot infer a type for this parameter. To specify it explicitly use the {(p : Type) -> ...} notation
+// ERROR: Cannot infer a type for this parameter. Please specify it explicitly.
+// ERROR: Cannot infer a type for this parameter. Please specify it explicitly.
 fun main() {
    val sum = { (x, <caret>y) -> x + y  // Type of x and y cannot be inferred, so intention can't be used
 }