Switch to IdentifierContext.

pkg/front_end/lib/src/fasta/kernel/body_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.body_builder;
 
 import '../parser/parser.dart' show FormalParameterType, optional;
 
 import '../parser/error_kind.dart' show ErrorKind;
 
@@ skipping 92 matching lines @@
 
   final Scope enclosingScope;
 
   final bool isDartLibrary;
 
   @override
   final Uri uri;
 
   Scope formalParameterScope;
 
-  bool isFirstIdentifier = false;
-
   bool inInitializer = false;
 
   bool inCatchClause = false;
 
   int functionNestingLevel = 0;
 
   Statement compileTimeErrorInTry;
 
   Statement compileTimeErrorInLoopOrSwitch;
 
@@ skipping 21 matching lines @@
   bool get inConstructor {
     return functionNestingLevel == 0 && member is KernelConstructorBuilder;
   }
 
   bool get isInstanceContext {
     return isInstanceMember || member is KernelConstructorBuilder;
   }
 
   @override
   void push(Object node) {
-    isFirstIdentifier = false;
     inInitializer = false;
     super.push(node);
   }
 
   Expression popForValue() => toValue(pop());
 
   Expression popForEffect() => toEffect(pop());
 
   Expression popForValueIfNotNull(Object value) {
     return value == null ? null : popForValue();
@@ skipping 541 matching lines @@
     }
     if (cls != null) {
       for (Constructor constructor in cls.constructors) {
         if (constructor.name == name) return constructor;
       }
     }
     return null;
   }
 
   @override
-  void beginExpression(Token token) {
-    debugEvent("beginExpression");
-    isFirstIdentifier = true;
-  }
-
-  @override
   void handleIdentifier(Token token, IdentifierContext context) {
     debugEvent("handleIdentifier");
     String name = token.lexeme;
-    if (isFirstIdentifier) {
+    if (context.isScopeReference) {
       assert(!inInitializer ||
           this.scope == enclosingScope ||
           this.scope.parent == enclosingScope);
       // This deals with this kind of initializer: `C(a) : a = a;`
       Scope scope = inInitializer ? enclosingScope : this.scope;
       Builder builder = scope.lookup(name, token.charOffset, uri);
       push(builderToFirstExpression(builder, name, token.charOffset));
     } else {
       push(new Identifier(name)..fileOffset = token.charOffset);
     }
@@ skipping 405 matching lines @@
   }
 
   @override
   void endLiteralMapEntry(Token colon, Token endToken) {
     debugEvent("LiteralMapEntry");
     Expression value = popForValue();
     Expression key = popForValue();
     push(new MapEntry(key, value));
   }
 
-  @override
-  void beginLiteralSymbol(Token token) {
-    isFirstIdentifier = false;
-  }
-
   String symbolPartToString(name) {
     if (name is Identifier) {
       return name.name;
     } else if (name is Operator) {
       return name.name;
     } else {
       return internalError("Unhandled: ${name.runtimeType}");
     }
   }
 
   @override
   void endLiteralSymbol(Token hashToken, int identifierCount) {
     debugEvent("LiteralSymbol");
     String value;
     if (identifierCount == 1) {
       value = symbolPartToString(popForValue());
     } else {
       List parts = popList(identifierCount);
       value = symbolPartToString(parts.first);
       for (int i = 1; i < parts.length; i++) {
         value += ".${symbolPartToString(parts[i])}";
       }
     }
     push(new SymbolLiteral(value));
   }
 
-  DartType toKernelType(String name, List<DartType> arguments, int charOffset) {
+  DartType kernelTypeFromString(
+      String name, List<DartType> arguments, int charOffset) {
     Builder builder = scope.lookup(name, charOffset, uri);
+    if (builder == null) {
+      warning("Type not found: '$name'.", charOffset);
+      return const DynamicType();
+    } else {
+      return kernelTypeFromBuilder(builder, arguments, charOffset);
+    }
+  }
+
+  DartType kernelTypeFromBuilder(
+      Builder builder, List<DartType> arguments, int charOffset) {
     if (builder is TypeDeclarationBuilder) {
       return builder.buildTypesWithBuiltArguments(library, arguments);
-    }
-    if (builder == null) {
-      warning("Type not found: '$name'.", charOffset);
+    } else if (builder.hasProblem) {
+      ProblemBuilder problem = builder;
+      addCompileTimeError(charOffset, problem.message);
     } else {
-      warning("Not a type: '$name'.", charOffset);
+      warning("Not a type: '${builder.fullNameForErrors}'.", charOffset);
     }
     // TODO(ahe): Create an error somehow.
     return const DynamicType();
   }
 
   @override
   void handleType(Token beginToken, Token endToken) {
     // TODO(ahe): The scope is wrong for return types of generic functions.
     debugEvent("Type");
     List<DartType> arguments = pop();
@@ skipping 10 matching lines @@
       if (suffix is Identifier) {
         suffix = suffix.name;
       }
       Builder builder;
       if (prefix is Builder) {
         builder = prefix;
       } else {
         builder = scope.lookup(prefix, beginToken.charOffset, uri);
       }
       if (builder is PrefixBuilder) {
-        name = builder.exports[suffix];
+        name = builderToFirstExpression(
+            builder.exports[suffix], suffix, beginToken.charOffset,
+            isPrefix: true);
       } else {
         push(const DynamicType());
         addCompileTimeError(beginToken.charOffset,
             "Can't be used as a type: '${debugName(prefix, suffix)}'.");
         return;
       }
     }
     if (name is Identifier) {
       name = name.name;
     }
     if (name is BuilderAccessor) {
       warning("'${beginToken.lexeme}' isn't a type.", beginToken.charOffset);
       push(const DynamicType());
     } else if (name is UnresolvedIdentifier) {
       warning("'${name.name}' isn't a type.", beginToken.charOffset);
       push(const DynamicType());
     } else if (name is TypeVariableBuilder) {
       push(name.buildTypesWithBuiltArguments(library, arguments));
     } else if (name is TypeDeclarationBuilder) {
       push(name.buildTypesWithBuiltArguments(library, arguments));
     } else if (name is TypeBuilder) {
       push(name.build(library));
+    } else if (name is Builder) {
+      push(kernelTypeFromBuilder(name, arguments, beginToken.charOffset));
+    } else if (name is String) {
+      push(kernelTypeFromString(name, arguments, beginToken.charOffset));
     } else {
-      push(toKernelType(name, arguments, beginToken.charOffset));
+      internalError("Unhandled: '${name.runtimeType}'.");
     }
     if (peek() is TypeParameterType) {
       TypeParameterType type = peek();
       if (!isInstanceContext && type.parameter.parent is Class) {
         pop();
         warning("Type variables can only be used in instance methods.",
             beginToken.charOffset);
         push(const DynamicType());
       }
     }
@@ skipping 456 matching lines @@
 
   @override
   void endTypeArguments(int count, Token beginToken, Token endToken) {
     debugEvent("TypeArguments");
     push(popList(count));
   }
 
   @override
   void handleThisExpression(Token token, IdentifierContext context) {
     debugEvent("ThisExpression");
-    if (isFirstIdentifier && isInstanceContext) {
+    if (context.isScopeReference && isInstanceContext) {
       push(new ThisAccessor(this, token.charOffset, inInitializer));
     } else {
       push(new IncompleteError(
           this, token.charOffset, "Expected identifier, but got 'this'."));
     }
   }
 
   @override
   void handleSuperExpression(Token token, IdentifierContext context) {
     debugEvent("SuperExpression");
-    if (isFirstIdentifier && isInstanceContext) {
+    if (context.isScopeReference && isInstanceContext) {
       Member member = this.member.target;
       member.transformerFlags |= TransformerFlag.superCalls;
       push(new ThisAccessor(this, token.charOffset, inInitializer,
           isSuper: true));
     } else {
       push(new IncompleteError(
           this, token.charOffset, "Expected identifier, but got 'super'."));
     }
   }
 
@@ skipping 990 matching lines @@
   } else if (node is PrefixBuilder) {
     return node.name;
   } else if (node is ThisAccessor) {
     return node.isSuper ? "super" : "this";
   } else if (node is BuilderAccessor) {
     return node.plainNameForRead;
   } else {
     return internalError("Unhandled: ${node.runtimeType}");
   }
 }