Devtools: [WIP] Implement enhanced devtools extension language APIs

Source/devtools/front_end/sdk/RuntimeModel.js

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 19 matching lines @@
 
 /**
  * @constructor
  * @extends {WebInspector.SDKModel}
  * @param {!WebInspector.Target} target
  */
 WebInspector.RuntimeModel = function(target)
 {
     WebInspector.SDKModel.call(this, WebInspector.RuntimeModel, target);
 
+    /**
+     * @param {!WebInspector.DebuggerModel.Location} raw
+     * @suppress {missingProperties}
+     */
+    this._locationResolver = raw => {

[pfeldman, 2015/08/13 21:15:46]

SDK can't depend on the bindings, source mappings are external to SDK.

[wes, 2015/08/14 00:55:05]

This was literally a hack I threw in the other day after fiddling about. :D

So I added the transpile call as close to the sdk API as I could (knowing I'd
want 
some debugger info and not knowing the design
goals of the system very well) to reduce code duplication. Given what I've been
told now, 
it should be lifted from within ExecutionContext (which shouldn't know about
languages 
since its in sdk) and out to where `evaluate` gets called. This means lifting it
into 
JavaScriptSourceFrame _and_ WatchExpressionsSidebarPane in the sources module -
where 
the mapping can be done without this hack. This implies that in order to reuse
code 
I'll end up needing a TranspilingExecutionContextWrapper in sources for both to
use.

I also now realize I was creating awkward multiple transpiling code paths in
WatchExpressionsSidebarPane.

[pfeldman, 2015/08/17 21:15:52]

Your _locationResolver looks very similar to the source mapping that is baked
into both SDK and workspace. Are you doing the same thing here?

[wes, 2015/08/25 18:13:18]

Already gone. :3

+        if (!WebInspector.debuggerWorkspaceBinding) return;
+        var loc = WebInspector.debuggerWorkspaceBinding.rawLocationToUILocation(raw);
+        return {
+            source: loc.uiSourceCode.contentURL(),
+            line: loc.lineNumber,
+            column: loc.columnNumber
+        };
+    };
     this._agent = target.runtimeAgent();
     this.target().registerRuntimeDispatcher(new WebInspector.RuntimeDispatcher(this));
     if (target.hasJSContext())
         this._agent.enable();
     /**
      * @type {!Object.<number, !WebInspector.ExecutionContext>}
      */
     this._executionContextById = {};
 
     if (!Runtime.experiments.isEnabled("customObjectFormatters"))
@@ skipping 24 matching lines @@
 
     /**
      * @param {!RuntimeAgent.ExecutionContextDescription} context
      */
     _executionContextCreated: function(context)
     {
         // The private script context should be hidden behind an experiment.
         if (context.name == WebInspector.RuntimeModel._privateScript && !context.origin && !Runtime.experiments.isEnabled("privateScriptInspection")) {
             return;
         }
-        var executionContext = new WebInspector.ExecutionContext(this.target(), context.id, context.name, context.origin, !!context.isPageContext, context.frameId);
+        var executionContext = new WebInspector.ExecutionContext(this.target(), this._locationResolver, context.id, context.name, context.origin, !!context.isPageContext, context.frameId);
         this._executionContextById[executionContext.id] = executionContext;
         this.dispatchEventToListeners(WebInspector.RuntimeModel.Events.ExecutionContextCreated, executionContext);
     },
 
     /**
      * @param {number} executionContextId
      */
     _executionContextDestroyed: function(executionContextId)
     {
         var executionContext = this._executionContextById[executionContextId];
@@ skipping 98 matching lines @@
     {
         this._runtimeModel._executionContextsCleared();
     }
 
 }
 
 /**
  * @constructor
  * @extends {WebInspector.SDKObject}
  * @param {!WebInspector.Target} target
+ * @param {function(!WebInspector.DebuggerModel.Location): ({source: string, line: number, column: number}|undefined)} locationResolver
  * @param {number|undefined} id
  * @param {string} name
  * @param {string} origin
  * @param {boolean} isPageContext
  * @param {string=} frameId
  */
-WebInspector.ExecutionContext = function(target, id, name, origin, isPageContext, frameId)
+WebInspector.ExecutionContext = function(target, locationResolver, id, name, origin, isPageContext, frameId)
 {
     WebInspector.SDKObject.call(this, target);
+    this._locationResolver = locationResolver;
     this.id = id;
     this.name = name;
     this.origin = origin;
     this.isMainWorldContext = isPageContext;
     this.runtimeModel = target.runtimeModel;
     this.debuggerModel = WebInspector.DebuggerModel.fromTarget(target);
     this.frameId = frameId;
 }
 
 /**
@@ skipping 93 matching lines @@
                 return;
             }
 
             if (returnByValue)
                 callback(null, !!wasThrown, wasThrown ? null : result, exceptionDetails);
             else
                 callback(this.runtimeModel.createRemoteObject(result), !!wasThrown, undefined, exceptionDetails);
         }
         this.target().runtimeAgent().evaluate(expression, objectGroup, includeCommandLineAPI, doNotPauseOnExceptionsAndMuteConsole, this.id, returnByValue, generatePreview, evalCallback.bind(this));
     },
+    
+    /**
+     * @return {({source: string, line: number, column: number}|undefined)}
+     */
+    pauseLocation: function() {
+        var frame = this.debuggerModel.selectedCallFrame();
+        var raw;
+        if (frame && (raw = frame.location())) {
+            return this._locationResolver(raw);
+        }
+        return;
+    },
 
     /**
      * @param {string} expressionString
+     * @param {string} text
+     * @param {number} cursorOffset
      * @param {string} prefix
      * @param {boolean} force
      * @param {function(!Array.<string>, number=)} completionsReadyCallback
      */
-    completionsForExpression: function(expressionString, prefix, force, completionsReadyCallback)
+    completionsForExpression: function(expressionString, text, cursorOffset, prefix, force, completionsReadyCallback)
     {
+        var location = this.pauseLocation();

[pfeldman, 2015/08/13 21:15:46]

You should transpile expressionString prior to getting here, this is just and
SDK, language support layer needs to be on top of it.

[wes, 2015/08/14 00:55:05]

Is expressionString supposed to be an identifier for member completions or
something? I don't think the still-being-built
string-in-the-console-or-watch-window should be transpiled by this point... so
it's not that... In fact, on inspection of my code at present, when a language
service is queried for completions at this point, expressionString isn't even
used in that process! Though to be fair, the debuggerCompletions codepath also
doesn't query the debugger for completion members (since the service is supposed
to know those). This is one of those things which has more use the more dynamic
the completions are supposed to be, I think?
 
So! This function is called in exactly one place (in the components module), but
that static delegate in components gets reused in a few places (in components &
console). Moving this into that delegate is pretty simple (since... it doesn't
rely on anything private here), but it means components will take a dependency
on language now. Is that okay (it gets it out of SDK, which is the goal, so I
think so)? 

[pfeldman, 2015/08/17 21:15:52]

This would also go into your module

[wes, 2015/08/25 18:13:18]

And so it has.

+        
+        function handleDebuggerCompletionsComplete(vals) {
+            if (!vals) {
+                completionsReadyCallback([]);
+            }
+            completionsReadyCallback(vals.map(function(v) { return v.text; }));
+        }
+
+        //If possible, ceede to the language service
+        if (location) { //paused - get active mime from pause location
+            var mime = WebInspector.ResourceType.mimeFromUrl(location.source);
+
+            if (WebInspector.languageService.handles.debuggerCompletions(mime)) {
+                WebInspector.languageService.debuggerCompletions(mime, text, cursorOffset, prefix, location).then(handleDebuggerCompletionsComplete);
+                return;
+            }
+        } else { //not paused - get active mime from source pane
+            var activeDocMime = WebInspector.ResourceType.fromActivePanel();
+            
+            if (WebInspector.languageService.handles.debuggerCompletions(activeDocMime)) {
+                WebInspector.languageService.debuggerCompletions(activeDocMime, text, cursorOffset, prefix, undefined).then(handleDebuggerCompletionsComplete);
+                return;
+            }
+        }
+
         var lastIndex = expressionString.length - 1;
 
         var dotNotation = (expressionString[lastIndex] === ".");
         var bracketNotation = (expressionString[lastIndex] === "[");
 
         if (dotNotation || bracketNotation)
             expressionString = expressionString.substr(0, lastIndex);
 
         if (expressionString && parseInt(expressionString, 10) == expressionString) {
             // User is entering float value, do not suggest anything.
             completionsReadyCallback([]);
             return;
         }
 
         if (!prefix && !expressionString && !force) {
             completionsReadyCallback([]);
             return;
         }
 
-        if (!expressionString && this.debuggerModel.selectedCallFrame())
-            this.debuggerModel.selectedCallFrame().variableNames(receivedPropertyNames.bind(this));
+        var frame = this.debuggerModel.selectedCallFrame();
+        if (!expressionString && frame)
+            frame.variableNames(receivedPropertyNames.bind(this));
         else
             this.evaluate(expressionString, "completion", true, true, false, false, evaluated.bind(this));
 
         /**
          * @this {WebInspector.ExecutionContext}
          */
         function evaluated(result, wasThrown)
         {
             if (!result || wasThrown) {
                 completionsReadyCallback([]);
@@ skipping 188 matching lines @@
     /**
      * @return {!RuntimeAgent.RemoteObjectId}
      */
      objectId: function()
      {
         return this._objectId;
      },
 
     __proto__: WebInspector.SDKObject.prototype
 }