Fix factories in Frog to correspond to the new syntax.

frog/parser.dart

 // Copyright (c) 2011, 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.
 
 // TODO(jimhug): Error recovery needs major work!
 /**
  * A simple recursive descent parser for the dart language.
  *
  * This parser is designed to be more permissive than the official
  * Dart grammar.  It is expected that many grammar errors would be
@@ skipping 257 matching lines @@
     if (_maybeEat(TokenKind.IMPLEMENTS)) {
       _implements = typeList();
     }
 
     var _native = null;
     if (_maybeEat(TokenKind.NATIVE)) {
       _native = maybeStringLiteral();
       if (_native != null) _native = new NativeType(_native);
     }
 
-    var _factory = null;
-    if (_maybeEat(TokenKind.FACTORY)) {
-      // Note: this can't be type(), because for some strange reason these are
-      // type parameters, not type arguments.
-      _factory = nameTypeReference();
+    bool oldFactory = _maybeEat(TokenKind.FACTORY);
+    var defaultType = null;
+    if (oldFactory || _maybeEat(TokenKind.DEFAULT)) {
+      // TODO(jmesserly): keep old factory support for now. Remove soon.
+      if (oldFactory) {
+        world.warning('factory no longer supported, use "default" instead',

[sra1, 2011/12/15 02:38:17]

I think Frog warnings need to be consistent with quoting.
I would suggest always using single quotes in the message, e.g.

world.warning("'factory' no longer supported, use 'default' instead",

[jimhug, 2011/12/15 17:05:04]

SGTM.  I just checked and both Python and JS use single quotes so I think
Stephen's choice is the rightest <smile> one.  This is obviously low-pri, but a
good thing to keep in mind - and someone (me?) should get a wiki setup for
capturing these kinds of conventions.
On 2011/12/15 02:38:17, sra1 wrote:

[Jennifer Messerly, 2011/12/15 19:28:18]

+1 on consistency. I'm trying to be consistent with most of the other messages
in Frog which use double quotes AFAIK. Let's do the mass search/replace at some
point in the future--it seems much lower priority than just about anything else
we could work on.

+            _previousToken.span);
+      }
+
+      // Note: this can't be type() because it has type parameters not type
+      // arguments.
+      var baseType = nameTypeReference();
+      var typeParams = null;
       if (_peekKind(TokenKind.LT)) {
-        // TODO(jmesserly): not sure what to do with these. They aren't used for
-        // anything as far as I can tell.
-        typeParameters();
+        typeParams = typeParameters();
       }
+      defaultType = new DefaultTypeReference(oldFactory,
+          baseType, typeParams, _makeSpan(baseType.span.start));
     }
 
     var body = [];
     if (_maybeEat(TokenKind.LBRACE)) {
       while (!_maybeEat(TokenKind.RBRACE)) {
         body.add(declaration());
         if (_recover) {
           if (!_recoverTo(TokenKind.RBRACE, TokenKind.SEMICOLON)) break;
           _maybeEat(TokenKind.SEMICOLON);
         }
       }
     } else {
       _errorExpected('block starting with "{" or ";"');
     }
     return new TypeDefinition(kind == TokenKind.CLASS, name, typeParams,
-      _extends, _implements, _native, _factory, body, _makeSpan(start));
+      _extends, _implements, _native, defaultType, body, _makeSpan(start));
   }
 
   functionTypeAlias() {
     int start = _peekToken.start;
     _eat(TokenKind.TYPEDEF);
 
     var di = declaredIdentifier(false);
     var typeParams = null;
     if (_peekKind(TokenKind.LT)) {
       typeParams = typeParameters();
     }
     var formals = formalParameterList();
     _eatSemicolon();
 
     var func = new FunctionDefinition(null, di.type, di.name, formals,
-        null, null, null, null, _makeSpan(start));
+        null, null, null, _makeSpan(start));
 
     return new FunctionTypeDefinition(func, typeParams, _makeSpan(start));
   }
 
   initializers() {
     _inhibitLambda = true;
     var ret = [];
     do {
       ret.add(expression());
     } while (_maybeEat(TokenKind.COMMA));
@@ skipping 18 matching lines @@
       }
     } else if (!inExpression) {
       if (_maybeEat(TokenKind.SEMICOLON)) {
         return null;
       }
     }
 
     _error('Expected function body (neither { nor => found)');
   }
 
-  finishField(start, modifiers, typeParams, type, name, value) {
-    if (typeParams != null) {
-      world.internalError('trying to create a generic field',
-        _makeSpan(start));
-    }
+  finishField(start, modifiers, type, name, value) {
     var names = [name];
     var values = [value];
 
     while (_maybeEat(TokenKind.COMMA)) {
       names.add(identifier());
       if (_maybeEat(TokenKind.ASSIGN)) {
         values.add(expression());
       } else {
         values.add(null);
       }
     }
 
     _eatSemicolon();
     return new VariableDefinition(modifiers, type, names, values,
                                    _makeSpan(start));
   }
 
-  finishDefinition(int start, List<Token> modifiers, di,
-      List<ParameterType> typeParams) {
+  finishDefinition(int start, List<Token> modifiers, di) {
     switch(_peek()) {
       case TokenKind.LPAREN:
         var formals = formalParameterList();
         var inits = null, native = null;
         if (_maybeEat(TokenKind.COLON)) {
           inits = initializers();
         }
         if (_maybeEat(TokenKind.NATIVE)) {
           native = maybeStringLiteral();
           if (native == null) native = '';
         }
         var body = functionBody(/*inExpression:*/false);
         if (di.name == null) {
           // TODO(jimhug): Must be named constructor - verify how?
           di.name = di.type.name;
         }
         return new FunctionDefinition(modifiers, di.type, di.name, formals,
-          typeParams, inits, native, body, _makeSpan(start));
+          inits, native, body, _makeSpan(start));
 
       case TokenKind.ASSIGN:
         _eat(TokenKind.ASSIGN);
         var value = expression();
-        return finishField(start, modifiers, typeParams, di.type, di.name, value);
+        return finishField(start, modifiers, di.type, di.name, value);
 
       case TokenKind.COMMA:
       case TokenKind.SEMICOLON:
-        return finishField(start, modifiers, typeParams, di.type, di.name, null);
+        return finishField(start, modifiers, di.type, di.name, null);
 
       default:
         // TODO(jimhug): This error message sucks.
         _errorExpected('declaration');
 
         return null;
     }
   }
 
   declaration([bool includeOperators=true]) {
     int start = _peekToken.start;
     if (_peekKind(TokenKind.FACTORY)) {
       return factoryConstructorDeclaration();
     }
 
     var modifiers = _readModifiers();
     return finishDefinition(start, modifiers,
-        declaredIdentifier(includeOperators), null);
+        declaredIdentifier(includeOperators));
   }
 
+  // TODO(jmesserly): do we still need this method?
+  // I left it here for now to support old-style factories

[jimhug, 2011/12/15 17:05:04]

I think we need this "forever" as we still have factory constructors - they just
don't share a name with default implementations anymore (yay!).  However, the
typeParameters part below can go away pretty soon - yay!

[Jennifer Messerly, 2011/12/15 19:28:18]

Ah, I might be misremembering the history of the code. At one point weren't
factories handled through finishDefinition? Other than the "factory" modifier,
they look just like normal constructors now, AFAIK.

   factoryConstructorDeclaration() {
     int start = _peekToken.start;
     var factoryToken = _next();
 
     var names = [identifier()];
     while (_maybeEat(TokenKind.DOT)) {
       names.add(identifier());
     }
-    var typeParams = null;
     if (_peekKind(TokenKind.LT)) {
-      typeParams = typeParameters();
+      var tp = typeParameters();
+      world.warning('type parameters on factories are no longer supported, '
+          + 'place them on the class instead', _makeSpan(tp[0].span.start));
     }
 
     var name = null;
     var type = null;
     if (_maybeEat(TokenKind.DOT)) {
       name = identifier();
-    } else if (typeParams == null) {
+    } else {
       if (names.length > 1) {
         name = names.removeLast();
       } else {
         name = new Identifier('', names[0].span);
       }
-    } else {
-      name = new Identifier('', names[0].span);
     }
 
     if (names.length > 1) {
       // TODO(jimhug): This is nasty to support and currently unused.
       _error('unsupported qualified name for factory', names[0].span);
     }
     type = new NameTypeReference(false, names[0], null, names[0].span);
     var di = new DeclaredIdentifier(type, name, _makeSpan(start));
-    return finishDefinition(start, [factoryToken], di, typeParams);
+    return finishDefinition(start, [factoryToken], di);
   }
 
   ///////////////////////////////////////////////////////////////////
   // Statement productions
   ///////////////////////////////////////////////////////////////////
   Statement statement() {
     switch (_peek()) {
       case TokenKind.BREAK:
         return breakStatement();
       case TokenKind.CONTINUE:
@@ skipping 49 matching lines @@
       if (expr.func.body is! BlockStatement) {
         _eatSemicolon();
         expr.func.span = _makeSpan(start);
       }
       return expr.func;
     } else if (expr is DeclaredIdentifier) {
       var value = null;
       if (_maybeEat(TokenKind.ASSIGN)) {
         value = expression();
       }
-      return finishField(start, null, null, expr.type, expr.name, value);
+      return finishField(start, null, expr.type, expr.name, value);
     } else if (_isBin(expr, TokenKind.ASSIGN) &&
                (expr.x is DeclaredIdentifier)) {
       DeclaredIdentifier di = expr.x; // TODO(jimhug): inference should handle!
-      return finishField(start, null, null, di.type, di.name, expr.y);
+      return finishField(start, null, di.type, di.name, expr.y);
     } else if (_isBin(expr, TokenKind.LT) && _maybeEat(TokenKind.COMMA)) {
       var baseType = _makeType(expr.x);
       var typeArgs = [_makeType(expr.y)];
       var gt = _finishTypeArguments(baseType, 0, typeArgs);
       var name = identifier();
       var value = null;
       if (_maybeEat(TokenKind.ASSIGN)) {
         value = expression();
       }
-      return finishField(expr.span.start, null, null, gt, name, value);
+      return finishField(expr.span.start, null, gt, name, value);
     } else {
       _eatSemicolon();
       return new ExpressionStatement(expr, _makeSpan(expr.span.start));
     }
   }
 
   Expression testCondition() {
     _eatLeftParen();
     var ret = expression();
     _eat(TokenKind.RPAREN);
@@ skipping 658 matching lines @@
     }
     return null;
   }
 
   _parenOrLambda() {
     int start = _peekToken.start;
     if (_atClosureParameters()) {
       var formals = formalParameterList();
       var body = functionBody(true);
       var func = new FunctionDefinition(null, null, null, formals, null, null,
-        null, body, _makeSpan(start));
+        body, _makeSpan(start));
       return new LambdaExpression(func, func.span);
     } else {
       _eatLeftParen();
       var saved = _inhibitLambda;
       _inhibitLambda = false;
       var expr = expression();
       _eat(TokenKind.RPAREN);
       _inhibitLambda = saved;
       return new ParenExpression(expr, _makeSpan(start));
     }
@@ skipping 403 matching lines @@
 
     var value = null;
     if (_maybeEat(TokenKind.ASSIGN)) {
       if (!inOptionalBlock) {
         _error('default values only allowed inside [optional] section');
       }
       value = expression();
     } else if (_peekKind(TokenKind.LPAREN)) {
       var formals = formalParameterList();
       var func = new FunctionDefinition(null, type, name, formals,
-          null, null, null, null, _makeSpan(start));
+          null, null, null, _makeSpan(start));
       type = new FunctionTypeReference(false, func, func.span);
     }
     if (inOptionalBlock && value == null) {
       value = new NullExpression(_makeSpan(start));
     }
 
     return new FormalNode(isThis, isRest, type, name, value, _makeSpan(start));
   }
 
   formalParameterList() {
@@ skipping 46 matching lines @@
       name = expr.name;
       type = null;
     } else if (expr is DeclaredIdentifier) {
       name = expr.name;
       type = expr.type;
     } else {
       _error('bad function body', expr.span);
     }
     var span = new SourceSpan(expr.span.file, expr.span.start, body.span.end);
     var func = new FunctionDefinition(null, type, name, formals, null, null,
-                                      null, body, span);
+                                      body, span);
     return new LambdaExpression(func, func.span);
   }
 
   /** Converts an expression to a [DeclaredIdentifier]. */
   _makeDeclaredIdentifier(e) {
     if (e is VarExpression) {
       return new DeclaredIdentifier(null, e.name, e.span);
     } else if (e is DeclaredIdentifier) {
       return e;
     } else {
@@ skipping 38 matching lines @@
   int _pos = 0;
   next() {
     var token = tokens[_pos];
     ++_pos;
     if (_pos == tokens.length) {
       parser.tokenizer = previousTokenizer;
     }
     return token;
   }
 }