Fix bug 578

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 249 matching lines @@
 
     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, _makeSpan(start));
+                                       null, null, null, _makeSpan(start));
 
     return new FunctionTypeDefinition(func, typeParams, _makeSpan(start));
   }
 
   initializers() {
     _inInitializers = true;
     var ret = [];
     do {
       ret.add(expression());
     } while (_maybeEat(TokenKind.COMMA));
@@ skipping 28 matching lines @@
           // TODO(jimhug): This is just to get isolate.dart to parse - while
           //   we figure out what's really going on in there.
           return functionBody(inExpression);
         }
       }
     }
 
     _error('Expected function body (neither { nor => found)');
   }
 
-  finishField(start, modifiers, type, name, value) {
+  finishField(start, modifiers, typeParams, type, name, value) {
+    if (typeParams !== null) {
+      world.internalError('trying to create a generic field',
+        _makeSpan(start));
+    }
     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(start, modifiers, di) {
+  finishDefinition(int start, List<Token> modifiers, di,
+      List<ParameterType> typeParams) {
     switch(_peek()) {
       case TokenKind.LPAREN:
         var formals = formalParameterList();
         var inits = null;
         if (_maybeEat(TokenKind.COLON)) {
           inits = initializers();
         }
         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,
-                                       inits, body, _makeSpan(start));
+          typeParams, inits, body, _makeSpan(start));
 
       case TokenKind.ASSIGN:
         _eat(TokenKind.ASSIGN);
         var value = expression();
-        return finishField(start, modifiers, di.type, di.name, value);
+        return finishField(start, modifiers, typeParams, di.type, di.name, value);
 
       case TokenKind.COMMA:
       case TokenKind.SEMICOLON:
-        return finishField(start, modifiers, di.type, di.name, null);
+        return finishField(start, modifiers, typeParams, 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));
+        declaredIdentifier(includeOperators), null);
   }
 
   factoryConstructorDeclaration() {
     int start = _peekToken.start;
     var factoryToken = _next();
 
     var names = [identifier()];
     while (_maybeEat(TokenKind.DOT)) {
       names.add(identifier());
     }
@@ skipping 15 matching lines @@
     } 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);
+    return finishDefinition(start, [factoryToken], di, typeParams);
   }
 
   ///////////////////////////////////////////////////////////////////
   // 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, expr.type, expr.name, value);
+      return finishField(start, null, 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, di.type, di.name, expr.y);
+      return finishField(start, null, 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, gt, name, value);
+      return finishField(expr.span.start, null, null, gt, name, value);
     } else {
       _eatSemicolon();
       return new ExpressionStatement(expr, _makeSpan(expr.span.start));
     }
   }
 
   Expression testCondition() {
     _eatLeftParen();
     var ret = expression();
     _eat(TokenKind.RPAREN);
@@ skipping 646 matching lines @@
       _errorExpected('string literal, but found incomplete string');
     }
     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,
+      var func = new FunctionDefinition(null, null, null, formals, null, null,
         body, _makeSpan(start));
       return new LambdaExpression(func, func.span);
     } else {
       var saved = _inInitializers;
       _inInitializers = false;
       var args = arguments();
       _inInitializers = saved;
       if (args.length == 1) {
         return new ParenExpression(args[0].value, _makeSpan(start));
       } else {
@@ skipping 245 matching lines @@
           modifiers.add(_next());
           break;
         default:
           return modifiers;
       }
     }
 
     return null;
   }
 
-  typeParameter() {
+  ParameterType typeParameter() {
     // non-recursive - so always starts from zero depth
     int start = _peekToken.start;
     var name = identifier();
     var myType = null;
     if (_maybeEat(TokenKind.EXTENDS)) {
       myType = type(1);
     }
-    return new TypeParameter(name, myType, _makeSpan(start));
+
+    var tp = new TypeParameter(name, myType, _makeSpan(start));
+    return new ParameterType(name.name, tp);
   }
 
-  typeParameters() {
+  List<ParameterType> typeParameters() {
     // always starts from zero depth
     _eat(TokenKind.LT);
 
     bool closed = false;
     var ret = [];
     do {
-      // inlining typeParameter to handle scope issues?
       var tp = typeParameter();
       ret.add(tp);
-      if (tp.extendsType is GenericTypeReference && tp.extendsType.depth == 0) {
+      if (tp.typeParameter.extendsType is GenericTypeReference &&
+          tp.typeParameter.extendsType.depth == 0) {
         closed = true;
         break;
       }
     } while (_maybeEat(TokenKind.COMMA));
     if (!closed) {
       _eat(TokenKind.GT);
     }
     return ret;
   }
 
@@ skipping 92 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, _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, body, span);
+        new FunctionDefinition(null, type, name, formals, null, null, 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;
   }
 }