index class methods, can navigate (#323)

CHANGELOG.md

@@ -13,6 +13,7 @@
 ## Unreleased
 
 - :bug: [#358](https://github.com/giraud/reasonml-idea-plugin/issues/358) Incorrect resolution with module in pattern
+- :bug: [#323](https://github.com/giraud/reasonml-idea-plugin/issues/323) Method declarations in .ml files should link to their implementations
 
 NOTE: minimal version supported is 2021.3
 

build.gradle

@@ -38,6 +38,7 @@ intellij {
         changeNotes = """
                 <ul>
                     <li>#358 - Incorrect resolution with module in pattern</li>
+                    <li>#323 - Method declarations in .ml files should link to their implementations</li>
                 </ul>
                 <p><a href="https://github.com/giraud/reasonml-idea-plugin/blob/master/CHANGELOG.md">Full change log...</a></p>
                 <p/>

resources/META-INF/plugin.xml

@@ -126,7 +126,7 @@
                                        implementationClass="com.reason.ide.highlight.RmlSyntaxHighlighterFactory"/>
         <!-- Rescript -->
         <stubElementTypeHolder externalIdPrefix="Rescript."
-                               class="com.reason.lang.core.stub.RescriptStubBasedElementTypes"/>
+                               class="com.reason.lang.core.stub.ResStubBasedElementTypes"/>
         <lang.ast.factory language="Rescript" implementationClass="com.reason.lang.rescript.ResASTFactory"/>
         <lang.parserDefinition language="Rescript" implementationClass="com.reason.lang.rescript.ResSafeParserDefinition"/>
         <lang.syntaxHighlighterFactory language="Rescript"
@@ -232,7 +232,8 @@
         <stubIndex implementation="com.reason.ide.search.index.ModuleIndex"/>
         <stubIndex implementation="com.reason.ide.search.index.ModuleAliasedIndex"/>
         <stubIndex implementation="com.reason.ide.search.index.ModuleAliasesIndex"/>
-        <stubIndex implementation="com.reason.ide.search.index.KlassFqnIndex"/>
+        <stubIndex implementation="com.reason.ide.search.index.ClassFqnIndex"/>
+        <stubIndex implementation="com.reason.ide.search.index.ClassMethodFqnIndex"/>
         <stubIndex implementation="com.reason.ide.search.index.LetIndex"/>
         <stubIndex implementation="com.reason.ide.search.index.LetFqnIndex"/>
         <stubIndex implementation="com.reason.ide.search.index.ValIndex"/>

src/com/reason/hints/InsightManagerImpl.java

@@ -98,6 +98,12 @@ public void queryTypes(@NotNull VirtualFile sourceFile, @NotNull Path cmtPath, @
         String ocamlVersion = Rincewind.extractOcamlVersion(fullVersion);
         String rincewindVersion = Rincewind.getLatestVersion(ocamlVersion);
 
+        // ocaml version default - opam -> use ocaml -version ??
+        // opam switch different than default
+        // opam settings set correctly (not default)
+
+
+
         if (ocamlVersion != null && !rincewindVersion.equals(excludedVersion)) {
             return "rincewind_" + getOsPrefix() + ocamlVersion + "-" + rincewindVersion + ".exe";
         }

src/com/reason/hints/RincewindProcess.java

@@ -59,6 +59,7 @@ public void types(@NotNull VirtualFile sourceFile, @NotNull String rincewindBina
             StringBuilder msgBuffer = new StringBuilder();
             if (errReader.ready()) {
                 errReader.lines().forEach(line -> msgBuffer.append(line).append(System.lineSeparator()));
+                LOG.warn("Error when processing types");
                 LOG.warn(msgBuffer.toString());
             } else {
                 final InferredTypesImplementation types = new InferredTypesImplementation();

src/com/reason/ide/go/ORLineMarkerProvider.java

@@ -82,26 +82,33 @@ protected void collectNavigationMarkers(@NotNull PsiElement element, @NotNull Co
                         .ifPresent(psiTarget ->
                                 result.add(createGutterIcon(element, isInterface, "method", (FileBase) psiTarget.getContainingFile(), psiTarget))
                         );
-            } else {
-                if (parent instanceof PsiType) {
-                    String valQName = ((PsiTypeImpl) parent).getQualifiedName();
-                    Collection<PsiType> elements = TypeFqnIndex.getElements(valQName.hashCode(), project, scope);
-                    elements.stream()
-                            .filter(isInterface ? PSI_IMPL_PREDICATE : PSI_INTF_PREDICATE)
-                            .findFirst()
-                            .ifPresent(psiTarget ->
-                                    result.add(createGutterIcon(element, isInterface, "type", (FileBase) psiTarget.getContainingFile(), psiTarget))
-                            );
-                } else if (parent instanceof PsiKlass) {
-                    String qName = ((PsiKlassImpl) parent).getQualifiedName();
-                    Collection<PsiKlass> elements = KlassFqnIndex.getElements(qName.hashCode(), project, scope);
-                    elements.stream()
-                            .filter(isInterface ? PSI_IMPL_PREDICATE : PSI_INTF_PREDICATE)
-                            .findFirst()
-                            .ifPresent(psiTarget ->
-                                    result.add(createGutterIcon(element, isInterface, "class", (FileBase) psiTarget.getContainingFile(), psiTarget))
-                            );
-                }
+            } else if (parent instanceof PsiType) {
+                String valQName = ((PsiTypeImpl) parent).getQualifiedName();
+                Collection<PsiType> elements = TypeFqnIndex.getElements(valQName.hashCode(), project, scope);
+                elements.stream()
+                        .filter(isInterface ? PSI_IMPL_PREDICATE : PSI_INTF_PREDICATE)
+                        .findFirst()
+                        .ifPresent(psiTarget ->
+                                result.add(createGutterIcon(element, isInterface, "type", (FileBase) psiTarget.getContainingFile(), psiTarget))
+                        );
+            } else if (parent instanceof RsiClass) {
+                String qName = ((RsiClassImpl) parent).getQualifiedName();
+                Collection<RsiClass> elements = ClassFqnIndex.getElements(qName.hashCode(), project, scope);
+                elements.stream()
+                        .filter(isInterface ? PSI_IMPL_PREDICATE : PSI_INTF_PREDICATE)
+                        .findFirst()
+                        .ifPresent(psiTarget ->
+                                result.add(createGutterIcon(element, isInterface, "class", (FileBase) psiTarget.getContainingFile(), psiTarget))
+                        );
+            } else if (parent instanceof RsiClassMethodImpl) {
+                String qName = ((RsiClassMethodImpl) parent).getQualifiedName();
+                Collection<RsiClassMethod> elements = ClassMethodFqnIndex.getElements(qName.hashCode(), project, scope);
+                elements.stream()
+                        .filter(isInterface ? PSI_IMPL_PREDICATE : PSI_INTF_PREDICATE)
+                        .findFirst()
+                        .ifPresent(psiTarget ->
+                                result.add(createGutterIcon(element, isInterface, "method", (FileBase) psiTarget.getContainingFile(), psiTarget))
+                        );
             }
         } else if (element instanceof PsiUpperSymbol) {
             if (parent instanceof PsiInnerModule) {

src/com/reason/ide/insight/provider/DotExpressionCompletionProvider.java

@@ -117,7 +117,7 @@ private static void addFileExpressions(@NotNull FileBase element, @NotNull Colle
         modules.remove(modules.size() - 1); // remove fake module
         expressions.addAll(modules);
         expressions.addAll(PsiTreeUtil.getStubChildrenOfTypeAsList(element, PsiFunctor.class));
-        expressions.addAll(PsiTreeUtil.getStubChildrenOfTypeAsList(element, PsiKlass.class));
+        expressions.addAll(PsiTreeUtil.getStubChildrenOfTypeAsList(element, RsiClass.class));
         expressions.addAll(PsiTreeUtil.getStubChildrenOfTypeAsList(element, PsiExternal.class));
         expressions.addAll(PsiTreeUtil.getStubChildrenOfTypeAsList(element, PsiException.class));
     }
@@ -177,7 +177,7 @@ private static void addChildren(@Nullable PsiElement body, @NotNull Collection<P
         expressions.addAll(PsiTreeUtil.getStubChildrenOfTypeAsList(body, PsiVal.class));
         expressions.addAll(PsiTreeUtil.getStubChildrenOfTypeAsList(body, PsiModule.class));
         expressions.addAll(PsiTreeUtil.getStubChildrenOfTypeAsList(body, PsiFunctor.class));
-        expressions.addAll(PsiTreeUtil.getStubChildrenOfTypeAsList(body, PsiKlass.class));
+        expressions.addAll(PsiTreeUtil.getStubChildrenOfTypeAsList(body, RsiClass.class));
         expressions.addAll(PsiTreeUtil.getStubChildrenOfTypeAsList(body, PsiExternal.class));
         expressions.addAll(PsiTreeUtil.getStubChildrenOfTypeAsList(body, PsiException.class));
     }

src/com/reason/ide/search/index/KlassFqnIndex.java → src/com/reason/ide/search/index/ClassFqnIndex.java

@@ -9,18 +9,18 @@
 
 import java.util.*;
 
-public class KlassFqnIndex extends IntStubIndexExtension<PsiKlass> {
+public class ClassFqnIndex extends IntStubIndexExtension<RsiClass> {
     @Override
     public int getVersion() {
-        return super.getVersion() + ORStubVersions.KLASS;
+        return super.getVersion() + ORStubVersions.CLASS;
     }
 
     @Override
-    public @NotNull StubIndexKey<Integer, PsiKlass> getKey() {
+    public @NotNull StubIndexKey<Integer, RsiClass> getKey() {
         return IndexKeys.CLASSES_FQN;
     }
 
-    public static @NotNull Collection<PsiKlass> getElements(int key, @NotNull Project project, @Nullable GlobalSearchScope scope) {
-        return StubIndex.getElements(IndexKeys.CLASSES_FQN, key, project, scope, PsiKlass.class);
+    public static @NotNull Collection<RsiClass> getElements(int key, @NotNull Project project, @Nullable GlobalSearchScope scope) {
+        return StubIndex.getElements(IndexKeys.CLASSES_FQN, key, project, scope, RsiClass.class);
     }
 }

src/com/reason/ide/search/index/ClassMethodFqnIndex.java

@@ -0,0 +1,26 @@
+package com.reason.ide.search.index;
+
+import com.intellij.openapi.project.*;
+import com.intellij.psi.search.*;
+import com.intellij.psi.stubs.*;
+import com.reason.lang.core.psi.*;
+import com.reason.lang.core.stub.type.*;
+import org.jetbrains.annotations.*;
+
+import java.util.*;
+
+public class ClassMethodFqnIndex extends IntStubIndexExtension<RsiClassMethod> {
+    @Override
+    public int getVersion() {
+        return super.getVersion() + ORStubVersions.CLASS_METHOD;
+    }
+
+    @Override
+    public @NotNull StubIndexKey<Integer, RsiClassMethod> getKey() {
+        return IndexKeys.CLASS_METHODS_FQN;
+    }
+
+    public static @NotNull Collection<RsiClassMethod> getElements(int key, @NotNull Project project, @Nullable GlobalSearchScope scope) {
+        return StubIndex.getElements(IndexKeys.CLASS_METHODS_FQN, key, project, scope, RsiClassMethod.class);
+    }
+}

src/com/reason/ide/search/index/IndexKeys.java

@@ -19,7 +19,8 @@ interface ProcessElement<T> {
     public static final StubIndexKey<String, PsiModule> MODULES_ALIASED = StubIndexKey.createIndexKey("reason.module.aliased");
     public static final StubIndexKey<String, PsiModule> MODULES_ALIASES = StubIndexKey.createIndexKey("reason.module.aliases");
     public static final StubIndexKey<Integer, PsiModule> MODULES_FQN = StubIndexKey.createIndexKey("reason.module.fqn");
-    public static final StubIndexKey<Integer, PsiKlass> CLASSES_FQN = StubIndexKey.createIndexKey("reason.class.fqn");
+    public static final StubIndexKey<Integer, RsiClass> CLASSES_FQN = StubIndexKey.createIndexKey("reason.class.fqn");
+    public static final StubIndexKey<Integer, RsiClassMethod> CLASS_METHODS_FQN = StubIndexKey.createIndexKey("reason.method.fqn");
     public static final StubIndexKey<String, PsiVariantDeclaration> VARIANTS = StubIndexKey.createIndexKey("reason.variant");
     public static final StubIndexKey<Integer, PsiVariantDeclaration> VARIANTS_FQN = StubIndexKey.createIndexKey("reason.variant.fqn");
     public static final StubIndexKey<String, PsiLet> LETS = StubIndexKey.createIndexKey("reason.let");

src/com/reason/ide/settings/ORSettingsConfigurable.java

@@ -1,6 +1,5 @@
 package com.reason.ide.settings;
 
-import com.intellij.execution.wsl.*;
 import com.intellij.openapi.application.*;
 import com.intellij.openapi.fileChooser.*;
 import com.intellij.openapi.module.Module;

src/com/reason/ide/structure/StructureViewElement.java

@@ -148,8 +148,8 @@ public Icon getIcon(boolean unused) {
             treeElements = buildFunctorStructure((PsiFunctor) m_element);
         } else if (m_element instanceof PsiType) {
             treeElements = buildTypeStructure((PsiType) m_element);
-        } else if (m_element instanceof PsiKlass) {
-            treeElements = buildClassStructure((PsiKlass) m_element);
+        } else if (m_element instanceof RsiClass) {
+            treeElements = buildClassStructure((RsiClass) m_element);
         } else if (m_element instanceof PsiStanza) {
             treeElements = buildStanzaStructure((PsiStanza) m_element);
         } else if (m_element instanceof PsiLet) {
@@ -212,7 +212,7 @@ public Icon getIcon(boolean unused) {
         return treeElements;
     }
 
-    private @NotNull List<TreeElement> buildClassStructure(@NotNull PsiKlass classElement) {
+    private @NotNull List<TreeElement> buildClassStructure(@NotNull RsiClass classElement) {
         List<TreeElement> treeElements = new ArrayList<>();
 
         PsiElement rootElement = classElement.getClassBody();

src/com/reason/lang/PsiFileHelper.java

@@ -109,8 +109,8 @@ public static List<PsiFunctor> getFunctorExpressions(@Nullable PsiFile file) {
     }
 
     @NotNull
-    public static List<PsiKlass> getClassExpressions(@Nullable PsiFile file) {
-        return PsiTreeUtil.getStubChildrenOfTypeAsList(file, PsiKlass.class);
+    public static List<RsiClass> getClassExpressions(@Nullable PsiFile file) {
+        return PsiTreeUtil.getStubChildrenOfTypeAsList(file, RsiClass.class);
     }
 
     @NotNull

src/com/reason/lang/core/psi/PsiKlass.java → src/com/reason/lang/core/psi/RsiClass.java

@@ -8,19 +8,19 @@
 import java.util.*;
 
 // Using a K to avoid confusion with PsiClass from IntelliJ
-public interface PsiKlass extends PsiQualifiedPathElement, NavigatablePsiElement, PsiStructuredElement, StubBasedPsiElement<PsiKlassStub> {
+public interface RsiClass extends PsiQualifiedPathElement, NavigatablePsiElement, PsiStructuredElement, StubBasedPsiElement<RsiClassStub> {
     @Nullable
     PsiElement getClassBody();
 
     @NotNull
-    Collection<PsiClassField> getFields();
+    Collection<RsiClassField> getFields();
 
     @NotNull
-    Collection<PsiClassMethod> getMethods();
+    Collection<RsiClassMethod> getMethods();
 
     @NotNull
     Collection<PsiParameters> getParameters();
 
     @Nullable
-    PsiClassConstructor getConstructor();
+    RsiClassConstructor getConstructor();
 }

src/com/reason/lang/core/psi/RsiClassMethod.java

@@ -0,0 +1,10 @@
+package com.reason.lang.core.psi;
+
+import com.intellij.psi.*;
+import com.reason.lang.core.stub.*;
+import org.jetbrains.annotations.*;
+
+// Using a K to avoid confusion with PsiClass from IntelliJ
+public interface RsiClassMethod extends PsiQualifiedPathElement, NavigatablePsiElement, PsiNameIdentifierOwner, PsiStructuredElement, StubBasedPsiElement<RsiClassMethodStub> {
+    @Nullable PsiSignature getSignature();
+}

src/com/reason/lang/core/psi/impl/ORASTFactory.java

@@ -132,13 +132,10 @@ public ORASTFactory(T types) {
             return new PsiOption(myTypes, type);
         }
         if (type == myTypes.C_CLASS_CONSTR) {
-            return new PsiClassConstructor(myTypes, type);
+            return new RsiClassConstructor(myTypes, type);
         }
         if (type == myTypes.C_CLASS_FIELD) {
-            return new PsiClassField(myTypes, type);
-        }
-        if (type == myTypes.C_CLASS_METHOD) {
-            return new PsiClassMethod(myTypes, type);
+            return new RsiClassField(myTypes, type);
         }
         if (type == myTypes.C_SWITCH_BODY) {
             return new PsiSwitchBody(myTypes, type);

src/com/reason/lang/core/psi/impl/PsiClassConstructor.java → src/com/reason/lang/core/psi/impl/RsiClassConstructor.java

@@ -4,8 +4,8 @@
 import com.reason.lang.core.type.*;
 import org.jetbrains.annotations.*;
 
-public class PsiClassConstructor extends ORCompositePsiElement<ORTypes> {
-    protected PsiClassConstructor(@NotNull ORTypes types, @NotNull IElementType elementType) {
+public class RsiClassConstructor extends ORCompositePsiElement<ORTypes> {
+    protected RsiClassConstructor(@NotNull ORTypes types, @NotNull IElementType elementType) {
         super(types, elementType);
     }
 }

src/com/reason/lang/core/psi/impl/PsiClassField.java → src/com/reason/lang/core/psi/impl/RsiClassField.java

@@ -12,8 +12,8 @@
 
 import javax.swing.*;
 
-public class PsiClassField extends ORCompositePsiElement<ORTypes> implements NavigatablePsiElement, PsiNameIdentifierOwner, PsiStructuredElement {
-    protected PsiClassField(@NotNull ORTypes types, @NotNull IElementType elementType) {
+public class RsiClassField extends ORCompositePsiElement<ORTypes> implements NavigatablePsiElement, PsiNameIdentifierOwner, PsiStructuredElement {
+    protected RsiClassField(@NotNull ORTypes types, @NotNull IElementType elementType) {
         super(types, elementType);
     }
 

src/com/reason/lang/core/psi/impl/PsiKlassImpl.java → src/com/reason/lang/core/psi/impl/RsiClassImpl.java

@@ -16,13 +16,13 @@
 import javax.swing.*;
 import java.util.*;
 
-public class PsiKlassImpl extends PsiTokenStub<ORTypes, PsiKlass, PsiKlassStub> implements PsiKlass {
+public class RsiClassImpl extends PsiTokenStub<ORTypes, RsiClass, RsiClassStub> implements RsiClass {
     // region Constructors
-    public PsiKlassImpl(@NotNull ORTypes types, @NotNull ASTNode node) {
+    public RsiClassImpl(@NotNull ORTypes types, @NotNull ASTNode node) {
         super(types, node);
     }
 
-    public PsiKlassImpl(@NotNull ORTypes types, @NotNull PsiKlassStub stub, @NotNull IStubElementType nodeType) {
+    public RsiClassImpl(@NotNull ORTypes types, @NotNull RsiClassStub stub, @NotNull IStubElementType nodeType) {
         super(types, stub, nodeType);
     }
     // endregion
@@ -44,11 +44,10 @@ public PsiKlassImpl(@NotNull ORTypes types, @NotNull PsiKlassStub stub, @NotNull
     }
     // endregion
 
-
     //region PsiQualifiedName
     @Override
     public @Nullable String[] getPath() {
-        PsiKlassStub stub = getGreenStub();
+        RsiClassStub stub = getGreenStub();
         if (stub != null) {
             return stub.getPath();
         }
@@ -58,7 +57,7 @@ public PsiKlassImpl(@NotNull ORTypes types, @NotNull PsiKlassStub stub, @NotNull
 
     @Override
     public @NotNull String getQualifiedName() {
-        PsiKlassStub stub = getGreenStub();
+        RsiClassStub stub = getGreenStub();
         if (stub != null) {
             return stub.getQualifiedName();
         }
@@ -73,13 +72,13 @@ public PsiKlassImpl(@NotNull ORTypes types, @NotNull PsiKlassStub stub, @NotNull
     }
 
     @Override
-    public @NotNull Collection<PsiClassField> getFields() {
-        return PsiTreeUtil.findChildrenOfType(getClassBody(), PsiClassField.class);
+    public @NotNull Collection<RsiClassField> getFields() {
+        return PsiTreeUtil.findChildrenOfType(getClassBody(), RsiClassField.class);
     }
 
     @Override
-    public @NotNull Collection<PsiClassMethod> getMethods() {
-        return PsiTreeUtil.findChildrenOfType(getClassBody(), PsiClassMethod.class);
+    public @NotNull Collection<RsiClassMethod> getMethods() {
+        return PsiTreeUtil.findChildrenOfType(getClassBody(), RsiClassMethod.class);
     }
 
     @Override
@@ -88,8 +87,8 @@ public PsiKlassImpl(@NotNull ORTypes types, @NotNull PsiKlassStub stub, @NotNull
     }
 
     @Override
-    public @Nullable PsiClassConstructor getConstructor() {
-        return findChildByClass(PsiClassConstructor.class);
+    public @Nullable RsiClassConstructor getConstructor() {
+        return findChildByClass(RsiClassConstructor.class);
     }
 
     public ItemPresentation getPresentation() {