Redo "Add more MiniJsParser functionality."

sdk/lib/_internal/compiler/implementation/js/builder.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // Utilities for building JS ASTs at runtime.  Contains a builder class
 // and a parser that parses part of the language.
 
 part of js;
 
 class JsBuilder {
   const JsBuilder();
 
-  // Parse a bit of JavaScript, and return an expression.
-  // See the MiniJsParser class.
-  // You can provide an expression or a list of expressions, which will be
-  // interpolated into the source at the '#' signs.
+  /**
+   * Parses a bit of JavaScript, and returns an expression.
+   *
+   * See the MiniJsParser class.
+   *
+   * [expression] can be an [Expression] or a list of [Expression]s, which will
+   * be interpolated into the source at the '#' signs.
+   */
   Expression call(String source, [var expression]) {
     var result = new MiniJsParser(source).expression();
     if (expression == null) return result;
 
-    List<Expression> expressions;
+    List<Node> nodes;
     if (expression is List) {
-      expressions = expression;
+      nodes = expression;
     } else {
-      expressions = <Expression>[expression];
+      nodes = <Node>[expression];
     }
-    if (expressions.length != result.interpolatedExpressions.length) {
-      throw "Unmatched number of interpolated expressions";
+    if (nodes.length != result.interpolatedNodes.length) {
+      throw 'Unmatched number of interpolated expressions given ${nodes.length}'
+          ' expected ${result.interpolatedNodes.length}';
     }
-    for (int i = 0; i < expressions.length; i++) {
-      result.interpolatedExpressions[i].value = expressions[i];
+    for (int i = 0; i < nodes.length; i++) {
+      result.interpolatedNodes[i].assign(nodes[i]);
     }
 
     return result.value;
   }
 
+  Statement statement(String source) {
+    var result = new MiniJsParser(source).statement();
+    // TODO(sra): Interpolation.
+    return result;
+  }
+
   // Parse JavaScript written in the JS foreign instruction.
   Expression parseForeignJS(String source, [var expression]) {
     // We can parse simple JS with the mini parser.  At the moment we can't
     // handle JSON literals and function literals, both of which contain "{".
     if (source.contains("{") || source.startsWith("throw ")) {
       assert(expression == null);
       return new LiteralExpression(source);
     }
     return call(source, expression);
   }
@@ skipping 207 matching lines @@
         position = 0 {
     getToken();
   }
 
   int lastCategory = NONE;
   String lastToken = null;
   int lastPosition = 0;
   int position = 0;
   bool skippedNewline = false;  // skipped newline in last getToken?
   final String src;
-  final List<InterpolatedExpression> interpolatedValues =
-      <InterpolatedExpression>[];
+  final List<InterpolatedNode> interpolatedValues = <InterpolatedNode>[];
 
   static const NONE = -1;
   static const ALPHA = 0;
   static const NUMERIC = 1;
   static const STRING = 2;
   static const SYMBOL = 3;
   static const ASSIGNMENT = 4;
   static const DOT = 5;
   static const LPAREN = 6;
   static const RPAREN = 7;
@@ skipping 89 matching lines @@
   }
 
   String getDelimited(int startPosition) {
     position = startPosition;
     int delimiter = src.codeUnitAt(startPosition);
     int currentCode;
     do {
       position++;
       if (position >= src.length) error("Unterminated literal");
       currentCode = src.codeUnitAt(position);
+      if (currentCode == charCodes.$LF) error("Unterminated literal");
       if (currentCode == charCodes.$BACKSLASH) {
         if (++position >= src.length) error("Unterminated literal");
         int escaped = src.codeUnitAt(position);
         if (escaped == charCodes.$x || escaped == charCodes.$X ||
             escaped == charCodes.$u || escaped == charCodes.$U ||
             category(escaped) == NUMERIC) {
           error('Numeric and hex escapes are not allowed in literals');
         }
       }
     } while (currentCode != delimiter);
     position++;
     return src.substring(lastPosition, position);
   }
 
   void getToken() {
     skippedNewline = false;
-    for(;;) {
+    for (;;) {
       if (position >= src.length) break;
       int code = src.codeUnitAt(position);
-      if (category(code) != WHITESPACE) break;
-      if (code == charCodes.$LF) skippedNewline = true;
-      ++position;
+      //  Skip '//' style comment.
+      if (code == charCodes.$SLASH &&
+          position + 1 < src.length &&
+          src.codeUnitAt(position + 1) == charCodes.$SLASH) {
+        int nextPosition = src.indexOf('\n', position);
+        if (nextPosition == -1) nextPosition = src.length;
+        position = nextPosition;
+      } else {
+        if (category(code) != WHITESPACE) break;
+        if (code == charCodes.$LF) skippedNewline = true;
+        ++position;
+      }
     }
 
     if (position == src.length) {
       lastCategory = NONE;
       lastToken = null;
       lastPosition = position;
       return;
     }
     int code = src.codeUnitAt(position);
     lastPosition = position;
@@ skipping 74 matching lines @@
   }
 
   void expectSemicolon() {
     if (acceptSemicolon()) return;
     error('Expected SEMICOLON');
   }
 
   bool acceptSemicolon() {
     // Accept semicolon or automatically inserted semicolon before close brace.
     // Miniparser forbids other kinds of semicolon insertion.
+    if (RBRACE == lastCategory) return true;
     if (skippedNewline) {
       error('No automatic semicolon insertion at preceding newline');
     }
-    return acceptCategory(SEMICOLON) || RBRACE == lastCategory;
+    return acceptCategory(SEMICOLON);
   }
 
   bool acceptString(String string) {
     if (lastToken == string) {
       getToken();
       return true;
     }
     return false;
   }
 
@@ skipping 17 matching lines @@
       }
     } else if (acceptCategory(LPAREN)) {
       Expression expression = parseExpression();
       expectCategory(RPAREN);
       return expression;
     } else if (acceptCategory(STRING)) {
       return new LiteralString(last);
     } else if (acceptCategory(NUMERIC)) {
       return new LiteralNumber(last);
     } else if (acceptCategory(LBRACE)) {
-      expectCategory(RBRACE);
-      return new ObjectInitializer([]);
+      return parseObjectInitializer();
     } else if (acceptCategory(LSQUARE)) {
       var values = <ArrayElement>[];
       if (!acceptCategory(RSQUARE)) {
         do {
           values.add(new ArrayElement(values.length, parseAssignment()));
         } while (acceptCategory(COMMA));
         expectCategory(RSQUARE);
       }
       return new ArrayInitializer(values.length, values);
     } else if (last.startsWith("/")) {
       String regexp = getDelimited(lastPosition);
       getToken();
       String flags = lastToken;
       if (!acceptCategory(ALPHA)) flags = "";
       Expression expression = new RegExpLiteral(regexp + flags);
       return expression;
     } else if (acceptCategory(HASH)) {
       InterpolatedExpression expression = new InterpolatedExpression(null);
       interpolatedValues.add(expression);
       return expression;
     } else {
       error("Expected primary expression");
       return null;
     }
   }
 
   Expression parseFunctionExpression() {
-    String functionName = null;
     String last = lastToken;
-    if (acceptCategory(ALPHA)) functionName = last;
+    if (acceptCategory(ALPHA)) {
+      String functionName = last;
+      return new NamedFunction(new VariableDeclaration(functionName),
+          parseFun());
+    }
+    return parseFun();
+  }
+
+  Expression parseFun() {
     List<Parameter> params = <Parameter>[];
     expectCategory(LPAREN);
     String argumentName = lastToken;
     if (acceptCategory(ALPHA)) {
       params.add(new Parameter(argumentName));
       while (acceptCategory(COMMA)) {
         argumentName = lastToken;
         expectCategory(ALPHA);
         params.add(new Parameter(argumentName));
       }
     }
     expectCategory(RPAREN);
     expectCategory(LBRACE);
     Block block = parseBlock();
-    Fun fun = new Fun(params, block);
-    if (functionName == null) {
-      return fun;
-    } else {
-      return new NamedFunction(new VariableDeclaration(functionName), fun);
+    return new Fun(params, block);
+  }
+
+  Expression parseObjectInitializer() {
+    List<Property> properties = <Property>[];
+    for (;;) {
+      if (acceptCategory(RBRACE)) break;
+      // Limited subset: keys are identifiers, no 'get' or 'set' properties.
+      Literal propertyName;
+      String identifier = lastToken;
+      if (acceptCategory(ALPHA)) {
+        propertyName = new LiteralString('"$identifier"');
+      } else if (acceptCategory(STRING)) {
+        propertyName = new LiteralString(identifier);
+      } else {
+        error('Expected property name');
+      }
+      expectCategory(COLON);
+      Expression value = parseAssignment();
+      properties.add(new Property(propertyName, value));
+      if (acceptCategory(RBRACE)) break;
+      expectCategory(COMMA);
     }
+    return new ObjectInitializer(properties);
   }
 
   Expression parseMember() {
     Expression receiver = parsePrimary();
     while (true) {
       if (acceptCategory(DOT)) {
         receiver = getDotRhs(receiver);
       } else if (acceptCategory(LSQUARE)) {
         Expression inBraces = parseExpression();
         expectCategory(RSQUARE);
@@ skipping 189 matching lines @@
     Expression expression = parseVarDeclarationOrExpression();
     if (lastCategory != NONE || position != src.length) {
       error("Unparsed junk: ${categoryToString(lastCategory)}");
     }
     if (!interpolatedValues.isEmpty) {
       return new JSExpression(expression, interpolatedValues);
     }
     return expression;
   }
 
+  Statement statement() {
+    Statement statement = parseStatement();
+    if (lastCategory != NONE || position != src.length) {
+      error("Unparsed junk: ${categoryToString(lastCategory)}");
+    }
+    // TODO(sra): interpolated capture here?
+    return statement;
+  }
+
   Block parseBlock() {
     List<Statement> statements = <Statement>[];
 
     while (!acceptCategory(RBRACE)) {
       Statement statement = parseStatement();
       statements.add(statement);
     }
     return new Block(statements);
   }
 
   Statement parseStatement() {
     if (acceptCategory(LBRACE)) return parseBlock();
 
     if (lastCategory == ALPHA) {
       if (acceptString('return')) return parseReturn();
 
+      if (acceptString('throw')) return parseThrow();
+
       if (acceptString('break')) {
         return parseBreakOrContinue((label) => new Break(label));
       }
 
       if (acceptString('continue')) {
         return parseBreakOrContinue((label) => new Continue(label));
       }
 
       if (acceptString('if')) return parseIfThenElse();
 
       if (acceptString('for')) return parseFor();
 
+      if (acceptString('function')) return parseFunctionDeclaration();
+
       if (acceptString('var')) {
         Expression declarations = parseVariableDeclarationList();
         expectSemicolon();
         return new ExpressionStatement(declarations);
       }
+
+      if (lastToken == 'case' ||
+          lastToken == 'do' ||
+          lastToken == 'while' ||
+          lastToken == 'switch' ||
+          lastToken == 'try' ||
+          lastToken == 'with') {
+        error('Not implemented in mini parser');
+      }
+    }
+
+    if (acceptCategory(HASH)) {
+      InterpolatedStatement statement = new InterpolatedStatement(null);
+      interpolatedValues.add(statement);
+      return statement;
     }
 
     // TODO:  label: statement
 
     Expression expression = parseExpression();
     expectSemicolon();
     return new ExpressionStatement(expression);
   }
 
   Statement parseReturn() {
     if (acceptSemicolon()) return new Return();
     Expression expression = parseExpression();
     expectSemicolon();
     return new Return(expression);
   }
 
+  Statement parseThrow() {
+    if (skippedNewline) error('throw expression must be on same line');
+    Expression expression = parseExpression();
+    expectSemicolon();
+    return new Throw(expression);
+  }
+
   Statement parseBreakOrContinue(constructor) {
     var identifier = lastToken;
     if (!skippedNewline && acceptCategory(ALPHA)) {
       expectSemicolon();
       return constructor(identifier);
     }
     expectSemicolon();
     return constructor(null);
   }
 
@@ skipping 50 matching lines @@
       Expression declarations = finishVariableDeclarationList(identifier);
       expectCategory(SEMICOLON);
       return finishFor(declarations);
     }
 
     Expression init = parseExpression();
     expectCategory(SEMICOLON);
     return finishFor(init);
   }
 
+  Statement parseFunctionDeclaration() {
+    String name = lastToken;
+    expectCategory(ALPHA);
+    Expression fun = parseFun();
+    return new FunctionDeclaration(new VariableDeclaration(name), fun);
+  }
 }
 
 /**
  * Clone a JSExpression node into an expression where all children
  * have been cloned, and [InterpolatedExpression]s have been replaced
  * with real [Expression].
  */
 class UninterpolateJSExpression extends BaseVisitor<Node> {
   final List<Expression> arguments;
   int argumentIndex = 0;
@@ skipping 38 matching lines @@
 
   Node visitCall(Call node) {
     return copyPosition(node,
         new Call(visit(node.target), visitList(node.arguments)));
   }
 
   Node visitInterpolatedExpression(InterpolatedExpression expression) {
     return arguments[argumentIndex++];
   }
 
+  Node visitInterpolatedStatement(InterpolatedStatement statement) {
+    return arguments[argumentIndex++];
+  }
+
   Node visitJSExpression(JSExpression expression) {
     assert(argumentIndex == 0);
     Node result = visit(expression.value);
     if (argumentIndex != arguments.length) {
       error("Invalid number of arguments");
     }
     assert(result is! JSExpression);
     return result;
   }
 
@@ skipping 56 matching lines @@
   }
 
   Node visitLiteralNull(LiteralNull node) {
     return node;
   }
 
   Node visitLiteralBool(LiteralBool node) {
     return node;
   }
 }