Devtools: [WIP] Implement enhanced devtools extension language APIs

Source/devtools/front_end/sdk/RuntimeModel.js

Index: Source/devtools/front_end/sdk/RuntimeModel.js
diff --git a/Source/devtools/front_end/sdk/RuntimeModel.js b/Source/devtools/front_end/sdk/RuntimeModel.js
index 44f8c32c01b7ee86eb0fe3153e64c7d3c95c310e..f402b5a95a147a0d09f312d28fdff537f69c3f80 100644
--- a/Source/devtools/front_end/sdk/RuntimeModel.js
+++ b/Source/devtools/front_end/sdk/RuntimeModel.js
@@ -37,6 +37,19 @@ 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())
@@ -81,7 +94,7 @@ WebInspector.RuntimeModel.prototype = {
         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);
     },
@@ -200,15 +213,17 @@ WebInspector.RuntimeDispatcher.prototype = {
  * @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;
@@ -322,15 +337,55 @@ WebInspector.ExecutionContext.prototype = {
         }
         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] === ".");
@@ -350,8 +405,9 @@ WebInspector.ExecutionContext.prototype = {
             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));