Implement parsing and resolving of type-variables.

frog/leg/tree/nodes.dart

-// Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
+// Copyright (c) 2012, 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.
 
 interface Visitor<R> {
   R visitBlock(Block node);
   R visitBreakStatement(BreakStatement node);
   R visitCatchBlock(CatchBlock node);
   R visitClassNode(ClassNode node);
   R visitConditional(Conditional node);
   R visitContinueStatement(ContinueStatement node);
@@ skipping 27 matching lines @@
   R visitSend(Send node);
   R visitSendSet(SendSet node);
   R visitStringInterpolation(StringInterpolation node);
   R visitStringInterpolationPart(StringInterpolationPart node);
   R visitSwitchCase(SwitchCase node);
   R visitSwitchStatement(SwitchStatement node);
   R visitThrow(Throw node);
   R visitTryStatement(TryStatement node);
   R visitTypeAnnotation(TypeAnnotation node);
   R visitTypedef(Typedef node);
+  R visitTypeVariable(TypeVariable node);
   R visitVariableDefinitions(VariableDefinitions node);
   R visitWhile(While node);
 }
 
 Token firstBeginToken(Node first, Node second) {
   if (first !== null) return first.getBeginToken();
   if (second !== null) return second.getBeginToken();
   return null;
 }
 
@@ skipping 76 matching lines @@
   SendSet asSendSet() => null;
   Statement asStatement() => null;
   StringInterpolation asStringInterpolation() => null;
   StringInterpolationPart asStringInterpolationPart() => null;
   SwitchCase asSwitchCase() => null;
   SwitchStatement asSwitchStatement() => null;
   Throw asThrow() => null;
   TryStatement asTryStatement() => null;
   TypeAnnotation asTypeAnnotation() => null;
   Typedef asTypedef() => null;
+  TypeVariable asTypeVariable() => null;
   VariableDefinitions asVariableDefinitions() => null;
   While asWhile() => null;
 
   bool isValidBreakTarget() => false;
   bool isValidContinueTarget() => false;
 }
 
 class ClassNode extends Node {
   final Identifier name;
   final TypeAnnotation superclass;
   final NodeList interfaces;
+  final NodeList typeParameters;
 
   // Using a NodeList to record the keyword "default".
   // TODO(ahe): Consider if there is a better way to represent this.
   final NodeList defaultClause;
 
   final Token beginToken;
   final Token extendsKeyword;
   final Token endToken;
 
-  ClassNode(this.name, this.superclass, this.interfaces, this.defaultClause,
-            this.beginToken, this.extendsKeyword, this.endToken);
+  ClassNode(this.name, this.typeParameters, this.superclass, this.interfaces,
+            this.defaultClause, this.beginToken, this.extendsKeyword,
+            this.endToken);
 
   ClassNode asClassNode() => this;
 
   accept(Visitor visitor) => visitor.visitClassNode(this);
 
   visitChildren(Visitor visitor) {
     if (name !== null) name.accept(visitor);
     if (superclass !== null) superclass.accept(visitor);
     if (interfaces !== null) interfaces.accept(visitor);
   }
@@ skipping 886 matching lines @@
   visitChildren(Visitor visitor) {
     typeName.accept(visitor);
     if (typeArguments !== null) typeArguments.accept(visitor);
   }
 
   Token getBeginToken() => typeName.getBeginToken();
 
   Token getEndToken() => typeName.getEndToken();
 }
 
+class TypeVariable extends Node {
+  final Identifier name;
+  final TypeAnnotation bound;
+  TypeVariable(Identifier this.name, TypeAnnotation this.bound);
+
+  accept(Visitor visitor) => visitor.visitTypeVariable(this);
+
+  visitChildren(Visitor visitor) {
+    name.accept(visitor);
+    if (bound !== null) {
+      bound.accept(visitor);
+    }
+  }
+
+  TypeVariable asTypeVariable() => this;
+
+  Token getBeginToken() => name.getBeginToken();
+
+  Token getEndToken() {
+    return (bound !== null) ? bound.getEndToken() : name.getEndToken();
+  }
+}
+
 class VariableDefinitions extends Statement {
   final Token endToken;
   final TypeAnnotation type;
   final Modifiers modifiers;
   final NodeList definitions;
   VariableDefinitions(this.type, this.modifiers, this.definitions,
                       this.endToken);
 
   VariableDefinitions asVariableDefinitions() => this;
 
@@ skipping 625 matching lines @@
   static bool isConstructorRedirect(Send node) {
     return (node.receiver === null &&
             node.selector.asIdentifier() !== null &&
             node.selector.asIdentifier().isThis()) ||
            (node.receiver !== null &&
             node.receiver.asIdentifier() !== null &&
             node.receiver.asIdentifier().isThis() &&
             node.selector.asIdentifier() !== null);
   }
 }