Handle unresolved identifiers with an accessor.

pkg/front_end/lib/src/fasta/kernel/fasta_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.fasta_accessors;
 
 export 'package:kernel/frontend/accessors.dart' show wrapInvalid;
 
 import 'package:kernel/frontend/accessors.dart'
     show Accessor, buildIsNull, makeLet;
@@ skipping 70 matching lines @@
 
   Expression makeInvalidRead() {
     return buildThrowNoSuchMethodError(new Arguments.empty(), isGetter: true);
   }
 
   Expression makeInvalidWrite(Expression value) {
     return buildThrowNoSuchMethodError(new Arguments(<Expression>[value]),
         isSetter: true);
   }
 
-  /* Expression | FastaAccessor */ doInvocation(
+  /* Expression | FastaAccessor | Initializer */ doInvocation(
       int offset, Arguments arguments);
 
   /* Expression | FastaAccessor */ buildPropertyAccess(
       IncompleteSend send, bool isNullAware) {
     if (send is SendAccessor) {
       return buildMethodInvocation(
           buildSimpleRead(), send.name, send.arguments, send.offset,
           isNullAware: isNullAware);
     } else {
       return PropertyAccessor.make(helper, send.offset, buildSimpleRead(),
           send.name, null, null, isNullAware);
     }
   }
 
   /* Expression | FastaAccessor */ buildThrowNoSuchMethodError(
       Arguments arguments,
       {bool isSuper: false,
-      isGetter: false,
-      isSetter: false,
+      bool isGetter: false,
+      bool isSetter: false,
       String name,
       int offset}) {
     return helper.throwNoSuchMethodError(
         name ?? plainNameForWrite, arguments, offset ?? this.offset,
         isGetter: isGetter, isSetter: isSetter, isSuper: isSuper);
   }
 
   bool get isThisPropertyAccessor => false;
 }
 
-abstract class CompileTimeErrorAccessor implements FastaAccessor {
+abstract class ErrorAccessor implements FastaAccessor {
   @override
   Expression get builtBinary => internalError("Unsupported operation.");
 
   @override
   void set builtBinary(Expression expression) {
     internalError("Unsupported operation.");
   }
 
   @override
   Expression get builtGetter => internalError("Unsupported operation.");
 
   @override
   void set builtGetter(Expression expression) {
     internalError("Unsupported operation.");
   }
 
-  Expression buildError();
+  /// Pass [arguments] that must be evaluated before throwing an error.  At
+  /// most one of [isGetter] and [isSetter] should be true and they're passed
+  /// to [BuilderHelper.buildThrowNoSuchMethodError] if it is used.
+  Expression buildError(Arguments arguments,
+      {bool isGetter: false, bool isSetter: false, int offset});
 
   Name get name => internalError("Unsupported operation.");
 
+  @override
   String get plainNameForRead => name.name;
 
   withReceiver(Object receiver, {bool isNullAware}) => this;
 
+  @override
   Initializer buildFieldInitializer(
       Map<String, FieldInitializer> initializers) {
-    return new LocalInitializer(new VariableDeclaration.forValue(buildError()));
+    return new LocalInitializer(new VariableDeclaration.forValue(
+        buildError(new Arguments.empty(), isSetter: true)));
   }
 
-  doInvocation(int offset, Arguments arguments) => this;
+  @override
+  doInvocation(int offset, Arguments arguments) {
+    return buildError(arguments, offset: offset);
+  }
 
+  @override
   buildPropertyAccess(IncompleteSend send, bool isNullAware) => this;
 
+  @override
   buildThrowNoSuchMethodError(Arguments arguments,
       {bool isSuper: false,
       isGetter: false,
       isSetter: false,
       String name,
       int offset}) {
     return this;
   }
 
+  @override
   Expression buildAssignment(Expression value, {bool voidContext: false}) {
-    return buildError();
+    return buildError(new Arguments(<Expression>[value]), isSetter: true);
   }
 
+  @override
   Expression buildCompoundAssignment(Name binaryOperator, Expression value,
       {int offset: TreeNode.noOffset,
       bool voidContext: false,
       Procedure interfaceTarget}) {
-    return buildError();
+    return buildError(new Arguments(<Expression>[value]), isGetter: true);
   }
 
+  @override
   Expression buildPrefixIncrement(Name binaryOperator,
       {int offset: TreeNode.noOffset,
       bool voidContext: false,
       Procedure interfaceTarget}) {
-    return buildError();
+    return buildError(new Arguments(<Expression>[new IntLiteral(1)]),
+        isGetter: true);
   }
 
+  @override
   Expression buildPostfixIncrement(Name binaryOperator,
       {int offset: TreeNode.noOffset,
       bool voidContext: false,
       Procedure interfaceTarget}) {
-    return buildError();
+    return buildError(new Arguments(<Expression>[new IntLiteral(1)]),
+        isGetter: true);
   }
 
+  @override
   Expression buildNullAwareAssignment(Expression value, DartType type,
       {bool voidContext: false}) {
-    return buildError();
+    return buildError(new Arguments(<Expression>[value]), isSetter: true);
   }
 
-  Expression buildSimpleRead() => buildError();
+  @override
+  Expression buildSimpleRead() =>
+      buildError(new Arguments.empty(), isGetter: true);
 
-  Expression makeInvalidRead() => buildError();
+  @override
+  Expression makeInvalidRead() =>
+      buildError(new Arguments.empty(), isGetter: true);
 
-  Expression makeInvalidWrite(Expression value) => buildError();
+  @override
+  Expression makeInvalidWrite(Expression value) {
+    return buildError(new Arguments(<Expression>[value]), isSetter: true);
+  }
 }
 
 class ThisAccessor extends FastaAccessor {
   final BuilderHelper helper;
 
   final int offset;
 
   final bool isInitializer;
 
   final bool isSuper;
@@ skipping 145 matching lines @@
   Expression get builtGetter => internalError("Unsupported operation.");
 
   @override
   void set builtGetter(Expression expression) {
     internalError("Unsupported operation.");
   }
 
   withReceiver(Object receiver, {bool isNullAware});
 }
 
-class IncompleteError extends IncompleteSend with CompileTimeErrorAccessor {
+class IncompleteError extends IncompleteSend with ErrorAccessor {
   final Object error;
 
   IncompleteError(BuilderHelper helper, int offset, this.error)
       : super(helper, offset, null);
 
-  Expression buildError() {
-    return helper.buildCompileTimeError(error, offset);
+  @override
+  Expression buildError(Arguments arguments,
+      {bool isGetter: false, bool isSetter: false, int offset}) {
+    return helper.buildCompileTimeError(error, offset ?? this.offset);
   }
+
+  @override
+  doInvocation(int offset, Arguments arguments) => this;
 }
 
 class SendAccessor extends IncompleteSend {
   final Arguments arguments;
 
   SendAccessor(BuilderHelper helper, int offset, Name name, this.arguments)
       : super(helper, offset, name) {
     assert(arguments != null);
   }
 
@@ skipping 18 matching lines @@
     }
     if (receiver is PrefixBuilder) {
       PrefixBuilder prefix = receiver;
       receiver = helper.builderToFirstExpression(
           prefix.exports[name.name], "${prefix.name}.${name.name}", offset);
       return helper.finishSend(receiver, arguments, offset);
     }
     Expression result;
     if (receiver is KernelClassBuilder) {
       Builder builder = receiver.findStaticBuilder(name.name, offset, uri);
-      if (builder == null) {
+      if (builder == null || builder is AccessErrorBuilder) {
         return buildThrowNoSuchMethodError(arguments);
       }
       if (builder.hasProblem) {
         result = helper.buildProblemExpression(builder, offset);
       } else {
         Member target = builder.target;
         if (target != null) {
           if (target is Field) {
             result = buildMethodInvocation(new StaticGet(target), callName,
                 arguments, offset + (target.name?.name?.length ?? 0),
@@ skipping 373 matching lines @@
   ParenthesizedExpression(
       BuilderHelper helper, Expression expression, int offset)
       : super(helper, expression, "<a parenthesized expression>", offset);
 
   Expression makeInvalidWrite(Expression value) {
     return helper.buildCompileTimeError(
         "Can't assign to a parenthesized expression.", offset);
   }
 }
 
+class UnresolvedAccessor extends FastaAccessor with ErrorAccessor {
+  @override
+  final int offset;
+
+  @override
+  final BuilderHelper helper;
+
+  @override
+  final Name name;
+
+  UnresolvedAccessor(this.helper, this.name, this.offset);
+
+  Expression doInvocation(int charOffset, Arguments arguments) {
+    return buildError(arguments, offset: charOffset);
+  }
+
+  @override
+  Expression buildError(Arguments arguments,
+      {bool isGetter: false, bool isSetter: false, int offset}) {
+    return helper.throwNoSuchMethodError(
+        plainNameForRead, arguments, offset ?? this.offset,
+        isGetter: isGetter, isSetter: isSetter);
+  }
+}
+
 bool isFieldOrGetter(Member member) {
   return member is Field || (member is Procedure && member.isGetter);
 }
 
 Expression buildMethodInvocation(
     Expression receiver, Name name, Arguments arguments, int offset,
     {bool isNullAware: false}) {
   if (isNullAware) {
     VariableDeclaration variable = new VariableDeclaration.forValue(receiver);
     return makeLet(
         variable,
         new ConditionalExpression(
             buildIsNull(new VariableGet(variable)),
             new NullLiteral(),
             new MethodInvocation(new VariableGet(variable), name, arguments)
               ..fileOffset = offset,
             const DynamicType()));
   } else {
     return new MethodInvocation(receiver, name, arguments)..fileOffset = offset;
   }
 }