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)
+      .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(''));
   var whiteSpaceChars = new Set(' \r\n\t'.split(''));
   var continueChars = new Set('[. \r\n\t'.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;
     if (whiteSpaceChars.has(text.charAt(index)) && !continueChars.has(text.charAt(index - 1)))
       break;
   }
   var clippedExpression = text.substring(index + 1).trim();
   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).trim();
-
-  return Components.JavaScriptAutocomplete.completionsForExpression(clippedExpression, query, force);
+  return clippedExpression.substring(index + 1).trim();
 };
 
 /**
+ * @param {string} text
+ * @param {string} query
+ * @return {!Promise<!UI.SuggestBox.Suggestions>}
+ */
+Components.JavaScriptAutocomplete._mapCompletions = function(text, query) {
+  var mapMatch = text.match(/\.\s*(get|set|delete)\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));
+  var fulfill;
+  var promise = new Promise(x => fulfill = x);
+  executionContext.evaluate(clippedExpression, 'completion', true, true, false, false, false, evaluated);
+  return promise;
+
+  /**
+   * @param {?SDK.RemoteObject} result
+   * @param {!Protocol.Runtime.ExceptionDetails=} exceptionDetails
+   */
+  function evaluated(result, exceptionDetails) {
+    if (!result || !!exceptionDetails || result.subtype !== 'map') {
+      fulfill([]);
+      return;
+    }
+    result.getOwnPropertiesPromise().then(extractEntriesProperty);
+  }
+
+  /**
+   * @param {!{properties: ?Array<!SDK.RemoteObjectProperty>, internalProperties: ?Array<!SDK.RemoteObjectProperty>}} properties
+   */
+  function extractEntriesProperty(properties) {
+    var internalProperties = properties.internalProperties || [];
+    var entriesProperty = internalProperties.find(property => property.name === '[[Entries]]');
+    if (!entriesProperty) {
+      fulfill([]);
+      return;
+    }
+    entriesProperty.value.callFunctionJSONPromise(getEntries).then(keysObj => gotKeys(Object.keys(keysObj)));
+  }
+
+  /**
+   * @suppressReceiverCheck
+   * @this {!Array<{key:?, value:?}>}
+   * @return {!Object}
+   */
+  function getEntries() {
+    var result = {__proto__: null};
+    for (var i = 0; i < this.length; i++) {
+      if (typeof this[i].key === 'string')
+        result[this[i].key] = true;
+    }
+    return result;
+  }
+
+  /**
+   * @param {!Array<string>} rawKeys
+   */
+  function gotKeys(rawKeys) {
+    var caseSensitivePrefix = [];
+    var caseInsensitivePrefix = [];
+    var caseSensitiveAnywhere = [];
+    var caseInsensitiveAnywhere = [];
+    var quoteChar = '"';
+    if (query.startsWith('\''))
+      quoteChar = '\'';
+    var endChar = ')';
+    if (mapMatch[0].indexOf('set') !== -1)
+      endChar = ', ';
+
+    var keys = rawKeys.sort(String.naturalOrderComparator).map(key => quoteChar + key + quoteChar + endChar);

[dgozman, 2017/01/23 23:57:49]

Let's not use naturalOrderComparator for large arrays.

[einbinder, 2017/01/24 19:06:32]

Done.

+
+    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 = Common.UIString('Keys');
+    fulfill(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([]);
 
   var lastIndex = expressionString.length - 1;
 
   var dotNotation = (expressionString[lastIndex] === '.');
   var bracketNotation = (expressionString.length > 1 && expressionString[lastIndex] === '[');
 
   if (dotNotation || bracketNotation)
     expressionString = expressionString.substr(0, lastIndex);
   else
     expressionString = '';
 
   // User is entering float value, do not suggest anything.
   if ((expressionString && !isNaN(expressionString)) || (!expressionString && query && !isNaN(query)))
     return Promise.resolve([]);
 
 
   if (!query && !expressionString && !force)
     return Promise.resolve([]);
 
-  var fufill;
-  var promise = new Promise(x => fufill = x);
+  var fulfill;
+  var promise = new Promise(x => fulfill = x);
   var selectedFrame = executionContext.debuggerModel.selectedCallFrame();
   if (!expressionString && selectedFrame)
     variableNamesInScopes(selectedFrame, receivedPropertyNames);
   else
     executionContext.evaluate(expressionString, 'completion', true, true, false, false, false, evaluated);
 
   return promise;
   /**
    * @param {?SDK.RemoteObject} result
    * @param {!Protocol.Runtime.ExceptionDetails=} exceptionDetails
    */
   function evaluated(result, exceptionDetails) {
     if (!result || !!exceptionDetails) {
-      fufill([]);
+      fulfill([]);
       return;
     }
 
     /**
      * @param {?SDK.RemoteObject} object
      * @return {!Promise<?SDK.RemoteObject>}
      */
     function extractTarget(object) {
       if (!object)
         return Promise.resolve(/** @type {?SDK.RemoteObject} */ (null));
@@ skipping 107 matching lines @@
 
   /**
    * @param {?SDK.RemoteObject} result
    * @param {!Protocol.Runtime.ExceptionDetails=} exceptionDetails
    */
   function receivedPropertyNamesFromEval(result, exceptionDetails) {
     executionContext.target().runtimeAgent().releaseObjectGroup('completion');
     if (result && !exceptionDetails)
       receivedPropertyNames(/** @type {!Object} */ (result.value));
     else
-      fufill([]);
+      fulfill([]);
   }
 
   /**
    * @param {?Object} object
    */
   function receivedPropertyNames(object) {
     executionContext.target().runtimeAgent().releaseObjectGroup('completion');
     if (!object) {
-      fufill([]);
+      fulfill([]);
       return;
     }
     var propertyGroups = /** @type {!Array<!Components.JavaScriptAutocomplete.CompletionGroup>} */ (object);
     var includeCommandLineAPI = (!dotNotation && !bracketNotation);
     if (includeCommandLineAPI) {
       const commandLineAPI = [
         'dir',
         'dirxml',
         'keys',
         'values',
         'profile',
         'profileEnd',
         'monitorEvents',
         'unmonitorEvents',
         'inspect',
         'copy',
         'clear',
         'getEventListeners',
         'debug',
         'undebug',
         'monitor',
         'unmonitor',
         'table',
         '$',
         '$$',
         '$x'
       ];
       propertyGroups.push({items: commandLineAPI});
     }
-    fufill(Components.JavaScriptAutocomplete._completionsForQuery(
+    fulfill(Components.JavaScriptAutocomplete._completionsForQuery(
         dotNotation, bracketNotation, expressionString, query, propertyGroups));
   }
 };
 
 /**
    * @param {boolean} dotNotation
    * @param {boolean} bracketNotation
    * @param {string} expressionString
    * @param {string} query
    * @param {!Array<!Components.JavaScriptAutocomplete.CompletionGroup>} propertyGroups
@@ skipping 71 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);
   }
 };