Fixing parsing of factories.

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 234 matching lines @@
     }
 
     var _native = null;
     if (_maybeEat(TokenKind.NATIVE)) {
       _native = maybeStringLiteral();
       if (_native !== null) _native = new NativeType(_native);
     }
 
     var _factory = null;
     if (_maybeEat(TokenKind.FACTORY)) {
-      _factory = type();
+      // Note: this can't be type(), because for some strange reason these are
+      // type parameters, not type arguments.
+      _factory = nameTypeReference();
+      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.

[jimhug, 2011/12/08 16:24:30]

Just hold your nose and parse them <smile/frown>

+        typeParameters();
+      }
     }
 
     var body = [];
     if (_maybeEat(TokenKind.LBRACE)) {
       while (!_maybeEat(TokenKind.RBRACE)) {
         if (isPrematureEndOfFile()) break;
         body.add(declaration());
       }
     } else {
       _errorExpected('block starting with "{" or ";"');
@@ skipping 1257 matching lines @@
 
   typeList() {
     var types = [];
     do {
       types.add(type());
     } while (_maybeEat(TokenKind.COMMA));
 
     return types;
   }
 
-  type([int depth = 0]) {
+  nameTypeReference() {
     int start = _peekToken.start;
     var name;
     var names = null;
     var typeArgs = null;
     var isFinal = false;
 
     switch (_peek()) {
       case TokenKind.VOID:
         return new TypeReference(_next().span, world.voidType);
       case TokenKind.VAR:
         return new TypeReference(_next().span, world.varType);
       case TokenKind.FINAL:
         _eat(TokenKind.FINAL);
         isFinal = true;
         name = identifier();
         break;
       default:
         name = identifier();
         break;
     }
 
     while (_maybeEat(TokenKind.DOT)) {
       if (names === null) names = [];
       names.add(identifier());
     }
 
-    var typeRef = new NameTypeReference(isFinal, name, names,
-      _makeSpan(start));
+    return new NameTypeReference(isFinal, name, names, _makeSpan(start));
+  }
+
+  type([int depth = 0]) {
+    var typeRef = nameTypeReference();
 
     if (_peekKind(TokenKind.LT)) {
       return addTypeArguments(typeRef, depth);
     } else {
       return typeRef;
     }
   }
 
   formalParameter(bool inOptionalBlock) {
     int start = _peekToken.start;
@@ skipping 131 matching lines @@
   int _pos = 0;
   next() {
     var token = tokens[_pos];
     ++_pos;
     if (_pos == tokens.length) {
       parser.tokenizer = previousTokenizer;
     }
     return token;
   }
 }