DevTools: Console: Provide autocompletions for Maps

third_party/WebKit/Source/devtools/front_end/components/JavaScriptAutocomplete.js

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 Components.JavaScriptAutocomplete = {};
 
 /** @typedef {{title:(string|undefined), items:Array<string>}} */
 Components.JavaScriptAutocomplete.CompletionGroup;
 
 /**
  * @param {string} text
  * @param {string} query
  * @param {boolean=} force
  * @return {!Promise<!UI.SuggestBox.Suggestions>}
  */
 Components.JavaScriptAutocomplete.completionsForTextInCurrentContext = function(text, query, force) {
+  var clippedExpression = Components.JavaScriptAutocomplete._clipExpression(text, true);
+  var mapCompletionsPromise = Components.JavaScriptAutocomplete._mapCompletions(text, query);
+  return Components.JavaScriptAutocomplete.completionsForExpression(clippedExpression, query, force)

[dgozman, 2017/01/18 17:02:39]

Should this be Promise.all instead?

[einbinder, 2017/01/19 01:20:40]

The promise has already been triggered. Promise.all seems equally clumsy.

+      .then(completions => mapCompletionsPromise.then(mapCompletions => mapCompletions.concat(completions)));
+};
+
+/**
+ * @param {string} text
+ * @param {boolean=} allowEndingBracket
+ * @return {string}
+ */
+Components.JavaScriptAutocomplete._clipExpression = function(text, allowEndingBracket) {
   var index;
   var stopChars = new Set(' =:({;,!+-*/&|^<>`'.split(''));
   for (index = text.length - 1; index >= 0; index--) {
-    // Pass less stop characters to rangeOfWord so the range will be a more complete expression.
     if (stopChars.has(text.charAt(index)))
       break;
   }
   var clippedExpression = text.substring(index + 1);
   var bracketCount = 0;
 
   index = clippedExpression.length - 1;
   while (index >= 0) {
     var character = clippedExpression.charAt(index);
     if (character === ']')
       bracketCount++;
     // Allow an open bracket at the end for property completion.
-    if (character === '[' && index < clippedExpression.length - 1) {
+    if (character === '[' && (index < clippedExpression.length - 1 || !allowEndingBracket)) {
       bracketCount--;
       if (bracketCount < 0)
         break;
     }
     index--;
   }
-  clippedExpression = clippedExpression.substring(index + 1);
-
-  return Components.JavaScriptAutocomplete.completionsForExpression(clippedExpression, query, force);
+  return clippedExpression.substring(index + 1);
 };
 
 /**
+ * @param {string} text
+ * @param {string} query
+ * @return {!Promise<!UI.SuggestBox.Suggestions>}
+ */
+Components.JavaScriptAutocomplete._mapCompletions = function(text, query) {
+  var mapMatch = text.match(/\.\s*[gs]et\s*\(\s*$/);
+  var executionContext = UI.context.flavor(SDK.ExecutionContext);
+  if (!executionContext || !mapMatch)
+    return Promise.resolve([]);
+
+  var clippedExpression = Components.JavaScriptAutocomplete._clipExpression(text.substring(0, mapMatch.index), true);
+  var fufill;
+  var promise = new Promise(x => fufill = x);
+  executionContext.evaluate(clippedExpression, 'completion', true, true, false, true, false, evaluated);
+  return promise;
+
+  /**
+     * @param {?SDK.RemoteObject} result

[dgozman, 2017/01/18 17:02:39]

indentation is off

[einbinder, 2017/01/19 01:20:40]

Fixed.

+     * @param {!Protocol.Runtime.ExceptionDetails=} exceptionDetails
+     */
+  function evaluated(result, exceptionDetails) {
+    if (!result || !!exceptionDetails || !result.preview || result.preview.subtype !== 'map') {

[dgozman, 2017/01/18 17:02:39]

Don't use preview:
- subtype is available in RemoteObject;
- it's not reliable (changes often);
- it's limited to ~100 items, so you may just miss completions.
Instead, get the internal properties which contain all entries.

[einbinder, 2017/01/19 01:20:40]

Done.

+      fufill([]);
+      return;
+    }
+
+    var caseSensitivePrefix = [];
+    var caseInsensitivePrefix = [];
+    var caseSensitiveAnywhere = [];
+    var caseInsensitiveAnywhere = [];
+    var qouteChar = '"';
+    if (query.startsWith('\''))
+      qouteChar = '\'';
+    var endChar = ')';
+    if (mapMatch[0].indexOf('s') !== -1)
+      endChar = ', ';
+    var keys = result.preview.entries.filter(entry => entry.key.type === 'string')
+                   .map(entry => entry.key.description)
+                   .sort(String.naturalOrderComparator)
+                   .map(key => qouteChar + key + qouteChar + endChar);
+
+    for (var key of keys) {
+      if (key.length < query.length)
+        continue;
+      if (query.length && key.toLowerCase().indexOf(query.toLowerCase()) === -1)
+        continue;
+      // Substitute actual newlines with newline characters. @see crbug.com/498421
+      var title = key.split('\n').join('\\n');
+
+      if (key.startsWith(query))
+        caseSensitivePrefix.push({title: title, priority: 4});
+      else if (key.toLowerCase().startsWith(query.toLowerCase()))
+        caseInsensitivePrefix.push({title: title, priority: 3});
+      else if (key.indexOf(query) !== -1)
+        caseSensitiveAnywhere.push({title: title, priority: 2});
+      else
+        caseInsensitiveAnywhere.push({title: title, priority: 1});
+    }
+    var suggestions = caseSensitivePrefix.concat(caseInsensitivePrefix, caseSensitiveAnywhere, caseInsensitiveAnywhere);
+    if (suggestions.length)
+      suggestions[0].subtitle = 'Keys';
+    fufill(suggestions);
+  }
+};
+
+/**
  * @param {string} expressionString
  * @param {string} query
  * @param {boolean=} force
  * @return {!Promise<!UI.SuggestBox.Suggestions>}
  */
 Components.JavaScriptAutocomplete.completionsForExpression = function(expressionString, query, force) {
   var executionContext = UI.context.flavor(SDK.ExecutionContext);
   if (!executionContext)
     return Promise.resolve([]);
 
@@ skipping 285 matching lines @@
   function itemComparator(a, b) {
     var aStartsWithUnderscore = a.startsWith('_');
     var bStartsWithUnderscore = b.startsWith('_');
     if (aStartsWithUnderscore && !bStartsWithUnderscore)
       return 1;
     if (bStartsWithUnderscore && !aStartsWithUnderscore)
       return -1;
     return String.naturalOrderComparator(a, b);
   }
 };