Reworked some of the built-in symbol information and completion functionality

Author: halirutan

resources/mathematica/FunctionInformation.m

@@ -12,13 +12,15 @@
 (* :Keywords:                  *)
 (* :Discussion:                *)
 
-BeginPackage["FunctionInformation`"]
+BeginPackage["FunctionInformation`"];
 
 CreateCompletionInformation::usage = "CreateCompletionInformation[] returns a list of strings where each element is an \
 entry of the .properties file that is used to enable autocompletion in idea.";
 
 Begin["`Private`"] (* Begin Private Context *)
 
+<< JLink`;
+
 (* For good code completion we need an ordering of all possible completions. This is done with the *)
 (* function frequency list that comes with Mathematica nowadays. I just assign numbers according to the *)
 (* place in this list. The higher the number, the more important and the more like is the completion result. *)
@@ -34,15 +36,11 @@
   Rule @@@ Get[file]
 ];
 
-makeContextNames[context_String] :=
-    Append[StringReplace[
-      Names[RegularExpression[context <> "`\$?[A-Z]\\w*"]],
-      context ~~ "`" ~~ rest__ :> rest], context];
+makeContextNames[context_String] := Block[{$ContextPath = {context}},
+  StringJoin[context, #]& /@ Names[RegularExpression[context <> "\$?[A-Z]\\w*"]]
+];
 
-names = Sort[
-  Join[Names[RegularExpression["\$?[A-Z]\\w*"]],
-    makeContextNames["JLink"],
-    Names[RegularExpression["(Developer|Internal)`\$?[A-Z]\\w*"]]]];
+names = Sort[Flatten[ makeContextNames /@ {"System`", "Developer`", "Internal`", "JLink`"} ]];
 
 isFunction[str_String] :=
     With[{usg =
@@ -92,7 +90,7 @@
 
 
 createInformation[name_String] := Module[{importance, info, context},
-  importance = name /. $functionFrequency;
+  importance = StringReplace[name, "System`" ~~ n__ :> n] /. $functionFrequency;
   Check[
     context = Context[name];
     info = Cases[

src/de/halirutan/mathematica/codeinsight/completion/BuiltinFunctionCompletionProvider.java

@@ -24,9 +24,10 @@
 import com.intellij.codeInsight.completion.*;
 import com.intellij.codeInsight.completion.impl.CamelHumpMatcher;
 import com.intellij.codeInsight.lookup.LookupElementBuilder;
-import com.intellij.patterns.PsiElementPattern;
+import com.intellij.patterns.PsiElementPattern.Capture;
 import com.intellij.psi.PsiElement;
 import com.intellij.util.ProcessingContext;
+import de.halirutan.mathematica.codeinsight.completion.SymbolInformationProvider.SymbolInformation;
 import de.halirutan.mathematica.parsing.MathematicaElementTypes;
 import org.jetbrains.annotations.NotNull;
 
@@ -35,19 +36,21 @@
 import static com.intellij.patterns.PlatformPatterns.psiElement;
 
 /**
- * @author patrick (4/2/13)
+ * Provides completion for Mathematica built-in symbols. The underlying important file with all information can be
+ * found in the resource directory de/halirutan/mathematica/codeinsight/completion.
+ * @author hal (4/2/13)
  */
 public class BuiltinFunctionCompletionProvider extends MathematicaCompletionProvider {
 
   @Override
   void addTo(CompletionContributor contributor) {
-    final PsiElementPattern.Capture<PsiElement> psiElementCapture = psiElement().withElementType(MathematicaElementTypes.IDENTIFIER);
+    final Capture<PsiElement> psiElementCapture = psiElement().withElementType(MathematicaElementTypes.IDENTIFIER);
     contributor.extend(CompletionType.BASIC, psiElementCapture, this);
   }
 
   @Override
   protected void addCompletions(@NotNull CompletionParameters parameters, ProcessingContext context, @NotNull CompletionResultSet result) {
-    HashMap<String, SymbolInformationProvider.SymbolInformation> symbols = SymbolInformationProvider.getSymbolNames();
+    HashMap<String, SymbolInformation> symbols = SymbolInformationProvider.getSymbolNames();
 
     if (Character.isLowerCase(parameters.getPosition().getText().charAt(0))) {
       return;
@@ -58,11 +61,11 @@ protected void addCompletions(@NotNull CompletionParameters parameters, Processi
 
     CompletionResultSet result2 = result.withPrefixMatcher(matcher);
     for (String name : symbols.keySet()) {
-      SymbolInformationProvider.SymbolInformation symbol = symbols.get(name);
+      SymbolInformation symbol = symbols.get(name);
       LookupElementBuilder elm = LookupElementBuilder
-          .create(name)
+          .create(symbol.context.compareTo("System`") == 0 ? symbol.nameWithoutContext : symbol.name)
           .withInsertHandler(MathematicaBracketInsertHandler.getInstance())
-          .withTypeText(symbol.context + "`")
+          .withTypeText(symbol.context)
           .withPresentableText(symbol.nameWithoutContext);
       result2.addElement(PrioritizedLookupElement.withPriority(elm, symbol.importance));
     }

src/de/halirutan/mathematica/codeinsight/completion/SymbolInformationProvider.java

@@ -26,30 +26,32 @@
 import java.util.ResourceBundle;
 
 /**
- * @author patrick (4/3/13)
+ * Loads and extracts all information of Mathematica built-in symbols that are used for completion and intelligent
+ * code insight.
+ * @author hal (4/3/13)
  */
 public class SymbolInformationProvider {
 
-  private static HashMap<String, SymbolInformation> ourSymbols;
+  private final static String ourSymbolInformationFile = "/de/halirutan/mathematica/codeinsight/completion/symbolInformationV10_3_1";
+  private final static HashMap<String, SymbolInformation> ourSymbols;
 
-  private SymbolInformationProvider() {
-  }
-
-  private static void initialize() {
+  private SymbolInformationProvider() {}
 
-    ResourceBundle info = ResourceBundle.getBundle("/de/halirutan/mathematica/codeinsight/completion/symbolInformationV10_0_2");
+  static {
 
+    ResourceBundle info = ResourceBundle.getBundle(ourSymbolInformationFile);
     ourSymbols = new HashMap<String, SymbolInformation>(6000);
 
     Enumeration<String> names = info.getKeys();
     while (names.hasMoreElements()) {
       String name = names.nextElement();
+      String context = name.split("`")[0] + "`";
+      String nameWithoutContext = name.substring(context.length());
       String parts[] = info.getString(name).split(";");
 
       boolean isFunction = false;
       int importance = 0;
       String attributes[] = {};
-      String shortName = "";
       String pattern = "";
       String options[] = {};
 
@@ -67,10 +69,8 @@ private static void initialize() {
         attributes = parts[1].trim().split(" ");
       }
 
-      if (parts.length > 2) {
-        shortName = parts[2];
-
-      }
+      // part 2 is missing because it was used as "ShortName" until everything was refactored and the short name is
+      // now extracted from the full context name of a symbol
 
       if (parts.length > 3) {
         pattern = parts[3].trim();
@@ -84,58 +84,37 @@ private static void initialize() {
         isFunction = true;
       }
 
-      ourSymbols.put(name, new SymbolInformation(name, shortName, importance, pattern, isFunction, attributes, options));
+      ourSymbols.put(name, new SymbolInformation(name, nameWithoutContext, context, importance, pattern, isFunction, attributes, options));
     }
 
   }
 
   public static HashMap<String, SymbolInformation> getSymbolNames() {
-    if (ourSymbols == null) {
-      initialize();
-    }
     return ourSymbols;
   }
 
+  @SuppressWarnings("InstanceVariableNamingConvention")
   public static class SymbolInformation {
     public final String name;
     public final int importance;
-    public final String shortName;
     public final String callPattern;
     public final boolean function;
     public final String attributes[];
     public final String options[];
-    public String context = "System";
+    public String context;
     public String nameWithoutContext;
 
-    public SymbolInformation(String name, String shortName, int importance, String callPattern, boolean function, String[] attributes, String[] options) {
-      this.name = name;
-      this.nameWithoutContext = name;
-      this.shortName = shortName.length() == 0 ? name : shortName;
-      this.importance = importance;
-      this.callPattern = callPattern;
-      this.function = function;
-      this.attributes = attributes;
-      this.options = options;
-
-      if (name.contains("`")) {
-        context = name.split("`")[0];
-        nameWithoutContext = name.substring(context.length() + 1);
-      }
-
-
+    public SymbolInformation(String nameIn, String nameWithoutContextIn, String contextIn, int importanceIn, String callPatternIn, boolean functionIn, String[] attributesIn, String[] optionsIn) {
+      this.name = nameIn;
+      this.nameWithoutContext = nameWithoutContextIn;
+      this.context = contextIn;
+      this.importance = importanceIn;
+      this.callPattern = callPatternIn;
+      this.function = functionIn;
+      this.attributes = attributesIn;
+      this.options = optionsIn;
     }
 
-    public SymbolInformation(String name) {
-      this.name = name;
-      shortName = name;
-      importance = 0;
-      callPattern = "";
-      function = false;
-      attributes = new String[0];
-      options = new String[0];
-    }
-
-
   }
 
 }