Use source offset ranges instead of source locations.

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/IrDeclarationGenerator.kt

@@ -25,6 +25,8 @@ import org.jetbrains.kotlin.ir.expressions.IrExpressionBodyImpl
 import org.jetbrains.kotlin.ir.expressions.IrReturnExpressionImpl
 import org.jetbrains.kotlin.ir.expressions.returnedExpression
 import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.psi.psiUtil.endOffset
+import org.jetbrains.kotlin.psi.psiUtil.startOffset
 import org.jetbrains.kotlin.resolve.BindingContext
 
 interface IrDeclarationGenerator : IrGenerator {
@@ -92,16 +94,18 @@ abstract class IrDeclarationGeneratorBase(
     }
 
     fun generateExpressionBody(ktBody: KtExpression): IrBody {
-        val sourceLocation = fileElementFactory.getLocationInFile(ktBody)
         val irExpression = irExpressionGenerator.generateExpression(ktBody)
 
+        val startOffset = ktBody.startOffset
+        val endOffset = ktBody.endOffset
+
         val bodyExpression =
                 if (ktBody is KtBlockExpression)
                     irExpression
                 else
-                    IrReturnExpressionImpl(sourceLocation, irExpression.type)
+                    IrReturnExpressionImpl(startOffset, endOffset, irExpression.type)
                             .apply { returnedExpression = irExpression }
 
-        return IrExpressionBodyImpl(sourceLocation, containingDeclaration).apply { childExpression = bodyExpression }
+        return IrExpressionBodyImpl(startOffset, endOffset, containingDeclaration).apply { childExpression = bodyExpression }
     }
 }

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/IrExpressionGenerator.kt

@@ -18,6 +18,8 @@ package org.jetbrains.kotlin.psi2ir
 
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.psi.psiUtil.endOffset
+import org.jetbrains.kotlin.psi.psiUtil.startOffset
 import org.jetbrains.kotlin.resolve.constants.IntValue
 import org.jetbrains.kotlin.resolve.constants.StringValue
 import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator
@@ -26,24 +28,23 @@ class IrExpressionGenerator(
         override val context: IrGeneratorContext,
         val fileElementFactory: IrFileElementFactory
 ) : KtVisitor<IrExpressionBase, Nothing?>(), IrGenerator {
-    fun generateExpression(ktExpression: KtExpression) = ktExpression.irExpr()
+    fun generateExpression(ktExpression: KtExpression) = ktExpression.generate()
 
-    private fun KtElement.irExpr(): IrExpressionBase = accept(this@IrExpressionGenerator, null)
+    private fun KtElement.generate(): IrExpressionBase = accept(this@IrExpressionGenerator, null)
-    private fun KtElement.loc() = this@IrExpressionGenerator.fileElementFactory.getLocationInFile(this)
     private fun KtExpression.type() = getType(this) ?: TODO("no type for expression")
 
     override fun visitExpression(expression: KtExpression, data: Nothing?): IrExpressionBase =
-            IrDummyExpression(expression.loc(), expression.type())
+            IrDummyExpression(expression.startOffset, expression.endOffset, expression.type())
 
     override fun visitBlockExpression(expression: KtBlockExpression, data: Nothing?): IrExpressionBase {
-        val irBlock = IrBlockExpressionImpl(expression.loc(), expression.type())
+        val irBlock = IrBlockExpressionImpl(expression.startOffset, expression.endOffset, expression.type())
-        expression.statements.forEach { irBlock.childExpressions.add(it.irExpr()) }
+        expression.statements.forEach { irBlock.childExpressions.add(it.generate()) }
         return irBlock
     }
 
     override fun visitReturnExpression(expression: KtReturnExpression, data: Nothing?): IrExpressionBase =
-            IrReturnExpressionImpl(expression.loc(), expression.type())
+            IrReturnExpressionImpl(expression.startOffset, expression.endOffset, expression.type())
-                    .apply { this.childExpression = expression.returnedExpression?.irExpr() }
+                    .apply { this.childExpression = expression.returnedExpression?.generate() }
 
     override fun visitConstantExpression(expression: KtConstantExpression, data: Nothing?): IrExpressionBase {
         val compileTimeConstant = ConstantExpressionEvaluator.getConstant(expression, context.bindingContext)
@@ -53,9 +54,9 @@ class IrExpressionGenerator(
 
         return when (constantValue) {
             is StringValue ->
-                IrLiteralExpressionImpl.string(expression.loc(), constantType, constantValue.value)
+                IrLiteralExpressionImpl.string(expression.startOffset, expression.endOffset, constantType, constantValue.value)
             is IntValue ->
-                IrLiteralExpressionImpl.int(expression.loc(), constantType, constantValue.value)
+                IrLiteralExpressionImpl.int(expression.startOffset, expression.endOffset, constantType, constantValue.value)
             else ->
                 TODO("handle other literal types: ${constantValue.type}")
         }
@@ -63,14 +64,14 @@ class IrExpressionGenerator(
 
     override fun visitStringTemplateExpression(expression: KtStringTemplateExpression, data: Nothing?): IrExpressionBase {
         if (expression.entries.size == 1 && expression.entries[0] is KtLiteralStringTemplateEntry) {
-            return expression.entries[0].irExpr()
+            return expression.entries[0].generate()
         }
 
-        val irStringTemplate = IrStringConcatenationExpressionImpl(expression.loc(), expression.type())
+        val irStringTemplate = IrStringConcatenationExpressionImpl(expression.startOffset, expression.endOffset, expression.type())
-        expression.entries.forEach { irStringTemplate.addChildExpression(it.irExpr()) }
+        expression.entries.forEach { irStringTemplate.addChildExpression(it.generate()) }
         return irStringTemplate
     }
 
     override fun visitLiteralStringTemplateEntry(entry: KtLiteralStringTemplateEntry, data: Nothing?): IrExpressionBase =
-            IrLiteralExpressionImpl.string(entry.loc(), context.builtIns.stringType, entry.text)
+            IrLiteralExpressionImpl.string(entry.startOffset, entry.endOffset, context.builtIns.stringType, entry.text)
 }

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/IrFileElementFactory.kt

@@ -20,6 +20,8 @@ import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.expressions.IrBody
 import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.psi.psiUtil.endOffset
+import org.jetbrains.kotlin.psi.psiUtil.startOffset
 
 class IrFileElementFactory private constructor(
         val fileEntry: PsiSourceManager.PsiFileEntry,
@@ -29,23 +31,17 @@ class IrFileElementFactory private constructor(
     fun createChild(containingDeclaration: IrCompoundDeclaration) =
             IrFileElementFactory(fileEntry, irFileImpl, containingDeclaration)
 
-    fun getRootLocationInFile() =
-            fileEntry.getRootSourceLocation()
-
-    fun getLocationInFile(ktElement: KtElement) =
-            fileEntry.getSourceLocationForElement(ktElement)
-
     private fun <D : IrMemberDeclaration> D.addToContainer(): D =
-            apply {
+            apply { containingDeclaration.addChildDeclaration(this) }
-                this@IrFileElementFactory.containingDeclaration.addChildDeclaration(this)
-            }
 
     fun createFunction(ktFunction: KtFunction, functionDescriptor: FunctionDescriptor, body: IrBody): IrFunction =
-            IrFunctionImpl(getLocationInFile(ktFunction), IrDeclarationOriginKind.DEFINED, functionDescriptor, body)
+            IrFunctionImpl(ktFunction.startOffset, ktFunction.endOffset,
+                           IrDeclarationOriginKind.DEFINED, functionDescriptor, body)
                     .addToContainer()
 
     fun createSimpleProperty(ktProperty: KtProperty, propertyDescriptor: PropertyDescriptor, valueInitializer: IrBody?): IrSimpleProperty =
-            IrSimplePropertyImpl(getLocationInFile(ktProperty), IrDeclarationOriginKind.DEFINED, propertyDescriptor, valueInitializer)
+            IrSimplePropertyImpl(ktProperty.startOffset, ktProperty.endOffset,
+                                 IrDeclarationOriginKind.DEFINED, propertyDescriptor, valueInitializer)
                     .addToContainer()
 
     fun createPropertyGetter(
@@ -54,7 +50,8 @@ class IrFileElementFactory private constructor(
             getterDescriptor: PropertyGetterDescriptor,
             getterBody: IrBody
     ): IrPropertyGetter =
-            IrPropertyGetterImpl(getLocationInFile(ktPropertyAccessor), IrDeclarationOriginKind.DEFINED, getterDescriptor, getterBody)
+            IrPropertyGetterImpl(ktPropertyAccessor.startOffset, ktPropertyAccessor.endOffset,
+                                 IrDeclarationOriginKind.DEFINED, getterDescriptor, getterBody)
                     .apply { irProperty.getter = this }
                     .addToContainer()
 
@@ -64,16 +61,17 @@ class IrFileElementFactory private constructor(
             setterDescriptor: PropertySetterDescriptor,
             setterBody: IrBody
     ) : IrPropertySetter =
-            IrPropertySetterImpl(getLocationInFile(ktPropertyAccessor), IrDeclarationOriginKind.DEFINED, setterDescriptor, setterBody)
+            IrPropertySetterImpl(ktPropertyAccessor.startOffset, ktPropertyAccessor.endOffset,
+                                 IrDeclarationOriginKind.DEFINED, setterDescriptor, setterBody)
                     .apply { irProperty.setter = this }
                     .addToContainer()
 
     companion object {
         fun create(irModule: IrModuleImpl, sourceManager: PsiSourceManager, ktFile: KtFile, descriptor: PackageFragmentDescriptor): IrFileElementFactory {
             val fileEntry = sourceManager.getOrCreateFileEntry(ktFile)
-            val fileSourceLocation = fileEntry.getRootSourceLocation()
             val fileName = fileEntry.getRecognizableName()
-            val irFile = IrFileImpl(fileSourceLocation, fileName, descriptor)
+            val irFile = IrFileImpl(fileEntry, fileName, descriptor)
+            sourceManager.putFileEntry(irFile, fileEntry)
             irModule.addFile(irFile)
             return IrFileElementFactory(fileEntry, irFile, irFile)
         }

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/PsiSourceManager.kt

@@ -16,52 +16,63 @@
 
 package org.jetbrains.kotlin.psi2ir
 
-import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiFile
-import org.jetbrains.kotlin.ir.SourceLocation
 import org.jetbrains.kotlin.ir.SourceLocationManager
-import org.jetbrains.kotlin.ir.fileIndex
+import org.jetbrains.kotlin.ir.SourceRangeInfo
-import org.jetbrains.kotlin.ir.fileOffset
+import org.jetbrains.kotlin.ir.declarations.IrFile
 import java.util.*
 
 class PsiSourceManager : SourceLocationManager {
-    class PsiFileEntry (val index: Int, val file: PsiFile) : SourceLocationManager.FileEntry {
+    class PsiFileEntry(val psiFile: PsiFile) : SourceLocationManager.FileEntry {
-        private val document = file.viewProvider.document
+        private val document = psiFile.viewProvider.document
 
-        override fun getLineNumber(sourceLocation: SourceLocation): Int =
+        override val maxOffset: Int
-                document?.getLineNumber(sourceLocation.fileOffset) ?: -1
+            get() = document?.textLength ?: Int.MAX_VALUE
 
-        override fun getColumnNumber(sourceLocation: SourceLocation): Int =
+        override fun getLineNumber(offset: Int): Int =
-                document?.getLineStartOffset(sourceLocation.fileOffset) ?: -1
+                document?.getLineNumber(offset) ?: -1
 
-        fun getRootSourceLocation(): SourceLocation =
+        override fun getColumnNumber(offset: Int): Int {
-                SourceLocation(index, 0)
+            val startOffset = document?.getLineStartOffset(offset) ?: return -1
+            return offset - startOffset
+        }
 
-        fun getSourceLocationForElement(element: PsiElement): SourceLocation =
+        override fun getSourceRangeInfo(beginOffset: Int, endOffset: Int): SourceRangeInfo =
-                SourceLocation(index, element.textOffset)
+                SourceRangeInfo(
+                        filePath = getRecognizableName(),
+                        startOffset = beginOffset,
+                        startLineNumber = getLineNumber(beginOffset),
+                        startColumnNumber = getColumnNumber(beginOffset),
+                        endOffset = endOffset,
+                        endLineNumber = getLineNumber(endOffset),
+                        endColumnNumber = getColumnNumber(endOffset)
+                )
 
-        fun getRecognizableName(): String = file.virtualFile?.path ?: file.name
+        fun getRecognizableName(): String = psiFile.virtualFile?.path ?: psiFile.name
 
-        override fun toString(): String = "#$index: ${getRecognizableName()}"
+        override fun toString(): String = "${getRecognizableName()}"
     }
 
-    private val fileEntries = ArrayList<PsiFileEntry>()
     private val fileEntriesByPsiFile = HashMap<PsiFile, PsiFileEntry>()
-
+    private val fileEntriesByIrFile = HashMap<IrFile, PsiFileEntry>()
-    override fun getFileEntry(sourceLocation: Long): PsiFileEntry? =
-            fileEntries.getOrNull(sourceLocation.fileIndex)
 
     fun createFileEntry(psiFile: PsiFile): PsiFileEntry {
         if (psiFile in fileEntriesByPsiFile) error("PsiFileEntry is already created for $psiFile")
-
+        val newEntry = PsiFileEntry(psiFile)
-        val newEntry = PsiFileEntry(fileEntries.size, psiFile)
-        fileEntries.add(newEntry)
         fileEntriesByPsiFile[psiFile] = newEntry
         return newEntry
     }
 
+    fun putFileEntry(irFile: IrFile, fileEntry: PsiFileEntry) {
+        fileEntriesByIrFile[irFile] = fileEntry
+    }
+
     fun getOrCreateFileEntry(psiFile: PsiFile): PsiFileEntry =
             fileEntriesByPsiFile.getOrElse(psiFile) { createFileEntry(psiFile) }
 
-    fun getFileEntry(psiFile: PsiFile): PsiFileEntry? = fileEntriesByPsiFile[psiFile]
+    fun getFileEntry(psiFile: PsiFile): PsiFileEntry? =
+            fileEntriesByPsiFile[psiFile]
+
+    override fun getFileEntry(irFile: IrFile): SourceLocationManager.FileEntry =
+            fileEntriesByIrFile[irFile]!!
 }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/IrElement.kt

@@ -19,11 +19,12 @@ package org.jetbrains.kotlin.ir
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
 interface IrElement {
-    val sourceLocation: SourceLocation
+    val startOffset: Int
+    val endOffset: Int
     val parent: IrElement?
 
     fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R
     fun <D> acceptChildren(visitor: IrElementVisitor<Unit, D>, data: D): Unit
 }
 
-abstract class IrElementBase(override val sourceLocation: SourceLocation) : IrElement
+abstract class IrElementBase(override val startOffset: Int, override val endOffset: Int) : IrElement

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/SourceLocation.kt

@@ -1,32 +0,0 @@
-/*
- * Copyright 2010-2016 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.ir
-
-typealias SourceLocation = Long
-
-fun SourceLocation(index: Int, offset: Int) =
-        (index.toLong() shl 32) + offset.toLong()
-
-const val NO_LOCATION: SourceLocation = Long.MIN_VALUE
-const val UNDEFINED_INDEX: Int = -1
-const val UNDEFINED_OFFSET: Int = -1
-
-val SourceLocation.fileIndex: Int
-    get() = if (this == NO_LOCATION) UNDEFINED_INDEX else (this ushr 32).toInt()
-
-val SourceLocation.fileOffset: Int
-    get() = if (this == NO_LOCATION) UNDEFINED_OFFSET else (this and 0xFFFFFFFFL).toInt()

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/SourceLocationManager.kt

@@ -16,11 +16,27 @@
 
 package org.jetbrains.kotlin.ir
 
+import org.jetbrains.kotlin.ir.declarations.IrFile
+
+const val UNDEFINED_OFFSET: Int = -1
+
+data class SourceRangeInfo(
+        val filePath: String,
+        val startOffset: Int,
+        val startLineNumber: Int,
+        val startColumnNumber: Int,
+        val endOffset: Int,
+        val endLineNumber: Int,
+        val endColumnNumber: Int
+)
+
 interface SourceLocationManager {
     interface FileEntry {
-        fun getLineNumber(sourceLocation: SourceLocation): Int
+        val maxOffset: Int
-        fun getColumnNumber(sourceLocation: SourceLocation): Int
+        fun getSourceRangeInfo(beginOffset: Int, endOffset: Int): SourceRangeInfo
+        fun getLineNumber(offset: Int): Int
+        fun getColumnNumber(offset: Int): Int
     }
 
-    fun getFileEntry(sourceLocation: SourceLocation): FileEntry?
+    fun getFileEntry(irFile: IrFile): FileEntry?
 }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrClass.kt

@@ -17,7 +17,6 @@
 package org.jetbrains.kotlin.ir.declarations
 
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import org.jetbrains.kotlin.ir.SourceLocation
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
 interface IrClass : IrCompoundDeclaration, IrMemberDeclaration {
@@ -28,10 +27,11 @@ interface IrClass : IrCompoundDeclaration, IrMemberDeclaration {
 }
 
 class IrClassImpl(
-        sourceLocation: SourceLocation,
+        startOffset: Int,
+        endOffset: Int,
         originKind: IrDeclarationOriginKind,
         override val descriptor: ClassDescriptor
-) : IrCompoundMemberDeclarationBase(sourceLocation, originKind), IrClass {
+) : IrCompoundMemberDeclarationBase(startOffset, endOffset, originKind), IrClass {
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
             visitor.visitClass(this, data)
 }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrCompoundDeclaration.kt

@@ -18,7 +18,6 @@ package org.jetbrains.kotlin.ir.declarations
 
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.IrElementBase
-import org.jetbrains.kotlin.ir.SourceLocation
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 import java.util.*
 
@@ -44,8 +43,9 @@ interface IrMemberDeclaration : IrDeclaration {
 }
 
 abstract class IrDeclarationOwnerBase(
-        sourceLocation: SourceLocation
+        startOffset: Int,
-) : IrElementBase(sourceLocation), IrDeclarationOwner {
+        endOffset: Int
+) : IrElementBase(startOffset, endOffset), IrDeclarationOwner {
     protected val childDeclarations: MutableList<IrMemberDeclaration> = ArrayList()
 
     override val childrenCount: Int
@@ -87,9 +87,10 @@ abstract class IrDeclarationOwnerBase(
 
 // TODO synchronization?
 abstract class IrCompoundDeclarationBase(
-        sourceLocation: SourceLocation,
+        startOffset: Int,
+        endOffset: Int,
         override val originKind: IrDeclarationOriginKind
-) : IrDeclarationOwnerBase(sourceLocation), IrCompoundDeclaration {
+) : IrDeclarationOwnerBase(startOffset, endOffset), IrCompoundDeclaration {
     override var indexInParent: Int = IrDeclaration.DETACHED_INDEX
 
     override fun <D> acceptChildren(visitor: IrElementVisitor<Unit, D>, data: D) {
@@ -98,9 +99,10 @@ abstract class IrCompoundDeclarationBase(
 }
 
 abstract class IrCompoundMemberDeclarationBase(
-        sourceLocation: SourceLocation,
+        startOffset: Int,
+        endOffset: Int,
         originKind: IrDeclarationOriginKind
-) : IrCompoundDeclarationBase(sourceLocation, originKind), IrMemberDeclaration {
+) : IrCompoundDeclarationBase(startOffset, endOffset, originKind), IrMemberDeclaration {
     private var parentImpl: IrDeclarationOwner? = null
 
     override var parent: IrDeclarationOwner
@@ -116,9 +118,10 @@ abstract class IrCompoundMemberDeclarationBase(
 }
 
 abstract class IrMemberDeclarationBase(
-        sourceLocation: SourceLocation,
+        startOffset: Int,
+        endOffset: Int,
         originKind: IrDeclarationOriginKind
-) : IrDeclarationBase(sourceLocation, originKind), IrMemberDeclaration {
+) : IrDeclarationBase(startOffset, endOffset, originKind), IrMemberDeclaration {
     private var parentImpl: IrDeclarationOwner? = null
 
     override var parent: IrDeclarationOwner

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrDeclaration.kt

@@ -19,7 +19,6 @@ package org.jetbrains.kotlin.ir.declarations
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.IrElementBase
-import org.jetbrains.kotlin.ir.SourceLocation
 
 interface IrDeclaration : IrElement {
     override val parent: IrDeclarationOwner?
@@ -51,8 +50,9 @@ enum class IrDeclarationOriginKind {
 }
 
 abstract class IrDeclarationBase(
-        sourceLocation: SourceLocation,
+        startOffset: Int,
+        endOffset: Int,
         override val originKind: IrDeclarationOriginKind
-) : IrElementBase(sourceLocation), IrDeclaration {
+) : IrElementBase(startOffset, endOffset), IrDeclaration {
     override var indexInParent: Int = IrDeclaration.DETACHED_INDEX
 }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrFile.kt

@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.ir.declarations
 
 import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
-import org.jetbrains.kotlin.ir.SourceLocation
+import org.jetbrains.kotlin.ir.SourceLocationManager
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
 interface IrFile : IrCompoundDeclaration {
@@ -32,10 +32,10 @@ interface IrFile : IrCompoundDeclaration {
 }
 
 class IrFileImpl(
-        sourceLocation: SourceLocation,
+        val fileEntry: SourceLocationManager.FileEntry,
         override val name: String,
         override val descriptor: PackageFragmentDescriptor
-) : IrCompoundDeclarationBase(sourceLocation, IrDeclarationOriginKind.DEFINED), IrFile {
+) : IrCompoundDeclarationBase(0, fileEntry.maxOffset, IrDeclarationOriginKind.DEFINED), IrFile {
     override lateinit var module: IrModule
 
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrFunction.kt

@@ -17,7 +17,6 @@
 package org.jetbrains.kotlin.ir.declarations
 
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
-import org.jetbrains.kotlin.ir.SourceLocation
 import org.jetbrains.kotlin.ir.expressions.IrBody
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
@@ -30,20 +29,22 @@ interface IrFunction : IrMemberDeclaration {
 }
 
 abstract class IrFunctionBase(
-        sourceLocation: SourceLocation,
+        startOffset: Int,
+        endOffset: Int,
         originKind: IrDeclarationOriginKind
-) : IrMemberDeclarationBase(sourceLocation, originKind), IrFunction {
+) : IrMemberDeclarationBase(startOffset, endOffset, originKind), IrFunction {
     override fun <D> acceptChildren(visitor: IrElementVisitor<Unit, D>, data: D) {
         body.accept(visitor, data)
     }
 }
 
 class IrFunctionImpl(
-        sourceLocation: SourceLocation,
+        startOffset: Int,
+        endOffset: Int,
         originKind: IrDeclarationOriginKind,
         override val descriptor: FunctionDescriptor,
         override val body: IrBody
-) : IrFunctionBase(sourceLocation, originKind) {
+) : IrFunctionBase(startOffset, endOffset, originKind) {
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
             visitor.visitFunction(this, data)
 }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrModule.kt

@@ -17,14 +17,16 @@
 package org.jetbrains.kotlin.ir.declarations
 
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-import org.jetbrains.kotlin.ir.IrElement
+import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
-import org.jetbrains.kotlin.ir.NO_LOCATION
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 import java.util.*
 
 interface IrModule : IrDeclaration {
     override val descriptor: ModuleDescriptor
 
+    override val startOffset: Int get() = UNDEFINED_OFFSET
+    override val endOffset: Int get() = UNDEFINED_OFFSET
+
     override val parent: Nothing? get() = null
     override val indexInParent: Int get() = MODULE_INDEX
 
@@ -41,8 +43,6 @@ interface IrModule : IrDeclaration {
 class IrModuleImpl(
         override val descriptor: ModuleDescriptor
 ) : IrModule {
-    override val sourceLocation: Long
-        get() = NO_LOCATION
 
     override val originKind: IrDeclarationOriginKind
         get() = IrDeclarationOriginKind.DEFINED

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrProperty.kt

@@ -17,7 +17,6 @@
 package org.jetbrains.kotlin.ir.declarations
 
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
-import org.jetbrains.kotlin.ir.SourceLocation
 import org.jetbrains.kotlin.ir.expressions.IrBody
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
@@ -42,10 +41,11 @@ interface IrDelegatedProperty : IrProperty {
 
 // TODO synchronization?
 abstract class IrPropertyBase(
-        sourceLocation: SourceLocation,
+        startOffset: Int,
+        endOffset: Int,
         originKind: IrDeclarationOriginKind,
         override val descriptor: PropertyDescriptor
-) : IrMemberDeclarationBase(sourceLocation, originKind), IrProperty {
+) : IrMemberDeclarationBase(startOffset, endOffset, originKind), IrProperty {
     override var getter: IrPropertyGetter? = null
         set(newGetter) {
             newGetter?.property = this
@@ -65,11 +65,12 @@ abstract class IrPropertyBase(
 }
 
 class IrSimplePropertyImpl(
-        sourceLocation: SourceLocation,
+        startOffset: Int,
+        endOffset: Int,
         originKind: IrDeclarationOriginKind,
         descriptor: PropertyDescriptor,
         override val valueInitializer: IrBody?
-) : IrPropertyBase(sourceLocation, originKind, descriptor), IrSimpleProperty {
+) : IrPropertyBase(startOffset, endOffset, originKind, descriptor), IrSimpleProperty {
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
             visitor.visitSimpleProperty(this, data)
 
@@ -79,11 +80,12 @@ class IrSimplePropertyImpl(
 }
 
 class IrDelegatedPropertyImpl(
-        sourceLocation: SourceLocation,
+        startOffset: Int,
+        endOffset: Int,
         originKind: IrDeclarationOriginKind,
         descriptor: PropertyDescriptor,
         override val delegateInitializer: IrBody
-) : IrPropertyBase(sourceLocation, originKind, descriptor), IrDelegatedProperty {
+) : IrPropertyBase(startOffset, endOffset, originKind, descriptor), IrDelegatedProperty {
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
             visitor.visitDelegatedProperty(this, data)
 

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrPropertyAccessor.kt

@@ -19,7 +19,6 @@ package org.jetbrains.kotlin.ir.declarations
 import org.jetbrains.kotlin.descriptors.PropertyAccessorDescriptor
 import org.jetbrains.kotlin.descriptors.PropertyGetterDescriptor
 import org.jetbrains.kotlin.descriptors.PropertySetterDescriptor
-import org.jetbrains.kotlin.ir.SourceLocation
 import org.jetbrains.kotlin.ir.expressions.IrBody
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
@@ -43,29 +42,32 @@ interface IrPropertySetter : IrPropertyAccessor {
 }
 
 abstract class IrPropertyAccessorBase(
-        sourceLocation: SourceLocation,
+        startOffset: Int,
+        endOffset: Int,
         originKind: IrDeclarationOriginKind,
         override val body: IrBody
-) : IrFunctionBase(sourceLocation, originKind), IrPropertyAccessor {
+) : IrFunctionBase(startOffset, endOffset, originKind), IrPropertyAccessor {
     override var property: IrProperty? = null
 }
 
 class IrPropertyGetterImpl(
-        sourceLocation: SourceLocation,
+        startOffset: Int,
+        endOffset: Int,
         originKind: IrDeclarationOriginKind,
         override val descriptor: PropertyGetterDescriptor,
         body: IrBody
-) : IrPropertyAccessorBase(sourceLocation, originKind, body), IrPropertyGetter {
+) : IrPropertyAccessorBase(startOffset, endOffset, originKind, body), IrPropertyGetter {
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
             visitor.visitPropertyGetter(this, data)
 }
 
 class IrPropertySetterImpl(
-        sourceLocation: SourceLocation,
+        startOffset: Int,
+        endOffset: Int,
         originKind: IrDeclarationOriginKind,
         override val descriptor: PropertySetterDescriptor,
         body: IrBody
-) : IrPropertyAccessorBase(sourceLocation, originKind, body), IrPropertySetter {
+) : IrPropertyAccessorBase(startOffset, endOffset, originKind, body), IrPropertySetter {
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
             visitor.visitPropertySetter(this, data)
 }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrBlockExpression.kt

@@ -16,7 +16,6 @@
 
 package org.jetbrains.kotlin.ir.expressions
 
-import org.jetbrains.kotlin.ir.SourceLocation
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 import org.jetbrains.kotlin.types.KotlinType
 
@@ -24,9 +23,10 @@ import org.jetbrains.kotlin.types.KotlinType
 interface IrBlockExpression : IrCompoundExpressionN
 
 class IrBlockExpressionImpl(
-        sourceLocation: SourceLocation,
+        startOffset: Int,
+        endOffset: Int,
         type: KotlinType
-) : IrCompoundExpressionNBase(sourceLocation, type), IrBlockExpression {
+) : IrCompoundExpressionNBase(startOffset, endOffset, type), IrBlockExpression {
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
             visitor.visitBlockExpression(this, data)
 

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrBody.kt

@@ -17,12 +17,9 @@
 package org.jetbrains.kotlin.ir.expressions
 
 import org.jetbrains.kotlin.ir.IrElement
-import org.jetbrains.kotlin.ir.IrElementBase
-import org.jetbrains.kotlin.ir.SourceLocation
 import org.jetbrains.kotlin.ir.declarations.IrDeclaration
 import org.jetbrains.kotlin.ir.declarations.IrDeclarationOwner
 import org.jetbrains.kotlin.ir.declarations.IrDeclarationOwnerBase
-import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
 interface IrBody : IrElement {
@@ -33,9 +30,10 @@ interface IrExpressionBody : IrBody, IrExpressionOwner1, IrDeclarationOwner
 
 // TODO IrExpressionBodyImpl vs IrCompoundExpression1Impl: extract common base class?
 class IrExpressionBodyImpl(
-        sourceLocation: SourceLocation,
+        startOffset: Int,
+        endOffset: Int,
         override val parent: IrDeclaration
-) : IrDeclarationOwnerBase(sourceLocation), IrExpressionBody {
+) : IrDeclarationOwnerBase(startOffset, endOffset), IrExpressionBody {
     override var childExpression: IrExpression? = null
         set(newExpression) {
             field?.detach()

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrCompoundExpression.kt

@@ -16,7 +16,6 @@
 
 package org.jetbrains.kotlin.ir.expressions
 
-import org.jetbrains.kotlin.ir.SourceLocation
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 import org.jetbrains.kotlin.types.KotlinType
 import java.util.*
@@ -28,9 +27,10 @@ interface IrCompoundExpression1 : IrCompoundExpression, IrExpressionOwner1
 interface IrCompoundExpressionN : IrCompoundExpression, IrExpressionOwnerN
 
 abstract class IrCompoundExpressionNBase(
-        sourceLocation: SourceLocation,
+        startOffset: Int,
+        endOffset: Int,
         override val type: KotlinType
-) : IrExpressionBase(sourceLocation, type), IrCompoundExpressionN {
+) : IrExpressionBase(startOffset, endOffset, type), IrCompoundExpressionN {
     override val childExpressions: MutableList<IrExpression> = ArrayList()
 
     override fun <D> acceptChildren(visitor: IrElementVisitor<Unit, D>, data: D) {
@@ -68,9 +68,10 @@ abstract class IrCompoundExpressionNBase(
 
 // TODO IrExpressionBodyImpl vs IrCompoundExpression1Impl: extract common base class?
 abstract class IrCompoundExpression1Base(
-        sourceLocation: SourceLocation,
+        startOffset: Int,
+        endOffset: Int,
         override val type: KotlinType
-) : IrExpressionBase(sourceLocation, type), IrCompoundExpression1 {
+) : IrExpressionBase(startOffset, endOffset, type), IrCompoundExpression1 {
     override var childExpression: IrExpression? = null
         set(newExpression) {
             field?.detach()

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrDummyExpression.kt

@@ -16,14 +16,14 @@
 
 package org.jetbrains.kotlin.ir.expressions
 
-import org.jetbrains.kotlin.ir.SourceLocation
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 import org.jetbrains.kotlin.types.KotlinType
 
 class IrDummyExpression(
-        sourceLocation: SourceLocation,
+        startOffset: Int,
+        endOffset: Int,
         type: KotlinType
-) : IrExpressionBase(sourceLocation, type) {
+) : IrExpressionBase(startOffset, endOffset, type) {
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
             visitor.visitElement(this, data)
 

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrExpression.kt

@@ -18,7 +18,6 @@ package org.jetbrains.kotlin.ir.expressions
 
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.IrElementBase
-import org.jetbrains.kotlin.ir.SourceLocation
 import org.jetbrains.kotlin.types.KotlinType
 
 
@@ -43,9 +42,10 @@ fun IrExpressionOwner.validateChild(child: IrExpression) {
 }
 
 abstract class IrExpressionBase(
-        sourceLocation: SourceLocation,
+        startOffset: Int,
+        endOffset: Int,
         override val type: KotlinType
-) : IrElementBase(sourceLocation), IrExpression {
+) : IrElementBase(startOffset, endOffset), IrExpression {
     override var parent: IrExpressionOwner? = null
     override var index: Int = IrExpression.DETACHED_INDEX
 

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrLiteralExpression.kt

@@ -16,8 +16,6 @@
 
 package org.jetbrains.kotlin.ir.expressions
 
-import org.jetbrains.kotlin.ir.IrElement
-import org.jetbrains.kotlin.ir.SourceLocation
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 import org.jetbrains.kotlin.types.KotlinType
 
@@ -45,11 +43,12 @@ sealed class IrLiteralKind<out T>(val asString: kotlin.String)  {
 }
 
 class IrLiteralExpressionImpl<out T> (
-        sourceLocation: SourceLocation,
+        startOffset: Int,
+        endOffset: Int,
         type: KotlinType,
         override val kind: IrLiteralKind<T>,
         override val value: T
-) : IrExpressionBase(sourceLocation, type), IrLiteralExpression<T> {
+) : IrExpressionBase(startOffset, endOffset, type), IrLiteralExpression<T> {
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
             visitor.visitLiteral(this, data)
 
@@ -58,11 +57,11 @@ class IrLiteralExpressionImpl<out T> (
     }
 
     companion object {
-        fun string(sourceLocation: SourceLocation, type: KotlinType, value: String): IrLiteralExpressionImpl<String> =
+        fun string(startOffset: Int, endOffset: Int, type: KotlinType, value: String): IrLiteralExpressionImpl<String> =
-                IrLiteralExpressionImpl(sourceLocation, type, IrLiteralKind.String, value)
+                IrLiteralExpressionImpl(startOffset, endOffset, type, IrLiteralKind.String, value)
 
-        fun int(sourceLocation: SourceLocation, type: KotlinType, value: Int): IrLiteralExpressionImpl<Int> =
+        fun int(startOffset: Int, endOffset: Int, type: KotlinType, value: Int): IrLiteralExpressionImpl<Int> =
-                IrLiteralExpressionImpl(sourceLocation, type, IrLiteralKind.Int, value)
+                IrLiteralExpressionImpl(startOffset, endOffset, type, IrLiteralKind.Int, value)
     }
 }
 

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrReturnExpression.kt

@@ -16,7 +16,6 @@
 
 package org.jetbrains.kotlin.ir.expressions
 
-import org.jetbrains.kotlin.ir.SourceLocation
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 import org.jetbrains.kotlin.types.KotlinType
 
@@ -30,9 +29,10 @@ var IrReturnExpression.returnedExpression: IrExpression?
     }
 
 class IrReturnExpressionImpl(
-        sourceLocation: SourceLocation,
+        startOffset: Int,
+        endOffset: Int,
         type: KotlinType
-) : IrCompoundExpression1Base(sourceLocation, type), IrReturnExpression {
+) : IrCompoundExpression1Base(startOffset, endOffset, type), IrReturnExpression {
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
             visitor.visitReturnExpression(this, data)
 }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrStringConcatenationExpression.kt

@@ -16,18 +16,16 @@
 
 package org.jetbrains.kotlin.ir.expressions
 
-import org.jetbrains.kotlin.ir.IrElement
-import org.jetbrains.kotlin.ir.SourceLocation
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 import org.jetbrains.kotlin.types.KotlinType
-import java.util.*
 
 interface IrStringConcatenationExpression : IrCompoundExpressionN
 
 class IrStringConcatenationExpressionImpl(
-        sourceLocation: SourceLocation,
+        startOffset: Int,
+        endOffset: Int,
         type: KotlinType
-) : IrCompoundExpressionNBase(sourceLocation, type), IrStringConcatenationExpression {
+) : IrCompoundExpressionNBase(startOffset, endOffset, type), IrStringConcatenationExpression {
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
             visitor.visitStringTemplate(this, data)
 }