Extensions PsiElement.getParentOfType with reified T

1. Renamed *ByType -> *OfType (as in PsiTreeUtil.java)
2. Introduced PsiElement.getStrictParentOfType and PsiElement.getNonStrictParentOfType
with reified TP
3. Replaced current usages of PsiTreeUtil.getParentOfType and current
extensions
4. Made reified version of PsiElement.getParentOfTypeAndBranch with
default strict value --- false (as it used)

compiler/frontend/src/org/jetbrains/jet/lang/evaluate/ConstantExpressionEvaluator.kt

@@ -32,8 +32,8 @@ import org.jetbrains.jet.lang.resolve.calls.model.ResolvedValueArgument
 import org.jetbrains.jet.JetNodeTypes
 import java.math.BigInteger
 import org.jetbrains.jet.lang.diagnostics.Errors
-import com.intellij.psi.util.PsiTreeUtil
 import org.jetbrains.jet.lang.resolve.calls.callUtil.getResolvedCall
+import org.jetbrains.jet.lang.psi.psiUtil.getStrictParentOfType
 
 public class ConstantExpressionEvaluator private (val trace: BindingTrace) : JetVisitor<CompileTimeConstant<*>, JetType>() {
 
@@ -257,7 +257,7 @@ public class ConstantExpressionEvaluator private (val trace: BindingTrace) : Jet
         assert (name == "minus", "Only negation should be checked for overflow")
 
         if (receiver.value == result) {
-            trace.report(Errors.INTEGER_OVERFLOW.on(PsiTreeUtil.getParentOfType(callExpression, javaClass<JetExpression>()) ?: callExpression))
+            trace.report(Errors.INTEGER_OVERFLOW.on(callExpression.getStrictParentOfType<JetExpression>() ?: callExpression))
         }
         return result
     }
@@ -282,7 +282,7 @@ public class ConstantExpressionEvaluator private (val trace: BindingTrace) : Jet
         val resultInBigIntegers = checker(toBigInteger(receiver.value), toBigInteger(parameter.value))
 
         if (toBigInteger(actualResult) != resultInBigIntegers) {
-            trace.report(Errors.INTEGER_OVERFLOW.on(PsiTreeUtil.getParentOfType(callExpression, javaClass<JetExpression>()) ?: callExpression))
+            trace.report(Errors.INTEGER_OVERFLOW.on(callExpression.getStrictParentOfType<JetExpression>() ?: callExpression))
         }
         return actualResult
     }

compiler/frontend/src/org/jetbrains/jet/lang/psi/psiUtil/jetPsiUtil.kt

@@ -50,7 +50,7 @@ public fun JetCallElement.getCallNameExpression(): JetSimpleNameExpression? {
     }
 }
 
-public fun PsiElement.getParentByTypesAndPredicate<T: PsiElement>(
+public fun PsiElement.getParentOfTypesAndPredicate<T: PsiElement>(
         strict : Boolean = false, vararg parentClasses : Class<T>, predicate: (T) -> Boolean
 ) : T? {
     var element = if (strict) getParent() else this
@@ -69,8 +69,20 @@ public fun PsiElement.getParentByTypesAndPredicate<T: PsiElement>(
     return null
 }
 
-public fun PsiElement.getParentByType<T: PsiElement>(parentClass : Class<T>, strict : Boolean = false) : T? {
-    return PsiTreeUtil.getParentOfType(this, parentClass, strict)
+public fun PsiElement.getNonStrictParentOfType<T: PsiElement>(parentClass : Class<T>) : T? {
+    return PsiTreeUtil.getParentOfType(this, parentClass, false)
+}
+
+inline public fun PsiElement.getParentOfType<reified T: PsiElement>(strict: Boolean): T? {
+    return PsiTreeUtil.getParentOfType(this, javaClass<T>(), strict)
+}
+
+inline public fun PsiElement.getStrictParentOfType<reified T: PsiElement>(): T? {
+    return PsiTreeUtil.getParentOfType(this, javaClass<T>(), true)
+}
+
+inline public fun PsiElement.getNonStrictParentOfType<reified T: PsiElement>(): T? {
+    return PsiTreeUtil.getParentOfType(this, javaClass<T>(), false)
 }
 
 public fun PsiElement?.isAncestor(element: PsiElement, strict: Boolean = false): Boolean {
@@ -81,9 +93,8 @@ public fun <T: PsiElement> T.getIfChildIsInBranch(element: PsiElement, branch: T
     return if (branch().isAncestor(element)) this else null
 }
 
-public fun PsiElement.getParentByTypeAndBranch<T: PsiElement>(
-        parentClass : Class<T>, strict : Boolean = false, branch: T.() -> PsiElement?) : T? {
-    return getParentByType(parentClass, strict)?.getIfChildIsInBranch(this, branch)
+inline public fun PsiElement.getParentOfTypeAndBranch<reified T: PsiElement>(strict: Boolean = false, noinline branch: T.() -> PsiElement?) : T? {
+    return getParentOfType<T>(strict)?.getIfChildIsInBranch(this, branch)
 }
 
 public fun JetClassOrObject.effectiveDeclarations(): List<JetDeclaration> =
@@ -192,7 +203,7 @@ public fun JetDeclaration.isOverridable(): Boolean {
 public fun PsiElement.isExtensionDeclaration(): Boolean {
     val callable: JetCallableDeclaration? = when (this) {
         is JetNamedFunction, is JetProperty -> this as JetCallableDeclaration
-        is JetPropertyAccessor -> getParentByType(javaClass<JetProperty>())
+        is JetPropertyAccessor -> getNonStrictParentOfType<JetProperty>()
         else -> null
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContextUtils.kt

@@ -22,7 +22,7 @@ import org.jetbrains.jet.lang.descriptors.FunctionDescriptor
 import org.jetbrains.jet.lang.resolve.BindingContext.LABEL_TARGET
 import org.jetbrains.jet.lang.resolve.BindingContext.FUNCTION
 import org.jetbrains.jet.lang.resolve.BindingContext.DECLARATION_TO_DESCRIPTOR
-import org.jetbrains.jet.lang.psi.psiUtil.getParentByType
+import org.jetbrains.jet.lang.psi.psiUtil.getNonStrictParentOfType
 import org.jetbrains.jet.lang.psi.JetDeclarationWithBody
 import org.jetbrains.jet.lang.resolve.DescriptorUtils
 import org.jetbrains.jet.lang.descriptors.impl.AnonymousFunctionDescriptor
@@ -34,7 +34,7 @@ public fun JetReturnExpression.getTargetFunctionDescriptor(context: BindingConte
     val targetLabel = getTargetLabel()
     if (targetLabel != null) return context[LABEL_TARGET, targetLabel]?.let { context[FUNCTION, it] }
 
-    val declarationDescriptor = context[DECLARATION_TO_DESCRIPTOR, getParentByType(javaClass<JetDeclarationWithBody>())]
+    val declarationDescriptor = context[DECLARATION_TO_DESCRIPTOR, getNonStrictParentOfType<JetDeclarationWithBody>()]
     val containingFunctionDescriptor = DescriptorUtils.getParentOfType(declarationDescriptor, javaClass<FunctionDescriptor>(), false)
     if (containingFunctionDescriptor == null) return null
 

compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightMethodForDeclaration.kt

@@ -26,7 +26,7 @@ import com.intellij.psi.util.PsiModificationTracker
 import com.intellij.psi.util.CachedValueProvider
 import com.intellij.psi.util.CachedValue
 import org.jetbrains.jet.lang.psi.JetPropertyAccessor
-import org.jetbrains.jet.lang.psi.psiUtil.getParentByType
+import org.jetbrains.jet.lang.psi.psiUtil.getNonStrictParentOfType
 import org.jetbrains.jet.lang.psi.JetProperty
 import org.jetbrains.jet.lang.psi.JetClassOrObject
 import com.intellij.psi.impl.light.LightTypeParameterListBuilder
@@ -56,7 +56,7 @@ open public class KotlinLightMethodForDeclaration(
     private val typeParamsList: CachedValue<PsiTypeParameterList> by Delegates.blockingLazy {
         val cacheManager = CachedValuesManager.getManager(delegate.getProject())
         cacheManager.createCachedValue<PsiTypeParameterList>({
-            val declaration = if (origin is JetPropertyAccessor) origin.getParentByType(javaClass<JetProperty>()) else origin
+            val declaration = if (origin is JetPropertyAccessor) origin.getNonStrictParentOfType<JetProperty>() else origin
 
             val list = if (origin is JetClassOrObject) {
                 LightTypeParameterListBuilder(getManager(), getLanguage())

compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/lightClassUtils.kt

@@ -19,7 +19,7 @@ package org.jetbrains.jet.asJava
 import com.intellij.psi.*
 import org.jetbrains.jet.lang.psi.*
 import java.util.Collections
-import org.jetbrains.jet.lang.psi.psiUtil.getParentByType
+import org.jetbrains.jet.lang.psi.psiUtil.getNonStrictParentOfType
 import java.util.ArrayList
 import org.jetbrains.jet.lang.psi.psiUtil.isExtensionDeclaration
 import org.jetbrains.jet.utils.addToStdlib.singletonOrEmptyList
@@ -64,7 +64,7 @@ public fun PsiElement.getRepresentativeLightMethod(): PsiMethod? =
         }
 
 public fun JetParameter.toPsiParameter(): PsiParameter? {
-    val paramList = getParentByType(javaClass<JetParameterList>())
+    val paramList = getNonStrictParentOfType<JetParameterList>()
     if (paramList == null) return null
 
     val paramIndex = paramList.getParameters().indexOf(this)
@@ -85,11 +85,11 @@ public fun JetParameter.toPsiParameter(): PsiParameter? {
 }
 
 public fun JetTypeParameter.toPsiTypeParameters(): List<PsiTypeParameter> {
-    val paramList = getParentByType(javaClass<JetTypeParameterList>())
+    val paramList = getNonStrictParentOfType<JetTypeParameterList>()
     if (paramList == null) return listOf()
 
     val paramIndex = paramList.getParameters().indexOf(this)
-    val jetDeclaration = paramList.getParentByType(javaClass<JetDeclaration>()) ?: return listOf()
+    val jetDeclaration = paramList.getNonStrictParentOfType<JetDeclaration>() ?: return listOf()
     val lightOwners = jetDeclaration.toLightElements()
 
     return lightOwners.map { lightOwner -> (lightOwner as PsiTypeParameterListOwner).getTypeParameters()[paramIndex] }
@@ -100,4 +100,4 @@ public val PsiElement.unwrapped: PsiElement?
     get() = if (this is KotlinLightElement<*, *>) origin else this
 
 public val PsiElement.namedUnwrappedElement: PsiNamedElement?
-    get() = unwrapped?.getParentByType(javaClass<PsiNamedElement>())
+    get() = unwrapped?.getNonStrictParentOfType<PsiNamedElement>()

compiler/tests/org/jetbrains/jet/resolve/calls/AbstractResolvedCallsTest.kt

@@ -33,13 +33,13 @@ import com.intellij.openapi.util.io.FileUtil
 import org.jetbrains.jet.lang.psi.ValueArgument
 import org.jetbrains.jet.lang.psi.JetPsiFactory
 import org.jetbrains.jet.lang.psi.JetExpression
-import com.intellij.psi.util.PsiTreeUtil
 import org.jetbrains.jet.lang.resolve.calls.model.VariableAsFunctionResolvedCall
 import org.jetbrains.jet.lang.resolve.calls.callUtil.getParentResolvedCall
 import org.jetbrains.jet.lang.descriptors.ReceiverParameterDescriptor
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ExtensionReceiver
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ClassReceiver
+import org.jetbrains.jet.lang.psi.psiUtil.getStrictParentOfType
 
 public abstract class AbstractResolvedCallsTest() : JetLiteFixture() {
     override fun createEnvironment(): JetCoreEnvironment = createEnvironmentWithMockJdk(ConfigurationKind.ALL)
@@ -51,7 +51,7 @@ public abstract class AbstractResolvedCallsTest() : JetLiteFixture() {
         val bindingContext = JvmResolveUtil.analyzeOneFileWithJavaIntegration(jetFile).bindingContext
 
         val element = jetFile.findElementAt(text.indexOf("<caret>"))
-        val expression = PsiTreeUtil.getParentOfType(element, javaClass<JetExpression>())
+        val expression = element.getStrictParentOfType<JetExpression>()
 
         val cachedCall = expression?.getParentResolvedCall(bindingContext, strict = false)