Add "external" prefix to methods and constructors.

lib/compiler/implementation/scanner/parser.dart

 // 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.
 
 /**
  * An event generating parser of Dart programs. This parser expects
  * all tokens in a linked list (aka a token stream).
  *
  * The class [Scanner] is used to generate a token stream. See the
  * file scanner.dart.
@@ skipping 449 matching lines @@
 
   Token expectSemicolon(Token token) {
     return expect(';', token);
   }
 
   Token parseModifier(Token token) {
     assert(('final' === token.stringValue) ||
            ('var' === token.stringValue) ||
            ('const' === token.stringValue) ||
            ('abstract' === token.stringValue) ||
-           ('static' === token.stringValue));
+           ('static' === token.stringValue) ||
+           ('external' === token.stringValue));
     listener.handleModifier(token);
     return token.next;
   }
 
   Token parseModifiers(Token token) {
     int count = 0;
     while (token.kind === KEYWORD_TOKEN) {
       final String value = token.stringValue;
       if (('final' !== value) &&
           ('var' !== value) &&
           ('const' !== value) &&
           ('abstract' !== value) &&
-          ('static' !== value))
+          ('static' !== value) &&
+          ('external' !== value))
         break;
       token = parseModifier(token);
       count++;
     }
     listener.handleModifiers(count);
     return token;
   }
 
   Token peekAfterType(Token token) {
     // TODO(ahe): Also handle var?
@@ skipping 66 matching lines @@
       final Token peek = peekAfterType(token);
       if (isGetOrSet(peek) && isIdentifier(peek.next)) {
         // type? get identifier
         return peek;
       }
     }
     return null;
   }
 
   Token parseMember(Token token) {
-    if (optional('factory', token)) {

[ahe, 2012/08/02 20:14:36]

This is kinda of a hack.

+    String value = token.stringValue;
+    if (value === 'factory' ||
+        (value === 'external' && optional('factory', token.next))) {

[ahe, 2012/08/02 20:14:36]

And now the hack doesn't work anymore.

       return parseFactoryMethod(token);
     }
     Token start = token;
     listener.beginMember(token);
     token = parseModifiers(token);
     Token getOrSet = findGetOrSet(token);
     if (token === getOrSet) token = token.next;
     Token peek = peekAfterType(token);
     if (isIdentifier(peek) && token.stringValue !== 'operator') {
       // Skip type.
@@ skipping 43 matching lines @@
       token = parseQualifiedRestOpt(token);
       token = parseFormalParameters(token);
       token = parseInitializersOpt(token);
       token = parseFunctionBody(token, false);
       listener.endMethod(getOrSet, start, token);
     }
     return token.next;
   }
 
   Token parseFactoryMethod(Token token) {
-    assert(optional('factory', token));
+    assert((optional('external', token) && optional('factory', token.next)) ||
+           optional('factory', token));
+    Token start = token;
+    if (start.stringValue === 'external') token = token.next;
     Token factoryKeyword = token;
     listener.beginFactoryMethod(factoryKeyword);
     token = token.next; // Skip 'factory'.
     token = parseIdentifier(token);
     token = parseQualifiedRestOpt(token);
     token = parseTypeVariablesOpt(token);
     Token period = null;
     if (optional('.', token)) {
       period = token;
       token = parseIdentifier(token.next);
     }
     token = parseFormalParameters(token);
     token = parseFunctionBody(token, false);
-    listener.endFactoryMethod(factoryKeyword, period, token);
+    listener.endFactoryMethod(factoryKeyword, period, start);
     return token.next;
   }
 
   Token parseOperatorName(Token token) {
     assert(optional('operator', token));
     if (isUserDefinableOperator(token.next.stringValue)) {
       Token operator = token;
       token = token.next;
       listener.handleOperatorName(operator, token);
       return token.next;
@@ skipping 1048 matching lines @@
     }
     listener.handleContinueStatement(hasTarget, continueKeyword, token);
     return expectSemicolon(token);
   }
 
   Token parseEmptyStatement(Token token) {
     listener.handleEmptyStatement(token);
     return expectSemicolon(token);
   }
 }