Add support for game variables

waleedyaseen · waleedyaseen · commit 89c8f6d9a56c · 2023-08-17T22:11:35.000+03:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -4,6 +4,7 @@
 ### Added
 - Support for basic spell checking and custom dictionary.
 - Support for specific parameter types in triggers.
+- Support for game variable type checking/refactoring/find usages.
 
 ## [1.1.0] - 2023-08-11
 
diff --git a/src/main/gen/io/runescript/plugin/lang/psi/RsElementTypes.java b/src/main/gen/io/runescript/plugin/lang/psi/RsElementTypes.java
@@ -43,7 +43,7 @@ public interface RsElementTypes {
   IElementType RELATIONAL_VALUE_EXPRESSION = new RsElementType("RELATIONAL_VALUE_EXPRESSION");
   IElementType RETURN_LIST = StubElementTypeFactory.create("RETURN_LIST");
   IElementType RETURN_STATEMENT = new RsElementType("RETURN_STATEMENT");
-  IElementType SCOPED_VARIABLE_EXPRESSION = new RsElementType("SCOPED_VARIABLE_EXPRESSION");
+  IElementType SCOPED_VARIABLE_EXPRESSION = StubElementTypeFactory.create("SCOPED_VARIABLE_EXPRESSION");
   IElementType SCRIPT = StubElementTypeFactory.create("SCRIPT");
   IElementType STATEMENT = new RsElementType("STATEMENT");
   IElementType STATEMENT_LIST = new RsElementType("STATEMENT_LIST");
diff --git a/src/main/gen/io/runescript/plugin/lang/psi/RsScopedVariableExpression.java b/src/main/gen/io/runescript/plugin/lang/psi/RsScopedVariableExpression.java
@@ -4,8 +4,10 @@
 import java.util.List;
 import org.jetbrains.annotations.*;
 import com.intellij.psi.PsiElement;
+import com.intellij.psi.StubBasedPsiElement;
+import io.runescript.plugin.lang.stubs.RsScopedVariableExpressionStub;
 
-public interface RsScopedVariableExpression extends RsExpression {
+public interface RsScopedVariableExpression extends RsExpression, RsNamedElement, StubBasedPsiElement<RsScopedVariableExpressionStub> {
 
   @NotNull
   RsNameLiteral getNameLiteral();
diff --git a/src/main/gen/io/runescript/plugin/lang/psi/RsVisitor.java b/src/main/gen/io/runescript/plugin/lang/psi/RsVisitor.java
@@ -155,6 +155,7 @@ public void visitReturnStatement(@NotNull RsReturnStatement o) {
 
   public void visitScopedVariableExpression(@NotNull RsScopedVariableExpression o) {
     visitExpression(o);
+    // visitNamedElement(o);
   }
 
   public void visitScript(@NotNull RsScript o) {
diff --git a/src/main/gen/io/runescript/plugin/lang/psi/impl/RsScopedVariableExpressionImpl.java b/src/main/gen/io/runescript/plugin/lang/psi/impl/RsScopedVariableExpressionImpl.java
@@ -8,15 +8,26 @@
 import com.intellij.psi.PsiElementVisitor;
 import com.intellij.psi.util.PsiTreeUtil;
 import static io.runescript.plugin.lang.psi.RsElementTypes.*;
+import io.runescript.plugin.lang.psi.mixin.RsScopedVariableExpressionMixin;
 import io.runescript.plugin.lang.psi.*;
+import io.runescript.plugin.lang.stubs.RsScopedVariableExpressionStub;
+import com.intellij.psi.stubs.IStubElementType;
+import com.intellij.psi.tree.IElementType;
 
-public class RsScopedVariableExpressionImpl extends RsExpressionImpl implements RsScopedVariableExpression {
+public class RsScopedVariableExpressionImpl extends RsScopedVariableExpressionMixin implements RsScopedVariableExpression {
 
   public RsScopedVariableExpressionImpl(@NotNull ASTNode node) {
     super(node);
   }
 
-  @Override
+  public RsScopedVariableExpressionImpl(@NotNull RsScopedVariableExpressionStub stub, @NotNull IStubElementType<?, ?> type) {
+    super(stub, type);
+  }
+
+  public RsScopedVariableExpressionImpl(@Nullable RsScopedVariableExpressionStub stub, @Nullable IElementType type, @Nullable ASTNode node) {
+    super(stub, type, node);
+  }
+
   public void accept(@NotNull RsVisitor visitor) {
     visitor.visitScopedVariableExpression(this);
   }
@@ -30,7 +41,7 @@ public void accept(@NotNull PsiElementVisitor visitor) {
   @Override
   @NotNull
   public RsNameLiteral getNameLiteral() {
-    return notNullChild(PsiTreeUtil.getChildOfType(this, RsNameLiteral.class));
+    return notNullChild(PsiTreeUtil.getStubChildOfType(this, RsNameLiteral.class));
   }
 
   @Override
diff --git a/src/main/grammars/RuneScript.bnf b/src/main/grammars/RuneScript.bnf
@@ -203,7 +203,13 @@ LocalVariableExpression ::= '$' NameLiteral {
 }
 
 ArrayAccessExpression ::= LocalVariableExpression '(' Expression ')'
-ScopedVariableExpression ::= '%' NameLiteral
+ScopedVariableExpression ::= '%' NameLiteral {
+    mixin="io.runescript.plugin.lang.psi.mixin.RsScopedVariableExpressionMixin"
+    stubClass="io.runescript.plugin.lang.stubs.RsScopedVariableExpressionStub"
+    elementTypeFactory = "io.runescript.plugin.lang.stubs.StubElementTypeFactory.create"
+    implements="io.runescript.plugin.lang.psi.RsNamedElement"
+}
+
 private LiteralExpression ::= IntegerLiteralExpression
                              | CoordLiteralExpression
                              | BooleanLiteralExpression
diff --git a/src/main/kotlin/io/runescript/plugin/ide/inspections/RuneScriptUnresolvedScopedVariableInspection.kt b/src/main/kotlin/io/runescript/plugin/ide/inspections/RuneScriptUnresolvedScopedVariableInspection.kt
@@ -0,0 +1,26 @@
+package io.runescript.plugin.ide.inspections
+
+import com.intellij.codeInspection.LocalInspectionTool
+import com.intellij.codeInspection.ProblemHighlightType
+import com.intellij.codeInspection.ProblemsHolder
+import com.intellij.psi.PsiElementVisitor
+import io.runescript.plugin.ide.RsBundle
+import io.runescript.plugin.lang.psi.RsScopedVariableExpression
+import io.runescript.plugin.lang.psi.RsVisitor
+
+class RuneScriptUnresolvedScopedVariableInspection : LocalInspectionTool() {
+
+    override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
+        return object : RsVisitor() {
+            override fun visitScopedVariableExpression(o: RsScopedVariableExpression) {
+                val reference = o.reference ?: return
+                if (reference.resolve() == null) {
+                    holder.registerProblem(o,
+                            RsBundle.message("inspection.error.unresolved.scoped.variable", o.nameLiteral.text),
+                            ProblemHighlightType.LIKE_UNKNOWN_SYMBOL
+                    )
+                }
+            }
+        }
+    }
+}
diff --git a/src/main/kotlin/io/runescript/plugin/ide/usages/RsReadWriteAccessDetector.kt b/src/main/kotlin/io/runescript/plugin/ide/usages/RsReadWriteAccessDetector.kt
@@ -3,22 +3,24 @@ package io.runescript.plugin.ide.usages
 import com.intellij.codeInsight.highlighting.ReadWriteAccessDetector
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiReference
-import io.runescript.plugin.lang.psi.RsAssignmentStatement
-import io.runescript.plugin.lang.psi.RsDynamicExpression
-import io.runescript.plugin.lang.psi.RsLocalVariableDeclarationStatement
-import io.runescript.plugin.lang.psi.RsLocalVariableExpression
+import io.runescript.plugin.lang.psi.*
+import io.runescript.plugin.symbollang.psi.RsSymSymbol
+import io.runescript.plugin.symbollang.psi.isVarFile
 
 class RsReadWriteAccessDetector : ReadWriteAccessDetector() {
 
     // TODO(Walied): Add array variable support and do not assume declaration
     //  without initializer are write accesses.
 
     override fun isReadWriteAccessible(element: PsiElement): Boolean {
+        if (element is RsSymSymbol) {
+            return element.containingFile?.virtualFile?.isVarFile() ?: false
+        }
         return element is RsLocalVariableExpression
     }
 
     override fun isDeclarationWriteAccess(element: PsiElement): Boolean {
-        require(element is RsLocalVariableExpression)
+        require(element is RsLocalVariableExpression || element is RsSymSymbol)
         val parent = element.parent
         return element is RsAssignmentStatement || parent is RsLocalVariableDeclarationStatement
     }
@@ -28,7 +30,9 @@ class RsReadWriteAccessDetector : ReadWriteAccessDetector() {
     }
 
     override fun getExpressionAccess(expression: PsiElement): Access {
-        require(expression is RsLocalVariableExpression || expression is RsDynamicExpression)
+        require(expression is RsLocalVariableExpression
+                || expression is RsScopedVariableExpression
+                || expression is RsDynamicExpression)
         val parent = expression.parent
         if (parent is RsAssignmentStatement || parent is RsLocalVariableDeclarationStatement) {
             return Access.Write
diff --git a/src/main/kotlin/io/runescript/plugin/lang/psi/mixin/RsScopedVariableExpressionMixin.kt b/src/main/kotlin/io/runescript/plugin/lang/psi/mixin/RsScopedVariableExpressionMixin.kt
@@ -0,0 +1,46 @@
+package io.runescript.plugin.lang.psi.mixin
+
+import com.intellij.extapi.psi.StubBasedPsiElementBase
+import com.intellij.lang.ASTNode
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiReference
+import com.intellij.psi.search.GlobalSearchScope
+import com.intellij.psi.search.SearchScope
+import com.intellij.psi.stubs.IStubElementType
+import com.intellij.psi.tree.IElementType
+import com.intellij.refactoring.suggested.startOffset
+import io.runescript.plugin.lang.psi.RsPsiImplUtil
+import io.runescript.plugin.lang.psi.RsScopedVariableExpression
+import io.runescript.plugin.lang.psi.refs.RsScopedVariableReference
+import io.runescript.plugin.lang.stubs.RsScopedVariableExpressionStub
+
+abstract class RsScopedVariableExpressionMixin : StubBasedPsiElementBase<RsScopedVariableExpressionStub>, RsScopedVariableExpression {
+
+    constructor(node: ASTNode) : super(node)
+    constructor(stub: RsScopedVariableExpressionStub, type: IStubElementType<*, *>) : super(stub, type)
+    constructor(stub: RsScopedVariableExpressionStub?, type: IElementType?, node: ASTNode?) : super(stub, type, node)
+
+    override fun getUseScope(): SearchScope {
+        return GlobalSearchScope.projectScope(project)
+    }
+
+    override fun getReference(): PsiReference? {
+        return RsScopedVariableReference(this)
+    }
+
+    override fun getTextOffset(): Int {
+        return nameLiteral.startOffset
+    }
+
+    override fun getNameIdentifier(): PsiElement {
+        return nameLiteral
+    }
+
+    override fun getName(): String {
+        return RsPsiImplUtil.getName(nameLiteral)
+    }
+
+    override fun setName(newName: String): PsiElement {
+        return RsPsiImplUtil.setName(nameLiteral, newName)
+    }
+}
diff --git a/src/main/kotlin/io/runescript/plugin/lang/psi/refs/RsScopedVariableReference.kt b/src/main/kotlin/io/runescript/plugin/lang/psi/refs/RsScopedVariableReference.kt
@@ -0,0 +1,35 @@
+package io.runescript.plugin.lang.psi.refs
+
+import com.intellij.psi.*
+import io.runescript.plugin.lang.psi.RsScopedVariableExpression
+import io.runescript.plugin.lang.psi.type.RsPrimitiveType
+import io.runescript.plugin.symbollang.psi.index.RsSymbolIndex
+
+class RsScopedVariableReference(element: RsScopedVariableExpression) :
+        PsiReferenceBase<RsScopedVariableExpression>(element, element.nameLiteral.textRangeInParent), PsiPolyVariantReference {
+
+    override fun resolve(): PsiElement? {
+        val result = multiResolve(false)
+        return result.singleOrNull()?.element
+    }
+
+    override fun multiResolve(incompleteCode: Boolean): Array<ResolveResult> {
+        return scopedVarTypes
+            .mapNotNull { RsSymbolIndex.lookup(element.project, it, element.name!!) }
+            .map { PsiElementResolveResult(it) }
+            .toTypedArray()
+    }
+
+    override fun handleElementRename(newElementName: String): PsiElement {
+        element.setName(newElementName)
+        return element
+    }
+
+    companion object {
+        private val scopedVarTypes = arrayOf(
+            RsPrimitiveType.VARP,
+            RsPrimitiveType.VARC,
+            RsPrimitiveType.VARBIT
+        )
+    }
+}
diff --git a/src/main/kotlin/io/runescript/plugin/lang/psi/type/inference/RsTypeInferenceVisitor.kt b/src/main/kotlin/io/runescript/plugin/lang/psi/type/inference/RsTypeInferenceVisitor.kt
@@ -314,6 +314,12 @@ class RsTypeInferenceVisitor(private val myInferenceData: RsTypeInference) : RsV
     }
 
     override fun visitScopedVariableExpression(o: RsScopedVariableExpression) {
+        val reference = o.reference?.resolve() as? RsSymSymbol
+        if (reference == null) {
+            o.type = RsErrorType
+            return
+        }
+        o.type = RsPrimitiveType.lookupReferencableOrNull(reference.fieldList[2].text) ?: RsErrorType
     }
 
     override fun visitLocalVariableExpression(o: RsLocalVariableExpression) {
diff --git a/src/main/kotlin/io/runescript/plugin/lang/stubs/RsScopedVariableExpressionStub.kt b/src/main/kotlin/io/runescript/plugin/lang/stubs/RsScopedVariableExpressionStub.kt
@@ -0,0 +1,9 @@
+package io.runescript.plugin.lang.stubs
+
+import com.intellij.psi.stubs.IStubElementType
+import com.intellij.psi.stubs.StubBase
+import com.intellij.psi.stubs.StubElement
+import io.runescript.plugin.lang.psi.RsScopedVariableExpression
+
+class RsScopedVariableExpressionStub(parent: StubElement<*>?, elementType: IStubElementType<*, *>, val name: String)
+    : StubBase<RsScopedVariableExpression>(parent, elementType)
diff --git a/src/main/kotlin/io/runescript/plugin/lang/stubs/StubElementTypeFactory.kt b/src/main/kotlin/io/runescript/plugin/lang/stubs/StubElementTypeFactory.kt
@@ -14,6 +14,7 @@ object StubElementTypeFactory {
             "RETURN_LIST" -> RsReturnListStubType
             "TYPE_NAME" -> RsTypeNameStubType
             "LOCAL_VARIABLE_EXPRESSION" -> RsLocalVariableExpressionStubType
+            "SCOPED_VARIABLE_EXPRESSION" -> RsScopedVariableExpressionStubType
             "NAME_LITERAL" -> RsNameLiteralStubType
             else -> error("Unrecognized stub type: $name")
         }
diff --git a/src/main/kotlin/io/runescript/plugin/lang/stubs/types/RsScopedVariableExpressionStubType.kt b/src/main/kotlin/io/runescript/plugin/lang/stubs/types/RsScopedVariableExpressionStubType.kt
@@ -0,0 +1,34 @@
+package io.runescript.plugin.lang.stubs.types
+
+import com.intellij.psi.PsiElement
+import com.intellij.psi.stubs.IndexSink
+import com.intellij.psi.stubs.StubElement
+import com.intellij.psi.stubs.StubInputStream
+import com.intellij.psi.stubs.StubOutputStream
+import io.runescript.plugin.lang.psi.RsScopedVariableExpression
+import io.runescript.plugin.lang.psi.RsStubType
+import io.runescript.plugin.lang.psi.impl.RsScopedVariableExpressionImpl
+import io.runescript.plugin.lang.stubs.RsScopedVariableExpressionStub
+
+object RsScopedVariableExpressionStubType : RsStubType<RsScopedVariableExpressionStub, RsScopedVariableExpression>("SCOPED_VARIABLE_EXPRESSION") {
+
+    override fun deserialize(dataStream: StubInputStream, parentStub: StubElement<*>?): RsScopedVariableExpressionStub {
+        return RsScopedVariableExpressionStub(parentStub, this, dataStream.readUTF())
+    }
+
+    override fun serialize(stub: RsScopedVariableExpressionStub, dataStream: StubOutputStream) {
+        dataStream.writeUTF(stub.name)
+    }
+
+    override fun createStub(psi: RsScopedVariableExpression, parentStub: StubElement<out PsiElement>?): RsScopedVariableExpressionStub {
+        return RsScopedVariableExpressionStub(parentStub, this, psi.name!!)
+    }
+
+    override fun createPsi(stub: RsScopedVariableExpressionStub): RsScopedVariableExpression {
+        return RsScopedVariableExpressionImpl(stub, this)
+    }
+
+    override fun indexStub(stub: RsScopedVariableExpressionStub, sink: IndexSink) {
+        // TODO
+    }
+}
diff --git a/src/main/kotlin/io/runescript/plugin/symbollang/psi/RsSymPsiExtensions.kt b/src/main/kotlin/io/runescript/plugin/symbollang/psi/RsSymPsiExtensions.kt
@@ -2,4 +2,5 @@ package io.runescript.plugin.symbollang.psi
 
 import com.intellij.openapi.vfs.VirtualFile
 
-fun VirtualFile.isConstantFile() = name == "constant.sym"
+fun VirtualFile.isConstantFile() = name == "constant.sym"
+fun VirtualFile.isVarFile() = name == "varp.sym" || name == "varc.sym"
diff --git a/src/main/resources/META-INF/inspections.xml b/src/main/resources/META-INF/inspections.xml
@@ -24,6 +24,12 @@
                          enabledByDefault="true"
                          level="ERROR"
                          implementationClass="io.runescript.plugin.ide.inspections.RuneScriptUnresolvedLocalVariableInspection"/>
+        <localInspection language="RuneScript"
+                         groupName="RuneScript"
+                         displayName="Unresolved game variable"
+                         enabledByDefault="true"
+                         level="ERROR"
+                         implementationClass="io.runescript.plugin.ide.inspections.RuneScriptUnresolvedScopedVariableInspection"/>
         <localInspection language="RuneScript"
                          groupName="RuneScript"
                          displayName="Unresolved command"
diff --git a/src/main/resources/inspectionDescriptions/RuneScriptUnresolvedScopedVariable.html b/src/main/resources/inspectionDescriptions/RuneScriptUnresolvedScopedVariable.html
@@ -0,0 +1,5 @@
+<html>
+<body>
+<p>Reports when a game variable is missing.</p>
+</body>
+</html>
diff --git a/src/main/resources/messages/RsBundle.properties b/src/main/resources/messages/RsBundle.properties
@@ -49,6 +49,7 @@ inspection.error.unresolved.clientscript=Unresolved clientscript `{0}`
 inspection.error.unresolved.reference=Unresolved reference `{0}`
 inspection.error.unresolved.command=Unresolved command `{0}`
 inspection.error.unresolved.local.variable=Unresolved local variable `{0}`
+inspection.error.unresolved.scoped.variable=Unresolved game variable `{0}`
 inspection.warning.unreachable.code=Unreachable code
 inspection.error.unrecognized.trigger.type=Unrecognized trigger name `{0}`
 inspection.error.trigger.return.list.not.allowed=Trigger type `{0}` does not allow for return list

Original file line number	Diff line number	Diff line change
`@@ -155,6 +155,7 @@ public void visitReturnStatement(@NotNull RsReturnStatement o) {`
`155`	`155`
`156`	`156`	`public void visitScopedVariableExpression(@NotNull RsScopedVariableExpression o) {`
`157`	`157`	`visitExpression(o);`
	`158`	`+ // visitNamedElement(o);`
`158`	`159`	`}`
`159`	`160`
`160`	`161`	`public void visitScript(@NotNull RsScript o) {`