IR: rework ScopeValidator

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/IrValidator.kt

@@ -67,7 +67,7 @@ class IrValidator(val context: CommonBackendContext, val config: IrValidatorConf
         currentFile = declaration
         super.visitFile(declaration)
         if (config.checkScopes) {
-            ScopeValidator(this::error).visitFile(declaration)
+            ScopeValidator(this::error).check(declaration)
         }
     }
 

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ScopeValidator.kt

@@ -15,179 +15,158 @@ import org.jetbrains.kotlin.ir.types.IrTypeProjection
 import org.jetbrains.kotlin.ir.util.constructors
 import org.jetbrains.kotlin.ir.util.parentAsClass
 import org.jetbrains.kotlin.ir.util.render
-import org.jetbrains.kotlin.ir.visitors.IrElementVisitorVoid
+import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
-import org.jetbrains.kotlin.ir.visitors.acceptChildrenVoid
 
 /* Make sure that all the variable references and type parameter references are within the scope of the corresponding variables and
    type parameters.
 */
 class ScopeValidator(
     private val reportError: ReportError
-) : IrElementVisitorVoid {
+) {
 
-    
+    fun check(element: IrElement) {
-    private val accessibleValues = mutableSetOf<IrValueDeclaration>()
+        element.accept(Checker(), Visibles(emptySet(), mutableSetOf()))
-    private val valuesStack = mutableListOf<MutableSet<IrValueDeclaration>>()
-
-    private val accessibleTypeParameters = mutableSetOf<IrTypeParameter>()
-
-
-    override fun visitElement(element: IrElement) {
-        element.acceptChildrenVoid(this)
     }
 
-    override fun visitClass(declaration: IrClass) {
+    inner class Visibles(val typeParameters: Set<IrTypeParameter>, val values: MutableSet<IrValueDeclaration>) {
-        handleTypeParameterContainer(declaration.typeParameters) {
+        fun visitTypeAccess(element: IrElement, type: IrType) {
+            if (type !is IrSimpleType) return
+            if (type.classifier is IrTypeParameterSymbol && type.classifier.owner !in this.typeParameters) {
+                reportError(element, "Type parameter ${type.classifier.owner.render()} not accessible")
+            }
+            for (arg in type.arguments) {
+                if (arg is IrTypeProjection) {
+                    visitTypeAccess(element, arg.type)
+                }
+            }
+        }
+
+        fun visitVariableAccess(element: IrElement, variable: IrValueDeclaration) {
+            if (variable !in this.values) {
+                reportError(element, "Value ${variable.render()} not accessible")
+            }
+        }
+
+        fun extend(newTypeParameters: Collection<IrTypeParameter>, newValues: Collection<IrValueDeclaration>): Visibles =
+            Visibles(
+                if (newTypeParameters.isEmpty()) typeParameters else typeParameters + newTypeParameters,
+                (values + newValues).toMutableSet()
+            )
+    }
+
+    inner class Checker : IrElementVisitor<Unit, Visibles> {
+        override fun visitElement(element: IrElement, data: Visibles) {
+            element.acceptChildren(this, data)
+        }
+
+        override fun visitClass(declaration: IrClass, data: Visibles) {
+            val newVisibles = data.extend(declaration.typeParameters, listOfNotNull(declaration.thisReceiver))
             for (superType in declaration.superTypes) {
-                visitTypeAccess(declaration, superType)
+                newVisibles.visitTypeAccess(declaration, superType)
             }
-            handleValuesContainer(listOfNotNull(declaration.thisReceiver)) {
+            super.visitClass(declaration, newVisibles)
-                super.visitClass(declaration)
+        }
+
+        override fun visitFunction(declaration: IrFunction, data: Visibles) {
+            val newVisibles = data.extend(
+                declaration.typeParameters,
+                listOfNotNull(declaration.dispatchReceiverParameter, declaration.extensionReceiverParameter) + declaration.valueParameters
+            )
+
+            newVisibles.visitTypeAccess(declaration, declaration.returnType)
+            super.visitFunction(declaration, newVisibles)
+        }
+
+        override fun visitAnonymousInitializer(declaration: IrAnonymousInitializer, data: Visibles) {
+            val primaryConstructor = declaration.parentAsClass.primaryConstructor()
+            if (primaryConstructor == null) {
+                super.visitAnonymousInitializer(declaration, data)
+            } else {
+                super.visitAnonymousInitializer(declaration, data.extend(emptySet(), primaryConstructor.valueParameters))
             }
         }
-    }
 
-    override fun visitFunction(declaration: IrFunction) {
+        override fun visitField(declaration: IrField, data: Visibles) {
-        handleTypeParameterContainer(declaration.typeParameters) {
+            data.visitTypeAccess(declaration, declaration.type)
-            visitTypeAccess(declaration, declaration.returnType)
+            if (declaration.initializer == null) {
-            handleValuesContainer(declaration.valueParameters) {
+                return super.visitField(declaration, data)
-                declaration.dispatchReceiverParameter?.let { addAccessibleValue(it) }
+            }
-                declaration.extensionReceiverParameter?.let { addAccessibleValue(it) }
+            val primaryConstructor = (declaration.parent as? IrClass)?.primaryConstructor()
-                super.visitFunction(declaration)
+            if (primaryConstructor == null) {
+                super.visitField(declaration, data)
+            } else {
+                super.visitField(declaration, data.extend(emptySet(), primaryConstructor.valueParameters))
             }
         }
-    }
 
-    override fun visitAnonymousInitializer(declaration: IrAnonymousInitializer) {
+        override fun visitBlock(expression: IrBlock, data: Visibles) {
-        val primaryConstructor = declaration.parentAsClass.primaryConstructor()
+            // Entering a new scope
-        if (primaryConstructor == null) {
+            super.visitBlock(expression, data.extend(emptySet(), emptySet()))
-            super.visitAnonymousInitializer(declaration)
+        }
-        } else {
+
-            handleValuesContainer(primaryConstructor.valueParameters) {
+        override fun visitVariable(declaration: IrVariable, data: Visibles) {
-                super.visitAnonymousInitializer(declaration)
+            data.visitTypeAccess(declaration, declaration.type)
+            super.visitVariable(declaration, data)
+            data.values.add(declaration)
+        }
+
+        override fun visitTypeAlias(declaration: IrTypeAlias, data: Visibles) {
+            val newVisibles = data.extend(declaration.typeParameters, emptySet())
+            newVisibles.visitTypeAccess(declaration, declaration.expandedType)
+            super.visitTypeAlias(declaration, newVisibles)
+        }
+
+        override fun visitTypeParameter(declaration: IrTypeParameter, data: Visibles) {
+            for (superType in declaration.superTypes) {
+                data.visitTypeAccess(declaration, superType)
             }
+            super.visitTypeParameter(declaration, data)
         }
-    }
 
-    override fun visitField(declaration: IrField) {
+        override fun visitValueParameter(declaration: IrValueParameter, data: Visibles) {
-        visitTypeAccess(declaration, declaration.type)
+            data.visitTypeAccess(declaration, declaration.type)
-        if (declaration.initializer == null) {
+            declaration.varargElementType?.let { data.visitTypeAccess(declaration, it) }
-            return super.visitField(declaration)
+            super.visitValueParameter(declaration, data)
         }
-        val primaryConstructor = (declaration.parent as? IrClass)?.primaryConstructor()
+
-        if (primaryConstructor == null) {
+        override fun visitValueAccess(expression: IrValueAccessExpression, data: Visibles) {
-            super.visitField(declaration)
+            data.visitVariableAccess(expression, expression.symbol.owner)
-        } else {
+            super.visitValueAccess(expression, data)
-            handleValuesContainer(primaryConstructor.valueParameters) {
+        }
-                super.visitField(declaration)
+
+        override fun visitMemberAccess(expression: IrMemberAccessExpression<*>, data: Visibles) {
+            for (i in 0 until expression.typeArgumentsCount) {
+                expression.getTypeArgument(i)?.let { data.visitTypeAccess(expression, it) }
             }
+            super.visitMemberAccess(expression, data)
         }
-    }
 
-    override fun visitBlock(expression: IrBlock) {
+        override fun visitCatch(aCatch: IrCatch, data: Visibles) {
-        handleValuesContainer(emptyList()) {
+            // catchParameter only has scope over result expression, so create a new scope
-            super.visitBlock(expression)
+            super.visitCatch(aCatch, data.extend(emptySet(), emptySet()))
         }
-    }
 
-    override fun visitVariable(declaration: IrVariable) {
+        override fun visitTypeOperator(expression: IrTypeOperatorCall, data: Visibles) {
-        visitTypeAccess(declaration, declaration.type)
+            data.visitTypeAccess(expression, expression.typeOperand)
-        super.visitVariable(declaration)
+            super.visitTypeOperator(expression, data)
-        addAccessibleValue(declaration)
-    }
-
-    override fun visitTypeAlias(declaration: IrTypeAlias) {
-        handleTypeParameterContainer(declaration.typeParameters) {
-            visitTypeAccess(declaration, declaration.expandedType)
-            super.visitTypeAlias(declaration)
         }
-    }
 
-    override fun visitTypeParameter(declaration: IrTypeParameter) {
+        override fun visitClassReference(expression: IrClassReference, data: Visibles) {
-        for (superType in declaration.superTypes) {
+            // classType should only contain star projections, but check it to be sure.
-            visitTypeAccess(declaration, superType)
+            data.visitTypeAccess(expression, expression.classType)
+            super.visitClassReference(expression, data)
         }
-        super.visitTypeParameter(declaration)
-    }
 
-    override fun visitValueParameter(declaration: IrValueParameter) {
+        override fun visitVararg(expression: IrVararg, data: Visibles) {
-        visitTypeAccess(declaration, declaration.type)
+            data.visitTypeAccess(expression, expression.varargElementType)
-        declaration.varargElementType?.let { visitTypeAccess(declaration, it) }
+            super.visitVararg(expression, data)
-        super.visitValueParameter(declaration)
-    }
-
-    override fun visitVariableAccess(expression: IrValueAccessExpression) {
-        if (expression.symbol.owner !in accessibleValues) {
-            reportError(expression, "Value ${expression.symbol.owner.render()} not accessible")
         }
-        super.visitVariableAccess(expression)
-    }
 
-    override fun visitMemberAccess(expression: IrMemberAccessExpression<*>) {
+        override fun visitExpression(expression: IrExpression, data: Visibles) {
-        for (i in 0 until expression.typeArgumentsCount) {
+            data.visitTypeAccess(expression, expression.type)
-            expression.getTypeArgument(i)?.let { visitTypeAccess(expression, it) }
+            super.visitExpression(expression, data)
         }
-        super.visitMemberAccess(expression)
-    }
 
-    override fun visitCatch(aCatch: IrCatch) {
+        private fun IrClass.primaryConstructor(): IrConstructor? = constructors.singleOrNull { it.isPrimary }
-        // catchParameter only has scope over result expression
-        handleValuesContainer(emptyList()) {
-            super.visitCatch(aCatch)
-        }
     }
-
-    override fun visitTypeOperator(expression: IrTypeOperatorCall) {
-        visitTypeAccess(expression, expression.typeOperand)
-        super.visitTypeOperator(expression)
-    }
-
-    override fun visitClassReference(expression: IrClassReference) {
-        // classType should only contain star projections, but check it to be sure.
-        visitTypeAccess(expression, expression.classType)
-        super.visitClassReference(expression)
-    }
-
-    override fun visitVararg(expression: IrVararg) {
-        visitTypeAccess(expression, expression.varargElementType)
-        super.visitVararg(expression)
-    }
-
-    override fun visitExpression(expression: IrExpression) {
-        visitTypeAccess(expression, expression.type)
-        super.visitExpression(expression)
-    }
-
-    private fun visitTypeAccess(element: IrElement, type: IrType) {
-        if (type !is IrSimpleType) return
-        if (type.classifier is IrTypeParameterSymbol && type.classifier.owner !in accessibleTypeParameters) {
-            reportError(element, "Type parameter ${type.classifier.owner.render()} not accessible")
-        }
-        for (arg in type.arguments) {
-            if (arg is IrTypeProjection) {
-                visitTypeAccess(element, arg.type)
-            }
-        }
-    }
-
-    private inline fun handleTypeParameterContainer(typeParameters: List<IrTypeParameter>, block: () -> Unit) {
-        accessibleTypeParameters.addAll(typeParameters)
-        block()
-        accessibleTypeParameters.removeAll(typeParameters)
-    }
-
-    private inline fun handleValuesContainer(values: List<IrValueDeclaration>, block: () -> Unit) {
-        accessibleValues.addAll(values)
-        valuesStack.add(values.toMutableSet())
-        block()
-        val toDrop = valuesStack.removeLast()
-        accessibleValues.removeAll(toDrop)
-    }
-
-    private fun addAccessibleValue(value: IrValueDeclaration) {
-        accessibleValues.add(value)
-        valuesStack.last().add(value)
-    }
-
-    private fun IrClass.primaryConstructor(): IrConstructor? = constructors.singleOrNull { it.isPrimary }
 }