Parse parenthesized expressions.

dart/frog/frogsh

 #!/usr/bin/env node
 //  ********** Library dart:core **************
 //  ********** Natives dart:core **************
 /**
  * Generates a dynamic call stub for a function.
  * Our goal is to create a stub method like this on-the-fly:
  *   function($0, $1, capture) { this($0, $1, true, capture); }
  *
  * This stub then replaces the dynamic one on Function, with one that is
  * specialized for that particular function, taking into account its default
@@ skipping 527 matching lines @@
 };
 Object.prototype.handleNoType$1 = function($0) {
   return this.noSuchMethod("handleNoType", [$0]);
 };
 Object.prototype.handleNoTypeArguments$1 = function($0) {
   return this.noSuchMethod("handleNoTypeArguments", [$0]);
 };
 Object.prototype.handleNoTypeVariables$1 = function($0) {
   return this.noSuchMethod("handleNoTypeVariables", [$0]);
 };
+Object.prototype.handleParenthesizedExpression$1 = function($0) {
+  return this.noSuchMethod("handleParenthesizedExpression", [$0]);
+};
 Object.prototype.handleUnaryPostfixExpression$1 = function($0) {
   return this.noSuchMethod("handleUnaryPostfixExpression", [$0]);
 };
 Object.prototype.handleUnaryPrefixExpression$1 = function($0) {
   return this.noSuchMethod("handleUnaryPrefixExpression", [$0]);
 };
 Object.prototype.handleVarKeyword$1 = function($0) {
   return this.noSuchMethod("handleVarKeyword", [$0]);
 };
 Object.prototype.handleVoidKeyword$1 = function($0) {
@@ skipping 4090 matching lines @@
       }
       else if (value === 'null') {
         return this.parseLiteralNull(token);
       }
       else {
         this.listener.unexpected$1(token);
         $throw('not yet implemented');
       }
     }
   }
+  else if (kind === 40/*null.LPAREN_TOKEN*/) {
+    return this.parseParenthesizedExpression(token);
+  }
   else {
     this.listener.unexpected$1(token);
     $throw('not yet implemented');
   }
 }
+Parser.prototype.parseParenthesizedExpression = function(token) {
+  var begin = (token && token.is$BeginGroupToken());
+  token = this.expect('(', token);
+  token = this.parseExpression(token);
+  $assert(begin.endGroup === token, "begin.endGroup === token", "parser.dart", 649, 12);
+  this.listener.handleParenthesizedExpression$1(begin);
+  return this.expect(')', token);
+}
 Parser.prototype.parseLiteralInt = function(token) {
   this.listener.handleLiteralInt$1(token);
   return token.next;
 }
 Parser.prototype.parseLiteralDouble = function(token) {
   this.listener.handleLiteralDouble$1(token);
   return token.next;
 }
 Parser.prototype.parseLiteralString = function(token) {
   this.listener.handleLiteralString$1(token);
@@ skipping 19 matching lines @@
     this.listener.handleNoArguments$1(token);
     return token;
   }
   else {
     return this.parseArguments(token);
   }
 }
 Parser.prototype.parseArguments = function(token) {
   var begin = token;
   this.listener.beginArguments$1(begin);
-  $assert('(' === token.get$stringValue(), "'(' === token.stringValue", "parser.dart", 688, 12);
+  $assert('(' === token.get$stringValue(), "'(' === token.stringValue", "parser.dart", 699, 12);
   var argumentCount = 0;
   if ($notnull_bool(this.optional(')', token.next))) {
     this.listener.endArguments$3(argumentCount, begin, token.next);
     return token.next.next;
   }
   do {
     token = this.parseExpression(token.next);
     ++argumentCount;
   }
   while ($notnull_bool(this.optional(',', token)))
@@ skipping 30 matching lines @@
     return token.next;
   }
   else {
     return this.parseType(token);
   }
 }
 Parser.prototype.parseIfStatement = function(token) {
   var ifToken = token;
   this.listener.beginIfStatement$1(ifToken);
   token = this.expect('if', token);
-  this.expect('(', token);
-  token = this.parseArguments(token);
+  token = this.parseParenthesizedExpression(token);
   token = this.parseStatement(token);
   var elseToken = null;
   if ($notnull_bool(this.optional('else', token))) {
     elseToken = token;
     token = this.parseStatement(token.next);
   }
   this.listener.endIfStatement$2(ifToken, elseToken);
   return token;
 }
 Parser.prototype.parseForStatement = function(token) {
   var forToken = token;
   this.listener.beginForStatement$1(forToken);
   token = this.expect('for', token);
   token = this.expect('(', token);
   token = this.parseVariablesDeclaration(token);
   token = this.parseExpressionStatement(token);
   token = this.parseExpression(token);
   token = this.expect(')', token);
   token = this.parseStatement(token);
   this.listener.endForStatement$2(forToken, token);
   return token;
 }
 Parser.prototype.parseWhileStatement = function(token) {
   var whileToken = token;
   this.listener.beginWhileStatement$1(whileToken);
   token = this.expect('while', token);
-  token = this.expect('(', token);
-  token = this.parseExpression(token);
-  token = this.expect(')', token);
+  token = this.parseParenthesizedExpression(token);
   token = this.parseStatement(token);
   this.listener.endWhileStatement$2(whileToken, token);
   return token;
 }
 Parser.prototype.parseDoWhileStatement = function(token) {
   var doToken = token;
   this.listener.beginDoWhileStatement$1(doToken);
   token = this.expect('do', token);
   token = this.parseStatement(token);
   var whileToken = token;
   token = this.expect('while', token);
-  token = this.expect('(', token);
-  token = this.parseExpression(token);
-  token = this.expect(')', token);
+  token = this.parseParenthesizedExpression(token);
   this.listener.endDoWhileStatement$3(doToken, whileToken, token);
   return this.expectSemicolon(token);
 }
 Parser.prototype.parseBlock = function(token) {
   var begin = token;
   this.listener.beginBlock$1(begin);
   var statementCount = 0;
   token = this.expect('{', token);
   while (!$notnull_bool(this.optional('}', token))) {
     token = this.parseStatement(token);
@@ skipping 219 matching lines @@
 }
 Listener.prototype.handleNoArguments = function(token) {
 
 }
 Listener.prototype.handleNoType = function(token) {
 
 }
 Listener.prototype.handleNoTypeVariables = function(token) {
 
 }
+Listener.prototype.handleParenthesizedExpression = function(token) {
+
+}
 Listener.prototype.handleUnaryPostfixExpression = function(token) {
 
 }
 Listener.prototype.handleUnaryPrefixExpression = function(token) {
 
 }
 Listener.prototype.handleVarKeyword = function(token) {
 
 }
 Listener.prototype.handleVoidKeyword = function(token) {
@@ skipping 203 matching lines @@
 };
 Listener.prototype.handleNoType$1 = function($0) {
   return this.handleNoType(($0 && $0.is$Token()));
 };
 Listener.prototype.handleNoTypeArguments$1 = function($0) {
   return this.handleNoTypeArguments(($0 && $0.is$Token()));
 };
 Listener.prototype.handleNoTypeVariables$1 = function($0) {
   return this.handleNoTypeVariables(($0 && $0.is$Token()));
 };
+Listener.prototype.handleParenthesizedExpression$1 = function($0) {
+  return this.handleParenthesizedExpression(($0 && $0.is$BeginGroupToken()));
+};
 Listener.prototype.handleUnaryPostfixExpression$1 = function($0) {
   return this.handleUnaryPostfixExpression(($0 && $0.is$Token()));
 };
 Listener.prototype.handleUnaryPrefixExpression$1 = function($0) {
   return this.handleUnaryPrefixExpression(($0 && $0.is$Token()));
 };
 Listener.prototype.handleVarKeyword$1 = function($0) {
   return this.handleVarKeyword(($0 && $0.is$Token()));
 };
 Listener.prototype.handleVoidKeyword$1 = function($0) {
@@ skipping 53 matching lines @@
   this.pushNode(new Identifier(token));
 }
 ElementListener.prototype.handleNoType = function(token) {
   this.pushNode(null);
 }
 ElementListener.prototype.endTypeArguments = function(count, beginToken, endToken) {
   for (; count > 0; --count) {
     this.popNode();
   }
 }
+ElementListener.prototype.handleParenthesizedExpression = function(token) {
+  var $0;
+  var expression = (($0 = this.popNode()) && $0.is$Expression());
+  this.pushNode(new ParenthesizedExpression(expression, token));
+}
 ElementListener.prototype.expected = function(string, token) {
   this.canceler.cancel(("Expected '" + string + "', but got '" + token + "'"), null, token);
 }
 ElementListener.prototype.expectedIdentifier = function(token) {
   this.canceler.cancel(("Expected identifier, but got '" + token + "'"), null, token);
 }
 ElementListener.prototype.expectedType = function(token) {
   this.canceler.cancel(("Expected a type, but got '" + token + "'"), null, token);
 }
 ElementListener.prototype.expectedBlock = function(token) {
   this.canceler.cancel(("Expected a block, but got '" + token + "'"), null, token);
 }
 ElementListener.prototype.unexpected = function(token) {
   this.canceler.cancel(("Unexpected token '" + token + "'"), null, token);
 }
 ElementListener.prototype.pushElement = function(element) {
   var $0;
   this.topLevelElements = (($0 = this.topLevelElements.prepend(element)) && $0.is$Link_Element());
 }
 ElementListener.prototype.pushNode = function(node) {
   var $0;
   this.nodes = (($0 = this.nodes.prepend(node)) && $0.is$Link_Node());
   if (false/*null.VERBOSE*/) this.log(("push " + this.nodes));
 }
 ElementListener.prototype.popNode = function() {
   var $0;
-  $assert(!$notnull_bool(this.nodes.isEmpty()), "!nodes.isEmpty()", "listener.dart", 359, 12);
+  $assert(!$notnull_bool(this.nodes.isEmpty()), "!nodes.isEmpty()", "listener.dart", 367, 12);
   var node = (($0 = this.nodes.get$head()) && $0.is$Node());
   this.nodes = (($0 = this.nodes.get$tail()) && $0.is$Link_Node());
   if (false/*null.VERBOSE*/) this.log(("pop " + this.nodes));
   return node;
 }
 ElementListener.prototype.log = function(message) {
 
 }
 ElementListener.prototype.beginLibraryTag$1 = function($0) {
   return this.beginLibraryTag(($0 && $0.is$Token()));
@@ skipping 27 matching lines @@
 };
 ElementListener.prototype.expectedType$1 = function($0) {
   return this.expectedType(($0 && $0.is$Token()));
 };
 ElementListener.prototype.handleIdentifier$1 = function($0) {
   return this.handleIdentifier(($0 && $0.is$Token()));
 };
 ElementListener.prototype.handleNoType$1 = function($0) {
   return this.handleNoType(($0 && $0.is$Token()));
 };
+ElementListener.prototype.handleParenthesizedExpression$1 = function($0) {
+  return this.handleParenthesizedExpression(($0 && $0.is$BeginGroupToken()));
+};
 ElementListener.prototype.unexpected$1 = function($0) {
   return this.unexpected(($0 && $0.is$Token()));
 };
 // ********** Code for NodeListener **************
 function NodeListener(canceler, logger) {
   this.logger = logger;
   // Initializers done
   ElementListener.call(this, canceler);
 }
 $inherits(NodeListener, ElementListener);
@@ skipping 120 matching lines @@
   var initializer = (($0 = this.popNode()) && $0.is$Expression());
   var arguments = new NodeList.singleton$ctor(initializer);
   var name = (($0 = this.popNode()) && $0.is$Expression());
   var op = new Operator(assignmentOperator);
   this.pushNode(new SendSet(null, name, op, arguments));
 }
 NodeListener.prototype.endIfStatement = function(ifToken, elseToken) {
   var $0;
   var elsePart = (($0 = (elseToken == null) ? null : this.popNode()) && $0.is$Statement());
   var thenPart = (($0 = this.popNode()) && $0.is$Statement());
-  var condition = (($0 = this.popNode()) && $0.is$NodeList());
+  var condition = (($0 = this.popNode()) && $0.is$ParenthesizedExpression());
   this.pushNode(new If(condition, thenPart, elsePart, ifToken, elseToken));
 }
 NodeListener.prototype.endForStatement = function(beginToken, endToken) {
   var $0;
   var body = (($0 = this.popNode()) && $0.is$Statement());
   var update = (($0 = this.popNode()) && $0.is$Expression());
   var condition = (($0 = this.popNode()) && $0.is$ExpressionStatement());
   var initializer = (($0 = this.popNode()) && $0.is$VariableDefinitions());
   this.pushNode(new For(initializer, condition, update, body, beginToken));
 }
@@ skipping 1175 matching lines @@
   return this.whileKeyword;
 }
 While.prototype.getEndToken = function() {
   return this.body.getEndToken();
 }
 While.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$Visitor()));
 };
 While.prototype.getBeginToken$0 = While.prototype.getBeginToken;
 While.prototype.getEndToken$0 = While.prototype.getEndToken;
+// ********** Code for ParenthesizedExpression **************
+function ParenthesizedExpression(expression, beginToken) {
+  this.expression = expression;
+  this.beginToken = beginToken;
+  // Initializers done
+  Expression.call(this);
+}
+$inherits(ParenthesizedExpression, Expression);
+ParenthesizedExpression.prototype.is$ParenthesizedExpression = function(){return this;};
+ParenthesizedExpression.prototype.accept = function(visitor) {
+  return visitor.visitParenthesizedExpression(this);
+}
+ParenthesizedExpression.prototype.getBeginToken = function() {
+  return this.beginToken;
+}
+ParenthesizedExpression.prototype.getEndToken = function() {
+  return this.beginToken.endGroup;
+}
+ParenthesizedExpression.prototype.accept$1 = function($0) {
+  return this.accept(($0 && $0.is$Visitor()));
+};
+ParenthesizedExpression.prototype.getBeginToken$0 = ParenthesizedExpression.prototype.getBeginToken;
+ParenthesizedExpression.prototype.getEndToken$0 = ParenthesizedExpression.prototype.getEndToken;
 // ********** Code for Unparser **************
 function Unparser(printDebugInfo) {
   this.printDebugInfo = printDebugInfo;
   // Initializers done
 }
 Unparser.prototype.is$Visitor = function(){return this;};
 Unparser.prototype.unparse = function(node) {
   this.sb = new StringBufferImpl("");
   this.visit(node);
   return this.sb.toString();
@@ skipping 153 matching lines @@
     this.add((($0 = node.endToken.get$value()) && $0.is$SourceString()));
   }
 }
 Unparser.prototype.visitDoWhile = function(node) {
   var $0;
   this.add((($0 = node.doKeyword.get$value()) && $0.is$SourceString()));
   this.sb.add(' ');
   this.visit(node.body);
   this.sb.add(' ');
   this.add((($0 = node.whileKeyword.get$value()) && $0.is$SourceString()));
-  this.sb.add(' (');
+  this.sb.add(' ');
   this.visit(node.condition);
-  this.sb.add(')');
   this.sb.add(node.endToken.get$value());
 }
 Unparser.prototype.visitWhile = function(node) {
   var $0;
   this.add((($0 = node.whileKeyword.get$value()) && $0.is$SourceString()));
-  this.sb.add(' (');
+  this.sb.add(' ');
   this.visit(node.condition);
-  this.sb.add(')');
   this.sb.add(' ');
   this.visit(node.body);
 }
+Unparser.prototype.visitParenthesizedExpression = function(node) {
+  var $0;
+  this.add((($0 = node.getBeginToken().get$value()) && $0.is$SourceString()));
+  this.visit(node.expression);
+  this.add((($0 = node.getEndToken().get$value()) && $0.is$SourceString()));
+}
 Unparser.prototype.add$1 = function($0) {
   return this.add(($0 && $0.is$SourceString()));
 };
 Unparser.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$Node()));
 };
 // ********** Code for AbstractVisitor **************
 function AbstractVisitor() {
   // Initializers done
 }
@@ skipping 89 matching lines @@
   return this.visitStatement(node);
 }
 AbstractVisitor_Type.prototype.visitNodeList = function(node) {
   var $0;
   return (($0 = this.visitNode(node)) && $0.is$Type());
 }
 AbstractVisitor_Type.prototype.visitOperator = function(node) {
   var $0;
   return (($0 = this.visitIdentifier(node)) && $0.is$Type());
 }
+AbstractVisitor_Type.prototype.visitParenthesizedExpression = function(node) {
+  return this.visitExpression(node);
+}
 AbstractVisitor_Type.prototype.visitReturn = function(node) {
   return this.visitStatement(node);
 }
 AbstractVisitor_Type.prototype.visitSend = function(node) {
   return this.visitExpression(node);
 }
 AbstractVisitor_Type.prototype.visitSendSet = function(node) {
   return this.visitSend(node);
 }
 AbstractVisitor_Type.prototype.visitStatement = function(node) {
@@ skipping 614 matching lines @@
 SsaBuilder.prototype.visitLiteralNull = function(node) {
   this.push(new HLiteral(null));
 }
 SsaBuilder.prototype.visitNodeList = function(node) {
   var $0;
   for (var link = node.get$nodes();
    !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link_Node())) {
     this.visit((($0 = link.get$head()) && $0.is$Node()));
   }
 }
+SsaBuilder.prototype.visitParenthesizedExpression = function(node) {
+  this.visit(node.expression);
+}
 SsaBuilder.prototype.visitOperator = function(node) {
   unreachable();
 }
 SsaBuilder.prototype.visitReturn = function(node) {
   var value;
   if (node.expression == null) {
     value = new HLiteral(null);
     this.add(value);
   }
   else {
@@ skipping 16 matching lines @@
   var $0;
   for (var link = node.definitions.get$nodes();
    !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link_Node())) {
     var definition = (($0 = link.get$head()) && $0.is$Node());
     if ((definition instanceof Identifier)) {
       var initialValue = new HLiteral(null);
       this.add(initialValue);
       this.updateDefinition(definition, initialValue);
     }
     else {
-      $assert((definition instanceof SendSet), "definition is SendSet", "builder.dart", 554, 16);
+      $assert((definition instanceof SendSet), "definition is SendSet", "builder.dart", 558, 16);
       this.visitSendSet((definition && definition.is$SendSet()));
       this.pop();
     }
   }
 }
 SsaBuilder.prototype.add$1 = function($0) {
   return this.add(($0 && $0.is$HInstruction()));
 };
 SsaBuilder.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$Node()));
@@ skipping 3545 matching lines @@
 }
 FullResolverVisitor.prototype.visitVariableDefinitions = function(node) {
   this.visit(node.type);
   var visitor = new VariableDefinitionsVisitor(node, this, const$274/*ElementKind.VARIABLE*/);
   visitor.visit(node.definitions);
 }
 FullResolverVisitor.prototype.visitWhile = function(node) {
   this.visit(node.condition);
   this.visitIn(node.body, new Scope(this.context));
 }
+FullResolverVisitor.prototype.visitParenthesizedExpression = function(node) {
+  this.visit(node.expression);
+}
 // ********** Code for ClassResolverVisitor **************
 function ClassResolverVisitor(compiler) {
   this.compiler = compiler;
   this.context = new TopScope(compiler.universe);
   // Initializers done
   AbstractVisitor_Type.call(this);
 }
 $inherits(ClassResolverVisitor, AbstractVisitor_Type);
 ClassResolverVisitor.prototype.visitClassNode = function(node) {
   var $0;
@@ skipping 42 matching lines @@
   // Initializers done
   AbstractVisitor_SourceString.call(this);
 }
 $inherits(VariableDefinitionsVisitor, AbstractVisitor_SourceString);
 VariableDefinitionsVisitor.prototype.get$definitions = function() { return this.definitions; };
 VariableDefinitionsVisitor.prototype.set$definitions = function(value) { return this.definitions = value; };
 VariableDefinitionsVisitor.prototype.get$kind = function() { return this.kind; };
 VariableDefinitionsVisitor.prototype.set$kind = function(value) { return this.kind = value; };
 VariableDefinitionsVisitor.prototype.visitSendSet = function(node) {
   var $0;
-  $assert(node.get$arguments().get$tail().isEmpty$0(), "node.arguments.tail.isEmpty()", "resolver.dart", 394, 12);
+  $assert(node.get$arguments().get$tail().isEmpty$0(), "node.arguments.tail.isEmpty()", "resolver.dart", 398, 12);
   if (node.receiver != null) {
     this.resolver.cancel(node, "receiver on a variable definition not implemented");
   }
   var selector = (($0 = node.selector) && $0.is$Identifier());
   this.resolver.visit((($0 = node.get$arguments().get$head()) && $0.is$Node()));
   return (($0 = this.visit(node.selector)) && $0.is$SourceString());
 }
 VariableDefinitionsVisitor.prototype.visitIdentifier = function(node) {
   return node.get$source();
 }
@@ skipping 441 matching lines @@
       var initializer = this.nonVoidType((($0 = link.get$head()) && $0.is$Node()));
       this.checkAssignable(node, type, initializer);
     }
   }
   return null;
 }
 TypeCheckerVisitor.prototype.visitWhile = function(node) {
   this.checkCondition(node.condition);
   this.type(node.body);
 }
+TypeCheckerVisitor.prototype.visitParenthesizedExpression = function(node) {
+  return this.type(node.expression);
+}
 // ********** Code for Universe **************
 function Universe() {
   this.elements = $map([]);
   this.generatedCode = $map([]);
   this.scope = new Element(const$4, null, null);
   // Initializers done
 }
 Universe.prototype.find = function(name) {
   var $0;
   return (($0 = this.elements.$index(name)) && $0.is$Element());
@@ skipping 11966 matching lines @@
       NATIVE,
       NEGATE,
       OPERATOR,
       SET,
       SOURCE,
       STATIC,
       TYPEDEF ]*/;
 var $globals = {};
 $static_init();
 main();