support the JS builtin

lib/src/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_ast;
 
 
@@ skipping 876 matching lines @@
 
   Expression parseObjectInitializer() {
     List<Property> properties = <Property>[];
     for (;;) {
       if (acceptCategory(RBRACE)) break;
       // Limited subset of ES6 object initializers.
       //
       // PropertyDefinition :
       //     PropertyName : AssignmentExpression
       //     MethodDefinition
+      properties.add(parseMethodOrProperty());
 
-      if (acceptCategory(HASH)) {
-        properties.add(parseInterpolatedMember());
-      } else {
-        bool isGetter = acceptString('get');
-        bool isSetter = isGetter ? false : acceptString('set');
-        Expression name = parsePropertyName();
-
-        if (lastCategory == LPAREN) {
-          Fun fun = parseFun();
-          properties.add(
-              new Method(name, fun, isGetter: isGetter, isSetter: isSetter));
-        } else {
-          expectCategory(COLON);
-          Expression value = parseAssignment();
-          properties.add(new Property(name, value));
-        }
-        if (acceptCategory(RBRACE)) break;
-        expectCategory(COMMA);
-      }
+      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)) {
@@ skipping 533 matching lines @@
       name = new VariableDeclaration(lastToken);
       expectCategory(ALPHA);
     }
     Expression heritage = null;
     if (acceptString('extends')) {
       heritage = parseLeftHandSide();
     }
     expectCategory(LBRACE);
     var methods = new List<Method>();
     while (lastCategory != RBRACE) {
-      methods.add(parseMethod());
+      methods.add(parseMethodOrProperty(onlyMethods: true));
     }
     expectCategory(RBRACE);
     return new ClassExpression(name, heritage, methods);
   }
 
-  Method parseMethod() {
-    if (acceptCategory(HASH)) return parseInterpolatedMember();
+  /**
+   * Parses a [Method] or a [Property].
+   *
+   * Most of the complexity is from supporting interpolation. Several forms
+   * are supported:
+   *
+   * - getter/setter names: `get #() { ... }`
+   * - method names: `#() { ... }`
+   * - property names: `#: ...`
+   * - entire methods: `#`
+   */
+  Property parseMethodOrProperty({bool onlyMethods: false}) {
+    bool isStatic = acceptString('static');
 
-    bool isStatic = acceptString('static');
-    bool isGetter = acceptString('get');
-    bool isSetter = isGetter ? false : acceptString('set');
-    var name = parsePropertyName();
-    var fun = parseFun();
-    return new Method(name, fun,
-        isGetter: isGetter, isSetter: isSetter, isStatic: isStatic);
-  }
+    bool isGetter = false;
+    bool isSetter = false;
+    Expression name = null;
+    if (acceptCategory(HASH)) {
+      if (lastCategory != LPAREN && (onlyMethods || lastCategory != COLON)) {
+        // Interpolated method
+        var member = new InterpolatedMethod(parseHash());
+        interpolatedValues.add(member);
+        return member;
+      }
+      name = parseInterpolatedExpression();
+    } else {
+      name = parsePropertyName();
+    }
 
-  InterpolatedMethod parseInterpolatedMember() {
-    var member = new InterpolatedMethod(parseHash());
-    interpolatedValues.add(member);
-    return member;
+    // Allow get or set to be followed by another property name.
+    if (lastCategory == ALPHA && name is PropertyName) {
+      PropertyName p = name;
+      isGetter = p.name == 'get';
+      isSetter = p.name == 'set';
+      if (isGetter || isSetter) {
+        name = parsePropertyName();
+      }
+    }
+
+    if (!onlyMethods && acceptCategory(COLON)) {
+      Expression value = parseAssignment();
+      return new Property(name, value);
+    } else {
+      var fun = parseFun();
+      return new Method(name, fun,
+          isGetter: isGetter, isSetter: isSetter, isStatic: isStatic);
+    }
   }
 
   Expression parsePropertyName() {
     String identifier = lastToken;
     if (acceptCategory(ALPHA)) {
       return new PropertyName(identifier);
     } else if (acceptCategory(STRING)) {
       return new LiteralString(identifier);
     } else if (acceptCategory(SYMBOL)) {
       // e.g. void
       return new LiteralString('"$identifier"');
     } else if (acceptCategory(LSQUARE)) {
       var expr = parseAssignment();
       expectCategory(RSQUARE);
       return expr;
     } else if (acceptCategory(HASH)) {
-      var nameOrPosition = parseHash();
-      var interpolatedLiteral = new InterpolatedLiteral(nameOrPosition);
-      interpolatedValues.add(interpolatedLiteral);
-      return interpolatedLiteral;
+      return parseInterpolatedExpression();
     } else {
       error('Expected property name');
       return null;
     }
   }
+
+  InterpolatedExpression parseInterpolatedExpression() {
+    var interpolated = new InterpolatedExpression(parseHash());
+    interpolatedValues.add(interpolated);
+    return interpolated;
+  }
 }