Create class AST nodes.

dart/frog/leg/scanner/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.
 
 /**
  * An event generating parser of Dart programs. This parser expects
  * all tokens in a linked list.
  */
-class Parser<L extends Listener> {
+class PartialParser<L extends Listener> {
   final L listener;
+  Function beginTypeArguments;

[kasperl, 2011/11/10 06:37:34]

I think these function fields deserve a comment. What's the purpose of them? I
guess it's cached versions of all the functions you pass to parseStuff?

[ahe, 2011/11/10 07:59:46]

I'll wrap these in a class and clean it up. After I have added the grouping
stack to the scanner. I should be able to do so and let V8 recognize each
production as a seperate class, hopefully making all ICs monomorphic. 

+  Function parseTypeFunction;
+  Function endTypeArguments;
+  Function handleNoTypeArguments;
 
-  Parser(L this.listener);
+  Function beginTypeVariables;
+  Function parseTypeVariableFunction;
+  Function endTypeVariables;
+  Function handleNoTypeVariables;
+
+  PartialParser(L this.listener) {
+    beginTypeArguments = listener.beginTypeArguments;
+    parseTypeFunction = parseType;
+    endTypeArguments = listener.endTypeArguments;
+    handleNoTypeArguments = listener.handleNoTypeArguments;
+
+    beginTypeVariables = listener.beginTypeVariables;
+    parseTypeVariableFunction = parseTypeVariable;
+    endTypeVariables = listener.endTypeVariables;
+    handleNoTypeVariables = listener.handleNoTypeVariables;
+  }
 
   // TODO(ahe): Rename this method. It is too subtle compared to token.next.
   Token next(Token token) => checkEof(token.next);
 
   Token checkEof(Token token) {
     if (token.kind === EOF_TOKEN) {
       listener.unexpectedEof();
       throw 'Unexpected EOF';
     }
     return token;
@@ skipping 139 matching lines @@
       token = next(token);
     } while (token !== null);
     throw 'Internal error: unreachable code';
   }
 
   Token parseClass(Token token) {
     Token begin = token;
     listener.beginClass(token);
     token = parseIdentifier(next(token));
     token = parseTypeVariablesOpt(token);
-    token = parseSuperclassClauseOpt(token);
-    token = parseImplementsOpt(token);
+    Token extendsKeyword;
+    if (optional('extends', token)) {
+      extendsKeyword = token;
+      token = parseType(next(token));
+    } else {
+      extendsKeyword = null;
+      listener.handleNoType(token);

[ngeoffray, 2011/11/10 08:27:42]

Should that be handleNoSuperType instead?

[ahe, 2011/11/10 13:37:23]

Not necessarily. I could change it if someone has a concrete use case.

+    }
+    Token implementsKeyword;
+    int interfacesCount = 0;
+    if (optional('implements', token)) {
+      do {
+        token = parseType(next(token));
+        ++interfacesCount;
+      } while (optional(',', token));
+    }
     token = parseNativeClassClauseOpt(token);
     token = parseClassBody(token);
-    listener.endClass(begin, token);
+    listener.endClass(interfacesCount, begin, extendsKeyword, implementsKeyword,
+                      token);
     return token.next;
   }
 
   Token parseNativeClassClauseOpt(Token token) {
     if (optional('native', token)) {
       return parseString(next(token));
     }
     return token;
   }
 
   Token parseString(Token token) {
     if (token.kind === STRING_TOKEN) {
       return next(token);
     } else {
       return listener.expected('string', token);
     }
   }
 
   Token parseIdentifier(Token token) {
     if (isIdentifier(token)) {
       listener.handleIdentifier(token);
     } else {
       listener.expectedIdentifier(token);
     }
     return next(token);
   }
 
-  Token parseTypeVariablesOpt(Token token) {
-    if (!optional('<', token)) {
-      listener.handleNoTypeVariables(token);
-      return token;
-    }
-    return parseTypeVariables(token);
-  }
-
-  Token parseTypeVariables(Token token) {
-    expect('<', token);
-    listener.beginTypeVariables(token);
-    do {
-      token = parseTypeVariable(next(token));
-    } while (optional(',', token));
-    listener.endTypeVariables(token);
-    return expect('>', token);
-  }
-
   Token expect(String string, Token token) {
     if (string !== token.stringValue) {
       return listener.expected(string, token);
     }
     return token.next;
   }
 
   Token parseTypeVariable(Token token) {
     listener.beginTypeVariable(token);
     token = parseIdentifier(token);
-    token = parseSuperclassClauseOpt(token);
+    if (optional('extends', token)) {
+      token = parseType(next(token));
+    } else {
+      listener.handleNoType(token);
+    }
     listener.endTypeVariable(token);
     return token;
   }
 
   bool optional(String value, Token token) => value === token.stringValue;
 
-  Token parseSuperclassClauseOpt(Token token) {
-    if (optional('extends', token)) {
-      return parseType(next(token));
-    }
-    return token;
-  }
-
   Token parseType(Token token) {
     // TODO(ahe): Rename this method to parseTypeOrVar?
     if (isIdentifier(token)) {
       token = parseIdentifier(token);
       while (optional('.', token)) {
         // TODO(ahe): Validate that there are at most two identifiers.
         token = parseIdentifier(next(token));
       }
     } else if (optional('var', token)) {
       listener.handleVarKeyword(token);
       listener.endType(token);
       return next(token);
     } else {
       token = listener.expectedType(token);
     }
     token = parseTypeArgumentsOpt(token);
     listener.endType(token);
     return token;
   }
 
   Token parseTypeArgumentsOpt(Token token) {
+    return parseStuff(token, beginTypeArguments, parseTypeFunction,
+                      endTypeArguments, handleNoTypeArguments);
+  }
+
+  Token parseTypeVariablesOpt(Token token) {
+    return parseStuff(token, beginTypeVariables, parseTypeVariableFunction,
+                      endTypeVariables, handleNoTypeVariables);
+  }
+
+  Token parseStuff(Token token, Function beginStuff, Function stuffParser,

[kasperl, 2011/11/10 06:37:34]

It would be nice with a more saying name for this. For now, a comment would
probably help (explain the format of what parseStuff deals with).

[ahe, 2011/11/10 13:37:23]

Added TODO.

+                   Function endStuff, Function handleNoStuff) {
     if (optional('<', token)) {
-      listener.beginTypeArguments(next(token));
+      Token begin = token;
+      beginStuff(begin);
+      int count = 0;
       do {
-        token = parseType(next(token));
+        token = stuffParser(next(token));
+        ++count;
       } while (optional(',', token));
+      endStuff(count, begin, token);
       return expect('>', token);
     }
+    handleNoStuff(token);
     return token;
   }
 
-  Token parseImplementsOpt(Token token) {
-    if (optional('implements', token)) {
-      do {
-        token = parseType(next(token));
-      } while (optional(',', token));
-    }
-    return token;
-  }
-
   Token parseClassBody(Token token) => skipBlock(token);
 
   Token parseTopLevelMember(Token token) {
     Token start = token;
     listener.beginTopLevelMember(token);
     Token previous = token;
     LOOP: while (token !== null) {
       final kind = token.kind;
       switch (true) {
         case kind === LBRACE_TOKEN:
@@ skipping 45 matching lines @@
     while (token !== null &&
            token.kind !== LPAREN_TOKEN &&
            token.kind !== RPAREN_TOKEN) {
       token = next(token);
     }
     token = expect(')', token);
     return expect(';', token);
   }
 }
 
-class BodyParser extends Parser/* <BodyListener> Frog bug #320 */ {
-  BodyParser(BodyListener listener) : super(listener);
+class Parser extends PartialParser/* <NodeListener> Frog bug #320 */ {
+  Parser(NodeListener listener) : super(listener);
 
   Token parseFunction(Token token) {
     listener.beginFunction(token);
     token = parseReturnTypeOpt(token);
     listener.beginFunctionName(token);
     token = parseIdentifier(token);
     listener.endFunctionName(token);
     token = parseFormalParameters(token);
     return parseFunctionBody(token);
   }
@@ skipping 342 matching lines @@
     if (optional(';', token)) {
       listener.endRethrowStatement(throwToken, token);
       return token.next;
     } else {
       token = parseExpression(token);
       listener.endThrowStatement(throwToken, token);
       return expectSemicolon(token);
     }
   }
 }