Implement AstBuilder support for library, part, and part-of declarations.

pkg/front_end/lib/src/fasta/analyzer/ast_builder.dart

 // Copyright (c) 2016, 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 fasta.analyzer.ast_builder;
 
 import 'package:front_end/src/fasta/scanner/token.dart'
     show BeginGroupToken, Token;
 
 import 'package:analyzer/analyzer.dart';
@@ skipping 35 matching lines @@
   final AstFactory ast = standard.astFactory;
 
   final KernelLibraryBuilder library;
 
   final Builder member;
 
   final ElementStore elementStore;
 
   bool isFirstIdentifier = false;
 
+  /// If `true`, the first call to [handleIdentifier] should push a
+  /// List<SimpleIdentifier> on the stack, and [handleQualified] should append
+  /// to the list.
+  var accumulateIdentifierComponents = false;

[ahe, 2017/02/20 09:59:40]

Should we change the parser so it can tell you how many components there are on
the stack instead?

[Paul Berry, 2017/02/20 14:48:31]

I don't know.  In general I like the "handleQualified" approach--I believe it's
a good match for analyzer data structures in most cases.  It's just the two
cases in this CL (library and part-of directives) that are a little weird.  So
my temptation would be to leave it as is.

+
   AstBuilder(this.library, this.member, this.elementStore, Scope scope)
       : super(scope);
 
   Uri get uri => library.fileUri ?? library.uri;
 
   createJumpTarget(JumpTargetKind kind, int charOffset) {
     // TODO(ahe): Implement jump targets.
     return null;
   }
 
@@ skipping 57 matching lines @@
   }
 
   void beginExpression(Token token) {
     isFirstIdentifier = true;
   }
 
   void handleIdentifier(Token token) {
     debugEvent("handleIdentifier");
     String name = token.value;
     SimpleIdentifier identifier = ast.simpleIdentifier(toAnalyzerToken(token));
-    if (isFirstIdentifier) {
-      Builder builder = scope.lookup(name, token.charOffset, uri);
-      if (builder != null) {
-        Element element = elementStore[builder];
-        assert(element != null);
-        identifier.staticElement = element;
+    if (accumulateIdentifierComponents) {
+      if (isFirstIdentifier) {
+        push([identifier]);
+      } else {
+        push(identifier);
       }
+    } else {
+      if (isFirstIdentifier) {
+        Builder builder = scope.lookup(name, token.charOffset, uri);
+        if (builder != null) {
+          Element element = elementStore[builder];
+          assert(element != null);
+          identifier.staticElement = element;
+        }
+      }
+      push(identifier);
     }
-    push(identifier);
     isFirstIdentifier = false;
   }
 
   void endSend(Token token) {
     debugEvent("Send");
     MethodInvocation arguments = pop();
     TypeArgumentList typeArguments = pop();
     if (arguments != null) {
       if (typeArguments != null) {
         arguments.typeArguments = typeArguments;
@@ skipping 697 matching lines @@
         toAnalyzerToken(classKeyword),
         name,
         typeParameters,
         equals,
         abstractKeyword,
         superclass,
         withClause,
         implementsClause,
         toAnalyzerToken(endToken)));
   }
+
+  @override
+  void beginLibraryName(Token token) {
+    accumulateIdentifierComponents = true;
+    isFirstIdentifier = true;
+  }
+
+  @override
+  void endLibraryName(Token libraryKeyword, Token semicolon) {
+    debugEvent("LibraryName");
+    List<SimpleIdentifier> libraryName = pop();
+    var name = ast.libraryIdentifier(libraryName);
+    List<Annotation> metadata = pop();
+    Comment comment = null; // TODO(paulberry)
+    push(ast.libraryDirective(comment, metadata,
+        toAnalyzerToken(libraryKeyword), name, toAnalyzerToken(semicolon)));
+    accumulateIdentifierComponents = false;
+  }
+
+  @override
+  void handleQualified(Token period) {
+    if (accumulateIdentifierComponents) {
+      SimpleIdentifier identifier = pop();
+      List<SimpleIdentifier> list = pop();
+      list.add(identifier);
+      push(list);
+    } else {
+      // TODO(paulberry): implement.
+      logEvent('Qualified');
+    }
+  }
+
+  @override
+  void endPart(Token partKeyword, Token semicolon) {
+    debugEvent("Part");
+    StringLiteral uri = pop();
+    List<Annotation> metadata = pop();
+    Comment comment = null; // TODO(paulberry)
+    push(ast.partDirective(comment, metadata, toAnalyzerToken(partKeyword), uri,
+        toAnalyzerToken(semicolon)));
+  }
+
+  @override
+  void beginPartOf(Token token) {
+    accumulateIdentifierComponents = true;
+    isFirstIdentifier = true;
+  }
+
+  @override
+  void endPartOf(Token partKeyword, Token semicolon) {
+    debugEvent("PartOf");
+    List<SimpleIdentifier> libraryName = pop();
+    var name = ast.libraryIdentifier(libraryName);
+    StringLiteral uri = null; // TODO(paulberry)
+    // TODO(paulberry,ahe): seems hacky.  It would be nice if the parser passed
+    // in a reference to the "of" keyword.

[ahe, 2017/02/20 09:59:40]

We can do so, just file a bug. 

[Paul Berry, 2017/02/20 14:48:32]

Acknowledged.

+    var ofKeyword = partKeyword.next;
+    List<Annotation> metadata = pop();
+    Comment comment = null; // TODO(paulberry)
+    push(ast.partOfDirective(comment, metadata, toAnalyzerToken(partKeyword),
+        toAnalyzerToken(ofKeyword), uri, name, toAnalyzerToken(semicolon)));
+    accumulateIdentifierComponents = false;
+  }
 }
 
 /// Data structure placed on the stack to represent a class body.
 ///
 /// This is needed because analyzer has no separate AST representation of a
 /// class body; it simply stores all of the relevant data in the
 /// [ClassDeclaration] object.
 class _ClassBody {
   final Token beginToken;
 
@@ skipping 12 matching lines @@
 /// [ClassDeclaration] or [ClassTypeAlias] object.
 class _MixinApplication {
   final TypeName supertype;
 
   final Token withKeyword;
 
   final List<TypeName> mixinTypes;
 
   _MixinApplication(this.supertype, this.withKeyword, this.mixinTypes);
 }