Minor refactoring

- Get rid of IrClassImpl usages where IrClass is enough
- Use startOffsetOrUndefined / endOffsetOrUndefined

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ClassGenerator.kt

@@ -85,7 +85,7 @@ class ClassGenerator(declarationGenerator: DeclarationGenerator) : DeclarationGe
         }
     }
 
-    private fun generateMembersDeclaredInSupertypeList(irClass: IrClassImpl, ktClassOrObject: KtClassOrObject) {
+    private fun generateMembersDeclaredInSupertypeList(irClass: IrClass, ktClassOrObject: KtClassOrObject) {
         ktClassOrObject.getSuperTypeList()?.let { ktSuperTypeList ->
             val delegatedMembers = irClass.descriptor.unsubstitutedMemberScope
                     .getContributedDescriptors(DescriptorKindFilter.CALLABLES)
@@ -102,8 +102,11 @@ class ClassGenerator(declarationGenerator: DeclarationGenerator) : DeclarationGe
         }
     }
 
-    private fun generateDelegatedImplementationMembers(irClass: IrClassImpl, ktEntry: KtDelegatedSuperTypeEntry,
-                                                       delegatedMembers: List<CallableMemberDescriptor>) {
+    private fun generateDelegatedImplementationMembers(
+            irClass: IrClass,
+            ktEntry: KtDelegatedSuperTypeEntry,
+            delegatedMembers: List<CallableMemberDescriptor>
+    ) {
         val ktDelegateExpression = ktEntry.delegateExpression!!
         val delegateType = getInferredTypeWithImplicitCastsOrFail(ktDelegateExpression)
         val superType = getOrFail(BindingContext.TYPE, ktEntry.typeReference!!)
@@ -194,15 +197,15 @@ class ClassGenerator(declarationGenerator: DeclarationGenerator) : DeclarationGe
         return irBlockBody
     }
 
-    private fun generateAdditionalMembersForDataClass(irClass: IrClassImpl, ktClassOrObject: KtClassOrObject) {
+    private fun generateAdditionalMembersForDataClass(irClass: IrClass, ktClassOrObject: KtClassOrObject) {
         DataClassMembersGenerator(declarationGenerator).generate(ktClassOrObject, irClass)
     }
 
-    private fun generateAdditionalMembersForEnumClass(irClass: IrClassImpl) {
+    private fun generateAdditionalMembersForEnumClass(irClass: IrClass) {
         EnumClassMembersGenerator(context).generateSpecialMembers(irClass)
     }
 
-    private fun generatePrimaryConstructor(irClass: IrClassImpl, ktClassOrObject: KtClassOrObject) {
+    private fun generatePrimaryConstructor(irClass: IrClass, ktClassOrObject: KtClassOrObject) {
         val classDescriptor = irClass.descriptor
         if (DescriptorUtils.isAnnotationClass(classDescriptor)) return
 
@@ -213,22 +216,20 @@ class ClassGenerator(declarationGenerator: DeclarationGenerator) : DeclarationGe
         irClass.addMember(irPrimaryConstructor)
     }
 
-    private fun generatePropertiesDeclaredInPrimaryConstructor(irClass: IrClassImpl, ktClassOrObject: KtClassOrObject) {
+    private fun generatePropertiesDeclaredInPrimaryConstructor(irClass: IrClass, ktClassOrObject: KtClassOrObject) {
         ktClassOrObject.primaryConstructor?.let { ktPrimaryConstructor ->
             for (ktParameter in ktPrimaryConstructor.valueParameters) {
                 if (ktParameter.hasValOrVar()) {
-                    val irProperty = PropertyGenerator(declarationGenerator).generatePropertyForPrimaryConstructorParameter(ktParameter)
-                    irClass.addMember(irProperty)
+                    irClass.addMember(PropertyGenerator(declarationGenerator).generatePropertyForPrimaryConstructorParameter(ktParameter))
                 }
             }
         }
     }
 
-    private fun generateMembersDeclaredInClassBody(irClass: IrClassImpl, ktClassOrObject: KtClassOrObject) {
+    private fun generateMembersDeclaredInClassBody(irClass: IrClass, ktClassOrObject: KtClassOrObject) {
         ktClassOrObject.getBody()?.let { ktClassBody ->
-            for (ktDeclaration in ktClassBody.declarations) {
-                val irMember = declarationGenerator.generateClassMemberDeclaration(ktDeclaration, irClass.descriptor)
-                irClass.addMember(irMember)
+            ktClassBody.declarations.mapTo(irClass.declarations) { ktDeclaration ->
+                declarationGenerator.generateClassMemberDeclaration(ktDeclaration, irClass.descriptor)
             }
         }
     }

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/DataClassMembersGenerator.kt

@@ -19,20 +19,18 @@ package org.jetbrains.kotlin.psi2ir.generators
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.backend.common.DataClassMethodGenerator
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
 import org.jetbrains.kotlin.ir.builders.*
 import org.jetbrains.kotlin.ir.declarations.IrClass
 import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
 import org.jetbrains.kotlin.ir.declarations.IrFunction
-import org.jetbrains.kotlin.ir.declarations.impl.IrClassImpl
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.mapValueParameters
 import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.KtParameter
-import org.jetbrains.kotlin.psi.psiUtil.endOffset
-import org.jetbrains.kotlin.psi.psiUtil.startOffset
 import org.jetbrains.kotlin.psi2ir.containsNull
+import org.jetbrains.kotlin.psi2ir.endOffsetOrUndefined
 import org.jetbrains.kotlin.psi2ir.findFirstFunction
+import org.jetbrains.kotlin.psi2ir.startOffsetOrUndefined
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.types.KotlinType
@@ -57,7 +55,7 @@ class DataClassMembersGenerator(
         ) {
             IrMemberFunctionBuilder(
                     context, irClass, function, IrDeclarationOrigin.GENERATED_DATA_CLASS_MEMBER,
-                    psiElement?.startOffset ?: UNDEFINED_OFFSET, psiElement?.endOffset ?: UNDEFINED_OFFSET
+                    psiElement.startOffsetOrUndefined, psiElement.endOffsetOrUndefined
             ).addToClass { irFunction ->
                 FunctionGenerator(declarationGenerator).generateSyntheticFunctionParameterDeclarations(irFunction)
                 body(irFunction)

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/DeclarationGenerator.kt

@@ -30,6 +30,8 @@ import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.endOffset
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
+import org.jetbrains.kotlin.psi2ir.endOffsetOrUndefined
+import org.jetbrains.kotlin.psi2ir.startOffsetOrUndefined
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 
@@ -86,8 +88,8 @@ class DeclarationGenerator(override val context: GeneratorContext) : Generator {
     ) {
         from.mapTo(irTypeParametersOwner.typeParameters) { typeParameterDescriptor ->
             val ktTypeParameterDeclaration = DescriptorToSourceUtils.getSourceFromDescriptor(typeParameterDescriptor)
-            val startOffset = ktTypeParameterDeclaration?.startOffset ?: UNDEFINED_OFFSET
-            val endOffset = ktTypeParameterDeclaration?.endOffset ?: UNDEFINED_OFFSET
+            val startOffset = ktTypeParameterDeclaration.startOffsetOrUndefined
+            val endOffset = ktTypeParameterDeclaration.endOffsetOrUndefined
             IrTypeParameterImpl(startOffset, endOffset, IrDeclarationOrigin.DEFINED, typeParameterDescriptor)
         }
     }

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/EnumClassMembersGenerator.kt

@@ -17,21 +17,21 @@
 package org.jetbrains.kotlin.psi2ir.generators
 
 import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
-import org.jetbrains.kotlin.ir.declarations.impl.IrClassImpl
+import org.jetbrains.kotlin.ir.declarations.IrClass
 import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
 import org.jetbrains.kotlin.ir.declarations.addMember
 import org.jetbrains.kotlin.ir.declarations.impl.IrFunctionImpl
-import org.jetbrains.kotlin.ir.expressions.impl.IrSyntheticBodyImpl
 import org.jetbrains.kotlin.ir.expressions.IrSyntheticBodyKind
+import org.jetbrains.kotlin.ir.expressions.impl.IrSyntheticBodyImpl
 import org.jetbrains.kotlin.psi2ir.findFirstFunction
 
 class EnumClassMembersGenerator(override val context: GeneratorContext) : Generator {
-    fun generateSpecialMembers(irClass: IrClassImpl) {
+    fun generateSpecialMembers(irClass: IrClass) {
         generateValues(irClass)
         generateValueOf(irClass)
     }
 
-    private fun generateValues(irClass: IrClassImpl) {
+    private fun generateValues(irClass: IrClass) {
         val valuesFunction = irClass.descriptor.staticScope.findFirstFunction("values") {
             it.dispatchReceiverParameter == null &&
             it.extensionReceiverParameter == null &&
@@ -46,7 +46,7 @@ class EnumClassMembersGenerator(override val context: GeneratorContext) : Genera
         )
     }
 
-    private fun generateValueOf(irClass: IrClassImpl) {
+    private fun generateValueOf(irClass: IrClass) {
         val valueOfFunction = irClass.descriptor.staticScope.findFirstFunction("valueOf") {
             it.dispatchReceiverParameter == null &&
             it.extensionReceiverParameter == null &&

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/Generator.kt

@@ -27,6 +27,8 @@ import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.psi.psiUtil.endOffset
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
+import org.jetbrains.kotlin.psi2ir.endOffsetOrUndefined
+import org.jetbrains.kotlin.psi2ir.startOffsetOrUndefined
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.types.KotlinType
@@ -68,11 +70,7 @@ inline fun GeneratorWithScope.irBlock(ktElement: KtElement?,
                                       origin: IrStatementOrigin? = null, resultType: KotlinType? = null,
                                       body: IrBlockBuilder.() -> Unit
 ): IrExpression =
-        this.irBlock(ktElement?.startOffset ?: UNDEFINED_OFFSET,
-                     ktElement?.endOffset ?: UNDEFINED_OFFSET,
-                     origin, resultType, body)
+        this.irBlock(ktElement.startOffsetOrUndefined, ktElement.endOffsetOrUndefined, origin, resultType, body)
 
 inline fun GeneratorWithScope.irBlockBody(ktElement: KtElement?, body: IrBlockBodyBuilder.() -> Unit) : IrBlockBody =
-        this.irBlockBody(ktElement?.startOffset ?: UNDEFINED_OFFSET,
-                         ktElement?.endOffset ?: UNDEFINED_OFFSET,
-                         body)
+        this.irBlockBody(ktElement.startOffsetOrUndefined, ktElement.endOffsetOrUndefined, body)

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/intermediate/ArrayAccessAssignmentReceiver.kt

@@ -33,8 +33,8 @@ class ArrayAccessAssignmentReceiver(
         val endOffset: Int,
         val origin: IrStatementOrigin
 ) : AssignmentReceiver {
-    private val type: KotlinType = indexedGetCall?.let { it.descriptor.returnType!! } ?:
-                                   indexedSetCall?.let { it.descriptor.valueParameters.last().type } ?:
+    private val type: KotlinType = indexedGetCall?.run { descriptor.returnType!! } ?:
+                                   indexedSetCall?.run { descriptor.valueParameters.last().type } ?:
                                    throw AssertionError("Array access should have either indexed-get call or indexed-set call")
 
     override fun assign(withLValue: (LValue) -> IrExpression): IrExpression {

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/IrMemberFunctionBuilder.kt

@@ -20,7 +20,6 @@ import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
 import org.jetbrains.kotlin.ir.declarations.IrClass
-import org.jetbrains.kotlin.ir.declarations.impl.IrClassImpl
 import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
 import org.jetbrains.kotlin.ir.declarations.IrFunction
 import org.jetbrains.kotlin.ir.declarations.impl.IrFunctionImpl