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 12 matching lines @@
 import '../parser/dart_vm_native.dart' show skipNativeClause;
 
 import '../scanner/token.dart'
     show BeginGroupToken, Token, isBinaryOperator, isMinusOperator;
 
 import '../errors.dart' show formatUnexpected, internalError;
 
 import '../source/scope_listener.dart'
     show JumpTargetKind, NullValue, ScopeListener;
 
-import '../builder/scope.dart' show AccessErrorBuilder, AmbiguousBuilder, Scope;
+import '../builder/scope.dart' show ProblemBuilder, Scope;
 
 import '../source/outline_builder.dart' show asyncMarkerFromTokens;
 
 import 'builder_accessors.dart';
 
 import 'frontend_accessors.dart' show buildIsNull, makeBinary, makeLet;
 
 import 'builder_accessors.dart' as builder_accessors
     show throwNoSuchMethodError;
 
@@ skipping 59 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 23 matching lines @@
         return new TypeLiteral(type);
       }
     } else if (node is TypeDeclarationBuilder) {
       return new TypeLiteral(node.buildTypesWithBuiltArguments(library, null));
     } else if (node is KernelTypeBuilder) {
       return new TypeLiteral(node.build(library));
     } else if (node is Expression) {
       return node;
     } else if (node is PrefixBuilder) {
       return buildCompileTimeError("A library can't be used as an expression.");
+    } else if (node is ProblemBuilder) {
+      return buildProblemExpression(node, -1);
     } else {
       return internalError("Unhandled: ${node.runtimeType}");
     }
   }
 
   Expression toEffect(Object node) {
     if (node is BuilderAccessor) return node.buildForEffect();
     return toValue(node);
   }
 
@@ skipping 496 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;
-  }
-
-  Builder computeSetter(
-      Builder builder, Scope scope, String name, int charOffset) {
-    if (builder.isSetter) return builder;
-    if (builder.isGetter) return scope.lookupSetter(name, charOffset, uri);
-    return builder.isField ? (builder.isFinal ? null : builder) : null;
-  }
-
-  @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 22 matching lines @@
           this, charOffset, new Name(name, library.library), null, null);
     } else if (builder.isRegularMethod) {
       assert(builder.isStatic || builder.isTopLevel);
       return new StaticAccessor(this, charOffset, builder.target, null);
     } else if (builder is PrefixBuilder) {
       return builder;
     } else if (builder is MixedAccessor) {
       return new StaticAccessor(
           this, charOffset, builder.getter.target, builder.setter.target);
     } else {
-      if (builder is AccessErrorBuilder) {
-        AccessErrorBuilder error = builder;
-        builder = error.builder;
+      if (builder.hasProblem && builder is! AccessErrorBuilder) return builder;
+      Builder setter;
+      if (builder.isSetter) {
+        setter = builder;
+      } else if (builder.isGetter) {
+        setter = scope.lookupSetter(name, charOffset, uri);
+      } else if (builder.isField && !builder.isFinal) {
+        setter = builder;
       }
-      if (builder.target == null) {
-        return internalError("Unhandled: ${builder}");
-      }
-      Member getter = builder.target.hasGetter ? builder.target : null;
-      Member setter = builder.target.hasSetter ? builder.target : null;
-      setter ??= computeSetter(builder, scope, name, charOffset)?.target;
-      return new StaticAccessor(this, charOffset, getter, setter);
+      return new StaticAccessor.fromBuilder(this, builder, charOffset, setter);
     }
   }
 
   @override
   void handleQualified(Token period) {
     debugEvent("Qualified");
     Identifier name = pop();
     var receiver = pop();
     push([receiver, name]);
   }
@@ skipping 17 matching lines @@
       Token token = pop();
       push(new StringLiteral(unescapeString(token.lexeme)));
     } else {
       List parts = popList(1 + interpolationCount * 2);
       Token first = parts.first;
       Token last = parts.last;
       Quote quote = analyzeQuote(first.lexeme);
       List<Expression> expressions = <Expression>[];
       // Contains more than just \' or \".
       if (first.lexeme.length > 1) {
-        expressions
-          .add(new StringLiteral(unescapeFirstStringPart(first.lexeme, quote)));
+        expressions.add(
+            new StringLiteral(unescapeFirstStringPart(first.lexeme, quote)));
       }
       for (int i = 1; i < parts.length - 1; i++) {
         var part = parts[i];
         if (part is Token) {
           if (part.lexeme.length != 0) {
             expressions.add(new StringLiteral(unescape(part.lexeme, quote)));
           }
         } else {
           expressions.add(toValue(part));
         }
       }
       // Contains more than just \' or \".
       if (last.lexeme.length > 1) {
         expressions
-          .add(new StringLiteral(unescapeLastStringPart(last.lexeme, quote)));
+            .add(new StringLiteral(unescapeLastStringPart(last.lexeme, quote)));
       }
       push(new StringConcatenation(expressions)
         ..fileOffset = endToken.charOffset);
     }
   }
 
   @override
   void handleScript(Token token) {
     debugEvent("Script");
   }
@@ skipping 140 matching lines @@
 
   @override
   void handleAssignmentExpression(Token token) {
     debugEvent("AssignmentExpression");
     Expression value = popForValue();
     var accessor = pop();
     if (accessor is TypeDeclarationBuilder) {
       push(wrapInvalid(new TypeLiteral(
           accessor.buildTypesWithBuiltArguments(library, null))));
     } else if (accessor is! BuilderAccessor) {
+      print(accessor);
       push(buildCompileTimeError("Can't assign to this.", token.charOffset));
     } else {
       push(new DelayedAssignment(
           this, token.charOffset, accessor, value, token.stringValue));
     }
   }
 
   @override
   void enterLoop(int charOffset) {
     if (peek() is LabelTarget) {
@@ skipping 142 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) {
     if (identical(name, "void")) return const VoidType();
     if (identical(name, "dynamic")) return const DynamicType();
     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 358 matching lines @@
     }
     if (target is Constructor) {
       return new ConstructorInvocation(target, arguments)..isConst = isConst;
     } else {
       return new StaticInvocation(target, arguments)..isConst = isConst;
     }
   }
 
   bool checkArguments(FunctionNode function, Arguments arguments,
       List<TypeParameter> typeParameters) {
-
     if (arguments.positional.length < function.requiredParameterCount ||
         arguments.positional.length > function.positionalParameters.length) {
       return false;
     }
     Map<String, VariableDeclaration> names;
     if (function.namedParameters.isNotEmpty) {
       names = <String, VariableDeclaration>{};
       for (VariableDeclaration parameter in function.namedParameters) {
         names[parameter.name] = parameter;
       }
@@ skipping 76 matching lines @@
     handleNewExpression(token);
   }
 
   @override
   void endTypeArguments(int count, Token beginToken, Token endToken) {
     debugEvent("TypeArguments");
     push(popList(count));
   }
 
   @override
-  void handleThisExpression(Token token) {
+  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) {
+  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 503 matching lines @@
     return new ExpressionStatement(buildCompileTimeError(error, charOffset));
   }
 
   @override
   Initializer buildCompileTimeErrorIntializer(error, [int charOffset = -1]) {
     return new LocalInitializer(new VariableDeclaration.forValue(
         buildCompileTimeError(error, charOffset)));
   }
 
   @override
-  Expression buildProblemExpression(Builder builder, String name) {
-    if (builder is AmbiguousBuilder) {
-      return buildCompileTimeError("Duplicated named: '$name'.");
-    } else if (builder is AccessErrorBuilder) {
-      return buildCompileTimeError("Access error: '$name'.");
-    } else {
-      return internalError("Unhandled: ${builder.runtimeType}");
-    }
+  Expression buildProblemExpression(ProblemBuilder builder, int charOffset) {
+    return buildCompileTimeError(builder.message, charOffset);
   }
 
   @override
   void handleOperator(Token token) {
     debugEvent("Operator");
     push(new Operator(token.stringValue)..fileOffset = token.charOffset);
   }
 
   @override
   void handleSymbolVoid(Token token) {
@@ skipping 99 matching lines @@
 
   final int charOffset;
 
   final BuilderAccessor accessor;
 
   ContextAccessor(this.helper, this.charOffset, this.accessor);
 
   String get plainNameForRead => internalError("Unsupported operation.");
 
   Expression doInvocation(int charOffset, Arguments arguments) {
-    print("$uri:$charOffset: Internal error: Unhandled: ${runtimeType}");
-    return internalError("Unhandled: ${runtimeType}");
+    return internalError("Unhandled: ${runtimeType}", uri, charOffset);
   }
 
   Expression buildSimpleRead();
 
   Expression buildForEffect();
 
   Expression buildAssignment(Expression value, {bool voidContext: false}) {
     return makeInvalidWrite(value);
   }
 
@@ skipping 174 matching lines @@
     users.clear();
   }
 
   void resolveGotos(SwitchCase target) {
     assert(isGotoTarget);
     for (ContinueSwitchStatement user in users) {
       user.target = target;
     }
     users.clear();
   }
+
+  @override
+  String get fullNameForErrors => "<jump-target>";
 }
 
 class LabelTarget extends Builder implements JumpTarget {
   final JumpTarget breakTarget;
 
   final JumpTarget continueTarget;
 
   final int functionNestingLevel;
 
   LabelTarget(MemberBuilder member, this.functionNestingLevel, int charOffset)
@@ skipping 31 matching lines @@
     breakTarget.resolveBreaks(target);
   }
 
   void resolveContinues(LabeledStatement target) {
     continueTarget.resolveContinues(target);
   }
 
   void resolveGotos(SwitchCase target) {
     internalError("Unsupported operation.");
   }
+
+  @override
+  String get fullNameForErrors => "<label-target>";
 }
 
 class OptionalFormals {
   final FormalParameterType kind;
 
   final List<VariableDeclaration> formals;
 
   OptionalFormals(this.kind, this.formals);
 }
 
@@ skipping 94 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}");
   }
 }