Use KernelToElementMap (more) directly in KernelSsaBuilder

pkg/compiler/lib/src/kernel/element_map.dart

 // Copyright (c) 2017, 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.
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/names.dart';
 import '../constants/constructors.dart';
 import '../constants/expressions.dart';
@@ skipping 124 matching lines @@
 
   /// Compute the kind of foreign helper function called by [node], if any.
   ForeignKind getForeignKind(ir.StaticInvocation node);
 
   /// Computes the [InterfaceType] referenced by a call to the
   /// [JS_INTERCEPTOR_CONSTANT] function, if any.
   InterfaceType getInterfaceTypeForJsInterceptorCall(ir.StaticInvocation node);
 
   /// Computes the [ConstantValue] for the constant [expression].
   ConstantValue getConstantValue(ir.Expression expression);
+
+  /// Returns the `noSuchMethod` [FunctionEntity] call from a
+  /// `super.noSuchMethod` invocation within [cls].
+  FunctionEntity getSuperNoSuchMethod(ClassEntity cls);
 }
 
 /// Kinds of foreign functions.
 enum ForeignKind {
   JS,
   JS_BUILTIN,
   JS_EMBEDDED_GLOBAL,
   JS_INTERCEPTOR_CONSTANT,
   NONE,
 }
@@ skipping 310 matching lines @@
   /// Computes the native behavior for calling [procedure].
   // TODO(johnniwinther): Cache this for later use.
   native.NativeBehavior getNativeBehaviorForMethod(ir.Procedure procedure,
       {bool isJsInterop}) {
     DartType type = getFunctionType(procedure.function);
     List<ConstantValue> metadata = getMetadata(procedure.annotations);
     return nativeBehaviorBuilder.buildMethodBehavior(
         type, metadata, typeLookup(resolveAsRaw: false),
         isJsInterop: isJsInterop);
   }
+
+  @override
+  FunctionEntity getSuperNoSuchMethod(ClassEntity cls) {
+    while (cls != null) {
+      cls = elementEnvironment.getSuperClass(cls);
+      MemberEntity member =
+          elementEnvironment.lookupClassMember(cls, Identifiers.noSuchMethod_);
+      if (member != null) {
+        if (member.isFunction) {
+          FunctionEntity function = member;
+          if (function.parameterStructure.positionalParameters >= 1) {
+            return function;
+          }
+        }
+        // If [member] is not a valid `noSuchMethod` the target is
+        // `Object.superNoSuchMethod`.
+        break;
+      }
+    }
+    FunctionEntity function = elementEnvironment.lookupClassMember(
+        commonElements.objectClass, Identifiers.noSuchMethod_);
+    assert(invariant(cls, function != null,
+        message: "No super noSuchMethod found for class $cls."));
+    return function;
+  }
 }
 
 /// Visitor that converts string literals and concatenations of string literals
 /// into the string value.
 class Stringifier extends ir.ExpressionVisitor<String> {
   @override
   String visitStringLiteral(ir.StringLiteral node) => node.value;
 
   @override
   String visitStringConcatenation(ir.StringConcatenation node) {
@@ skipping 357 matching lines @@
     }
     if (isRedirecting) {
       return new RedirectingGenerativeConstantConstructor(
           defaultValues, superConstructorInvocation);
     } else {
       return new GenerativeConstantConstructor(
           type, defaultValues, fieldMap, superConstructorInvocation);
     }
   }
 }