[FIR] Add start offset and end offset to FirSourceElement

compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/converter/BaseConverter.kt

@@ -21,18 +21,19 @@ import org.jetbrains.kotlin.lexer.KtToken
 import org.jetbrains.kotlin.lexer.KtTokens.*
 import org.jetbrains.kotlin.name.Name
 import kotlin.contracts.ExperimentalContracts
-import kotlin.contracts.InvocationKind
-import kotlin.contracts.contract
 
 open class BaseConverter(
     baseSession: FirSession,
-    private val tree: FlyweightCapableTreeStructure<LighterASTNode>,
+    val tree: FlyweightCapableTreeStructure<LighterASTNode>,
+    val offset: Int,
     context: Context<LighterASTNode> = Context()
 ) : BaseFirBuilder<LighterASTNode>(baseSession, context) {
     protected val implicitType = buildImplicitTypeRef()
 
     override fun LighterASTNode.toFirSourceElement(): FirSourceElement {
-        return FirLightSourceElement(this, tree)
+        val startOffset = offset + tree.getStartOffset(this)
+        val endOffset = offset + tree.getEndOffset(this)
+        return FirLightSourceElement(this, startOffset, endOffset, tree)
     }
 
     override val LighterASTNode.elementType: IElementType

compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt

@@ -52,9 +52,10 @@ class DeclarationsConverter(
     private val baseScopeProvider: FirScopeProvider,
     private val stubMode: Boolean,
     tree: FlyweightCapableTreeStructure<LighterASTNode>,
+    offset: Int = 0,
     context: Context<LighterASTNode> = Context()
-) : BaseConverter(session, tree, context) {
-    private val expressionConverter = ExpressionsConverter(session, stubMode, tree, this, context)
+) : BaseConverter(session, tree, offset, context) {
+    private val expressionConverter = ExpressionsConverter(session, stubMode, tree, this, offset + 1, context)
 
     /**
      * [org.jetbrains.kotlin.parsing.KotlinParsing.parseFile]
@@ -1194,7 +1195,7 @@ class DeclarationsConverter(
         return if (!stubMode) {
             val blockTree = LightTree2Fir.buildLightTreeBlockExpression(block.asText)
             return DeclarationsConverter(
-                baseSession, baseScopeProvider, stubMode, blockTree, context
+                baseSession, baseScopeProvider, stubMode, blockTree, offset = tree.getStartOffset(block), context
             ).convertBlockExpression(blockTree.root)
         } else {
             FirSingleExpressionBlock(

compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/converter/ExpressionsConverter.kt

@@ -50,8 +50,9 @@ class ExpressionsConverter(
     private val stubMode: Boolean,
     tree: FlyweightCapableTreeStructure<LighterASTNode>,
     private val declarationsConverter: DeclarationsConverter,
+    offset: Int,
     context: Context<LighterASTNode> = Context()
-) : BaseConverter(session, tree, context) {
+) : BaseConverter(session, tree, offset, context) {
 
     inline fun <reified R : FirElement> getAsFirExpression(expression: LighterASTNode?, errorReason: String = ""): R {
         return expression?.let { convertExpression(it, errorReason) } as? R ?: (buildErrorExpression(null, ConeSimpleDiagnostic(errorReason, DiagnosticKind.Syntax)) as R)
@@ -63,7 +64,7 @@ class ExpressionsConverter(
             return when (expression.tokenType) {
                 LAMBDA_EXPRESSION -> {
                     val lambdaTree = LightTree2Fir.buildLightTreeLambdaExpression(expression.asText)
-                    ExpressionsConverter(baseSession, stubMode, lambdaTree, declarationsConverter, context)
+                    ExpressionsConverter(baseSession, stubMode, lambdaTree, declarationsConverter, offset, context)
                         .convertLambdaExpression(lambdaTree.root)
                 }
                 BINARY_EXPRESSION -> convertBinaryExpression(expression)

compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirSourceElement.kt

@@ -12,17 +12,32 @@ import com.intellij.psi.tree.IElementType
 import com.intellij.util.diff.FlyweightCapableTreeStructure
 import org.jetbrains.kotlin.KtNodeTypes
 import org.jetbrains.kotlin.psi.KtModifierListOwner
+import org.jetbrains.kotlin.psi.psiUtil.endOffset
+import org.jetbrains.kotlin.psi.psiUtil.startOffset
 
 sealed class FirSourceElement {
     abstract val elementType: IElementType
+    abstract val startOffset: Int
+    abstract val endOffset: Int
 }
 
 class FirPsiSourceElement(val psi: PsiElement) : FirSourceElement() {
     override val elementType: IElementType
         get() = psi.node.elementType
+
+    override val startOffset: Int
+        get() = psi.startOffset
+
+    override val endOffset: Int
+        get() = psi.endOffset
 }
 
-class FirLightSourceElement(val element: LighterASTNode, val tree: FlyweightCapableTreeStructure<LighterASTNode>) : FirSourceElement() {
+class FirLightSourceElement(
+    val element: LighterASTNode,
+    override val startOffset: Int,
+    override val endOffset: Int,
+    val tree: FlyweightCapableTreeStructure<LighterASTNode>
+) : FirSourceElement() {
     override val elementType: IElementType
         get() = element.tokenType
 }