Add contextual information about identifiers to the parser listener API.

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 11 matching lines @@
 import '../errors.dart' show internalError;
 
 import '../source/scope_listener.dart'
     show JumpTargetKind, NullValue, Scope, ScopeListener;
 
 import '../kernel/kernel_builder.dart'
     show Builder, KernelLibraryBuilder, ProcedureBuilder;
 
 import '../parser/parser.dart' show optional;
 
+import '../parser/identifier_context.dart' show IdentifierContext;
+
 import '../quote.dart';
 
 import '../source/outline_builder.dart' show asyncMarkerFromTokens;
 
 import 'element_store.dart'
     show
         AnalyzerLocalVariableElemment,
         AnalyzerParameterElement,
         ElementStore,
         KernelClassElement;
 
 import 'token_utils.dart' show toAnalyzerToken;
 
 import 'analyzer.dart' show toKernel;
 
 class AstBuilder extends ScopeListener {
   final AstFactory ast = standard.astFactory;
 
   final KernelLibraryBuilder library;
 
   final Builder member;
 
   final ElementStore elementStore;
 
-  bool isFirstIdentifier = false;
-
   @override
   final Uri uri;
 
-  /// 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;
-
   AstBuilder(this.library, this.member, this.elementStore, Scope scope,
       [Uri uri])
       : uri = uri ?? library.fileUri,
         super(scope);
 
   createJumpTarget(JumpTargetKind kind, int charOffset) {
     // TODO(ahe): Implement jump targets.
     return null;
   }
 
@@ skipping 49 matching lines @@
   }
 
   void endArguments(int count, Token beginToken, Token endToken) {
     debugEvent("Arguments");
     List expressions = popList(count);
     ArgumentList arguments = ast.argumentList(
         toAnalyzerToken(beginToken), expressions, toAnalyzerToken(endToken));
     push(ast.methodInvocation(null, null, null, null, arguments));
   }
 
-  void beginExpression(Token token) {
-    isFirstIdentifier = true;
-  }
-
-  void handleIdentifier(Token token) {
+  void handleIdentifier(Token token, IdentifierContext context) {
     debugEvent("handleIdentifier");
     String name = token.value;
     SimpleIdentifier identifier = ast.simpleIdentifier(toAnalyzerToken(token));
-    if (accumulateIdentifierComponents) {
-      if (isFirstIdentifier) {
+    if (context.inLibraryOrPartOfDeclaration) {
+      if (!context.isContinuation) {
         push([identifier]);
       } else {
         push(identifier);
       }
     } else {
-      if (isFirstIdentifier) {
+      if (context.isScopeReference) {
         Builder builder = scope.lookup(name, token.charOffset, uri);
         if (builder != null) {
           Element element = elementStore[builder];
           assert(element != null);
           identifier.staticElement = element;
         }
       }
       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 229 matching lines @@
   void handleAsyncModifier(Token asyncToken, Token starToken) {
     debugEvent("AsyncModifier");
     push(asyncMarkerFromTokens(asyncToken, starToken));
   }
 
   void endAwaitExpression(Token beginToken, Token endToken) {
     debugEvent("AwaitExpression");
     push(ast.awaitExpression(toAnalyzerToken(beginToken), pop()));
   }
 
-  void beginLiteralSymbol(Token token) {
-    isFirstIdentifier = false;
-  }
-
   void handleLiteralBool(Token token) {
     debugEvent("LiteralBool");
     bool value = identical(token.stringValue, "true");
     assert(value || identical(token.stringValue, "false"));
     push(ast.booleanLiteral(toAnalyzerToken(token), value));
   }
 
   void handleLiteralDouble(Token token) {
     debugEvent("LiteralDouble");
     push(ast.doubleLiteral(toAnalyzerToken(token), double.parse(token.value)));
@@ skipping 30 matching lines @@
     push(ast.symbolLiteral(toAnalyzerToken(hashToken), components));
   }
 
   void endType(Token beginToken, Token endToken) {
     debugEvent("Type");
     TypeArgumentList arguments = pop();
     Identifier name = pop();
     // TODO(paulberry,ahe): what if the type doesn't resolve to a class
     // element?
     KernelClassElement cls = name.staticElement;
-    if (cls == null) {
-      // TODO(paulberry): This is a kludge.  Ideally we should already have
-      // set the static element at the time that handleIdentifier was called.
-      Builder builder = scope.lookup(name.name, beginToken.charOffset, uri);
-      if (builder == null) {
-        internalError("Undefined name: $name");
-      }
-      cls = elementStore[builder];
-      assert(cls != null);
-      if (name is SimpleIdentifier) {
-        name.staticElement = cls;
-      }
-    }
-    push(ast.typeName(name, arguments)..type = cls.rawType);
+    push(ast.typeName(name, arguments)..type = cls?.rawType);
   }
 
   void handleAsOperator(Token operator, Token endToken) {
     debugEvent("AsOperator");
     TypeName type = pop();
     Expression expression = pop();
     push(ast.asExpression(expression, toAnalyzerToken(operator), type));
   }
 
   void handleIsOperator(Token operator, Token not, Token endToken) {
@@ skipping 382 matching lines @@
     debugEvent("MixinApplication");
     List<TypeName> mixinTypes = pop();
     // TODO(paulberry,ahe): the parser doesn't give us enough information to
     // locate the "with" keyword.
     Token withKeyword;
     TypeName supertype = pop();
     push(new _MixinApplication(supertype, withKeyword, mixinTypes));
   }
 
   @override
-  void endNamedMixinApplication(
-      Token beginToken, Token equalsToken, Token implementsKeyword, Token endToken) {
+  void endNamedMixinApplication(Token beginToken, Token equalsToken,
+      Token implementsKeyword, Token endToken) {
     debugEvent("NamedMixinApplication");
     ImplementsClause implementsClause;
     if (implementsKeyword != null) {
       List<TypeName> interfaces = pop();
       implementsClause =
           ast.implementsClause(toAnalyzerToken(implementsKeyword), interfaces);
     }
     _MixinApplication mixinApplication = pop();
     var superclass = mixinApplication.supertype;
     var withClause = ast.withClause(
@@ skipping 24 matching lines @@
         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();
     // TODO(paulberry): capture doc comments.  See dartbug.com/28851.
     Comment comment = null;
     push(ast.libraryDirective(comment, metadata,
         toAnalyzerToken(libraryKeyword), name, toAnalyzerToken(semicolon)));
-    accumulateIdentifierComponents = false;
   }
 
   @override
   void handleQualified(Token period) {
     SimpleIdentifier identifier = pop();
-    if (accumulateIdentifierComponents) {
-      List<SimpleIdentifier> list = pop();
-      list.add(identifier);
-      push(list);
+    var prefix = pop();
+    if (prefix is List) {
+      // We're just accumulating components into a list.
+      prefix.add(identifier);
+      push(prefix);
+    } else if (prefix is SimpleIdentifier) {
+      // TODO(paulberry): resolve [identifier].
+      push(ast.prefixedIdentifier(prefix, toAnalyzerToken(period), identifier));
     } else {
-      var prefix = pop();
-      if (prefix is SimpleIdentifier) {
-        // TODO(paulberry): resolve [identifier].
-        push(ast.prefixedIdentifier(prefix, toAnalyzerToken(period), identifier));
-      } else {
-        // TODO(paulberry): implement.
-        logEvent('Qualified with >1 dot');
-      }
+      // TODO(paulberry): implement.
+      logEvent('Qualified with >1 dot');
     }
   }
 
   @override
   void endPart(Token partKeyword, Token semicolon) {
     debugEvent("Part");
     StringLiteral uri = pop();
     List<Annotation> metadata = pop();
     // TODO(paulberry): capture doc comments.  See dartbug.com/28851.
     Comment comment = null;
     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.
     var ofKeyword = partKeyword.next;
     List<Annotation> metadata = pop();
     // TODO(paulberry): capture doc comments.  See dartbug.com/28851.
     Comment comment = null;
     push(ast.partOfDirective(comment, metadata, toAnalyzerToken(partKeyword),
         toAnalyzerToken(ofKeyword), uri, name, toAnalyzerToken(semicolon)));
-    accumulateIdentifierComponents = false;
   }
 
   void endUnnamedFunction(Token token) {
     // TODO(paulberry): set up scopes properly to resolve parameters and type
     // variables.  Note that this is tricky due to the handling of initializers
     // in constructors, so the logic should be shared with BodyBuilder as much
     // as possible.
     debugEvent("UnnamedFunction");
     var body = _endFunctionBody();
     FormalParameterList parameters = pop();
@@ skipping 107 matching lines @@
   @override
   void endMember() {
     debugEvent("Member");
   }
 
   @override
   void handleVoidKeyword(Token token) {
     debugEvent("VoidKeyword");
     // TODO(paulberry): is this sufficient, or do we need to hook the "void"
     // keyword up to an element?
-    handleIdentifier(token);
+    handleIdentifier(token, IdentifierContext.typeReference);
     handleNoTypeArguments(token);
     endType(token, token);
   }
 
   @override
   void endFunctionTypeAlias(Token typedefKeyword, Token endToken) {
     debugEvent("FunctionTypeAlias");
     FormalParameterList parameters = pop();
     TypeParameterList typeParameters = pop();
     SimpleIdentifier name = pop();
@@ skipping 36 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);
 }