Change how unresolved super sends are handled.

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;
 
 import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.dart'
     show
         KernelArguments,
         KernelComplexAssignment,
@@ skipping 84 matching lines @@
       [int charOffset = -1]);
 
   Expression buildStaticInvocation(Procedure target, Arguments arguments);
 
   Expression buildProblemExpression(ProblemBuilder builder, int offset);
 
   Expression throwNoSuchMethodError(
       Expression receiver, String name, Arguments arguments, int offset,
       {bool isSuper, bool isGetter, bool isSetter, bool isStatic});
 
-  Expression invokeSuperNoSuchMethod(
-      String name, Arguments arguments, int charOffset,
-      {bool isGetter, bool isSetter});
-
   bool checkArguments(FunctionNode function, Arguments arguments,
       List<TypeParameter> typeParameters);
 
   StaticGet makeStaticGet(Member readTarget, Token token);
 
   dynamic addCompileTimeError(int charOffset, String message, {bool silent});
 
   bool isIdentical(Member member);
 
   Expression buildMethodInvocation(
       Expression receiver, Name name, Arguments arguments, int offset,
       {bool isConstantExpression, bool isNullAware, bool isImplicitCall});
 
   DartType validatedTypeVariableUse(
       TypeParameterType type, int offset, bool nonInstanceAccessIsError);
 
   void warning(String message, [int charOffset]);
+
+  void warnUnresolvedSuperGet(Name name, int charOffset);
+
+  void warnUnresolvedSuperSet(Name name, int charOffset);
+
+  void warnUnresolvedSuperMethod(Name name, int charOffset);
 }
 
 abstract class FastaAccessor implements Accessor {
   BuilderHelper get helper;
 
   String get plainNameForRead;
 
   Uri get uri => helper.uri;
 
   String get plainNameForWrite => plainNameForRead;
@@ skipping 618 matching lines @@
       helper.addCompileTimeError(offset, "Not a constant expression.");
     }
     if (getter == null || isFieldOrGetter(getter)) {
       return helper.buildMethodInvocation(
           buildSimpleRead(), callName, arguments, offset,
           // This isn't a constant expression, but we have checked if a
           // constant expression error should be emitted already.
           isConstantExpression: true,
           isImplicitCall: true);
     } else {
-      return new DirectMethodInvocation(
-          new KernelThisExpression(), getter, arguments)
-        ..fileOffset = offset;
+      // TODO(ahe): This could be something like "super.property(...)" where
+      // property is a setter.
+      return internalError("Unhandled invocation ${getter.runtimeType}.",
+          helper.uri, offsetForToken(token));
     }
   }
 
-  Expression makeInvalidRead() {
-    int offset = offsetForToken(token);
-    return helper.invokeSuperNoSuchMethod(
-        plainNameForRead, new Arguments.empty()..fileOffset = offset, offset,
-        isGetter: true);
-  }
-
-  Expression makeInvalidWrite(Expression value) {
-    return helper.invokeSuperNoSuchMethod(
-        plainNameForRead,
-        new Arguments(<Expression>[value])..fileOffset = value.fileOffset,
-        offsetForToken(token),
-        isSetter: true);
-  }
-
   toString() => "SuperPropertyAccessor()";
 
   @override
   KernelComplexAssignment startComplexAssignment(Expression rhs) =>
       new KernelPropertyAssign(null, rhs, isSuper: true);
 }
 
 class ThisIndexAccessor extends kernel.ThisIndexAccessor with FastaAccessor {
   ThisIndexAccessor(BuilderHelper helper, Token token, Expression index,
       Procedure getter, Procedure setter)
@@ skipping 252 matching lines @@
     offset ??= offsetForToken(this.token);
     return helper.throwNoSuchMethodError(new NullLiteral()..fileOffset = offset,
         plainNameForRead, arguments, offset,
         isGetter: isGetter, isSetter: isSetter);
   }
 }
 
 bool isFieldOrGetter(Member member) {
   return member is Field || (member is Procedure && member.isGetter);
 }