Further reworking of local variable resolution: compileLikeVariables

Author: halirutan

.idea/runConfigurations/Mathematica_Plugin.xml

@@ -107,15 +107,15 @@ class MathematicaSpacingBuilderProvider {
 
   }
 
-  public static SpacingBuilder getSpacingBuilder(CommonCodeStyleSettings settings, MathematicaCodeStyleSettings mathematicaSettings) {
+  static SpacingBuilder getSpacingBuilder(CommonCodeStyleSettings settings, MathematicaCodeStyleSettings mathematicaSettings) {
     return new SpacingBuilder(settings.getRootSettings(), MathematicaLanguage.INSTANCE)
-        .around(ourAssignments).spaceIf(MathematicaCodeStyleSettings.SPACE_AROUND_ASSIGNMENT_OPERATIONS)
-        .around(ourArithmeticOperations).spaceIf(MathematicaCodeStyleSettings.SPACE_AROUND_ARITHMETIC_OPERATIONS)
-        .aroundInside(MINUS, MINUS_EXPRESSION).spaceIf(MathematicaCodeStyleSettings.SPACE_AROUND_ARITHMETIC_OPERATIONS)
-        .around(ourRelationalOperations).spaceIf(MathematicaCodeStyleSettings.SPACE_AROUND_RELATION_OPERATIONS)
-        .around(ourRuleOperations).spaceIf(MathematicaCodeStyleSettings.SPACE_AROUND_RULE_OPERATIONS)
-        .around(ourFunctionalOperations).spaceIf(MathematicaCodeStyleSettings.SPACE_AROUND_FUNCTIONAL_OPERATIONS)
-        .around(ourOtherOperations).spaceIf(MathematicaCodeStyleSettings.SPACE_AROUND_OTHER_OPERATIONS)
+        .around(ourAssignments).spaceIf(mathematicaSettings.SPACE_AROUND_ASSIGNMENT_OPERATIONS)
+        .around(ourArithmeticOperations).spaceIf(mathematicaSettings.SPACE_AROUND_ARITHMETIC_OPERATIONS)
+        .aroundInside(MINUS, MINUS_EXPRESSION).spaceIf(mathematicaSettings.SPACE_AROUND_ARITHMETIC_OPERATIONS)
+        .around(ourRelationalOperations).spaceIf(mathematicaSettings.SPACE_AROUND_RELATION_OPERATIONS)
+        .around(ourRuleOperations).spaceIf(mathematicaSettings.SPACE_AROUND_RULE_OPERATIONS)
+        .around(ourFunctionalOperations).spaceIf(mathematicaSettings.SPACE_AROUND_FUNCTIONAL_OPERATIONS)
+        .around(ourOtherOperations).spaceIf(mathematicaSettings.SPACE_AROUND_OTHER_OPERATIONS)
         .after(COMMA).spaceIf(settings.SPACE_AFTER_COMMA)
         .before(LEFT_BRACKET).none()
         .after(RIGHT_BRACKET).none();

src/de/halirutan/mathematica/codeinsight/formatter/MathematicaSpacingBuilderProvider.java

@@ -27,15 +27,15 @@
 /**
  * @author patrick (11/2/13)
  */
-@SuppressWarnings({"StaticVariableNamingConvention", "NonConstantFieldWithUpperCaseName"})
+@SuppressWarnings({"InstanceVariableNamingConvention", "NonConstantFieldWithUpperCaseName"})
 public class MathematicaCodeStyleSettings extends CustomCodeStyleSettings {
 
-  public static final boolean SPACE_AROUND_ARITHMETIC_OPERATIONS = true;
-  public static final boolean SPACE_AROUND_ASSIGNMENT_OPERATIONS = true;
-  public static final boolean SPACE_AROUND_RULE_OPERATIONS = true;
-  public static final boolean SPACE_AROUND_FUNCTIONAL_OPERATIONS = true;
-  public static final boolean SPACE_AROUND_OTHER_OPERATIONS = true;
-  public static final boolean SPACE_AROUND_RELATION_OPERATIONS = true;
+  public boolean SPACE_AROUND_ARITHMETIC_OPERATIONS = true;
+  public boolean SPACE_AROUND_ASSIGNMENT_OPERATIONS = true;
+  public boolean SPACE_AROUND_RULE_OPERATIONS = true;
+  public boolean SPACE_AROUND_FUNCTIONAL_OPERATIONS = true;
+  public boolean SPACE_AROUND_OTHER_OPERATIONS = true;
+  public boolean SPACE_AROUND_RELATION_OPERATIONS = true;
 
   public MathematicaCodeStyleSettings(CodeStyleSettings container) {
     super("MathematicaCodeStyleSettings", container);

src/de/halirutan/mathematica/codeinsight/formatter/settings/MathematicaCodeStyleSettings.java

@@ -71,7 +71,7 @@ public static boolean isBuiltInSymbol(PsiElement element) {
    * @return List of symbols which are assigned.
    */
   @Nullable
-  public static List<Symbol> getAssignmentSymbols(PsiElement element) {
+  static List<Symbol> getAssignmentSymbols(PsiElement element) {
     PsiElement firstChild = element.getFirstChild();
     final List<Symbol> assignees = Lists.newArrayList();
 
@@ -525,6 +525,48 @@ public static List<Symbol> getLocalCompileLikeVariables(FunctionCall element) {
     return localVariables;
   }
 
+
+  @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 de.halirutan.mathematica.lang.psi.api.lists.List) {
+      final PsiElement[] children = firstArgument.getChildren();
+      for (PsiElement child : children) {
+        if (child instanceof de.halirutan.mathematica.lang.psi.api.lists.List) {
+          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.
@@ -578,7 +620,7 @@ public static PsiElement getFirstListElement(@Nullable PsiElement list) {
    * @return List of arguments
    */
   @NotNull
-  public static List<PsiElement> getArguments(@Nullable PsiElement func) {
+  static List<PsiElement> getArguments(@Nullable PsiElement func) {
     List<PsiElement> allArguments = Lists.newLinkedList();
     if (!(func instanceof FunctionCall)) {
       return allArguments;
@@ -636,7 +678,7 @@ public static String getBeginContext(@NotNull PsiElement element) {
    * @return context string or null if it could not be extracted
    */
   @Nullable
-  public static String getContext(@NotNull PsiElement element, final boolean beginPackageOnly) {
+  private static String getContext(@NotNull PsiElement element, final boolean beginPackageOnly) {
     if (element instanceof FunctionCall) {
       final FunctionCall functionCall = (FunctionCall) element;
       if (functionCall.matchesHead("BeginPackage") || (!beginPackageOnly && functionCall.matchesHead("Begin"))) {

src/de/halirutan/mathematica/lang/psi/util/MathematicaPsiUtilities.java

@@ -122,16 +122,12 @@ public boolean execute(@NotNull PsiElement element, @NotNull ResolveState state)
           myResolveResult = MathematicaPsiUtilities.resolveLocalModuleLikeVariables(myStartElement, functionCall, state);
         } else if (LocalizationConstruct.isTableLike(scopingConstruct)) {
           myResolveResult = MathematicaPsiUtilities.resolveLocalTableLikeVariables(myStartElement, functionCall, state);
+        } else if (LocalizationConstruct.isManipulateLike(scopingConstruct)) {
+          myResolveResult = MathematicaPsiUtilities.resolveLocalTableLikeVariables(myStartElement, functionCall, state);
+        } else if (LocalizationConstruct.isCompileLike(scopingConstruct)) {
+          myResolveResult = MathematicaPsiUtilities.resolveLocalCompileLikeVariables(myStartElement, functionCall, state);
         }
 //
-//        if (LocalizationConstruct.isManipulateLike(scopingConstruct)) {
-//          vars = MathematicaPsiUtilities.getLocalManipulateLikeVariables(functionCall);
-//        }
-//
-//        if (LocalizationConstruct.isCompileLike(scopingConstruct)) {
-//          vars = MathematicaPsiUtilities.getLocalCompileLikeVariables(functionCall);
-//        }
-//
 //        if (LocalizationConstruct.isLimitLike(scopingConstruct)) {
 //          vars = MathematicaPsiUtilities.getLocalLimitVariables(functionCall);
 //        }