Implemented renaming functionality for usage message strings

Author: halirutan

.idea/dictionaries/patrick.xml

@@ -165,6 +165,7 @@
     <inspectionToolProvider
         implementation="de.halirutan.mathematica.codeinsight.inspections.MathematicaInspectionProvider"/>
 
+    <psi.referenceContributor language="Mathematica" implementation="de.halirutan.mathematica.parsing.psi.MathematicaReferenceContributor"/>
   </extensions>
 
   <actions>

.idea/runConfigurations/Mathematica_Plugin.xml

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2016 Patrick Scheibe
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package de.halirutan.mathematica.parsing.psi;
+
+import com.intellij.patterns.PlatformPatterns;
+import com.intellij.psi.PsiReferenceContributor;
+import com.intellij.psi.PsiReferenceRegistrar;
+import de.halirutan.mathematica.parsing.psi.api.string.MString;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author patrick (29.11.16).
+ */
+public class MathematicaReferenceContributor extends PsiReferenceContributor {
+
+  /**
+   * Gives registrar the chance to do registrar
+   * @param registrar will work as registrar
+   */
+  @Override
+  public void registerReferenceProviders(@NotNull PsiReferenceRegistrar registrar) {
+    registrar.registerReferenceProvider(PlatformPatterns.psiElement(MString.class),
+        new MathematicaStringReferenceProvider());
+  }
+}

resources/META-INF/plugin.xml

@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2016 Patrick Scheibe
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package de.halirutan.mathematica.parsing.psi;
+
+import com.intellij.openapi.util.TextRange;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiReference;
+import com.intellij.psi.PsiReferenceProvider;
+import com.intellij.util.ProcessingContext;
+import de.halirutan.mathematica.parsing.psi.api.Expression;
+import de.halirutan.mathematica.parsing.psi.api.MessageName;
+import de.halirutan.mathematica.parsing.psi.api.StringifiedSymbol;
+import de.halirutan.mathematica.parsing.psi.api.Symbol;
+import de.halirutan.mathematica.parsing.psi.api.assignment.Set;
+import de.halirutan.mathematica.parsing.psi.api.string.MString;
+import de.halirutan.mathematica.parsing.psi.api.string.StringJoin;
+import de.halirutan.mathematica.parsing.psi.impl.StringUsageReference;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * @author patrick (29.11.16).
+ */
+class MathematicaStringReferenceProvider extends PsiReferenceProvider {
+
+
+  @NotNull
+  @Override
+  public PsiReference[] getReferencesByElement(@NotNull PsiElement element, @NotNull ProcessingContext context) {
+    if (!(element instanceof MString)) {
+      return new PsiReference[0];
+    }
+    ArrayList<PsiReference> result = new ArrayList<PsiReference>();
+
+    PsiElement setElement = element.getParent();
+
+    // Specifically for Szabolcs who likes to <> usage messages
+    while (setElement instanceof StringJoin) {
+      setElement = setElement.getParent();
+    }
+
+    if (setElement instanceof Set) {
+      final PsiElement messageElement = setElement.getFirstChild();
+      if (messageElement instanceof MessageName) {
+        final StringifiedSymbol tag = ((MessageName) messageElement).getTag();
+        if ("usage".equals(tag != null ? tag.getText() : null)) {
+          final Expression symbol = ((MessageName) messageElement).getSymbol();
+          if (symbol instanceof Symbol) {
+            String usageText = element.getText();
+            final String symbolName = ((Symbol) symbol).getSymbolName();
+            Pattern symbolNamePattern = StringUsageReference.getSymbolPattern(symbolName);
+            final Matcher matcher = symbolNamePattern.matcher(usageText);
+            while (matcher.find()) {
+              final int start = matcher.start(2);
+              final int end = matcher.end(2);
+              result.add(
+                  new StringUsageReference((MString) element, TextRange.create(start, end), symbolName, (Symbol) symbol)
+              );
+            }
+          }
+
+
+        }
+      }
+    }
+    return result.toArray(PsiReference.EMPTY_ARRAY);
+  }
+
+
+}

src/de/halirutan/mathematica/parsing/psi/MathematicaReferenceContributor.java

@@ -21,8 +21,10 @@
 
 package de.halirutan.mathematica.parsing.psi.api.string;
 
+import com.intellij.psi.PsiNamedElement;
+
 /**
  * @author patrick (4/14/13)
  */
-public interface MString {
+public interface MString extends PsiNamedElement{
 }

src/de/halirutan/mathematica/parsing/psi/MathematicaStringReferenceProvider.java

@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2016 Patrick Scheibe
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package de.halirutan.mathematica.parsing.psi.impl;
+
+import com.intellij.openapi.util.TextRange;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiReferenceBase;
+import com.intellij.util.IncorrectOperationException;
+import de.halirutan.mathematica.parsing.psi.api.Symbol;
+import de.halirutan.mathematica.parsing.psi.api.string.MString;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * @author patrick (29.11.16).
+ */
+public class StringUsageReference extends PsiReferenceBase<MString> {
+
+  private MString myElement1;
+  private final String mySymbolNameInside;
+  private final Symbol myTarget;
+
+  public StringUsageReference(MString element, TextRange rangeInElement, final String symbolName, Symbol target) {
+    super(element, rangeInElement, true);
+    mySymbolNameInside = symbolName;
+    myElement1 = element;
+    myTarget = target;
+  }
+
+  @Nullable
+  @Override
+  public PsiElement resolve() {
+    return myTarget;
+  }
+
+  @NotNull
+  @Override
+  public Object[] getVariants() {
+    return new Object[0];
+  }
+
+  @Override
+  public PsiElement handleElementRename(String newElementName) throws IncorrectOperationException {
+    final String text = myElement1.getText();
+    Matcher matcher = getSymbolPattern(mySymbolNameInside).matcher(text);
+    String newContent = matcher.replaceAll("$1" + newElementName + "$3");
+    myElement1 = (MString) myElement1.setName(newContent);
+    return myElement1;
+  }
+
+  @Override
+  public boolean isReferenceTo(PsiElement element) {
+    return element.equals(myTarget);
+  }
+
+  /**
+   * Returns the pattern that matches the usage of a function-name or symbol inside a Mathematica usage string.
+   * Example: "ref[x] works like a charm. The head of ref[x] is ref."
+   * We match ref if it is at the beginning of a string or preceded by a whitespace. ref needs to be followed
+   * by either [, a whitespace, a literal dot, or the end of the string.
+   * @param symbolName the symbol name you want to match
+   * @return a compiled pattern to match symbolName inside a usage string
+   */
+  public static Pattern getSymbolPattern(String symbolName) {
+    return Pattern.compile("(\"|\\s)(" + symbolName + ")(\\[|\\.|\\s|\")");
+  }
+
+
+}

src/de/halirutan/mathematica/parsing/psi/api/string/MString.java

@@ -32,14 +32,14 @@
 import de.halirutan.mathematica.parsing.psi.api.Symbol;
 import de.halirutan.mathematica.parsing.psi.util.GlobalDefinitionResolveProcessor;
 import de.halirutan.mathematica.parsing.psi.util.LocalDefinitionResolveProcessor;
-import de.halirutan.mathematica.parsing.psi.util.LocalizationConstruct;
+import de.halirutan.mathematica.parsing.psi.util.LocalizationConstruct.ConstructType;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.Set;
 
 /**
- * Povides functionality to resolve where a certain symbol is defined in code. For this, the SymbolPsiReference class
+ * Provides functionality to resolve where a certain symbol is defined in code. For this, the SymbolPsiReference class
  * uses several processors which scan the local scope and global file scope. Note that GlobalDefinitionResolveProcessor
  * does not scan the whole file because this would be too slow. Instead, it expects that global symbol definitions are
  * done at file-scope. The class uses caching to speed up the resolve process. Once a definition for a symbol is found,
@@ -52,10 +52,12 @@ public class SymbolPsiReference extends CachingReference implements PsiReference
   private static final Set<String> NAMES = SymbolInformationProvider.getSymbolNames().keySet();
   private final Symbol myVariable;
 
-  public SymbolPsiReference(Symbol element) {
+  SymbolPsiReference(Symbol element) {
     myVariable = element;
   }
 
+
+
   @Nullable
   @Override
   public PsiElement resolveInner() {
@@ -64,7 +66,7 @@ public PsiElement resolveInner() {
 
     if (myVariable.cachedResolve()) {
       if (myVariable.getSymbolName().equals(myVariable.getResolveElement().getSymbolName()) ||
-          myVariable.getLocalizationConstruct().equals(LocalizationConstruct.ConstructType.ANONYMOUSFUNCTION)) {
+          myVariable.getLocalizationConstruct().equals(ConstructType.ANONYMOUSFUNCTION)) {
         return myVariable.getResolveElement();
       } else {
         myVariable.subtreeChanged();
@@ -86,7 +88,7 @@ public PsiElement resolveInner() {
 
     final PsiElement globalDefinition = globalProcessor.getMyReferringSymbol();
     if (globalDefinition instanceof Symbol) {
-      myVariable.setReferringElement((Symbol) globalDefinition, LocalizationConstruct.ConstructType.NULL, null);
+      myVariable.setReferringElement((Symbol) globalDefinition, ConstructType.NULL, null);
       return globalDefinition;
     }
     return null;

src/de/halirutan/mathematica/parsing/psi/impl/StringUsageReference.java

@@ -22,15 +22,59 @@
 package de.halirutan.mathematica.parsing.psi.impl.string;
 
 import com.intellij.lang.ASTNode;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiFileFactory;
+import com.intellij.psi.PsiReference;
+import com.intellij.psi.impl.source.resolve.reference.ReferenceProvidersRegistry;
+import com.intellij.util.IncorrectOperationException;
+import de.halirutan.mathematica.filetypes.MathematicaFileType;
+import de.halirutan.mathematica.parsing.MathematicaElementTypes;
 import de.halirutan.mathematica.parsing.psi.api.string.MString;
+import de.halirutan.mathematica.parsing.psi.impl.MathematicaPsiFileImpl;
 import de.halirutan.mathematica.parsing.psi.impl.OperatorNameProviderImpl;
+import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 
 /**
  *
  */
 public class StringImpl extends OperatorNameProviderImpl implements MString {
+
+  private PsiReference[] myReferences = null;
+
   public StringImpl(@NotNull ASTNode node) {
     super(node);
   }
+
+  @Override
+  public PsiElement setName(@NonNls @NotNull String name) throws IncorrectOperationException {
+    ASTNode literalNode = getNode().findChildByType(MathematicaElementTypes.STRING_LITERAL);
+    final PsiFileFactory fileFactory = PsiFileFactory.getInstance(getProject());
+    final MathematicaPsiFileImpl file = (MathematicaPsiFileImpl) fileFactory.createFileFromText("dummy.m", MathematicaFileType.INSTANCE, name);
+    ASTNode newElm = file.getFirstChild().getNode().findChildByType(MathematicaElementTypes.STRING_LITERAL);
+    if (literalNode != null && newElm != null) {
+      getNode().replaceChild(literalNode, newElm);
+    }
+    return this;
+  }
+
+  @Override
+  public PsiReference getReference() {
+    final PsiReference[] references = getReferences();
+    return references.length > 0 ? references[0] : null;
+  }
+
+  @Override
+  public void subtreeChanged() {
+    myReferences = null;
+  }
+
+  @NotNull
+  @Override
+  public PsiReference[] getReferences() {
+    if (myReferences == null) {
+      return myReferences = ReferenceProvidersRegistry.getReferencesFromProviders(this);
+    }
+    return myReferences;
+  }
 }

src/de/halirutan/mathematica/parsing/psi/impl/SymbolPsiReference.java

@@ -22,13 +22,14 @@
 package de.halirutan.mathematica.parsing.psi.impl.string;
 
 import com.intellij.lang.ASTNode;
+import de.halirutan.mathematica.parsing.psi.api.string.StringJoin;
 import de.halirutan.mathematica.parsing.psi.impl.OperatorNameProviderImpl;
 import org.jetbrains.annotations.NotNull;
 
 /**
  * @author patrick (4/14/13)
  */
-public class StringJoinImpl extends OperatorNameProviderImpl {
+public class StringJoinImpl extends OperatorNameProviderImpl implements StringJoin{
   public StringJoinImpl(@NotNull ASTNode node) {
     super(node);
   }