Merge pull request #197 from pontem-network/enum-feature-flag

enum/match feature flag

src/main/kotlin/org/move/ide/annotator/MvSyntaxErrorAnnotator.kt

@@ -18,13 +18,15 @@ class MvSyntaxErrorAnnotator: MvAnnotatorBase() {
     override fun annotateInternal(element: PsiElement, holder: AnnotationHolder) {
         val moveHolder = MvAnnotationHolder(holder)
         val visitor = object: MvVisitor() {
+
             override fun visitLitExpr(expr: MvLitExpr) = checkLitExpr(moveHolder, expr)
             override fun visitCastExpr(expr: MvCastExpr) = checkCastExpr(moveHolder, expr)
-//            override fun visitStruct(s: MvStruct) = checkStruct(moveHolder, s)
             override fun visitFunction(o: MvFunction) = checkFunction(moveHolder, o)
             override fun visitSpecFunction(o: MvSpecFunction) = checkSpecFunction(moveHolder, o)
             override fun visitIndexExpr(o: MvIndexExpr) = checkIndexExpr(moveHolder, o)
             override fun visitMethodCall(o: MvMethodCall) = checkMethodCall(moveHolder, o)
+            override fun visitEnum(o: MvEnum) = checkEnum(moveHolder, o)
+            override fun visitMatchExpr(o: MvMatchExpr) = checkMatchExpr(moveHolder, o)
 
             override fun visitModule(o: MvModule) {
                 checkVisibilityModifiers(moveHolder, o)
@@ -33,6 +35,22 @@ class MvSyntaxErrorAnnotator: MvAnnotatorBase() {
         element.accept(visitor)
     }
 
+    private fun checkEnum(holder: MvAnnotationHolder, enum: MvEnum) {
+        if (!enum.project.moveSettings.enableMove2) {
+            Diagnostic
+                .EnumIsNotSupportedInCompilerV1(enum)
+                .addToHolder(holder)
+        }
+    }
+
+    private fun checkMatchExpr(holder: MvAnnotationHolder, matchExpr: MvMatchExpr) {
+        if (!matchExpr.project.moveSettings.enableMove2) {
+            Diagnostic
+                .MatchExprIsNotSupportedInCompilerV1(matchExpr)
+                .addToHolder(holder)
+        }
+    }
+
     private fun checkFunction(holder: MvAnnotationHolder, function: MvFunction) {
         when {
             function.isEntry -> {
@@ -75,13 +93,6 @@ class MvSyntaxErrorAnnotator: MvAnnotatorBase() {
         }
     }
 
-//    private fun checkStruct(holder: MvAnnotationHolder, struct: MvStruct) {
-//        val native = struct.native ?: return
-//        val errorRange = TextRange.create(native.startOffset, struct.structKw.endOffset)
-//        Diagnostic.NativeStructNotSupported(struct, errorRange)
-//            .addToHolder(holder)
-//    }
-
     private fun checkVisibilityModifiers(
         holder: MvAnnotationHolder,
         module: MvModule

src/main/kotlin/org/move/lang/core/completion/KeywordCompletionContributor.kt

@@ -6,9 +6,11 @@ import com.intellij.codeInsight.completion.CompletionResultSet
 import com.intellij.codeInsight.completion.CompletionType
 import com.intellij.patterns.PlatformPatterns
 import com.intellij.patterns.PlatformPatterns.psiElement
+import com.intellij.util.containers.addAllIfNotNull
 import org.move.cli.settings.moveSettings
-import org.move.lang.MvElementTypes.*
-import org.move.lang.core.*
+import org.move.lang.MvElementTypes.FUNCTION_PARAMETER_LIST
+import org.move.lang.core.FUNCTION_MODIFIERS
+import org.move.lang.core.MvPsiPattern
 import org.move.lang.core.MvPsiPattern.afterAnySibling
 import org.move.lang.core.MvPsiPattern.anySpecStart
 import org.move.lang.core.MvPsiPattern.codeStatementPattern
@@ -20,6 +22,7 @@ import org.move.lang.core.MvPsiPattern.moduleSpecBlock
 import org.move.lang.core.MvPsiPattern.script
 import org.move.lang.core.MvPsiPattern.toplevel
 import org.move.lang.core.MvPsiPattern.typeParameter
+import org.move.lang.core.TYPES
 import org.move.lang.core.completion.providers.FunctionModifierCompletionProvider
 import org.move.lang.core.completion.providers.KeywordCompletionProvider
 
@@ -43,18 +46,24 @@ class KeywordCompletionContributor: CompletionContributor() {
         extend(
             CompletionType.BASIC,
             module().and(identifierStatementBeginningPattern()),
-            KeywordCompletionProvider(
-                *VISIBILITY_MODIFIERS,
-                *CONTEXT_FUNCTION_MODIFIERS,
-                "native",
-                "fun",
-                "struct",
-                "const",
-                "use",
-                "spec",
-                "friend",
-                "enum",
-            )
+            KeywordCompletionProvider { project ->
+                buildList {
+                    addAllIfNotNull(
+                        *VISIBILITY_MODIFIERS,
+                        *CONTEXT_FUNCTION_MODIFIERS,
+                        "native",
+                        "fun",
+                        "struct",
+                        "const",
+                        "use",
+                        "spec",
+                        "friend",
+                    )
+                    if (project.moveSettings.enableMove2) {
+                        add("enum")
+                    }
+                }
+            }
         )
         extend(
             CompletionType.BASIC,
@@ -87,19 +96,25 @@ class KeywordCompletionContributor: CompletionContributor() {
         extend(
             CompletionType.BASIC,
             codeStatementPattern().and(identifierStatementBeginningPattern()),
-            KeywordCompletionProvider(
-                "let",
-                "loop",
-                "while",
-                "continue",
-                "break",
-                "if",
-                "else",
-                "abort",
-                "return",
-                "for",
-                "match",
-            )
+            KeywordCompletionProvider { project ->
+                buildList {
+                    addAllIfNotNull(
+                        "let",
+                        "loop",
+                        "while",
+                        "continue",
+                        "break",
+                        "if",
+                        "else",
+                        "abort",
+                        "return",
+                        "for",
+                    )
+                    if (project.moveSettings.enableMove2) {
+                        add("match")
+                    }
+                }
+            }
         )
         extend(
             CompletionType.BASIC,

src/main/kotlin/org/move/lang/core/psi/ext/MvEnum.kt

@@ -1,8 +1,10 @@
 package org.move.lang.core.psi.ext
 
 import com.intellij.lang.ASTNode
+import com.intellij.psi.PsiElement
 import com.intellij.psi.stubs.IStubElementType
 import org.move.ide.MoveIcons
+import org.move.lang.MvElementTypes.ENUM_KW
 import org.move.lang.core.psi.MvAbilitiesList
 import org.move.lang.core.psi.MvEnum
 import org.move.lang.core.psi.MvEnumVariant
@@ -13,6 +15,7 @@ import org.move.lang.core.types.MvPsiTypeImplUtil
 import org.move.lang.core.types.ty.Ty
 import javax.swing.Icon
 
+val MvEnum.enumKw: PsiElement? get() = findFirstChildByType(ENUM_KW)
 val MvEnum.variants: List<MvEnumVariant> get() = enumBody?.enumVariantList.orEmpty()
 
 val MvEnum.tupleVariants: List<MvEnumVariant> get() = variants.filter { it.tupleFields != null }

src/main/kotlin/org/move/lang/core/psi/ext/MvMatchExpr.kt

@@ -1,10 +1,14 @@
 package org.move.lang.core.psi.ext
 
+import com.intellij.psi.PsiElement
+import org.move.lang.MvElementTypes.MATCH_KW
 import org.move.lang.core.psi.MvMatchArgument
 import org.move.lang.core.psi.MvMatchArm
 import org.move.lang.core.psi.MvMatchBody
 import org.move.lang.core.psi.MvMatchExpr
 
+val MvMatchExpr.matchKw: PsiElement? get() = findFirstChildByType(MATCH_KW)
+
 val MvMatchExpr.matchArgument: MvMatchArgument get() = childOfType<MvMatchArgument>()!!
 val MvMatchExpr.matchBody: MvMatchBody get() = childOfType<MvMatchBody>()!!
 val MvMatchExpr.arms: List<MvMatchArm> get() = matchBody.matchArmList

src/main/kotlin/org/move/lang/utils/Diagnostic.kt

@@ -203,6 +203,28 @@ sealed class Diagnostic(
         }
     }
 
+    class EnumIsNotSupportedInCompilerV1(enum: MvEnum): Diagnostic(enum.enumKw!!) {
+
+        override fun prepare(): PreparedAnnotation {
+            return PreparedAnnotation(
+                ERROR,
+                "Enums are not supported in Aptos Move V1",
+                fixes = listOf(EnableMoveV2Fix(element))
+            )
+        }
+    }
+
+    class MatchExprIsNotSupportedInCompilerV1(matchExpr: MvMatchExpr): Diagnostic(matchExpr.matchKw!!) {
+
+        override fun prepare(): PreparedAnnotation {
+            return PreparedAnnotation(
+                ERROR,
+                "Match expressions are not supported in Aptos Move V1",
+                fixes = listOf(EnableMoveV2Fix(element))
+            )
+        }
+    }
+
     class PublicPackageIsNotSupportedInCompilerV1(modifier: MvVisibilityModifier): Diagnostic(modifier) {
 
         override fun prepare(): PreparedAnnotation {

src/test/kotlin/org/move/ide/annotator/syntaxErrors/compilerV2/EnumMatchTest.kt

@@ -0,0 +1,43 @@
+package org.move.ide.annotator.syntaxErrors.compilerV2
+
+import org.move.ide.annotator.MvSyntaxErrorAnnotator
+import org.move.utils.tests.MoveV2
+import org.move.utils.tests.annotation.AnnotatorTestCase
+
+class EnumMatchTest: AnnotatorTestCase(MvSyntaxErrorAnnotator::class) {
+    @MoveV2(false)
+    fun `test enum is not supported in v1`() = checkWarnings("""
+        module 0x1::m {
+            <error descr="Enums are not supported in Aptos Move V1">enum</error> S { One }
+            
+        }        
+    """)
+
+    @MoveV2(true)
+    fun `test enums in v2`() = checkWarnings("""
+        module 0x1::m {
+            enum S { One }
+            
+        }        
+    """)
+
+    @MoveV2(false)
+    fun `test match is not supported in v1`() = checkWarnings("""
+        module 0x1::m {
+            struct S {}
+            fun main(s: S) {
+                <error descr="Match expressions are not supported in Aptos Move V1">match</error> (s) {}
+            }            
+        }        
+    """)
+
+    @MoveV2(true)
+    fun `test match in v2`() = checkWarnings("""
+        module 0x1::m {
+            struct S {}
+            fun main(s: S) {
+                match (s) {}
+            }            
+        }        
+    """)
+}

src/test/kotlin/org/move/lang/completion/KeywordCompletionTest.kt

@@ -627,6 +627,7 @@ class KeywordCompletionTest: CompletionTestCase() {
 //        """
 //    )
 
+    @MoveV2(enabled = true)
     fun `test enum completion`() = doSingleCompletion(
         """
             module 0x1::m {
@@ -640,6 +641,16 @@ class KeywordCompletionTest: CompletionTestCase() {
         """,
     )
 
+    @MoveV2(enabled = false)
+    fun `test no enum completion for v1`() = checkNoCompletion(
+        """
+            module 0x1::m {
+                enu/*caret*/
+            }            
+                """
+    )
+
+    @MoveV2(enabled = true)
     fun `test match completion`() = doSingleCompletion(
         """
             module 0x1::m {
@@ -657,6 +668,17 @@ class KeywordCompletionTest: CompletionTestCase() {
         """,
     )
 
+    @MoveV2(enabled = false)
+    fun `test no match completion for v1`() = checkNoCompletion(
+        """
+            module 0x1::m {
+                fun main() {
+                    mat/*caret*/
+                }
+            }            
+                """
+    )
+
     fun `test no boolean completion in fq path`() = checkNoCompletion("""
         module 0x1::m {
             fun main() {