Infer array element type from .push()

Author: klesun

src/org/klesun/deep_js_completion/resolvers/VarRes.scala

@@ -1,15 +1,20 @@
 package org.klesun.deep_js_completion.resolvers
 
 import java.util
+import java.util.Objects
 
+import com.intellij.lang.javascript.dialects.JSDialectSpecificHandlersFactory
 import com.intellij.lang.javascript.psi.impl.{JSDefinitionExpressionImpl, JSFunctionImpl, JSReferenceExpressionImpl}
 import com.intellij.lang.javascript.psi._
+import com.intellij.lang.javascript.psi.resolve.JSResolveUtil
 import com.intellij.lang.javascript.psi.types._
+import com.intellij.psi.impl.source.resolve.ResolveCache.PolyVariantResolver
 import com.intellij.psi.{PsiElement, PsiFile}
 import com.intellij.psi.impl.source.resolve.reference.impl.providers.{FileReference, FileReferenceSet}
 import com.intellij.psi.util.PsiTreeUtil
 import org.klesun.deep_js_completion.entry.PathStrGoToDecl
 import org.klesun.deep_js_completion.helpers.{ICtx, MultiType}
+import org.klesun.lang.Lang
 
 import scala.collection.JavaConverters._
 import org.klesun.lang.Lang._
@@ -87,6 +92,17 @@ case class VarRes(ctx: ICtx) {
       .take(1).toList.lift(0)
   }
 
+  def findUsages(ref: JSReferenceExpression): List[JSReferenceExpression] = {
+    Option(ref.resolve()).toList.flatMap(decl => {
+      val scope: PsiElement = Lang.findParent[JSFunctionExpression](decl)
+        .getOrElse(decl.getContainingFile)
+      Lang.findChildren[JSReferenceExpression](scope)
+          .filter(usage => Objects.equals(usage.getReferenceName, ref.getReferenceName))
+          .filter(usage => !Objects.equals(usage, ref))
+          .filter(usage => Objects.equals(decl, usage.resolve()))
+    })
+  }
+
   def resolve(ref: JSReferenceExpression): Option[JSType] = {
     // TODO: manually support re-assignment, like
     // var someVar = null;
@@ -100,6 +116,17 @@ case class VarRes(ctx: ICtx) {
         MultiType.getKey(qualT, keyTOpt)
       })
 
+    val pushRef = findUsages(ref)
+      .flatMap(usage => Option(usage.getParent))
+      .flatMap(cast[JSReferenceExpression](_))
+      .filter(superRef => "push".equals(superRef.getReferenceName))
+      .flatMap(psi => Option(psi.getParent))
+      .flatMap(cast[JSCallExpression](_))
+      .flatMap(call => call.getArguments.lift(0))
+      .filter(arg => Lang.log("arg " + arg.getText + " " + arg.getClass))
+      .flatMap(value => ctx.findExprType(value))
+      .map(elT => new JSArrayTypeImpl(elT, JSTypeSource.EMPTY))
+
     val briefRef = Option(ref.resolve())
       .flatMap(psi => psi match {
         case para: JSParameter => resolveArg(para)
@@ -128,6 +155,6 @@ case class VarRes(ctx: ICtx) {
           println("Unsupported var declaration - " + psi.getClass + " " + psi.getText)
           None
       })
-    MultiType.mergeTypes(deepRef ++ briefRef)
+    MultiType.mergeTypes(deepRef ++ pushRef ++ briefRef)
   }
 }

src/org/klesun/lang/Lang.scala

@@ -2,6 +2,8 @@ package org.klesun.lang
 
 import com.intellij.psi.PsiElement
 
+import com.intellij.psi.PsiElement
+
 import scala.reflect.{ClassTag, classTag}
 import scala.reflect.runtime.universe._
 
@@ -70,4 +72,21 @@ object Lang {
     val lines = text.split("\n").map(l => l.trim)
     substr(lines.mkString(" "), 0, length)
   }
+
+  def findParent[T <: PsiElement : ClassTag](psi: PsiElement): Option[T] = {
+    var parent = psi.getParent
+    var matching: Option[T] = None
+    while (parent != null && matching.isEmpty) {
+      matching = cast[T](parent)
+      parent = parent.getParent
+    }
+    matching
+  }
+
+  def findChildren[T <: PsiElement : ClassTag](parent: PsiElement): List[T] = {
+    parent.getChildren
+      .flatMap(c => findChildren[T](c))
+      .++(List(parent).flatMap(cast[T](_)))
+      .toList
+  }
 }

tests/index.js

@@ -2,6 +2,49 @@
 
     let ssrLineNumbers = [];
 
+    let collectSmfNotes = function(smf) {
+        let notes = [];
+        notes.push({zalupa:123});
+        let otherEvents = [];
+        let chanToNotes = range(0,16).map(i => []);
+        for (let [i, track] of Object.entries(smf.tracks)) {
+            let time = 0;
+            let noteOnIndex = 0;
+            for (let event of track.events) {
+                time += event.delta;
+                if (isNoteOn(event)) {
+                    let chan = event.midiChannel;
+                    let tone = event.parameter1;
+                    let velo = event.parameter2;
+                    let dura = 0;
+                    chanToNotes[chan][tone] = chanToNotes[chan][tone] || [];
+                    chanToNotes[chan][tone].push({
+                        tone, time, dura, chan, track: i,
+                        velo, index: noteOnIndex++,
+                    });
+                } else if (isNoteOff(event)) {
+                    let chan = event.midiChannel;
+                    let tone = event.parameter1;
+                    for (let note of chanToNotes[chan][tone] || []) {
+                        note.dura = time - note.time;
+                        notes.push(note);
+                    }
+                    chanToNotes[chan][tone] = [];
+                } else {
+                    otherEvents.push({time, event, track: i});
+                }
+            }
+        }
+        notes[0].a;
+        return {notes, otherEvents};
+    };
+
+    let testPushInference = function() {
+        let collected = collectSmfNotes();
+        // should suggest: zalupa, dura, tone, time, chan, track, velo, index
+        collected.notes[0].z;
+    };
+
     let testMiscStuff = function() {
         let getObj = function () {
             return {