Switch to IdentifierContext.

pkg/front_end/lib/src/fasta/kernel/builder_accessors.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.builder_accessors;
 
 export 'frontend_accessors.dart' show wrapInvalid;
 
 import 'frontend_accessors.dart' show Accessor;
 
 import 'package:kernel/ast.dart';
 
 import 'package:kernel/core_types.dart' show CoreTypes;
 
+import '../builder/scope.dart' show AccessErrorBuilder, ProblemBuilder;
+
 import '../errors.dart' show internalError, printUnexpected;
 
 import 'frontend_accessors.dart' as kernel
     show
         IndexAccessor,
         NullAwarePropertyAccessor,
         PropertyAccessor,
         StaticAccessor,
         SuperIndexAccessor,
         SuperPropertyAccessor,
@@ skipping 22 matching lines @@
   builderToFirstExpression(Builder builder, String name, int charOffset);
 
   finishSend(Object receiver, Arguments arguments, int charOffset);
 
   Expression buildCompileTimeError(error, [int charOffset]);
 
   Initializer buildCompileTimeErrorIntializer(error, [int charOffset]);
 
   Expression buildStaticInvocation(Procedure target, Arguments arguments);
 
-  Expression buildProblemExpression(Builder builder, String name);
+  Expression buildProblemExpression(ProblemBuilder builder, int charOffset);
 }
 
 abstract class BuilderAccessor implements Accessor {
   BuilderHelper get helper;
 
   int get charOffset;
 
   String get plainNameForRead;
 
   Uri get uri => helper.uri;
@@ skipping 272 matching lines @@
           prefix.exports[name.name], "${prefix.name}.${name.name}", charOffset);
       return helper.finishSend(receiver, arguments, charOffset);
     }
     Expression result;
     if (receiver is KernelClassBuilder) {
       Builder builder = receiver.findStaticBuilder(name.name, charOffset, uri);
       if (builder == null) {
         return buildThrowNoSuchMethodError(arguments);
       }
       if (builder.hasProblem) {
-        result = helper.buildProblemExpression(builder, name.name);
+        result = helper.buildProblemExpression(builder, charOffset);
       } else {
         Member target = builder.target;
         if (target != null) {
           if (target is Field) {
             result = buildMethodInvocation(
                 new StaticGet(target), new Name("call"), arguments, charOffset,
                 isNullAware: isNullAware);
           } else {
             result = helper.buildStaticInvocation(target, arguments);
           }
@@ skipping 59 matching lines @@
     if (receiver is BuilderAccessor) {
       return receiver.buildPropertyAccess(this, isNullAware);
     }
     if (receiver is PrefixBuilder) {
       PrefixBuilder prefix = receiver;
       return helper.builderToFirstExpression(
           prefix.exports[name.name], name.name, charOffset);
     }
     if (receiver is KernelClassBuilder) {
       Builder builder = receiver.findStaticBuilder(name.name, charOffset, uri);
-      Member getter = builder?.target;
-      Member setter;
       if (builder == null) {
-        builder = receiver.findStaticBuilder(name.name, charOffset, uri,
+        // If we find a setter, [builder] is an [AccessErrorBuilder], not null.
+        return buildThrowNoSuchMethodError(null);
+      }
+      Builder setter;
+      if (builder.isSetter) {
+        setter = builder;
+      } else if (builder.isGetter) {
+        setter = receiver.findStaticBuilder(name.name, charOffset, uri,
             isSetter: true);
-        if (builder == null) {
-          return buildThrowNoSuchMethodError(null);
-        }
-        setter = builder.target;
+      } else if (builder.isField && !builder.isFinal) {
+        setter = builder;
       }
-      if (builder.hasProblem) {
-        return helper.buildProblemExpression(builder, name.name)
-          ..fileOffset = charOffset;
-      }
-      if (getter is Field) {
-        if (!getter.isFinal && !getter.isConst) {
-          setter = getter;
-        }
-      } else if (getter is Procedure) {
-        if (getter.isGetter) {
-          builder = receiver.findStaticBuilder(name.name, charOffset, uri,
-              isSetter: true);
-          if (builder != null && !builder.hasProblem) {
-            setter = builder.target;
-          }
-        }
-      }
-      if (getter == null && setter == null) {
-        return internalError("No accessor for '$name'.");
-      }
-      return new StaticAccessor(helper, charOffset, getter, setter);
+      return new StaticAccessor.fromBuilder(
+          helper,
+          builder,
+          charOffset,
+          setter);
     }
     return PropertyAccessor.make(helper, charOffset, helper.toValue(receiver),
         name, null, null, isNullAware);
   }
 
   Expression buildNullAwareAssignment(Expression value, DartType type,
       {bool voidContext: false}) {
     return internalError("Unhandled");
   }
 
@@ skipping 95 matching lines @@
   final BuilderHelper helper;
 
   final int charOffset;
 
   StaticAccessor(
       this.helper, this.charOffset, Member readTarget, Member writeTarget)
       : super(readTarget, writeTarget) {
     assert(readTarget != null || writeTarget != null);
   }
 
+  factory StaticAccessor.fromBuilder(BuilderHelper helper, Builder builder,
+      int charOffset, Builder builderSetter) {
+    if (builder is AccessErrorBuilder) {
+      AccessErrorBuilder error = builder;
+      builder = error.builder;
+      // We should only see an access error here if we've looked up a setter
+      // when not explicitly looking for a setter.
+      assert(builder.isSetter);
+    } else if (builder.target == null) {
+      return internalError("Unhandled: ${builder}");
+    }
+    Member getter = builder.target.hasGetter ? builder.target : null;
+    Member setter = builder.target.hasSetter ? builder.target : null;
+    if (setter == null) {
+      if (builderSetter?.target?.hasSetter ?? false) {
+        setter = builderSetter.target;
+      }
+    }
+    return new StaticAccessor(helper, charOffset, getter, setter);
+  }
+
   String get plainNameForRead => (readTarget ?? writeTarget).name.name;
 
   Expression doInvocation(int charOffset, Arguments arguments) {
     if (readTarget == null || isFieldOrGetter(readTarget)) {
       return buildMethodInvocation(
           buildSimpleRead(), new Name("call"), arguments, charOffset);
     } else {
       return helper.buildStaticInvocation(readTarget, arguments)
         ..fileOffset = charOffset;
     }
@@ skipping 132 matching lines @@
     return buildMethodInvocation(buildSimpleRead(), new Name("call"), arguments,
         charOffset + (variable.name?.length ?? 0));
   }
 
   toString() => "VariableAccessor()";
 }
 
 Expression throwNoSuchMethodError(String name, Arguments arguments, Uri uri,
     int charOffset, CoreTypes coreTypes,
     {bool isSuper: false, isGetter: false, isSetter: false}) {
-  printUnexpected(uri, charOffset, "Method not found: '$name'.");
+  String errorName = name;
+  if (isSuper) {
+    errorName = "super.$name";
+  }
+  if (isGetter) {
+    printUnexpected(uri, charOffset, "Getter not found: '$errorName'.");
+  } else if (isSetter) {
+    printUnexpected(uri, charOffset, "Setter not found: '$errorName'.");
+  } else {
+    printUnexpected(uri, charOffset, "Method not found: '$name'.");
+  }
   Constructor constructor =
       coreTypes.getClass("dart:core", "NoSuchMethodError").constructors.first;
   return new Throw(new ConstructorInvocation(
       constructor,
       new Arguments(<Expression>[
         new NullLiteral(),
         new SymbolLiteral(name),
         new ListLiteral(arguments.positional),
         new MapLiteral(arguments.named.map((arg) {
           return new MapEntry(new SymbolLiteral(arg.name), arg.value);
@@ skipping 17 matching lines @@
             buildIsNull(new VariableGet(variable)),
             new NullLiteral(),
             new MethodInvocation(new VariableGet(variable), name, arguments)
               ..fileOffset = charOffset,
             const DynamicType()));
   } else {
     return new MethodInvocation(receiver, name, arguments)
       ..fileOffset = charOffset;
   }
 }