Move throwNoSuchMethodError to BodyBuilder.

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 '../errors.dart' show internalError;
 
 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,
         ThisIndexAccessor,
         ThisPropertyAccessor,
         VariableAccessor;
 
 import 'frontend_accessors.dart' show buildIsNull, makeLet;
 
 import 'kernel_builder.dart'
     show Builder, KernelClassBuilder, PrefixBuilder, TypeDeclarationBuilder;
 
 abstract class BuilderHelper {
   Uri get uri;
 
-  CoreTypes get coreTypes;
-
   Constructor lookupConstructor(Name name, {bool isSuper});
 
   Expression toSuperMethodInvocation(MethodInvocation node);
 
   Expression toValue(node);
 
   Member lookupSuperMember(Name name, {bool isSetter: false});
 
   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(ProblemBuilder builder, int charOffset);
+
+  Expression throwNoSuchMethodError(
+      String name, Arguments arguments, int charOffset,
+      {bool isSuper: false, isGetter: false, isSetter: false});
 }
 
 abstract class BuilderAccessor implements Accessor {
   BuilderHelper get helper;
 
   int get charOffset;
 
   String get plainNameForRead;
 
   Uri get uri => helper.uri;
 
-  CoreTypes get coreTypes => helper.coreTypes;
-
   String get plainNameForWrite => plainNameForRead;
 
   Expression buildForEffect() => buildSimpleRead();
 
   Initializer buildFieldInitializer(
       Map<String, FieldInitializer> initializers) {
     // TODO(ahe): This error message is really bad.
     return helper.buildCompileTimeErrorIntializer(
         "Can't use $plainNameForRead here.", charOffset);
   }
 
   Expression makeInvalidRead() {
-    return throwNoSuchMethodError(
-        plainNameForRead, new Arguments.empty(), uri, charOffset, coreTypes,
-        isGetter: true);
+    return buildThrowNoSuchMethodError(new Arguments.empty(), isGetter: true);
   }
 
   Expression makeInvalidWrite(Expression value) {
-    return throwNoSuchMethodError(plainNameForWrite,
-        new Arguments(<Expression>[value]), uri, charOffset, coreTypes,
+    return buildThrowNoSuchMethodError(new Arguments(<Expression>[value]),
         isSetter: true);
   }
 
-  TreeNode doInvocation(int charOffset, Arguments arguments);
+  /* Expression | BuilderAccessor */ doInvocation(
+      int charOffset, Arguments arguments);
 
-  buildPropertyAccess(IncompleteSend send, bool isNullAware) {
+  /* Expression | BuilderAccessor */ buildPropertyAccess(
+      IncompleteSend send, bool isNullAware) {
     if (send is SendAccessor) {
       return buildMethodInvocation(
           buildSimpleRead(), send.name, send.arguments, send.charOffset,
           isNullAware: isNullAware);
     } else {
       return PropertyAccessor.make(helper, send.charOffset, buildSimpleRead(),
           send.name, null, null, isNullAware);
     }
   }
 
-  Expression buildThrowNoSuchMethodError(Arguments arguments) {
-    bool isGetter = false;
-    if (arguments == null) {
-      arguments = new Arguments.empty();
-      isGetter = true;
-    }
-    return throwNoSuchMethodError(
-        plainNameForWrite, arguments, uri, charOffset, coreTypes,
-        isGetter: isGetter);
+  /* Expression | BuilderAccessor */ buildThrowNoSuchMethodError(
+      Arguments arguments,
+      {bool isSuper: false,
+      isGetter: false,
+      isSetter: false,
+      String name,
+      int charOffset}) {
+    return helper.throwNoSuchMethodError(
+        name ?? plainNameForWrite, arguments, charOffset ?? this.charOffset,
+        isGetter: isGetter, isSetter: isSetter, isSuper: isSuper);
   }
 
   bool get isThisPropertyAccessor => false;
 }
 
-abstract class CompileTimeErrorAccessor implements Accessor {
+abstract class CompileTimeErrorAccessor implements BuilderAccessor {
   Expression buildError();
 
   Name get name => internalError("Unsupported operation.");
 
   String get plainNameForRead => name.name;
 
   withReceiver(Object receiver, {bool isNullAware}) => this;
 
   Initializer buildFieldInitializer(
       Map<String, FieldInitializer> initializers) {
     return new LocalInitializer(new VariableDeclaration.forValue(buildError()));
   }
 
   doInvocation(int charOffset, Arguments arguments) => this;
 
   buildPropertyAccess(IncompleteSend send, bool isNullAware) => this;
 
-  buildThrowNoSuchMethodError(Arguments arguments) => this;
+  buildThrowNoSuchMethodError(Arguments arguments,
+      {bool isSuper: false,
+      isGetter: false,
+      isSetter: false,
+      String name,
+      int charOffset}) {
+    return this;
+  }
 
   Expression buildAssignment(Expression value, {bool voidContext: false}) {
     return buildError();
   }
 
   Expression buildCompoundAssignment(
       Name binaryOperator, Expression value, int charOffset,
       {bool voidContext: false, Procedure interfaceTarget}) {
     return buildError();
   }
@@ skipping 82 matching lines @@
           new ThisExpression(), new Name("call"), arguments, charOffset);
     }
   }
 
   Initializer buildConstructorInitializer(
       int charOffset, Name name, Arguments arguments) {
     Constructor constructor = helper.lookupConstructor(name, isSuper: isSuper);
     Initializer result;
     if (constructor == null) {
       result = new LocalInitializer(new VariableDeclaration.forValue(
-          throwNoSuchMethodError(
-              name.name, arguments, uri, charOffset, coreTypes,
-              isSuper: isSuper)));
+          buildThrowNoSuchMethodError(arguments,
+              isSuper: isSuper, name: name.name, charOffset: charOffset)));
     } else if (isSuper) {
       result = new SuperInitializer(constructor, arguments);
     } else {
       result = new RedirectingInitializer(constructor, arguments);
     }
     return result..fileOffset = charOffset;
   }
 
   Expression buildAssignment(Expression value, {bool voidContext: false}) {
     return buildAssignmentError();
@@ skipping 172 matching lines @@
     }
     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);
       if (builder == null) {
         // If we find a setter, [builder] is an [AccessErrorBuilder], not null.
-        return buildThrowNoSuchMethodError(null);
+        return buildThrowNoSuchMethodError(new Arguments.empty(),
+            isGetter: true);
       }
       Builder setter;
       if (builder.isSetter) {
         setter = builder;
       } else if (builder.isGetter) {
         setter = receiver.findStaticBuilder(name.name, charOffset, uri,
             isSetter: true);
       } else if (builder.isField && !builder.isFinal) {
         setter = builder;
       }
@@ skipping 271 matching lines @@
   Expression doInvocation(int charOffset, Arguments arguments) {
     // Normally the offset is at the start of the token, but in this case,
     // because we insert a '.call', we want it at the end instead.
     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}) {
-  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);
-        }).toList()),
-        new NullLiteral()
-      ])));
-}
-
 bool isFieldOrGetter(Member member) {
   return member is Field || (member is Procedure && member.isGetter);
 }
 
 Expression buildMethodInvocation(
     Expression receiver, Name name, Arguments arguments, int charOffset,
     {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 = charOffset,
             const DynamicType()));
   } else {
     return new MethodInvocation(receiver, name, arguments)
       ..fileOffset = charOffset;
   }
 }