Skip to site navigation (Press enter)

[webkit-changes] [198925] trunk

commit-queue Thu, 31 Mar 2016 15:51:07 -0700

Title: [198925] trunk

Revision: 198925
Author: [email protected]
Date: 2016-03-31 15:50:33 -0700 (Thu, 31 Mar 2016)

Log Message

Web Inspector: ScriptSyntaxTree doesn't handle RestElement AST nodes
https://bugs.webkit.org/show_bug.cgi?id=156085


Patch by Joseph Pecoraro <[email protected]> on 2016-03-31
Reviewed by Saam Barati.

Source/WebInspectorUI:

* UserInterface/Models/ScriptSyntaxTree.js:
(WebInspector.ScriptSyntaxTree.prototype._gatherIdentifiersInDeclaration.gatherIdentifiers):
(WebInspector.ScriptSyntaxTree.prototype._gatherIdentifiersInDeclaration):
When searching for identifiers in Function parameters, pass
through the RestElement to its argument.

(WebInspector.ScriptSyntaxTree.prototype._recurse):
(WebInspector.ScriptSyntaxTree.prototype._createInternalSyntaxTree):
Create a ScriptSyntaxTree RestElement node.
Also, every case in recurse visits the current
node, so simplify the code!

LayoutTests:

* inspector/model/parse-script-syntax-tree-expected.txt:
* inspector/model/parse-script-syntax-tree.html:
Add a test for a RestElement.

Modified Paths

trunk/LayoutTests/ChangeLog
trunk/LayoutTests/inspector/model/parse-script-syntax-tree-expected.txt
trunk/LayoutTests/inspector/model/parse-script-syntax-tree.html
trunk/Source/WebInspectorUI/ChangeLog
trunk/Source/WebInspectorUI/UserInterface/Models/ScriptSyntaxTree.js

Diff

Modified: trunk/LayoutTests/ChangeLog (198924 => 198925)


--- trunk/LayoutTests/ChangeLog	2016-03-31 22:43:45 UTC (rev 198924)
+++ trunk/LayoutTests/ChangeLog	2016-03-31 22:50:33 UTC (rev 198925)
@@ -1,3 +1,14 @@
+2016-03-31  Joseph Pecoraro  <[email protected]>
+
+        Web Inspector: ScriptSyntaxTree doesn't handle RestElement AST nodes
+        https://bugs.webkit.org/show_bug.cgi?id=156085
+
+        Reviewed by Saam Barati.
+
+        * inspector/model/parse-script-syntax-tree-expected.txt:
+        * inspector/model/parse-script-syntax-tree.html:
+        Add a test for a RestElement.
+
 2016-03-31  Daniel Bates  <[email protected]>
 
         REGRESSION (r195605): ASSERTION FAILED: !NoEventDispatchAssertion::isEventDispatchForbidden()

Modified: trunk/LayoutTests/inspector/model/parse-script-syntax-tree-expected.txt (198924 => 198925)


--- trunk/LayoutTests/inspector/model/parse-script-syntax-tree-expected.txt	2016-03-31 22:43:45 UTC (rev 198924)
+++ trunk/LayoutTests/inspector/model/parse-script-syntax-tree-expected.txt	2016-03-31 22:50:33 UTC (rev 198925)
@@ -26,6 +26,7 @@
 passed NewExpression
 passed ObjectExpression
 passed Property
+passed RestStatement
 passed ReturnStatement
 passed SequenceExpression
 passed SwitchStatement

Modified: trunk/LayoutTests/inspector/model/parse-script-syntax-tree.html (198924 => 198925)


--- trunk/LayoutTests/inspector/model/parse-script-syntax-tree.html	2016-03-31 22:43:45 UTC (rev 198924)
+++ trunk/LayoutTests/inspector/model/parse-script-syntax-tree.html	2016-03-31 22:50:33 UTC (rev 198925)
@@ -321,6 +321,13 @@
     InspectorTest.assert(node.right.properties[0].key.type === WebInspector.ScriptSyntaxTree.NodeType.Literal);
     InspectorTest.log("passed Property");
 
+    node = makeNode("function foo(...things) { return things; }", false);    
+    InspectorTest.assert(node.params.length === 1);
+    InspectorTest.assert(node.params[0].type === WebInspector.ScriptSyntaxTree.NodeType.RestElement);
+    InspectorTest.assert(node.params[0].argument.type === WebInspector.ScriptSyntaxTree.NodeType.Identifier);
+    InspectorTest.assert(node.params[0].argument.name === "things");
+    InspectorTest.log("passed RestStatement");
+
     node = makeNode("function foo() { return 20; }", false);
     InspectorTest.assert(node.body.body[0].type === WebInspector.ScriptSyntaxTree.NodeType.ReturnStatement);
     InspectorTest.assert(node.body.body[0].argument.type === WebInspector.ScriptSyntaxTree.NodeType.Literal);

Modified: trunk/Source/WebInspectorUI/ChangeLog (198924 => 198925)


--- trunk/Source/WebInspectorUI/ChangeLog	2016-03-31 22:43:45 UTC (rev 198924)
+++ trunk/Source/WebInspectorUI/ChangeLog	2016-03-31 22:50:33 UTC (rev 198925)
@@ -1,3 +1,22 @@
+2016-03-31  Joseph Pecoraro  <[email protected]>
+
+        Web Inspector: ScriptSyntaxTree doesn't handle RestElement AST nodes
+        https://bugs.webkit.org/show_bug.cgi?id=156085
+
+        Reviewed by Saam Barati.
+
+        * UserInterface/Models/ScriptSyntaxTree.js:
+        (WebInspector.ScriptSyntaxTree.prototype._gatherIdentifiersInDeclaration.gatherIdentifiers):
+        (WebInspector.ScriptSyntaxTree.prototype._gatherIdentifiersInDeclaration):
+        When searching for identifiers in Function parameters, pass
+        through the RestElement to its argument.
+
+        (WebInspector.ScriptSyntaxTree.prototype._recurse):
+        (WebInspector.ScriptSyntaxTree.prototype._createInternalSyntaxTree):
+        Create a ScriptSyntaxTree RestElement node.
+        Also, every case in recurse visits the current
+        node, so simplify the code!
+
 2016-03-30  Joseph Pecoraro  <[email protected]>
 
         Remove unused ScriptProfiler.Samples.totalTime

Modified: trunk/Source/WebInspectorUI/UserInterface/Models/ScriptSyntaxTree.js (198924 => 198925)


--- trunk/Source/WebInspectorUI/UserInterface/Models/ScriptSyntaxTree.js	2016-03-31 22:43:45 UTC (rev 198924)
+++ trunk/Source/WebInspectorUI/UserInterface/Models/ScriptSyntaxTree.js	2016-03-31 22:50:33 UTC (rev 198925)
@@ -261,13 +261,15 @@
                     return identifiers;
                 case WebInspector.ScriptSyntaxTree.NodeType.AssignmentPattern:
                     return gatherIdentifiers(node.left);
+                case WebInspector.ScriptSyntaxTree.NodeType.RestElement:
+                    return gatherIdentifiers(node.argument);
                 default:
                     console.assert(false, "Unexpected node type in variable declarator: " + node.type);
                     return [];
             }
         }
 
-        console.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.Identifier || node.type === WebInspector.ScriptSyntaxTree.NodeType.ObjectPattern || node.type === WebInspector.ScriptSyntaxTree.NodeType.ArrayPattern);
+        console.assert(node.type === WebInspector.ScriptSyntaxTree.NodeType.Identifier || node.type === WebInspector.ScriptSyntaxTree.NodeType.ObjectPattern || node.type === WebInspector.ScriptSyntaxTree.NodeType.ArrayPattern || node.type === WebInspector.ScriptSyntaxTree.NodeType.RestElement);
 
         return gatherIdentifiers(node);
     }
@@ -288,71 +290,59 @@
         if (state.shouldStopEarly || state.skipChildNodes)
             return;
 
+        callback(node, state);
+
         switch (node.type) {
         case WebInspector.ScriptSyntaxTree.NodeType.AssignmentExpression:
-            callback(node, state);
             this._recurse(node.left, callback, state);
             this._recurse(node.right, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.ArrayExpression:
         case WebInspector.ScriptSyntaxTree.NodeType.ArrayPattern:
-            callback(node, state);
             this._recurseArray(node.elements, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.AssignmentPattern:
-            callback(node, state);
             this._recurse(node.left, callback, state);
             this._recurse(node.right, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.BlockStatement:
-            callback(node, state);
             this._recurseArray(node.body, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.BinaryExpression:
-            callback(node, state);
             this._recurse(node.left, callback, state);
             this._recurse(node.right, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.BreakStatement:
-            callback(node, state);
             this._recurse(node.label, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.CatchClause:
-            callback(node, state);
             this._recurse(node.param, callback, state);
             this._recurse(node.body, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.CallExpression:
-            callback(node, state);
             this._recurse(node.callee, callback, state);
             this._recurseArray(node.arguments, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.ClassBody:
-            callback(node, state);
             this._recurseArray(node.body, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.ClassDeclaration:
         case WebInspector.ScriptSyntaxTree.NodeType.ClassExpression:
-            callback(node, state);
             this._recurse(node.id, callback, state);
             this._recurse(node.superClass, callback, state);
             this._recurse(node.body, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.ContinueStatement:
-            callback(node, state);
             this._recurse(node.label, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.DoWhileStatement:
-            callback(node, state);
             this._recurse(node.body, callback, state);
             this._recurse(node.test, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.ExpressionStatement:
-            callback(node, state);
             this._recurse(node._expression_, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.ForStatement:
-            callback(node, state);
             this._recurse(node.init, callback, state);
             this._recurse(node.test, callback, state);
             this._recurse(node.update, callback, state);
@@ -360,7 +350,6 @@
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.ForInStatement:
         case WebInspector.ScriptSyntaxTree.NodeType.ForOfStatement:
-            callback(node, state);
             this._recurse(node.left, callback, state);
             this._recurse(node.right, callback, state);
             this._recurse(node.body, callback, state);
@@ -368,134 +357,110 @@
         case WebInspector.ScriptSyntaxTree.NodeType.FunctionDeclaration:
         case WebInspector.ScriptSyntaxTree.NodeType.FunctionExpression:
         case WebInspector.ScriptSyntaxTree.NodeType.ArrowFunctionExpression:
-            callback(node, state);
             this._recurse(node.id, callback, state);
             this._recurseArray(node.params, callback, state);
             this._recurseArray(node.defaults, callback, state);
             this._recurse(node.body, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.IfStatement:
-            callback(node, state);
             this._recurse(node.test, callback, state);
             this._recurse(node.consequent, callback, state);
             this._recurse(node.alternate, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.LabeledStatement:
-            callback(node, state);
             this._recurse(node.label, callback, state);
             this._recurse(node.body, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.LogicalExpression:
-            callback(node, state);
             this._recurse(node.left, callback, state);
             this._recurse(node.right, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.MemberExpression:
-            callback(node, state);
             this._recurse(node.object, callback, state);
             this._recurse(node.property, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.MethodDefinition:
-            callback(node, state);
             this._recurse(node.key, callback, state);
             this._recurse(node.value, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.NewExpression:
-            callback(node, state);
             this._recurse(node.callee, callback, state);
             this._recurseArray(node.arguments, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.ObjectExpression:
         case WebInspector.ScriptSyntaxTree.NodeType.ObjectPattern:
-            callback(node, state);
             this._recurseArray(node.properties, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.Program:
-            callback(node, state);
             this._recurseArray(node.body, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.Property:
-            callback(node, state);
             this._recurse(node.key, callback, state);
             this._recurse(node.value, callback, state);
             break;
+        case WebInspector.ScriptSyntaxTree.NodeType.RestElement:
+            this._recurse(node.argument, callback, state);
+            break;
         case WebInspector.ScriptSyntaxTree.NodeType.ReturnStatement:
-            callback(node, state);
             this._recurse(node.argument, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.SequenceExpression:
-            callback(node, state);
             this._recurseArray(node.expressions, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.SpreadElement:
-            callback(node, state);
             this._recurse(node.argument, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.SwitchStatement:
-            callback(node, state);
             this._recurse(node.discriminant, callback, state);
             this._recurseArray(node.cases, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.SwitchCase:
-            callback(node, state);
             this._recurse(node.test, callback, state);
             this._recurseArray(node.consequent, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.ConditionalExpression:
-            callback(node, state);
             this._recurse(node.test, callback, state);
             this._recurse(node.consequent, callback, state);
             this._recurse(node.alternate, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.TaggedTemplateExpression:
-            callback(node, state);
             this._recurse(node.tag, callback, state);
             this._recurse(node.quasi, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.TemplateLiteral:
-            callback(node, state);
             this._recurseArray(node.quasis, callback, state);
             this._recurseArray(node.expressions, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.ThrowStatement:
-            callback(node, state);
             this._recurse(node.argument, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.TryStatement:
-            callback(node, state);
             this._recurse(node.block, callback, state);
             this._recurse(node.handler, callback, state);
             this._recurse(node.finalizer, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.UnaryExpression:
-            callback(node, state);
             this._recurse(node.argument, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.UpdateExpression:
-            callback(node, state);
             this._recurse(node.argument, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.VariableDeclaration:
-            callback(node, state);
             this._recurseArray(node.declarations, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.VariableDeclarator:
-            callback(node, state);
             this._recurse(node.id, callback, state);
             this._recurse(node.init, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.WhileStatement:
-            callback(node, state);
             this._recurse(node.test, callback, state);
             this._recurse(node.body, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.WithStatement:
-            callback(node, state);
             this._recurse(node.object, callback, state);
             this._recurse(node.body, callback, state);
             break;
         case WebInspector.ScriptSyntaxTree.NodeType.YieldExpression:
-            callback(node, state);
             this._recurse(node.argument, callback, state);
             break;
         // All the leaf nodes go here.
@@ -507,7 +472,6 @@
         case WebInspector.ScriptSyntaxTree.NodeType.Super:
         case WebInspector.ScriptSyntaxTree.NodeType.ThisExpression:
         case WebInspector.ScriptSyntaxTree.NodeType.TemplateElement:
-            callback(node, state);
             break;
         }
 
@@ -811,6 +775,12 @@
             if (result.kind === "get" || result.kind === "set" || result.method)
                 result.value.typeProfilingReturnDivot = node.range[0];  // "g" in "get" or "s" in "set" or "[" in "['computed']" method or "m" in "methodName".
             break;
+        case "RestElement":
+            result = {
+                type: WebInspector.ScriptSyntaxTree.NodeType.RestElement,
+                argument: this._createInternalSyntaxTree(node.argument)
+            };
+            break;            
         case "ReturnStatement":
             result = {
                 type: WebInspector.ScriptSyntaxTree.NodeType.ReturnStatement,
@@ -995,6 +965,7 @@
     ObjectPattern: Symbol("object-pattern"),
     Program: Symbol("program"),
     Property: Symbol("property"),
+    RestElement: Symbol("rest-element"),
     ReturnStatement: Symbol("return-statement"),
     SequenceExpression: Symbol("sequence-_expression_"),
     SpreadElement: Symbol("spread-element"),

_______________________________________________
webkit-changes mailing list
[email protected]
https://lists.webkit.org/mailman/listinfo/webkit-changes