Fix Function[] highlighting, update 2018 API changes, update gradle

Author: halirutan

build.gradle

@@ -1,32 +1,22 @@
 buildscript {
-    ext.kotlin_version = '1.1.61'
+    ext.kotlin_version = '1.2.40'
 
     repositories {
         mavenCentral()
-        maven {
-            url "https://oss.sonatype.org/content/repositories/snapshots/"
-        }
-        maven {
-            url 'http://dl.bintray.com/jetbrains/intellij-plugin-service'
-        }
-        maven {
-            url 'http://dl.bintray.com/kotlin/kotlin-eap-1.2'
-        }
     }
 
     dependencies {
-//        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-        classpath "org.jetbrains.intellij.plugins:gradle-intellij-plugin:0.3.0-SNAPSHOT"
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
     }
 }
 
 
 plugins {
-    id "org.jetbrains.kotlin.jvm" version '1.1.61'
+    id "org.jetbrains.kotlin.jvm" version "1.2.40"
+    id "org.jetbrains.intellij" version "0.3.1"
 }
 
 apply plugin: 'java'
-apply plugin: 'org.jetbrains.intellij'
 apply plugin: "kotlin"
 
 //noinspection GroovyAssignabilityCheck,GrUnresolvedAccess
@@ -78,10 +68,10 @@ task wrapper(type: Wrapper) {
 version '3.0pre10'
 
 intellij {
-    version = '2017.3.4'
+    version = '2018.1.2'
     downloadSources = true
     pluginName = 'Mathematica-IntelliJ-Plugin'
-    updateSinceUntilBuild = false
+    updateSinceUntilBuild = true
 }
 
 // Simple function to load change-notes.html and description.html into valid text for plugin.xml

src/de/halirutan/mathematica/codeinsight/completion/util/LocalDefinitionCompletionProvider.java

@@ -26,7 +26,7 @@
 import com.google.common.collect.Lists;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.ResolveState;
-import com.intellij.psi.scope.BaseScopeProcessor;
+import com.intellij.psi.scope.PsiScopeProcessor;
 import de.halirutan.mathematica.lang.psi.LocalizationConstruct;
 import de.halirutan.mathematica.lang.psi.api.FunctionCall;
 import de.halirutan.mathematica.lang.psi.api.Symbol;
@@ -49,7 +49,7 @@
  *
  * @author patrick (5/22/13)
  */
-public class LocalDefinitionCompletionProvider extends BaseScopeProcessor {
+public class LocalDefinitionCompletionProvider implements PsiScopeProcessor {
 
   private final List<Symbol> mySymbols = Lists.newLinkedList();
   private final Symbol myStartElement;
@@ -119,7 +119,8 @@ public List<Symbol> getSymbols() {
     mySymbols.sort(new SymbolComparator());
     Pattern pattern = Pattern.compile(myStartElement.getFullSymbolName().substring(0, 1) + ".*");
     Symbol tmp = null;
-    for (Iterator<Symbol> symbolIterator = mySymbols.iterator(); symbolIterator.hasNext(); ) {
+    Iterator<Symbol> symbolIterator = mySymbols.iterator();
+    while (symbolIterator.hasNext()) {
       Symbol next = symbolIterator.next();
 
       if (!pattern.matcher(next.getFullSymbolName()).matches()) {

src/de/halirutan/mathematica/errorreporting/IdeaInformationProxy.java

@@ -25,7 +25,7 @@
 import com.intellij.openapi.application.ApplicationNamesInfo;
 import com.intellij.openapi.application.ex.ApplicationInfoEx;
 import com.intellij.openapi.diagnostic.Attachment;
-import com.intellij.util.SystemProperties;
+import com.intellij.openapi.util.SystemInfo;
 
 import java.util.LinkedHashMap;
 
@@ -44,9 +44,9 @@ static LinkedHashMap<String, String> getKeyValuePairs(GitHubErrorBean error,
     params.put("Plugin Name", error.getPluginName());
     params.put("Plugin Version", error.getPluginVersion());
 
-    params.put("OS Name", SystemProperties.getOsName());
-    params.put("Java version", SystemProperties.getJavaVersion());
-    params.put("Java vm vendor", SystemProperties.getJavaVmVendor());
+    params.put("OS Name", SystemInfo.OS_NAME);
+    params.put("Java version", SystemInfo.JAVA_VERSION);
+    params.put("Java vm vendor", SystemInfo.JAVA_VENDOR);
 
     params.put("App Name", namesInfo.getProductName());
     params.put("App Full Name", namesInfo.getFullProductName());

src/de/halirutan/mathematica/lang/resolve/processors/LocalDefinitionResolveProcessor.kt

@@ -25,7 +25,7 @@ package de.halirutan.mathematica.lang.resolve.processors
 
 import com.intellij.psi.PsiElement
 import com.intellij.psi.ResolveState
-import com.intellij.psi.scope.BaseScopeProcessor
+import com.intellij.psi.scope.PsiScopeProcessor
 import com.intellij.psi.util.PsiTreeUtil
 import de.halirutan.mathematica.lang.psi.LocalizationConstruct
 import de.halirutan.mathematica.lang.psi.LocalizationConstruct.MScope
@@ -80,73 +80,73 @@ import de.halirutan.mathematica.lang.resolve.resolvers.TableLikeResolver
  *
  * @author patrick (5/22/13)
  */
-class LocalDefinitionResolveProcessor(private val myStartElement: Symbol) : BaseScopeProcessor() {
-    /**
-     * Returns the list of all symbols collected during a  run. Before returning
-     * the list, it removes duplicates, so that no entry appears more than once in the auto-completion window.
-     *
-     * @return Sorted and cleaned list of collected symbols.
-     */
-    var resolveResult: SymbolResolveResult? = null
+class LocalDefinitionResolveProcessor(private val myStartElement: Symbol) : PsiScopeProcessor {
+  /**
+   * Returns the list of all symbols collected during a  run. Before returning
+   * the list, it removes duplicates, so that no entry appears more than once in the auto-completion window.
+   *
+   * @return Sorted and cleaned list of collected symbols.
+   */
+  var resolveResult: SymbolResolveResult? = null
 
-    /**
-     * There are several places where a local variable can be "defined". First I check all localization constructs which
-     * are always function call like `Module[{var},...]`. The complete list of localization constructs can be
-     * found in [MScope].
-     *
-     *
-     * Secondly I check the patterns in e.g. ```f[var_]:=...!```  for `SetDelayed` and `TagSetDelayed`.
-     *
-     *
-     * Finally, `RuleDelayed` constructs are checked.
-     *
-     * @param element
-     * Element to check for defining the [.myStartElement].
-     * @param state State of the resolving.
-     * @return `false` if the search can be stopped, `true` otherwise
-     */
-    override fun execute(element: PsiElement, state: ResolveState): Boolean {
-        if (element is FunctionCall) {
+  /**
+   * There are several places where a local variable can be "defined". First I check all localization constructs which
+   * are always function call like `Module[{var},...]`. The complete list of localization constructs can be
+   * found in [MScope].
+   *
+   *
+   * Secondly I check the patterns in e.g. ```f[var_]:=...!```  for `SetDelayed` and `TagSetDelayed`.
+   *
+   *
+   * Finally, `RuleDelayed` constructs are checked.
+   *
+   * @param element
+   * Element to check for defining the [.myStartElement].
+   * @param state State of the resolving.
+   * @return `false` if the search can be stopped, `true` otherwise
+   */
+  override fun execute(element: PsiElement, state: ResolveState): Boolean {
+    if (element is FunctionCall) {
 
-            if (element.isScopingConstruct) {
-                val scopingConstruct = element.scopingConstruct
+      if (element.isScopingConstruct) {
+        val scopingConstruct = element.scopingConstruct
 
-                when {
-                  LocalizationConstruct.isModuleLike(scopingConstruct) -> resolveResult = ModuleLikeResolver().resolve(myStartElement, element, state)
-                  LocalizationConstruct.isFunctionLike(scopingConstruct) -> resolveResult = FunctionLikeResolver().resolve(myStartElement, element, state)
-                  LocalizationConstruct.isCompileLike(scopingConstruct) -> resolveResult = CompileLikeResolver().resolve(myStartElement, element, state)
-                  LocalizationConstruct.isTableLike(scopingConstruct) -> resolveResult = TableLikeResolver().resolve(myStartElement, element, state)
-                  LocalizationConstruct.isManipulateLike(scopingConstruct) -> resolveResult = TableLikeResolver().resolve(myStartElement, element, state)
-                }
-                resolveResult?.let { return false }
-            }
-        } else if (element is SetDelayed || element is TagSetDelayed || element is Set) {
+        when {
+          LocalizationConstruct.isModuleLike(scopingConstruct) -> resolveResult = ModuleLikeResolver().resolve(myStartElement, element, state)
+          LocalizationConstruct.isFunctionLike(scopingConstruct) -> resolveResult = FunctionLikeResolver().resolve(myStartElement, element, state)
+          LocalizationConstruct.isCompileLike(scopingConstruct) -> resolveResult = CompileLikeResolver().resolve(myStartElement, element, state)
+          LocalizationConstruct.isTableLike(scopingConstruct) -> resolveResult = TableLikeResolver().resolve(myStartElement, element, state)
+          LocalizationConstruct.isManipulateLike(scopingConstruct) -> resolveResult = TableLikeResolver().resolve(myStartElement, element, state)
+        }
+        resolveResult?.let { return false }
+      }
+    } else if (element is SetDelayed || element is TagSetDelayed || element is Set) {
 
-          val p2 = MathematicaPatternVisitor2()
-          element.accept(p2)
+      val p2 = MathematicaPatternVisitor2()
+      element.accept(p2)
 
-            val patternVisitor = MathematicaPatternVisitor()
-            element.accept(patternVisitor)
-            for (p in patternVisitor.patternSymbols) {
-                if (p.fullSymbolName == myStartElement.fullSymbolName) {
-                    if (element is Set && myStartElement !== p) {
-                        continue
-                    }
-                    resolveResult = SymbolResolveResult(p, MScope.SETDELAYED_SCOPE, element, true)
-                    return false
-                }
-            }
-        } else if (element is RuleDelayed) {
-          val patternExtractor = PatternSymbolExtractor()
-          element.accept(patternExtractor)
+      val patternVisitor = MathematicaPatternVisitor()
+      element.accept(patternVisitor)
+      for (p in patternVisitor.patternSymbols) {
+        if (p.fullSymbolName == myStartElement.fullSymbolName) {
+          if (element is Set && myStartElement !== p) {
+            continue
+          }
+          resolveResult = SymbolResolveResult(p, MScope.SETDELAYED_SCOPE, element, true)
+          return false
+        }
+      }
+    } else if (element is RuleDelayed) {
+      val patternExtractor = PatternSymbolExtractor()
+      element.accept(patternExtractor)
 
-          for (symbol in patternExtractor.patternSymbols) {
-                if (symbol.fullSymbolName == myStartElement.fullSymbolName) {
-                    resolveResult = SymbolResolveResult(symbol, MScope.RULEDELAYED_SCOPE, element, true)
-                    return false
-                }
-            }
+      for (symbol in patternExtractor.patternSymbols) {
+        if (symbol.fullSymbolName == myStartElement.fullSymbolName) {
+          resolveResult = SymbolResolveResult(symbol, MScope.RULEDELAYED_SCOPE, element, true)
+          return false
         }
-        return true
+      }
     }
+    return true
+  }
 }

src/de/halirutan/mathematica/lang/resolve/resolvers/FunctionLikeResolver.kt

@@ -56,8 +56,9 @@ class FunctionLikeResolver : Resolver {
             if (elm is Symbol && elm.hasSameName(symbol)) {
               return SymbolResolveResult(elm, scope, scopingElement, true)
             }
-
           }
+        } else if (defList is Symbol && defList.hasSameName(symbol)) {
+          return SymbolResolveResult(defList, scope, scopingElement, true)
         }
       }
     } else {
@@ -69,6 +70,8 @@ class FunctionLikeResolver : Resolver {
               return SymbolResolveResult(elm, scope, scopingElement, true)
             }
           }
+        } else if (expr is Symbol && expr == symbol) {
+          return SymbolResolveResult(symbol, scope, scopingElement, true)
         }
       }
     }

tests/de/halirutan/mathematica/lang/resolve/LocalVariableResolveTestCase.kt

@@ -51,7 +51,9 @@ class LocalVariableResolveTestCase : AbstractResolveTest() {
   )
 
   private val functionLike = mapOf(
-      "Function[{val, key}, val + <ref>key]" to TextRange.create(15, 18)
+      "Function[{val, key}, val + <ref>key]" to TextRange.create(15, 18),
+      "Function[val, <ref>val]" to TextRange.create(9, 12)
+
   )
 
   fun testModule() {