Provide completion from @param arg = SomeFunc()

klesun · klesun · commit ab75f5e73953 · 2018-08-12T13:54:22.000+03:00
diff --git a/src/org/klesun/deep_js_completion/completion_providers/DeepKeysPvdr.scala b/src/org/klesun/deep_js_completion/completion_providers/DeepKeysPvdr.scala
@@ -90,6 +90,7 @@ class DeepKeysPvdr extends CompletionProvider[CompletionParameters] {
     val psi = parameters.getOriginalPosition
     val depth = getMaxDepth(parameters.isAutoPopup)
     val search = new SearchCtx().setDepth(depth)
+    val startTime = System.nanoTime
     val suggestions = Option(parameters.getOriginalPosition.getParent)
       .flatMap(findRefExpr(_))
       .flatMap(ref => Option(ref.getQualifier))
@@ -99,6 +100,9 @@ class DeepKeysPvdr extends CompletionProvider[CompletionParameters] {
       .zipWithIndex
       .map({case (e,i) => makeLookup(e,i)})
 
+    val elapsed = System.nanoTime - startTime
+    result.addLookupAdvertisement("Resolved in " + (elapsed / 1000000000.0) + " seconds")
+
     val nameToLookup = ListMap(suggestions.map(t => t.getLookupString -> t) : _*)
     val builtInSuggestions = new util.ArrayList[LookupElement]
     val onlyTyped = JSRootConfiguration.getInstance(psi.getProject).isOnlyTypeBasedCompletion
diff --git a/src/org/klesun/deep_js_completion/resolvers/FuncCallRes.scala b/src/org/klesun/deep_js_completion/resolvers/FuncCallRes.scala
@@ -33,13 +33,7 @@ case class FuncCallRes(ctx: ICtx) {
     Option(funcCall.getMethodExpression)
       .flatMap(expr => {
         val definedRts = ctx.findExprType(expr)
-          .toList.flatMap(funcT => funcT match {
-            case funcT: JSFunctionTypeImpl => List(funcT)
-            case mt: JSContextualUnionTypeImpl => mt.getTypes.asScala
-                .flatMap(cast[JSFunctionTypeImpl](_))
-            case _ => List()
-          })
-          .flatMap(funcT => Option(funcT.getReturnType))
+          .toList.flatMap(funcT => MultiType.getReturnType(funcT))
         val builtInRts = cast[JSReferenceExpression](expr)
           .flatMap(ref => Option(ref.getReferenceName)
             .flatMap(name => Option(ref.getQualifier)
diff --git a/src/org/klesun/deep_js_completion/resolvers/MainRes.scala b/src/org/klesun/deep_js_completion/resolvers/MainRes.scala
@@ -18,7 +18,7 @@ import scala.util.Try
 
 object MainRes {
 
-  private def getReturns(func: PsiElement): List[JSExpression] = {
+  def getReturns(func: PsiElement): List[JSExpression] = {
     val arrow = cast[JSFunctionExpression](func)
       .flatMap(f => Option(f.getLastChild))
       .flatMap(cast[JSExpression](_))
diff --git a/src/org/klesun/deep_js_completion/resolvers/VarRes.scala b/src/org/klesun/deep_js_completion/resolvers/VarRes.scala
@@ -4,13 +4,17 @@ import java.util
 import java.util.Objects
 
 import com.intellij.lang.javascript.dialects.JSDialectSpecificHandlersFactory
+import com.intellij.lang.javascript.documentation.JSDocumentationUtils
 import com.intellij.lang.javascript.psi.impl.{JSDefinitionExpressionImpl, JSFunctionImpl, JSReferenceExpressionImpl}
 import com.intellij.lang.javascript.psi._
+import com.intellij.lang.javascript.psi.jsdoc.JSDocTag
+import com.intellij.lang.javascript.psi.jsdoc.impl.JSDocCommentImpl
 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.{PsiElement, PsiFile, PsiWhiteSpace}
 import com.intellij.psi.impl.source.resolve.reference.impl.providers.{FileReference, FileReferenceSet}
+import com.intellij.psi.impl.source.tree.LeafPsiElement
 import com.intellij.psi.util.PsiTreeUtil
 import org.klesun.deep_js_completion.entry.PathStrGoToDecl
 import org.klesun.deep_js_completion.helpers.{ICtx, MultiType}
@@ -19,6 +23,9 @@ import org.klesun.lang.Lang
 import scala.collection.JavaConverters._
 import org.klesun.lang.Lang._
 
+import scala.collection.GenTraversable
+import scala.collection.mutable.ListBuffer
+
 /**
  * resolves variable type
  */
@@ -79,9 +86,70 @@ case class VarRes(ctx: ICtx) {
     .flatMap(file => resolveRequireJsFormatDef(file))
     .flatMap(clsT => ensureFunc(clsT))
 
+  private def getDocTagComment(docTag: JSDocTag) = {
+    var next = docTag.getNextSibling
+    val tokens = new ListBuffer[PsiElement]
+    while (next != null && (
+      next.isInstanceOf[LeafPsiElement] ||
+      next.isInstanceOf[PsiWhiteSpace]
+    )) {
+      tokens.append(next)
+      next = next.getNextSibling
+    }
+    tokens.map(t => t.getText).mkString("")
+      .replaceAll("""\n\s*\* """, "\n")
+  }
+
+  private def findVarDecl(caretPsi: PsiElement, varName: String): Option[JSType] = {
+    Lang.findParent[JSBlockStatement](caretPsi)
+      .toList.flatMap(b => b.getStatements
+        .flatMap(st => st match {
+          case varSt: JSVarStatement =>
+            varSt.getDeclarations
+              .filter(own => varName.equals(own.getName))
+              .map(own => own.getInitializer)
+              .flatMap(expr => ctx.findExprType(expr))
+          case func: JSFunctionDeclaration =>
+            if (varName.equals(func.getName)) {
+              val rts = MainRes.getReturns(func)
+                .flatMap(ret => ctx.findExprType(ret))
+              val rt = MultiType.mergeTypes(rts).getOrElse(JSUnknownType.JS_INSTANCE)
+              Some(new JSFunctionTypeImpl(JSTypeSource.EMPTY, new util.ArrayList, rt))
+            } else {
+              None
+            }
+          case _ => None
+        })
+        .++(findVarDecl(b, varName))
+      )
+      .lift(0)
+  }
+
+  private def parseDocExpr(caretPsi: PsiElement, expr: String): Option[JSType] = {
+    """^\s*=\s*(\w+)(\([^\)]*\)|)\s*$""".r.findFirstMatchIn(expr)
+      .flatMap(found => {
+        val varName = found.group(1)
+        val isFuncCall = !found.group(2).equals("")
+        findVarDecl(caretPsi, varName)
+          .flatMap(t => if (isFuncCall) MultiType.getReturnType(t) else Some(t))
+      })
+  }
+
+  private def getArgDocExprType(func: JSFunction, para: JSParameter): List[JSType] = {
+    Option(JSDocumentationUtils.findDocComment(para))
+      .flatMap(cast[JSDocCommentImpl](_)).toList
+      .flatMap(tag => tag.getTags)
+      .filter(tag => "param".equals(tag.getName))
+      .filter(tag => Option(tag.getDocCommentData)
+        .exists(data => Objects.equals(para.getName, data.getText)))
+      .map(tag => getDocTagComment(tag))
+      .flatMap(expr => parseDocExpr(para, expr))
+  }
+
   private def resolveArg(para: JSParameter): Option[JSType] = {
     val types = Option(para.getDeclaringFunction)
       .toList.flatMap(func => List[JSType]()
+        ++ getArgDocExprType(func, para)
         ++ getInlineFuncArgType(func)
         ++ getKlesunRequiresArgType(func))
     MultiType.mergeTypes(types)
diff --git a/tests/KlesunRequires.js b/tests/KlesunRequires.js
@@ -0,0 +1,50 @@
+/**
+ * this is a handy wrapper for require.js
+ * are you tired of specifying module paths in one
+ * array, and matching resolved values in another?
+ * then this util is for you:
+ *
+ * Before:
+ * define(['A.js', 'B.js', 'E.js', 'D.js'], (A, B, E, D) => {...})
+ *
+ * After:
+ * klesun.requires('A.js').then = A =>
+ * klesun.requires('B.js').then = B =>
+ * klesun.requires('E.js').then = E =>
+ * klesun.requires('D.js').then = D =>
+ * klesun.whenLoaded = () => {...}
+ *
+ * Note that each module is supposed to return a function, so this
+ * util will be useful only for local project module resolution
+ */
+var Klesun = Klesun || (() => {
+    let modulePaths = [];
+    let loadedClasses = [];
+    return 1 && {
+        requires: function (modulePath) {
+            modulePaths.push(modulePath);
+            let i = modulePaths.length - 1;
+            let makeInstance = (...args) => {
+                let module = loadedClasses[i];
+                if (typeof module === 'function') {
+                    // module is a function (class) - call it with passed params
+                    return module(...args);
+                } else {
+                    // module is a static object - just return it
+                    return module;
+                }
+            };
+            return {
+                set then(callback) {
+                    callback(makeInstance);
+                }
+            };
+        },
+        set whenLoaded(finalCallback) {
+            define(modulePaths, (...modules) => {
+                loadedClasses.push(...modules);
+                return finalCallback();
+            });
+        },
+    };
+});
diff --git a/tests/Tls.js b/tests/Tls.js
@@ -0,0 +1,115 @@
+
+/**
+ * provides various coding tools like Optional-s and Promise-s
+ */
+define([], () => (...ctorArgs) => {
+
+    /** similar to Java's Optional
+     * @param forceIsPresent - use when value may be null (when it's not typed for example) */
+    let opt = function (value, forceIsPresent = false) {
+        let has = () => forceIsPresent ||
+            value !== null && value !== undefined;
+        let self;
+        return self = {
+            map: (f) => has() ? opt(f(value)) : opt(null),
+            /** flat map - return empty or mapped array*/
+            fmp: (f) => has() ? f(value) : [],
+            flt: (f) => has() && f(value) ? opt(value) : opt(null),
+            saf: (f) => {
+                if (has()) {
+                    try { return opt(f(value)); }
+                    catch (exc) { console.error('Opt mapping threw an exception', exc); }
+                }
+                return opt(null);
+            },
+            def: (def) => has() ? value : def,
+            has: has,
+            set get(cb) { if (has()) { cb(value); } },
+            wth: (f) => {
+                if (has()) { f(value); }
+                return self;
+            },
+            uni: (some, none) => has() ? some(value) : none(),
+            err: (none) => {
+                if (has()) {
+                    return { set els(some) { some(value); } };
+                } else {
+                    none();
+                    return { set els(some) { } };
+                }
+            },
+        };
+    };
+
+    /**
+     * similar to the built-in Promise, I guess,
+     * but in slightly more convenient format
+     */
+    let promise = function(giveMemento)
+    {
+        let done = false;
+        let result;
+        let thens = [];
+        giveMemento(r => {
+            done = true;
+            result = r;
+            thens.forEach((cb) => cb(result));
+        });
+        let self = {
+            set then(receive) {
+                if (done) {
+                    receive(result);
+                } else {
+                    thens.push(receive);
+                }
+            },
+            map: (f) => promise(
+                delayedReturn => self.then =
+                    (r) => delayedReturn(f(r))
+            ),
+        };
+        return self;
+    };
+
+    /** @param responseType = 'arraybuffer' | 'json' | 'text' */
+    let http = (url, responseType) => promise(done => {
+        let oReq = new XMLHttpRequest();
+        oReq.open("GET", url, true);
+        if (responseType) {
+            oReq.responseType = responseType;
+        }
+        oReq.onload = () => done(oReq.response);
+        oReq.send(null);
+    });
+
+    /** a shorthand to create dom elements in js with one expression */
+    let mkDom = (tagName, params) => {
+        let dom = document.createElement(tagName);
+        for (let [k,v] of Object.entries(params || {})) {
+            if (k === 'innerHTML') {
+                dom.innerHTML = v;
+            } else if (k === 'children') {
+                v.forEach(c => dom.appendChild(c));
+            } else if (k === 'style') {
+                Object.keys(v).forEach(k => dom.style[k] = v[k]);
+            } else if (k === 'classList') {
+                v.forEach(c => dom.classList.add(c));
+            } else {
+                dom[k] = v;
+                if (typeof v !== 'function') {
+                    dom.setAttribute(k, v);
+                }
+            }
+        }
+        return dom;
+    };
+
+    return {
+        opt: opt,
+        promise: promise,
+        http: http,
+        mkDom: mkDom,
+        range: (l, r) => new Array(r - l).fill(0).map((_, i) => l + i),
+        deepCopy: val => JSON.parse(JSON.stringify(val)),
+    };
+});
diff --git a/tests/index.js b/tests/index.js
@@ -2,6 +2,60 @@
 
     let ssrLineNumbers = [];
 
+    var klesun = Klesun();
+    klesun.requires('./Tls.js').then = Tls =>
+    klesun.whenLoaded = () => (...ctorParams) => {
+        let tls = Tls();
+        // should suggest: opt, promise, http, mkDom, range, deepCopy
+        tls.o;
+    };
+
+    define(['./Tls.js'], (Tls) => (...ctorArgs) => {
+        let tls = Tls();
+        // should suggest: opt, promise, http, mkDom, range, deepCopy
+        tls.o;
+    });
+
+    /**
+     * @typedef {Object} generatedPoint
+     * @type {Object}
+     * @property {number} x The x coordinate.
+     * @property {number} y The y coordinate.
+     * @property {number} amount
+     */
+
+    let a = 5,
+        b = 6;
+
+    /** @param whiskey {generatedPoint} */
+    let Denis = function(whiskey){
+        return {
+            monthsTilDiploma: 12 + whiskey.amount / 1000,
+            takeTripleShot: () => alert('I aint drunk yeaaaat'),
+            dropTheLocker: () => alert('Bam!'),
+        };
+    };
+
+    setTimeout(() => {
+        /**
+         * @param denis = Denis()
+         * @param tls = from('./Tls.js')()
+         * @param smf {from('./SmfAdapter.js')()}
+         * @param pax {{first: 'Vova', last: 'Pupkin', age: '18'}}
+         * @param segment {{a: string, b: int}}
+         * @param segment.from
+         * @param segment.to
+         */
+        let testArgDocComment = function(denis, tls, smf, pax, segment) {
+            // should suggest: yearsTilDiploma, takeTripleShot, dropTheLocker
+            denis.t;
+            // should suggest: first, last, age
+            pax.f;
+            // should suggest: opt, promise, http, mkDom, range, deepCopy
+            tls.o;
+        };
+    }, 100);
+
     let collectSmfNotes = function(smf) {
         let notes = [];
         notes.push({zalupa:123});
