Fixes in dart2js parser to be able to parse files without the diet-parser

pkg/compiler/lib/src/parser/node_listener.dart

 // Copyright (c) 2015, 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.node_listener;
 
 import '../common.dart';
 import '../elements/elements.dart' show CompilationUnitElement;
 import '../native/native.dart' as native;
 import '../tokens/precedence_constants.dart' as Precedence show INDEX_INFO;
 import '../tokens/token.dart' show ErrorToken, StringToken, Token;
 import '../tree/tree.dart';
 import '../util/util.dart' show Link;
 import 'element_listener.dart' show ElementListener, ScannerOptions;
 import 'partial_elements.dart' show PartialFunctionElement;
 
 class NodeListener extends ElementListener {
   NodeListener(ScannerOptions scannerOptions, DiagnosticReporter reporter,
       CompilationUnitElement element)
       : super(scannerOptions, reporter, element, null);
 
   void addLibraryTag(LibraryTag tag) {
     pushNode(tag);
   }
 
   void addPartOfTag(PartOf tag) {
     pushNode(tag);
   }
 
+  void endLibraryName(Token libraryKeyword, Token semicolon) {
+    Expression name = popNode();
+    pushNode(new LibraryName(libraryKeyword, name,
+          // TODO(sigmund): Import AST nodes have pointers to MetadataAnnotation
+          // (element) instead of Metatada (node).
+          null));
+  }
+
+  void endImport(Token importKeyword, Token deferredKeyword, Token asKeyword,
+      Token semicolon) {
+    NodeList combinators = popNode();
+    Identifier prefix = asKeyword != null ? popNode() : null;
+    NodeList conditionalUris = popNode();
+    StringNode uri = popLiteralString();
+    pushNode(new Import(importKeyword, uri, conditionalUris, prefix,
+          combinators,
+          // TODO(sigmund): Import AST nodes have pointers to MetadataAnnotation
+          // (element) instead of Metatada (node).
+          null, isDeferred: deferredKeyword != null));
+  }
+
+  void endExport(Token exportKeyword, Token semicolon) {
+    NodeList combinators = popNode();
+    NodeList conditionalUris = popNode();
+    StringNode uri = popLiteralString();
+    pushNode(new Export(exportKeyword, uri, conditionalUris, combinators,
+          // TODO(sigmund): Import AST nodes have pointers to MetadataAnnotation
+          // (element) instead of Metatada (node).
+          null));
+  }
+
+  void endPart(Token partKeyword, Token semicolon) {
+    StringNode uri = popLiteralString();
+    pushNode(new Part(partKeyword, uri,
+          // TODO(sigmund): Import AST nodes have pointers to MetadataAnnotation
+          // (element) instead of Metatada (node).
+          null));
+  }
+
+  void endPartOf(Token partKeyword, Token semicolon) {
+    Expression name = popNode(); // name
+    pushNode(new PartOf(partKeyword, name,
+          // TODO(sigmund): Import AST nodes have pointers to MetadataAnnotation
+          // (element) instead of Metatada (node).
+          null));
+  }
+
   void endClassDeclaration(int interfacesCount, Token beginToken,
       Token extendsKeyword, Token implementsKeyword, Token endToken) {
     NodeList body = popNode();
     NodeList interfaces =
         makeNodeList(interfacesCount, implementsKeyword, null, ",");
     Node supertype = popNode();
     NodeList typeParameters = popNode();
     Identifier name = popNode();
     Modifiers modifiers = popNode();
     pushNode(new ClassNode(modifiers, name, typeParameters, supertype,
         interfaces, beginToken, extendsKeyword, body, endToken));
   }
 
+  void endTopLevelDeclaration(Token token) {
+    // TODO(sigmund): consider moving metadata into each declaration
+    // element instead.
+    Node node = popNode(); // top-level declaration
+    popNode(); // Discard metadata
+    pushNode(node);
+    super.endTopLevelDeclaration(token);
+  }
+
   void endCompilationUnit(int count, Token token) {
     pushNode(makeNodeList(count, null, null, '\n'));
   }
 
   void endFunctionTypeAlias(Token typedefKeyword, Token endToken) {
     NodeList formals = popNode();
     NodeList typeParameters = popNode();
     Identifier name = popNode();
     TypeAnnotation returnType = popNode();
     pushNode(new Typedef(
@@ skipping 22 matching lines @@
   }
 
   void endTopLevelFields(int count, Token beginToken, Token endToken) {
     NodeList variables = makeNodeList(count, null, endToken, ",");
     TypeAnnotation type = popNode();
     Modifiers modifiers = popNode();
     pushNode(new VariableDefinitions(type, modifiers, variables));
   }
 
   void endTopLevelMethod(Token beginToken, Token getOrSet, Token endToken) {
-    popNode(); // body
-    popNode(); // formalParameters
-    popNode(); // typeVariables
+    Statement body = popNode();
+    AsyncModifier asyncModifier = popNode();
+    NodeList formals = popNode();
+    NodeList typeVariables = popNode();
     Identifier name = popNode();
-    popNode(); // type
+    TypeAnnotation type = popNode();
     Modifiers modifiers = popNode();
-    PartialFunctionElement element = new PartialFunctionElement(name.source,
-        beginToken, getOrSet, endToken, modifiers, compilationUnitElement);
-    pushElement(element);
+    pushNode(new FunctionExpression(name, typeVariables, formals, body, type,

[Siggi Cherem (dart-lang), 2016/09/30 22:28:07]

note: this was inconsistent (likely copy/paste error?) - it was never reached in
dart2js, but it will be reached when using the parser alone without the
diet-parser.

+        modifiers, null, getOrSet, asyncModifier));
   }
 
   void endFormalParameter(Token thisKeyword) {
     Expression name = popNode();
     if (thisKeyword != null) {
       Identifier thisIdentifier = new Identifier(thisKeyword);
       if (name.asSend() == null) {
         name = new Send(thisIdentifier, name);
       } else {
         name = name.asSend().copyWithReceiver(thisIdentifier, false);
@@ skipping 370 matching lines @@
   }
 
   void endInitializers(int count, Token beginToken, Token endToken) {
     pushNode(makeNodeList(count, beginToken, null, ','));
   }
 
   void handleNoInitializers() {
     pushNode(null);
   }
 
+  void endMember() {
+    // TODO(sigmund): consider moving metadata into each declaration
+    // element instead.
+    Node node = popNode(); // member
+    popNode(); // Discard metadata
+    pushNode(node);
+    super.endMember();
+  }
+
   void endFields(int count, Token beginToken, Token endToken) {
     NodeList variables = makeNodeList(count, null, endToken, ",");
     TypeAnnotation type = popNode();
     Modifiers modifiers = popNode();
     pushNode(new VariableDefinitions(type, modifiers, variables));
   }
 
   void endMethod(Token getOrSet, Token beginToken, Token endToken) {
     Statement body = popNode();
     AsyncModifier asyncModifier = popNode();
@@ skipping 192 matching lines @@
     if (awaitToken == null) {
       pushNode(new SyncForIn(
           declaredIdentifier, expression, body, forToken, inKeyword));
     } else {
       pushNode(new AsyncForIn(declaredIdentifier, expression, body, awaitToken,
           forToken, inKeyword));
     }
   }
 
   void endMetadataStar(int count, bool forParameter) {
-    // TODO(johnniwinther): Handle metadata for all node kinds.
-    if (forParameter) {
-      if (0 == count) {
-        pushNode(null);
-      } else {
-        pushNode(makeNodeList(count, null, null, ' '));
-      }
+    if (0 == count) {
+      pushNode(null);
+    } else {
+      pushNode(makeNodeList(count, null, null, ' '));
     }
   }
 
   void endMetadata(Token beginToken, Token periodBeforeName, Token endToken) {
     NodeList arguments = popNode();
     if (arguments == null) {
       // This is a constant expression.
       Identifier name;
       if (periodBeforeName != null) {
         name = popNode();
@@ skipping 74 matching lines @@
   void log(message) {
     reporter.log(message);
   }
 
   void internalError({Token token, Node node}) {
     // TODO(ahe): This should call reporter.internalError.
     Spannable spannable = (token == null) ? node : token;
     throw new SpannableAssertionFailure(spannable, 'Internal error in parser.');
   }
 }