Lots of frog cleanup

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 267 matching lines @@
     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',
             _previousToken.span);
       }
 
       // Note: this can't be type() because it has type parameters not type
       // arguments.
       var baseType = nameTypeReference();
-      var typeParams = null;
+      var factTypeParams = null;
       if (_peekKind(TokenKind.LT)) {
-        typeParams = typeParameters();
+        factTypeParams = typeParameters();
       }
       defaultType = new DefaultTypeReference(oldFactory,
-          baseType, typeParams, _makeSpan(baseType.span.start));
+          baseType, factTypeParams, _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);
         }
@@ skipping 1095 matching lines @@
         world.error('exactly one type argument expected for list',
           genericType.span);
       }
       return finishListLiteral(start, isConst, typeArgs[0]);
     } else if (_peekKind(TokenKind.LBRACE)) {
       var keyType, valueType;
       if (typeArgs.length == 1) {
         keyType = null;
         valueType = typeArgs[0];
       } else if (typeArgs.length == 2) {
-        var keyType = typeArgs[0];
+        keyType = typeArgs[0];
         // making key explicit is just a warning.
         world.warning(
             'a map literal takes one type argument specifying the value type',
             keyType.span);
         valueType = typeArgs[1];
       } // o.w. the type system will detect the mismatch in type arguments.
       return finishMapLiteral(start, isConst, keyType, valueType);
     } else {
       _errorExpected('array or map literal');
     }
@@ skipping 106 matching lines @@
 
   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);
+        return new SimpleTypeReference(world.voidType, _next().span);
       case TokenKind.VAR:
-        return new TypeReference(_next().span, world.varType);
+        return new SimpleTypeReference(world.varType, _next().span);
       case TokenKind.FINAL:
         _eat(TokenKind.FINAL);
         isFinal = true;
         name = identifier();
         break;
       default:
         name = identifier();
         break;
     }
 
@@ skipping 170 matching lines @@
   int _pos = 0;
   next() {
     var token = tokens[_pos];
     ++_pos;
     if (_pos == tokens.length) {
       parser.tokenizer = previousTokenizer;
     }
     return token;
   }
 }