GRAM: pin if let and while let conditions

Author: vlad20012

src/main/grammars/RustParser.bnf

@@ -1191,7 +1191,8 @@ WhileExpr ::= OuterAttr* LabelDecl? while Condition SimpleBlock {
                  "org.rust.lang.core.psi.ext.RsLooplikeExpr" ]
   elementTypeFactory = "org.rust.lang.core.stubs.StubImplementationsKt.factory"
 }
-Condition ::= [ let TopPat '=' ] NoStructLitExpr
+Condition ::= IfLetCondition | NoStructLitExpr
+private IfLetCondition ::= let TopPat '=' NoStructLitExpr { pin = 1 }
 
 LoopExpr ::= OuterAttr* LabelDecl? loop SimpleBlock {
   pin = 'loop'

src/main/kotlin/org/rust/ide/inspections/RsMissingElseInspection.kt

@@ -32,9 +32,9 @@ class RsMissingElseInspection : RsLocalInspectionTool() {
                     .dropWhile { (it is PsiWhiteSpace || it is PsiComment) && '\n' !in it.text }
                     .firstOrNull()
                     .extractIf() ?: return
-                val condition = nextIf.condition ?: return
+                val conditionExpr = nextIf.condition?.expr ?: return
                 val rangeStart = expr.startOffsetInParent + firstIf.textLength
-                val rangeLen = condition.expr.startOffset - firstIf.startOffset - firstIf.textLength
+                val rangeLen = conditionExpr.startOffset - firstIf.startOffset - firstIf.textLength
                 holder.registerProblem(
                     expr.parent,
                     TextRange(rangeStart, rangeStart + rangeLen),

src/main/kotlin/org/rust/ide/inspections/RsRedundantElseInspection.kt

@@ -59,7 +59,13 @@ class RsRedundantElseInspection : RsLocalInspectionTool() {
             }
         private val RsCondition.isRedundant: Boolean
             get() {
-                return patList?.all { pat -> pat.isIrrefutable } ?: (this.expr.evaluate().asBool() ?: false)
+                val patList = patList
+                return if (patList != null) {
+                    patList.all { pat -> pat.isIrrefutable }
+                } else {
+                    val expr = expr ?: return false
+                    expr.evaluate().asBool() == true
+                }
             }
     }
 }

src/main/kotlin/org/rust/ide/intentions/IfLetToMatchIntention.kt

@@ -103,7 +103,7 @@ class IfLetToMatchIntention : RsElementBaseIntentionAction<IfLetToMatchIntention
         val pat = condition.pat ?: return null
 
         //3) Extract the target
-        val target = condition.expr
+        val target = condition.expr ?: return null
 
         //4) Extract the if body
         val ifBody = iflet.block ?: return null

src/main/kotlin/org/rust/ide/intentions/InvertIfIntention.kt

@@ -15,7 +15,7 @@ import org.rust.lang.utils.negate
 class InvertIfIntention : RsElementBaseIntentionAction<InvertIfIntention.Context>() {
     data class Context(
         val ifExpr: RsIfExpr,
-        val condition: RsCondition,
+        val conditionExpr: RsExpr,
         val thenBlock: RsBlock,
         val elseBlock: RsBlock
     )
@@ -25,14 +25,15 @@ class InvertIfIntention : RsElementBaseIntentionAction<InvertIfIntention.Context
         val ifExpr = element.ancestorStrict<RsIfExpr>() ?: return null
         if (element != ifExpr.`if`) return null
         val condition = getSuitableCondition(ifExpr) ?: return null
+        val conditionExpr = condition.expr ?: return null
         val thenBlock = ifExpr.block ?: return null
         val elseBlock = ifExpr.elseBranch?.block ?: return null
 
-        return Context(ifExpr, condition, thenBlock, elseBlock)
+        return Context(ifExpr, conditionExpr, thenBlock, elseBlock)
     }
 
     override fun invoke(project: Project, editor: Editor, ctx: Context) {
-        val negatedCondition = ctx.condition.expr.negate() as? RsExpr ?: return
+        val negatedCondition = ctx.conditionExpr.negate() as? RsExpr ?: return
 
         val newIfExpr = RsPsiFactory(project).createIfElseExpression(negatedCondition, ctx.elseBlock, ctx.thenBlock)
         val replacedIfExpr = ctx.ifExpr.replace(newIfExpr) as RsIfExpr

src/main/kotlin/org/rust/ide/intentions/SplitIfIntention.kt

@@ -23,30 +23,34 @@ class SplitIfIntention : RsElementBaseIntentionAction<SplitIfIntention.Context>(
 
     data class Context(
         val binaryOp: RsBinaryOp,
-        val condition: RsCondition
+        val operatorType: LogicOp,
+        val conditionExpr: RsExpr,
+        val ifExpr: RsIfExpr
     )
 
     override fun findApplicableContext(project: Project, editor: Editor, element: PsiElement): Context? {
         val binExpr = element.ancestorStrict<RsBinaryExpr>() ?: return null
         if (binExpr.operatorType !is LogicOp) return null
-        if (element.parent != binExpr.binaryOp) return null
+        val binaryOp = binExpr.binaryOp
+        val operatorType = binaryOp.operatorType as? LogicOp ?: return null
+        if (element.parent != binaryOp) return null
         val condition = binExpr.findCondition() ?: return null
-        return Context(binExpr.binaryOp, condition)
+        if (condition.let != null) return null
+        val conditionExpr = condition.skipParenExprDown() ?: return null
+        val ifStatement = condition.ancestorOrSelf<RsIfExpr>() ?: return null
+        return Context(binaryOp, operatorType, conditionExpr, ifStatement)
     }
 
     override fun invoke(project: Project, editor: Editor, ctx: Context) {
-        val (binaryOp, condition) = ctx
-        val ifStatement = condition.ancestorOrSelf<RsIfExpr>() ?: return
+        val (binaryOp, operatorType, conditionExpr, ifStatement) = ctx
         val thenBranch = ifStatement.block?.text ?: "{ }"
         val elseBranch = ifStatement.elseBranch?.text ?: ""
 
-        val conditionExpr = condition.skipParenExprDown()
         val leftCondition = leftPart(conditionExpr, binaryOp)
         val rightCondition = rightPart(conditionExpr, binaryOp)
-        val generatedCode = when (binaryOp.operatorType) {
+        val generatedCode = when (operatorType) {
             LogicOp.AND -> createAndAnd(leftCondition, rightCondition, thenBranch, elseBranch)
             LogicOp.OR -> createOrOr(leftCondition, rightCondition, thenBranch, elseBranch)
-            else -> return
         }
 
         val newIfStatement = RsPsiFactory(project).createExpression(generatedCode) as RsIfExpr

src/main/kotlin/org/rust/ide/surroundWith/expression/RsWithIfExpSurrounder.kt

@@ -25,7 +25,7 @@ class RsWithIfExpSurrounder : RsExpressionSurrounderBase<RsIfExpr>() {
         RsPsiFactory(project).createExpression("if a {stmt;}") as RsIfExpr
 
     override fun getWrappedExpression(expression: RsIfExpr): RsExpr =
-        expression.condition!!.expr
+        expression.condition!!.expr!!
 
     override fun isApplicable(expression: RsExpr): Boolean =
         expression.type is TyBool

src/main/kotlin/org/rust/ide/surroundWith/expression/RsWithWhileExpSurrounder.kt

@@ -25,7 +25,7 @@ class RsWithWhileExpSurrounder : RsExpressionSurrounderBase<RsWhileExpr>() {
         RsPsiFactory(project).createExpression("while a {stmt;}") as RsWhileExpr
 
     override fun getWrappedExpression(expression: RsWhileExpr): RsExpr =
-        expression.condition!!.expr
+        expression.condition!!.expr!!
 
     override fun isApplicable(expression: RsExpr): Boolean =
         expression.type is TyBool

src/main/kotlin/org/rust/ide/utils/ExprUtils.kt

@@ -95,5 +95,5 @@ fun RsExpr.skipParenExprUp(): RsExpr {
  *
  * @return a child expression without parentheses.
  */
-fun RsCondition.skipParenExprDown(): RsExpr =
-    unwrapParenExprs(expr)
+fun RsCondition.skipParenExprDown(): RsExpr? =
+    expr?.let { unwrapParenExprs(it) }

src/main/kotlin/org/rust/lang/core/dfa/ExprUseWalker.kt

@@ -375,7 +375,7 @@ class ExprUseWalker(private val delegate: Delegate, private val mc: MemoryCatego
     }
 
     private fun walkCondition(condition: RsCondition) {
-        val init = condition.expr
+        val init = condition.expr ?: return
         walkExpr(init)
         val initCmt = mc.processExpr(init)
         for (pat in condition.patList.orEmpty()) {