Improved the GotoRelated functionality

Author: halirutan

.idea/dictionaries/patrick.xml

@@ -27,18 +27,44 @@
 import org.jetbrains.annotations.Nullable;
 
 /**
+ * Provides a {@link GotoRelatedItem} that is useful to give information about the usage of a Mathematica symbol
+ *
  * @author patrick (28.12.16).
  */
 public class GotoSymbolItem extends GotoRelatedItem {
+
   private final String myDescription;
-  GotoSymbolItem(@NotNull PsiElement element, final String description) {
+  private final String myContext;
+  private final int myLineNumber;
+
+  /**
+   * Create an entry with description text
+   * @param element {@link PsiElement} to navigate to
+   * @param description descriptive text that appears in the info box
+   * @param contextInfo additional information like line number and context
+   * @param lineNumber used for sorting the entries
+   */
+  GotoSymbolItem(@NotNull PsiElement element, @NotNull final String description, @NotNull final String contextInfo, final int lineNumber) {
     super(element);
     myDescription = description;
+    myContext = contextInfo;
+    myLineNumber = lineNumber;
+  }
+
+  @Nullable
+  @Override
+  public String getCustomContainerName() {
+    return myContext;
   }
 
   @Nullable
   @Override
   public String getCustomName() {
     return myDescription;
   }
+
+  int getLineNumber() {
+    return myLineNumber;
+  }
+
 }

src/de/halirutan/mathematica/codeinsight/navigation/GotoSymbolItem.java

@@ -23,45 +23,91 @@
 
 import com.intellij.navigation.GotoRelatedItem;
 import com.intellij.navigation.GotoRelatedProvider;
+import com.intellij.openapi.editor.Document;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.TextRange;
+import com.intellij.psi.PsiDocumentManager;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiReference;
 import com.intellij.psi.impl.source.tree.LeafPsiElement;
+import com.intellij.util.containers.SortedList;
 import de.halirutan.mathematica.parsing.MathematicaElementTypes;
 import de.halirutan.mathematica.parsing.psi.api.Symbol;
-import de.halirutan.mathematica.parsing.psi.util.GlobalDefinitionCollector;
-import de.halirutan.mathematica.parsing.psi.util.GlobalDefinitionCollector.AssignmentProperty;
-import de.halirutan.mathematica.parsing.psi.util.LocalizationConstruct.ConstructType;
 import org.jetbrains.annotations.NotNull;
 
-import java.util.ArrayList;
-import java.util.HashSet;
+import java.util.Comparator;
 import java.util.List;
-import java.util.Map;
 
 /**
+ * Provides functionality to navigate through different usages of the symbol under the caret.
+ * It will take the correct scope which means that it won't stupidly highlight symbols with the same name.
+ * Rather, it will find out if the symbol is globally defined, in a Module, or in any other scoping construct.
+ * Then, the list of suggestions contains only correct places which really refer to usages of the current symbol.
  * @author patrick (28.12.16).
  */
 public class MathematicaGotoRelatedProvider extends GotoRelatedProvider {
 
   @NotNull
   @Override
   public List<? extends GotoRelatedItem> getItems(@NotNull PsiElement psiElement) {
-    ArrayList<GotoRelatedItem> declarations = new ArrayList<>();
+    // I want the entries in the suggestion window to be sorted by line number!
+    SortedList<GotoSymbolItem> declarations = new SortedList<>(Comparator.comparingInt(GotoSymbolItem::getLineNumber));
     if (psiElement instanceof LeafPsiElement && ((LeafPsiElement) psiElement).getElementType().equals(MathematicaElementTypes.IDENTIFIER)) {
       psiElement = psiElement.getParent();
     }
     if (psiElement instanceof Symbol) {
+      final Project project = psiElement.getProject();
+      final PsiDocumentManager documentManager = PsiDocumentManager.getInstance(project);
+      final Document document = documentManager.getDocument(psiElement.getContainingFile());
+      if (document == null) {
+        return declarations;
+      }
       PsiReference ref = psiElement.getReference();
       if (ref != null) {
         PsiElement resolve = ref.resolve();
         if (resolve != null) {
-          if (resolve instanceof Symbol && ((Symbol) resolve).getLocalizationConstruct().equals(ConstructType.NULL)) {
-            GlobalDefinitionCollector collector = new GlobalDefinitionCollector(psiElement.getContainingFile());
-            Map<String, HashSet<AssignmentProperty>> assignments = collector.getAssignments();
-            for (AssignmentProperty property : assignments.get(((Symbol) resolve).getSymbolName())) {
-              String text = property.myLhsOfAssignment.getText();
-              GotoRelatedItem item = new GotoSymbolItem(property.myAssignmentSymbol, text.substring(0, Math.min(text.length(),50)));
-              declarations.add(item);
+          if (resolve instanceof Symbol) {
+            final PsiReference[] resolveReferences = resolve.getReferences();
+            for (PsiReference reference : resolveReferences) {
+              final PsiElement usageElement = reference.getElement();
+              if (usageElement instanceof Symbol && usageElement.isValid()) {
+                // What follows is that want to collect code around the found element.
+                // I will collect neighbouring PsiElements but not more than 20 characters to the right and
+                // to the left of the current usageElement.
+                final int elementTextOffset = usageElement.getTextOffset();
+                final int lineNumber = document.getLineNumber(elementTextOffset);
+                final int lineStartOffset = document.getLineStartOffset(lineNumber);
+                final int lineEndOffset = document.getLineEndOffset(lineNumber);
+                assert lineStartOffset <= lineEndOffset;
+
+                PsiElement displayStart = usageElement;
+                PsiElement displayEnd = usageElement;
+                while (displayStart.getPrevSibling() != null) {
+                  PsiElement tmpStart = displayStart.getPrevSibling();
+                  if (usageElement.getTextOffset() - tmpStart.getTextOffset() > 20
+                      || tmpStart.getTextOffset() < lineStartOffset) break;
+
+                  displayStart = tmpStart;
+                }
+
+                while (displayEnd.getNextSibling() != null) {
+                  PsiElement tmpEnd = displayEnd.getNextSibling();
+                  if (tmpEnd.getTextOffset() - (usageElement.getTextOffset() + usageElement.getTextLength()) > 20
+                      || tmpEnd.getTextOffset() + tmpEnd.getTextLength() > lineEndOffset) break;
+
+                  displayEnd = tmpEnd;
+                }
+
+                final String lineText = document.getText(
+                    TextRange.create(displayStart.getTextOffset(), displayEnd.getTextOffset() + displayEnd.getTextLength()));
+                final GotoSymbolItem item = new GotoSymbolItem(
+                    usageElement,
+                    lineText,
+                    "(" + (lineNumber+1) + " in " + ((Symbol) resolve).getLocalizationConstruct() +")", lineNumber);
+                declarations.add(item);
+
+              }
+
             }
           }
         }

src/de/halirutan/mathematica/codeinsight/navigation/MathematicaGotoRelatedProvider.java

@@ -114,7 +114,42 @@ public static ConstructType getType(String name) {
 
   public enum ConstructType {
     MODULE, BLOCK, WITH, FUNCTION, DYNAMICMODULE, TABLE, DO, SUM, NULL, INTEGRATE, NSUM, PLOT, PLOT3D, CONTOURPLOT, CONTOURPLOT3D,
-    LIMIT, RULEDELAYED, SETDELAYEDPATTERN, MANIPULATE, COMPILE, ANONYMOUSFUNCTION, PARAMETRICPLOT, PARAMETRICPLOT3D
+    LIMIT, RULEDELAYED, SETDELAYEDPATTERN, MANIPULATE, COMPILE, ANONYMOUSFUNCTION, PARAMETRICPLOT, PARAMETRICPLOT3D;
+
+
+    @Override
+    public String toString() {
+      switch (this) {
+        case ANONYMOUSFUNCTION:
+          return "Anonymous Function";
+        case DYNAMICMODULE:
+          return "DynamicModule";
+        case NSUM:
+          return "NSum";
+        case PLOT3D:
+          return "Plot3D";
+        case CONTOURPLOT:
+          return "ContourPlot";
+        case CONTOURPLOT3D:
+          return "ContourPlot3D";
+        case RULEDELAYED:
+          return "RuleDelayed";
+        case SETDELAYEDPATTERN:
+          return ":= Pattern";
+        case PARAMETRICPLOT:
+          return "ParametricPlot";
+        case PARAMETRICPLOT3D:
+          return "ParametricPlot3D";
+        case NULL:
+          return "file scope";
+        default:
+          String str = name().toLowerCase();
+          str = str.substring(0,1).toUpperCase() + str.substring(1);
+          return str;
+      }
+
+
+    }
   }