Extended SymbolResolveResult

Author: halirutan

.idea/modules/Mathematica-IntelliJ-Plugin_main.iml

@@ -21,8 +21,13 @@
 
 package de.halirutan.mathematica.file;
 
+import com.intellij.icons.AllIcons;
+import com.intellij.ide.DataManager;
 import com.intellij.openapi.fileTypes.FileTypeConsumer;
 import com.intellij.openapi.fileTypes.FileTypeFactory;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.project.ProjectManager;
+import com.intellij.openapi.project.ex.ProjectManagerEx;
 import de.halirutan.mathematica.file.MathematicaFileType;
 import org.jetbrains.annotations.NotNull;
 
@@ -33,6 +38,7 @@ public class MathematicaFileTypeFactory extends FileTypeFactory {
 
   @Override
   public void createFileTypes(@NotNull FileTypeConsumer consumer) {
+    final Project[] openProjects = ProjectManager.getInstance().getOpenProjects();
     consumer.consume(MathematicaFileType.INSTANCE, "m;mb;mt;nb;wl;wlt");
   }
 

.idea/modules/Mathematica-IntelliJ-Plugin_test.iml

@@ -132,10 +132,10 @@ public enum MScope {
         FILE_SCOPE("File Scope"),
         NULL_SCOPE("Null Scope");
 
-        private final String myName;
-        private final ScopeParameter myType;
-        private final int myScopePositionStart;
-        private final int myScopePositionEnd;
+        final String myName;
+        final ScopeParameter myType;
+        final int myScopePositionStart;
+        final int myScopePositionEnd;
 
         MScope(final String name, final ScopeParameter type, int start, int end) {
             myName = name;

.idea/scopes/scope_settings.xml

@@ -261,21 +261,23 @@ public static SymbolResolveResult resolveLocalFunctionVariables(Symbol myStartEl
       return null;
     }
 
+    final MScope scope = functionCall.getScopingConstruct();
+
     final PsiElement lastParent = state.get(SymbolResolveHint.LAST_PARENT);
     final PsiElement firstArgument = arguments.get(0);
     PsiElement definitions = arguments.size() > 1 ? firstArgument : null;
     if (definitions != null) {
-      boolean inDefition = definitions.equals(lastParent);
+      boolean inDefinition = definitions.equals(lastParent);
       if (firstArgument instanceof Symbol && !((Symbol) firstArgument).getSymbolName().equals("Null") && ((Symbol) firstArgument).getFullSymbolName().equals(myStartElement.getFullSymbolName())) {
-        return new SymbolResolveResult(firstArgument, MScope.FUNCTION, true);
+        return new SymbolResolveResult(firstArgument, scope, functionCall, true);
       } else if (firstArgument instanceof MList) {
-        final List<Symbol> defs = getDefinitionSymbolsFromList(firstArgument);
-        for (Symbol def : defs) {
+        final List<Symbol> defSymbols = getDefinitionSymbolsFromList(firstArgument);
+        for (Symbol def : defSymbols) {
           if (def.getFullSymbolName().equals(myStartElement.getFullSymbolName())) {
-            if (!inDefition || def.equals(myStartElement)) {
-              return new SymbolResolveResult(def, MScope.FUNCTION, true);
+            if (!inDefinition || def.equals(myStartElement)) {
+              return new SymbolResolveResult(def, scope, functionCall, true);
             } else {
-              return new SymbolResolveResult(myStartElement, MScope.NULL_SCOPE, true);
+              return new SymbolResolveResult(myStartElement, scope, functionCall, true);
             }
           }
         }
@@ -351,11 +353,11 @@ public static SymbolResolveResult resolveLocalModuleLikeVariables(@NotNull Symbo
           if (e instanceof Symbol) {
             if (((Symbol) e).getSymbolName().equals(symbol.getSymbolName())) {
               if (!isInDefList || e.equals(symbol)) {
-                return new SymbolResolveResult(e, scopingConstruct, true);
+                return new SymbolResolveResult(e, scopingConstruct, functionCall, true);
               } else {
                 final List<Symbol> definitionInList = getDefinitionSymbolsFromList(moduleDefList);
                 if (definitionInList.contains(symbol)) {
-                  return new SymbolResolveResult(symbol, scopingConstruct, false);
+                  return new SymbolResolveResult(symbol, scopingConstruct, functionCall, false);
                 } else {
                   return null;
                 }
@@ -425,7 +427,7 @@ public static SymbolResolveResult resolveLocalTableLikeVariables(Symbol myStartE
           final PsiElement firstListElement = getFirstListElement(currentIterator);
           if (firstListElement instanceof Symbol) {
             if (((Symbol) firstListElement).getFullSymbolName().equals(myStartElement.getFullSymbolName())) {
-              return new SymbolResolveResult(firstListElement, scopingConstruct, true);
+              return new SymbolResolveResult(firstListElement, scopingConstruct, functionCall, true);
             }
           }
         }
@@ -434,7 +436,7 @@ public static SymbolResolveResult resolveLocalTableLikeVariables(Symbol myStartE
       // self-reference if we are the iterator
       if (args[pos] instanceof MList) {
         if (Objects.equals(getFirstListElement(args[pos]), myStartElement)) {
-          return new SymbolResolveResult(myStartElement, scopingConstruct, true);
+          return new SymbolResolveResult(myStartElement, scopingConstruct, functionCall, true);
         }
       }
 
@@ -444,7 +446,7 @@ public static SymbolResolveResult resolveLocalTableLikeVariables(Symbol myStartE
           final PsiElement firstListElement = getFirstListElement(args[i]);
           if (firstListElement instanceof Symbol) {
             if (((Symbol) firstListElement).getFullSymbolName().equals(myStartElement.getFullSymbolName())) {
-              return new SymbolResolveResult(firstListElement, scopingConstruct, true);
+              return new SymbolResolveResult(firstListElement, scopingConstruct, functionCall, true);
             }
           }
         }
@@ -529,47 +531,6 @@ public static List<Symbol> getLocalCompileLikeVariables(FunctionCall element) {
   }
 
 
-  @Nullable
-  public static SymbolResolveResult resolveLocalCompileLikeVariables(Symbol myStartElement, FunctionCall functionCall, ResolveState state) {
-
-    final PsiElement lastParent = state.get(SymbolResolveHint.LAST_PARENT);
-    final List<PsiElement> arguments = getArguments(functionCall);
-    if (arguments.size() < 1) {
-      return null;
-    }
-
-    final PsiElement firstArgument = arguments.get(0);
-    boolean inDef = firstArgument.equals(lastParent);
-
-
-    final MScope scopingConstruct = functionCall.getScopingConstruct();
-    if (firstArgument instanceof Symbol) {
-      if (((Symbol) firstArgument).getFullSymbolName().equals(myStartElement.getFullSymbolName())) {
-        return new SymbolResolveResult(firstArgument, scopingConstruct, true);
-      }
-    } else if (firstArgument instanceof MList) {
-      final PsiElement[] children = firstArgument.getChildren();
-      for (PsiElement child : children) {
-        if (child instanceof MList) {
-          child = child.getFirstChild();
-        }
-        if (child instanceof Symbol) {
-          if (inDef) {
-            if (child.equals(myStartElement)) {
-              return new SymbolResolveResult(child, scopingConstruct, true);
-            }
-          } else {
-            if (((Symbol) child).getFullSymbolName().equals(myStartElement.getFullSymbolName())) {
-              return new SymbolResolveResult(child, scopingConstruct, true);
-            }
-          }
-        }
-      }
-    }
-    return null;
-  }
-
-
   /**
    * This extracts the local defined argument for a <code>Limit[Sin[x]/x, x-> 0]</code> call. Note that the returned
    * list has always only one element since <code>Limit</code> always uses only one variable.

.idea/vcs.xml

@@ -47,6 +47,11 @@
 import static de.halirutan.mathematica.lang.psi.util.MathematicaPsiUtilities.isBuiltInSymbol;
 
 /**
+ * The symbol resolver works currently in 3 steps to find a possible definition of a symbol that appears in the code.
+ * It will check if the symbol is a built-in symbol
+ * It will make a tree-walk upwards to check if the symbol is in any localization construct
+ * It will check the file, if the symbol is defined as a global symbol like a function at file-scope
+ * It will check the file-index and look for symbols that are exported from other files
  * @author patrick (08.07.17).
  */
 public class MathematicaSymbolResolver implements AbstractResolver<Symbol, SymbolResolveResult> {
@@ -56,27 +61,29 @@ public class MathematicaSymbolResolver implements AbstractResolver<Symbol, Symbo
   public SymbolResolveResult resolve(@NotNull Symbol ref, boolean incompleteCode) {
 
     if (isBuiltInSymbol(ref)){
-      return new SymbolResolveResult(new LightBuiltInSymbol(ref), MScope.KERNEL_SCOPE, true);
+      return new SymbolResolveResult(new LightBuiltInSymbol(ref), MScope.KERNEL_SCOPE, null, true);
     }
 
     LocalDefinitionResolveProcessor processor = new LocalDefinitionResolveProcessor(ref);
     final PsiFile containingFile = ref.getContainingFile();
     PsiTreeUtil.treeWalkUp(processor, ref, containingFile, ResolveState.initial());
-    final Symbol referringSymbol = processor.getMyReferringSymbol();
-    if (referringSymbol != null) {
-      return new SymbolResolveResult(referringSymbol, processor.getMyLocalization(), true);
+    final SymbolResolveResult resolveResult = processor.getResolveResult();
+    if (resolveResult != null) {
+      return resolveResult;
     }
 
     GlobalDefinitionResolveProcessor globalProcessor = new GlobalDefinitionResolveProcessor(ref);
     PsiTreeUtil.processElements(containingFile, globalProcessor);
 
 
-    final PsiElement globalDefinition = globalProcessor.getMyReferringSymbol();
-    if (globalDefinition != null) {
+    final SymbolResolveResult globalProcessorResolveResult = globalProcessor.getResolveResult();
+    if (globalProcessorResolveResult != null) {
       if (containingFile instanceof MathematicaPsiFile) {
-        ((MathematicaPsiFile) containingFile).cacheDefinition(globalDefinition.getText());
+        if (globalProcessorResolveResult.getElement() != null) {
+          ((MathematicaPsiFile) containingFile).cacheDefinition(globalProcessorResolveResult.getElement().getText());
+        }
       }
-      return new SymbolResolveResult(globalDefinition, MScope.FILE_SCOPE, true);
+      return globalProcessorResolveResult;
     }
 
     final FileBasedIndex fileIndex = FileBasedIndex.getInstance();
@@ -94,15 +101,15 @@ public SymbolResolveResult resolve(@NotNull Symbol ref, boolean incompleteCode)
 //            final PsiElement elementAt = psiFile.findElementAt(key.getOffset());
             final Symbol elementAt = PsiTreeUtil.findElementOfClassAtOffset(psiFile, key.getOffset(), Symbol.class, true);
             if (elementAt != null) {
-              return new SymbolResolveResult(elementAt, MScope.FILE_SCOPE, true);
+              return new SymbolResolveResult(elementAt, MScope.FILE_SCOPE, psiFile, true);
             }
-            return new SymbolResolveResult(psiFile, MScope.FILE_SCOPE, true);
+            return new SymbolResolveResult(psiFile, MScope.FILE_SCOPE, psiFile, true);
           }
         }
       }
     }
 
-    return new SymbolResolveResult(new LightUndefinedSymbol(ref), MScope.NULL_SCOPE, true);
+    return new SymbolResolveResult(new LightUndefinedSymbol(ref), MScope.NULL_SCOPE, ref.getContainingFile(), false);
 
   }
 

src/de/halirutan/mathematica/file/MathematicaFileTypeFactory.java

@@ -23,8 +23,8 @@
 
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.ResolveResult;
-import de.halirutan.mathematica.lang.psi.util.LocalizationConstruct;
 import de.halirutan.mathematica.lang.psi.util.LocalizationConstruct.MScope;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 /**
@@ -33,12 +33,14 @@
 public class SymbolResolveResult implements ResolveResult {
 
   private final PsiElement myElement;
+  private final PsiElement myScopingElement;
   private final boolean myIsValid;
   private MScope myLocalization;
 
-  public SymbolResolveResult(PsiElement element, MScope scope, boolean isValid) {
+  public SymbolResolveResult(@NotNull PsiElement element, @NotNull MScope scope, @Nullable PsiElement myScopingElement, boolean isValid) {
     this.myElement = element;
     this.myLocalization = scope;
+    this.myScopingElement = myScopingElement;
     this.myIsValid = isValid;
   }
 
@@ -52,6 +54,10 @@ public MScope getLocalization() {
     return myLocalization;
   }
 
+  public PsiElement getScopingElement() {
+    return myScopingElement;
+  }
+
   @Override
   public boolean isValidResult() {
     return myIsValid;