Improve NSM handling.

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 '../fasta_codes.dart'
     show FastaMessage, codeExpectedButGot, codeExpectedFunctionBody;
 
 import '../parser/parser.dart' show FormalParameterType, MemberKind, optional;
@@ skipping 767 matching lines @@
           // remove the next line:
           result =
               new KernelSuperMethodInvocation(node.name, node.arguments, null);
           return result;
         } else {
           isNoSuchMethod = true;
         }
       }
     }
     if (isNoSuchMethod) {
-      return throwNoSuchMethodError(
-          node.name.name, node.arguments, node.fileOffset,
-          isSuper: true);
+      return invokeSuperNoSuchMethod(
+          node.name.name, node.arguments, node.fileOffset);
     }
     Expression receiver = new KernelDirectPropertyGet(
         new ThisExpression()..fileOffset = node.fileOffset, target);
     // TODO(ahe): Use [DirectPropertyGet] when possible, that is, remove the
     // next line:
     receiver = new KernelSuperPropertyGet(node.name, target);
     return buildMethodInvocation(
         receiver, callName, node.arguments, node.fileOffset);
   }
 
   bool areArgumentsCompatible(FunctionNode function, Arguments arguments) {
     // TODO(ahe): Implement this.
     return true;
   }
 
   @override
   Expression throwNoSuchMethodError(
-      String name, Arguments arguments, int charOffset,
-      {bool isSuper: false, isGetter: false, isSetter: false}) {
+      Expression receiver, String name, Arguments arguments, int charOffset,
+      {bool isSuper: false,
+      bool isGetter: false,
+      bool isSetter: false,
+      bool isStatic: false}) {
     String errorName = isSuper ? "super.$name" : name;
     String message;
     if (isGetter) {
       message = "Getter not found: '$errorName'.";
     } else if (isSetter) {
       message = "Setter not found: '$errorName'.";
     } else {
       message = "Method not found: '$errorName'.";
     }
     if (constantExpressionRequired) {
       return buildCompileTimeError(message, charOffset);
     }
     warning(message, charOffset);
-    Constructor constructor =
-        coreTypes.noSuchMethodErrorClass.constructors.first;
-    return new Throw(new ConstructorInvocation(
-        constructor,
-        new KernelArguments(<Expression>[
-          new KernelNullLiteral(),
-          new SymbolLiteral(name),
-          new ListLiteral(arguments.positional),
-          new MapLiteral(arguments.named.map((arg) {
-            return new MapEntry(new SymbolLiteral(arg.name), arg.value);
-          }).toList()),
-          new KernelNullLiteral()
-        ])));
+    return new Throw(library.loader.instantiateNoSuchMethodError(
+        receiver, name, arguments, charOffset,
+        isMethod: !isGetter && !isSetter,
+        isGetter: isGetter,
+        isSetter: isSetter,
+        isStatic: isStatic,
+        isTopLevel: !isStatic && !isSuper));
   }
 
   @override
+  Expression invokeSuperNoSuchMethod(
+      String name, Arguments arguments, int charOffset,
+      {bool isGetter: false, bool isSetter: false}) {
+    String errorName = "super.$name";
+    String message;
+    if (isGetter) {
+      message = "Getter not found: '$errorName'.";
+      name = "get:$name";
+    } else if (isSetter) {
+      message = "Setter not found: '$errorName'.";
+      name = "set:$name";
+    } else {
+      message = "Method not found: '$errorName'.";
+    }
+    warning(message, charOffset);
+    VariableDeclaration value;
+    if (isSetter) {
+      value = new VariableDeclaration.forValue(arguments.positional.single,
+          isFinal: true)
+        ..fileOffset = charOffset;
+      arguments = new Arguments(<Expression>[
+        new VariableGet(value)..fileOffset = arguments.fileOffset
+      ]);
+    }
+    Expression result = new SuperMethodInvocation(
+        noSuchMethodName,
+        new Arguments(<Expression>[
+          library.loader.instantiateInvocation(
+              new ThisExpression()..fileOffset = charOffset,
+              name,
+              arguments,
+              charOffset,
+              true)
+        ])
+          ..fileOffset = arguments.fileOffset);
+    if (isSetter) {
+      result = new Let(
+          value,
+          new Let(
+              new VariableDeclaration.forValue(result, isFinal: true)
+                ..fileOffset = charOffset,
+              new VariableGet(value)..fileOffset = value.fileOffset))
+        ..fileOffset = charOffset;
+    }
+    return result;
+  }
+
+  @override
   Member lookupSuperMember(Name name, {bool isSetter: false}) {
     Class superclass = classBuilder.cls.superclass;
     return superclass == null
         ? null
         : hierarchy.getDispatchTarget(superclass, name, setter: isSetter);
   }
 
   @override
   Constructor lookupConstructor(Name name, {bool isSuper}) {
     Class cls = classBuilder.cls;
@@ skipping 1066 matching lines @@
 
   @override
   Expression buildStaticInvocation(Member target, Arguments arguments,
       {bool isConst: false, int charOffset: -1, Member initialTarget}) {
     List<TypeParameter> typeParameters = target.function.typeParameters;
     if (target is Constructor) {
       assert(!target.enclosingClass.isAbstract);
       typeParameters = target.enclosingClass.typeParameters;
     }
     if (!checkArguments(target.function, arguments, typeParameters)) {
-      return throwNoSuchMethodError(target.name.name, arguments, charOffset);
+      return throwNoSuchMethodError(new NullLiteral()..fileOffset = charOffset,
+          target.name.name, arguments, charOffset);
     }
     if (target is Constructor) {
       return new KernelConstructorInvocation(target, initialTarget, arguments,
           isConst: isConst)
         ..fileOffset = charOffset;
     } else if (target is Procedure && target.kind == ProcedureKind.Factory) {
       return new KernelFactoryConstructorInvocation(
           target, initialTarget, arguments,
           isConst: isConst)
         ..fileOffset = charOffset;
@@ skipping 128 matching lines @@
               charOffset: nameToken.charOffset,
               initialTarget: initialTarget));
           return;
         } else {
           errorName = debugName(type.name, name);
         }
       } else {
         errorName = debugName(getNodeName(type), name);
       }
       errorName ??= name;
-      push(throwNoSuchMethodError(errorName, arguments, nameToken.charOffset));
+      push(throwNoSuchMethodError(
+          new NullLiteral()..fileOffset = token.charOffset,
+          errorName,
+          arguments,
+          nameToken.charOffset));
     }();
     constantExpressionRequired = savedConstantExpressionRequired;
   }
 
   @override
   void endConstExpression(Token token) {
     debugEvent("endConstExpression");
     endNewExpression(token);
   }
 
@@ skipping 1240 matching lines @@
     if (starToken == null) {
       return AsyncMarker.Async;
     } else {
       assert(identical(starToken.stringValue, "*"));
       return AsyncMarker.AsyncStar;
     }
   } else {
     return internalError("Unknown async modifier: $asyncToken");
   }
 }