Patches to support Dart VM patch files in dart2js.

pkg/compiler/lib/src/parser/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.
 
 library dart2js.parser;
 
 import '../options.dart' show ParserOptions;
 import '../common.dart';
 import '../tokens/keyword.dart' show Keyword;
 import '../tokens/precedence.dart' show PrecedenceInfo;
@@ skipping 721 matching lines @@
         ++interfacesCount;
       } while (optional(',', token));
     }
     token = parseClassBody(token);
     listener.endClassDeclaration(
         interfacesCount, begin, extendsKeyword, implementsKeyword, token);
     return token.next;
   }
 
   Token parseStringPart(Token token) {
-    if (identical(token.kind, STRING_TOKEN)) {
-      listener.handleStringPart(token);
-      return token.next;
-    } else {
-      return listener.expected('string', token);
+    if (token.kind != STRING_TOKEN) {
+      token = listener.expectedString(token);
     }
+    listener.handleStringPart(token);
+    return token.next;
   }
 
   Token parseIdentifier(Token token) {
     if (!token.isIdentifier()) {
       token = listener.expectedIdentifier(token);
     }
     listener.handleIdentifier(token);
     return token.next;
   }
 
@@ skipping 359 matching lines @@
   ///     get foo async* { return null }
   /// results in
   ///     ['{', 'foo', 'get']
   ///
   ///
   ///     operator *(arg) => null;
   /// results in
   ///     ['(', '*', 'operator']
   ///
   Link<Token> findMemberName(Token token) {
+    Link<Token> discardNative(Link<Token> tokens) {
+      if (!tokens.isEmpty && !tokens.tail.isEmpty &&
+          tokens.tail.head.kind == STRING_TOKEN &&
+          !tokens.tail.tail.isEmpty &&
+          optional('native', tokens.tail.tail.head)) {
+        return tokens.tail.tail.tail.prepend(tokens.head);
+      } else {
+        return tokens;
+      }
+    }
+
     Link<Token> identifiers = const Link<Token>();
 
     // `true` if 'get' has been seen.
     bool isGetter = false;
     // `true` if an identifier has been seen after 'get'.
     bool hasName = false;
 
     while (token.kind != EOF_TOKEN) {
       String value = token.stringValue;
       if (value == 'get') {
         isGetter = true;
       } else if (hasName && (value == 'sync' || value == 'async')) {
         // Skip.
         token = token.next;
         value = token.stringValue;
         if (value == '*') {
           // Skip.
           token = token.next;
         }
         continue;
       } else if (value == '(' || value == '{' || value == '=>') {
         // A method.
         identifiers = identifiers.prepend(token);
-        return identifiers;
+        return discardNative(identifiers);
       } else if (value == '=' || value == ';' || value == ',') {
         // A field or abstract getter.
         identifiers = identifiers.prepend(token);
-        return identifiers;
+        return discardNative(identifiers);
       } else if (isGetter) {
         hasName = true;
       }
       identifiers = identifiers.prepend(token);
       if (isValidTypeReference(token)) {
         // type ...
         if (optional('.', token.next)) {
           // type '.' ...
           if (token.next.next.isIdentifier()) {
             // type '.' identifier
@@ skipping 549 matching lines @@
         star = token;
         token = token.next;
       } else {
         listener.reportError(async, MessageKind.INVALID_SYNC_MODIFIER);
       }
     }
     listener.handleAsyncModifier(async, star);
     return token;
   }
 
+  int statementDepth = 0;
   Token parseStatement(Token token) {
+    if (statementDepth++ > 500) {
+      listener.reportError(
+          token, MessageKind.GENERIC, {'text': 'Stack overflow'});
+      return listener.skipToEof(token);
+    }
+    Token result = parseStatementX(token);
+    statementDepth--;
+    return result;
+  }
+
+  Token parseStatementX(Token token) {
     final value = token.stringValue;
     if (identical(token.kind, IDENTIFIER_TOKEN)) {
       return parseExpressionStatementOrDeclaration(token);
     } else if (identical(value, '{')) {
       return parseBlock(token);
     } else if (identical(value, 'return')) {
       return parseReturnStatement(token);
     } else if (identical(value, 'var') || identical(value, 'final')) {
       return parseVariablesDeclaration(token);
     } else if (identical(value, 'if')) {
@@ skipping 179 matching lines @@
     return token;
   }
 
   Token parseExpressionStatement(Token token) {
     listener.beginExpressionStatement(token);
     token = parseExpression(token);
     listener.endExpressionStatement(token);
     return expectSemicolon(token);
   }
 
+  int expressionDepth = 0;
   Token parseExpression(Token token) {
-    return optional('throw', token)
+    if (expressionDepth++ > 500) {
+      listener.reportError(
+          token, MessageKind.GENERIC, {'text': 'Stack overflow'});
+      return token.next;
+    }
+    Token result = optional('throw', token)
         ? parseThrowExpression(token, true)
         : parsePrecedenceExpression(token, ASSIGNMENT_PRECEDENCE, true);
+    expressionDepth--;
+    return result;
   }
 
   Token parseExpressionWithoutCascade(Token token) {
     return optional('throw', token)
         ? parseThrowExpression(token, false)
         : parsePrecedenceExpression(token, ASSIGNMENT_PRECEDENCE, false);
   }
 
   Token parseConditionalExpressionRest(Token token) {
     assert(optional('?', token));
@@ skipping 921 matching lines @@
     }
     listener.handleContinueStatement(hasTarget, continueKeyword, token);
     return expectSemicolon(token);
   }
 
   Token parseEmptyStatement(Token token) {
     listener.handleEmptyStatement(token);
     return expectSemicolon(token);
   }
 }