for-loop name resolution and inference support

pontem-network · Jan 15, 2024 · 3cd8cf4 · 3cd8cf4
1 parent 99c6802
commit 3cd8cf4
Show file tree

Hide file tree

Showing 12 changed files with 151 additions and 42 deletions.
diff --git a/src/main/grammars/MoveParser.bnf b/src/main/grammars/MoveParser.bnf
@@ -948,10 +948,19 @@ private ConditionBody_recover ::= !')'
 
 ElseBlock ::= else AnyBlock { pin = 1 }
 
-LoopExpr ::= loop AnyBlock { pin = 1 }
-WhileExpr ::= while Condition AnyBlock { pin = 1 }
-ForExpr ::= for ForIterCondition AnyBlock { pin = 1 }
-ForIterCondition ::= '(' BindingPat in Expr ')' {
+LoopExpr ::= loop AnyBlock {
+    pin = 1
+    implements = [ "org.move.lang.core.psi.MvLoopLike" ]
+}
+WhileExpr ::= while Condition AnyBlock {
+    pin = 1
+    implements = [ "org.move.lang.core.psi.MvLoopLike" ]
+}
+ForExpr ::= for ForIterCondition AnyBlock {
+    pin = 1
+    implements = [ "org.move.lang.core.psi.MvLoopLike" ]
+}
+ForIterCondition ::= '(' BindingPat in RangeExpr ')' {
     pin = 1
 }
 

diff --git a/src/main/kotlin/org/move/ide/presentation/ty.kt b/src/main/kotlin/org/move/ide/presentation/ty.kt
@@ -136,7 +136,7 @@ private fun render(
         }
         is TyTuple -> ty.types.joinToString(", ", "(", ")", transform = r)
         is TyVector -> "vector<${r(ty.item)}>"
-        is TyIntegerRange -> "range"
+        is TyRange -> "range"
         is TyReference -> {
             val prefix = if (ty.permissions.contains(RefPermissions.WRITE)) "&mut " else "&"
             "$prefix${r(ty.referenced)}"

diff --git a/src/main/kotlin/org/move/lang/core/MvTokenType.kt b/src/main/kotlin/org/move/lang/core/MvTokenType.kt
@@ -13,10 +13,10 @@ class MvTokenType(debugName: String) : IElementType(debugName, MoveLanguage)
 fun tokenSetOf(vararg tokens: IElementType) = TokenSet.create(*tokens)
 
 val MOVE_KEYWORDS = tokenSetOf(
-    LET, MUT, ABORT, BREAK, CONTINUE, IF, ELSE, LOOP, RETURN, AS, WHILE,
+    LET, MUT, ABORT, BREAK, CONTINUE, IF, ELSE, LOOP, RETURN, AS, WHILE, FOR,
     SCRIPT_KW, ADDRESS, MODULE_KW, PUBLIC, FUN, STRUCT_KW, ACQUIRES, USE, HAS, PHANTOM,
-    MOVE, CONST_KW, NATIVE, FRIEND, ENTRY,
-    ASSUME, ASSERT, REQUIRES, ENSURES, INVARIANT, MODIFIES, PRAGMA, INCLUDE, ABORTS_IF, WITH,
+    MOVE, CONST_KW, NATIVE, FRIEND, ENTRY, INLINE,
+    ASSUME, ASSERT, REQUIRES, ENSURES, INVARIANT, MODIFIES, PRAGMA, INCLUDE, ABORTS_IF, WITH, UPDATE, DECREASES,
     SPEC, SCHEMA_KW, GLOBAL, LOCAL,
     EMITS, APPLY, TO, EXCEPT, INTERNAL,
     FORALL, EXISTS, IN, WHERE,

diff --git a/src/main/kotlin/org/move/lang/core/psi/MvLoopLike.kt b/src/main/kotlin/org/move/lang/core/psi/MvLoopLike.kt
@@ -0,0 +1,6 @@
+package org.move.lang.core.psi
+
+interface MvLoopLike: MvElement {
+    val codeBlock: MvCodeBlock?
+    val inlineBlock: MvInlineBlock?
+}
diff --git a/src/main/kotlin/org/move/lang/core/resolve/LexicalDeclarations.kt b/src/main/kotlin/org/move/lang/core/resolve/LexicalDeclarations.kt
@@ -48,6 +48,14 @@ fun processItemsInScope(
                     is MvScript -> processor.matchAll(contextScopeInfo, scope.consts())
                     is MvFunctionLike -> processor.matchAll(contextScopeInfo, scope.allParamsAsBindings)
                     is MvLambdaExpr -> processor.matchAll(contextScopeInfo, scope.bindingPatList)
+                    is MvForExpr -> {
+                        val iterConditionBindingPat = scope.forIterCondition?.bindingPat
+                        if (iterConditionBindingPat != null) {
+                            processor.match(iterConditionBindingPat)
+                        } else {
+                            false
+                        }
+                    }
                     is MvItemSpec -> {
                         val item = scope.item
                         when (item) {

diff --git a/src/main/kotlin/org/move/lang/core/types/infer/InferenceContext.kt b/src/main/kotlin/org/move/lang/core/types/infer/InferenceContext.kt
@@ -360,7 +360,7 @@ class InferenceContext(
             ty1msl is TyPrimitive && ty2msl is TyPrimitive && ty1msl.name == ty2msl.name -> Ok(Unit)
 
             ty1msl is TyVector && ty2msl is TyVector -> combineTypes(ty1msl.item, ty2msl.item)
-            ty1msl is TyIntegerRange && ty2msl is TyIntegerRange -> Ok(Unit)
+            ty1msl is TyRange && ty2msl is TyRange -> Ok(Unit)
 
             ty1msl is TyReference && ty2msl is TyReference
                     // inferredTy permissions should be a superset of expectedTy permissions

diff --git a/src/main/kotlin/org/move/lang/core/types/infer/TypeInferenceWalker.kt b/src/main/kotlin/org/move/lang/core/types/infer/TypeInferenceWalker.kt
@@ -59,7 +59,8 @@ class TypeInferenceWalker(
                         "${bindingContext.elementType} binding is not inferred",
                         TyUnknown
                     )
-                }            }
+                }
+            }
             this.ctx.writePatTy(binding, ty)
         }
     }
@@ -211,7 +212,7 @@ class TypeInferenceWalker(
 
             is MvDotExpr -> inferDotExprTy(expr)
             is MvDerefExpr -> inferDerefExprTy(expr)
-            is MvLitExpr -> inferLitExprTy(expr)
+            is MvLitExpr -> inferLitExprTy(expr, expected)
             is MvTupleLitExpr -> inferTupleLitExprTy(expr, expected)
             is MvLambdaExpr -> inferLambdaExpr(expr, expected)
 
@@ -239,6 +240,7 @@ class TypeInferenceWalker(
             is MvIfExpr -> inferIfExprTy(expr, expected)
             is MvWhileExpr -> inferWhileExpr(expr)
             is MvLoopExpr -> inferLoopExpr(expr)
+            is MvForExpr -> inferForExpr(expr)
             is MvReturnExpr -> {
                 expr.expr?.inferTypeCoercableTo(returnTy)
                 TyNever
@@ -559,7 +561,7 @@ class TypeInferenceWalker(
         val posExpr = indexExpr.exprList.drop(1).first()
         val posTy = posExpr.inferType()
         return when (posTy) {
-            is TyIntegerRange -> (receiverTy as? TyVector) ?: TyUnknown
+            is TyRange -> (receiverTy as? TyVector) ?: TyUnknown
             is TyNum -> (receiverTy as? TyVector)?.item ?: TyUnknown
             else -> TyUnknown
         }
@@ -582,7 +584,7 @@ class TypeInferenceWalker(
                 val rangeTy = quantBinding.expr?.inferType()
                 when (rangeTy) {
                     is TyVector -> rangeTy.item
-                    is TyIntegerRange -> TyInteger.DEFAULT
+                    is TyRange -> TyInteger.DEFAULT
                     else -> TyUnknown
                 }
             }
@@ -593,9 +595,11 @@ class TypeInferenceWalker(
     }
 
     private fun inferRangeExprTy(rangeExpr: MvRangeExpr): Ty {
-        rangeExpr.exprList.firstOrNull()?.inferTypeCoercableTo(TyInteger.DEFAULT)
-        rangeExpr.exprList.drop(1).firstOrNull()?.inferTypeCoercableTo(TyInteger.DEFAULT)
-        return TyIntegerRange
+        val leftTy = rangeExpr.exprList.firstOrNull()?.inferType() ?: TyUnknown
+//        rangeExpr.exprList.firstOrNull()?.inferTypeCoercableTo(TyInteger.DEFAULT)
+        rangeExpr.exprList.drop(1).firstOrNull()?.inferType(expected = leftTy)
+//        rangeExpr.exprList.drop(1).firstOrNull()?.inferTypeCoercableTo(TyInteger.DEFAULT)
+        return TyRange(leftTy)
     }
 
     private fun inferBinaryExprTy(binaryExpr: MvBinaryExpr): Ty {
@@ -768,19 +772,25 @@ class TypeInferenceWalker(
         return TyTuple(types)
     }
 
-    private fun inferLitExprTy(litExpr: MvLitExpr): Ty {
-        return when {
-            litExpr.boolLiteral != null -> TyBool
-            litExpr.addressLit != null -> TyAddress
-            litExpr.integerLiteral != null || litExpr.hexIntegerLiteral != null -> {
-                if (ctx.msl) return TyNum
-                val literal = (litExpr.integerLiteral ?: litExpr.hexIntegerLiteral)!!
-                return TyInteger.fromSuffixedLiteral(literal) ?: TyInfer.IntVar()
-            }
-            litExpr.byteStringLiteral != null -> TyByteString(ctx.msl)
-            litExpr.hexStringLiteral != null -> TyHexString(ctx.msl)
-            else -> TyUnknown
-        }
+    private fun inferLitExprTy(litExpr: MvLitExpr, expected: Expectation): Ty {
+        val litTy =
+            when {
+                litExpr.boolLiteral != null -> TyBool
+                litExpr.addressLit != null -> TyAddress
+                litExpr.integerLiteral != null || litExpr.hexIntegerLiteral != null -> {
+                    if (ctx.msl) return TyNum
+                    val literal = (litExpr.integerLiteral ?: litExpr.hexIntegerLiteral)!!
+                    return TyInteger.fromSuffixedLiteral(literal) ?: TyInfer.IntVar()
+                }
+                litExpr.byteStringLiteral != null -> TyByteString(ctx.msl)
+                litExpr.hexStringLiteral != null -> TyHexString(ctx.msl)
+                else -> TyUnknown
+            }
+        expected.onlyHasTy(this.ctx)
+            ?.let {
+                coerce(litExpr, litTy, it)
+            }
+        return litTy
     }
 
     private fun inferIfExprTy(ifExpr: MvIfExpr, expected: Expectation): Ty {
@@ -841,20 +851,35 @@ class TypeInferenceWalker(
         if (conditionExpr != null) {
             conditionExpr.inferTypeCoercableTo(TyBool)
         }
-        val codeBlock = whileExpr.codeBlock
-        val inlineBlockExpr = whileExpr.inlineBlock?.expr
+        return inferLoopLike(whileExpr)
+    }
 
-        val expected = Expectation.maybeHasType(TyUnit)
-        when {
-            codeBlock != null -> codeBlock.inferBlockType(expected)
-            inlineBlockExpr != null -> inlineBlockExpr.inferType(expected)
+    private fun inferLoopExpr(loopExpr: MvLoopExpr): Ty {
+        return inferLoopLike(loopExpr)
+    }
+
+    private fun inferForExpr(forExpr: MvForExpr): Ty {
+        val iterCondition = forExpr.forIterCondition
+        if (iterCondition != null) {
+            val rangeExpr = iterCondition.rangeExpr
+            val bindingTy =
+                if (rangeExpr != null) {
+                    val rangeTy = inferExprTy(rangeExpr) as? TyRange
+                    rangeTy?.itemTy ?: TyUnknown
+                } else {
+                    TyUnknown
+                }
+            val bindingPat = iterCondition.bindingPat
+            if (bindingPat != null) {
+                this.ctx.writePatTy(bindingPat, bindingTy)
+            }
         }
-        return TyUnit
+        return inferLoopLike(forExpr)
     }
 
-    private fun inferLoopExpr(loopExpr: MvLoopExpr): Ty {
-        val codeBlock = loopExpr.codeBlock
-        val inlineBlockExpr = loopExpr.inlineBlock?.expr
+    private fun inferLoopLike(loopLike: MvLoopLike): Ty {
+        val codeBlock = loopLike.codeBlock
+        val inlineBlockExpr = loopLike.inlineBlock?.expr
         val expected = Expectation.maybeHasType(TyUnit)
         when {
             codeBlock != null -> codeBlock.inferBlockType(expected)

diff --git a/...move/lang/core/types/ty/TyIntegerRange.kt → ...in/org/move/lang/core/types/ty/TyRange.kt b/...move/lang/core/types/ty/TyIntegerRange.kt → ...in/org/move/lang/core/types/ty/TyRange.kt
@@ -2,8 +2,7 @@ package org.move.lang.core.types.ty
 
 import org.move.ide.presentation.tyToString
 
-/// msl only
-object TyIntegerRange: Ty() {
+data class TyRange(val itemTy: Ty): Ty() {
     override fun abilities(): Set<Ability> = Ability.all()
     override fun toString(): String = tyToString(this)
 }
diff --git a/src/test/kotlin/org/move/ide/annotator/HighlightingAnnotatorTest.kt b/src/test/kotlin/org/move/ide/annotator/HighlightingAnnotatorTest.kt
@@ -278,4 +278,13 @@ class HighlightingAnnotatorTest : AnnotatorTestCase(HighlightingAnnotator::class
             }
         }        
     """)
+
+    fun `test for loop keywords`() = checkHighlighting("""
+        module 0x1::m {
+            fun main() {
+                let <VARIABLE>for</VARIABLE> = 1;
+                <KEYWORD>for</KEYWORD> (i <KEYWORD>in</KEYWORD> 1..10) {};
+            }
+        }        
+    """)
 }
diff --git a/src/test/kotlin/org/move/ide/inspections/MvTypeCheckInspectionTest.kt b/src/test/kotlin/org/move/ide/inspections/MvTypeCheckInspectionTest.kt
@@ -1470,4 +1470,12 @@ module 0x1::pool {
             }
         }
     """)
+
+    fun `test range expr second has different type`() = checkByText("""
+        module 0x1::m {
+            fun main() {
+                let a = 1..<error descr="Incompatible type 'bool', expected 'integer'">true</error>;
+            }
+        }        
+    """)
 }
diff --git a/src/test/kotlin/org/move/lang/resolve/ResolveVariablesTest.kt b/src/test/kotlin/org/move/lang/resolve/ResolveVariablesTest.kt
@@ -336,4 +336,16 @@ module 0x1::string_tests {
                      //^
 }
     """)
+
+    fun `test for loop name resolution`() = checkByCode("""
+        module 0x1::m {
+            fun main() {
+                for (ind in 0..10) {
+                    //X
+                    ind;
+                    //^
+                }
+            }
+        }        
+    """)
 }
diff --git a/src/test/kotlin/org/move/lang/types/ExpressionTypesTest.kt b/src/test/kotlin/org/move/lang/types/ExpressionTypesTest.kt
@@ -541,7 +541,7 @@ class ExpressionTypesTest : TypificationTestCase() {
         fun main() {
             let a = while (true) { 1; };
             a;
-          //^ ()  
+          //^ <never>  
         }
     }    
     """
@@ -1757,4 +1757,37 @@ module 0x1::main {
             }
         }
     """)
+
+    fun `test for expr index partial`() = testExpr("""
+        module 0x1::m {
+            fun main() {
+                for (i in ) {
+                    i;
+                  //^ <unknown>  
+                };
+            }
+        }        
+    """)
+
+    fun `test for expr index range expr int type`() = testExpr("""
+        module 0x1::m {
+            fun main() {
+                for (i in 1..10) {
+                    i;
+                  //^ integer  
+                };
+            }
+        }        
+    """)
+
+    fun `test for expr index range expr bool type`() = testExpr("""
+        module 0x1::m {
+            fun main() {
+                for (i in false..true) {
+                    i;
+                  //^ bool  
+                };
+            }
+        }        
+    """)
 }