Implement SuperPropertySet and SuperNoSuchMethod.

pkg/compiler/lib/src/ssa/builder_kernel.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.
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../closure.dart';
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/names.dart';
@@ skipping 13 matching lines @@
 import '../js_backend/backend.dart' show JavaScriptBackend;
 import '../kernel/kernel.dart';
 import '../native/native.dart' as native;
 import '../resolution/tree_elements.dart';
 import '../tree/dartstring.dart';
 import '../tree/nodes.dart' show Node;
 import '../types/masks.dart';
 import '../universe/call_structure.dart' show CallStructure;
 import '../universe/selector.dart';
 import '../universe/side_effects.dart' show SideEffects;
-import '../universe/use.dart' show StaticUse;
+import '../universe/use.dart' show DynamicUse, StaticUse;
 import '../world.dart';
 import 'graph_builder.dart';
 import 'jump_handler.dart';
 import 'kernel_ast_adapter.dart';
 import 'kernel_string_builder.dart';
 import 'locals_handler.dart';
 import 'loop_handler.dart';
 import 'nodes.dart';
 import 'ssa_branch_builder.dart';
 import 'switch_continue_analysis.dart';
@@ skipping 1856 matching lines @@
     _pushDynamicInvocation(
         propertySet,
         astAdapter.typeOfSet(propertySet, closedWorld),
         <HInstruction>[receiver, value]);
 
     pop();
     stack.add(value);
   }
 
   @override
+  void visitSuperPropertySet(ir.SuperPropertySet propertySet) {
+    propertySet.value.accept(this);
+    HInstruction value = pop();
+
+    if (propertySet.interfaceTarget == null) {
+      _generateSuperNoSuchMethod(
+          propertySet,
+          astAdapter.getSelector(propertySet).name + "=",
+          <HInstruction>[value]);
+    } else {
+      _buildInvokeSuper(
+          astAdapter.getSelector(propertySet),
+          _containingClass(propertySet),
+          propertySet.interfaceTarget,
+          <HInstruction>[value]);
+    }
+  }
+
+  @override
   void visitVariableSet(ir.VariableSet variableSet) {
     variableSet.value.accept(this);
     HInstruction value = pop();
     _visitLocalSetter(variableSet.variable, value);
   }
 
   @override
   void visitVariableDeclaration(ir.VariableDeclaration declaration) {
     Local local = astAdapter.getLocal(declaration);
     if (declaration.initializer == null) {
@@ skipping 706 matching lines @@
   }
 
   static ir.Class _containingClass(ir.TreeNode node) {
     while (node != null) {
       if (node is ir.Class) return node;
       node = node.parent;
     }
     return null;
   }
 
-  HInstruction _buildInvokeSuper(
-      ir.Expression invocation, List<HInstruction> arguments) {
-    // Invocation is either a method invocation or a property get/set.
-    // TODO(efortuna): Common interface?
+  /// Find the applicable NoSuchMethod method for an object of this particular
+  /// class.
+  ir.Procedure _findNoSuchMethodInClass(ir.Class cls) {
+    // TODO(efortuna): If we find ourselves doing this sort of calculation
+    // often, rewrite what is done with the original element class where we call
+    // lookupSuperMember.
+    ir.Procedure noSuchMethod = null;
+    while (cls != null && cls != astAdapter.objectClass) {
+      for (ir.Procedure procedure in cls.procedures) {
+        // TODO(efortuna): Do we need to check mixin classes as well?
+        if (procedure.name.name == Identifiers.noSuchMethod_ &&
+            Selectors.noSuchMethod_
+                .signatureApplies(astAdapter.getElement(procedure))) {
+          noSuchMethod = procedure;
+        }
+      }
+      cls = cls.superclass;
+    }
+
+    if (noSuchMethod == null) {
+      // There is no matching overloaded NoSuchMethod function in the containing
+      // class. Look on the Object class itself.
+      for (ir.Procedure procedure in astAdapter.objectClass.procedures) {
+        if (procedure.name.name == Identifiers.noSuchMethod_) {
+          noSuchMethod = procedure;
+        }
+      }
+    }
+    assert(noSuchMethod != null);
+    return noSuchMethod;
+  }
+
+  void _generateSuperNoSuchMethod(ir.Expression invocation, String publicName,
+      List<HInstruction> arguments) {
+    Selector selector = astAdapter.getSelector(invocation);
+    ir.Class cls = _containingClass(invocation).superclass;
+    assert(cls != null);
+    ir.Procedure noSuchMethod = _findNoSuchMethodInClass(cls);
+    if (backend.hasInvokeOnSupport &&
+        _containingClass(noSuchMethod) != astAdapter.objectClass) {
+      // Register the call as dynamic if [noSuchMethod] on the super
+      // class is _not_ the default implementation from [Object] (it might be
+      // overridden in the super class, but it might have a different number of
+      // arguments), in case the [noSuchMethod] implementation calls
+      // [JSInvocationMirror._invokeOn].
+      // TODO(johnniwinther): Register this more precisely.
+      registry?.registerDynamicUse(new DynamicUse(selector, null));
+    }
+
+    ConstantValue nameConstant =
+        backend.constantSystem.createString(new DartString.literal(publicName));
+
+    js.Name internalName = backend.namer.invocationName(selector);
+
+    var argumentsInstruction =
+        new HLiteralList(arguments, commonMasks.extendableArrayType);
+    add(argumentsInstruction);
+
+    var argumentNames = new List<HInstruction>();
+    for (String argumentName in selector.namedArguments) {
+      ConstantValue argumentNameConstant = backend.constantSystem
+          .createString(new DartString.literal(argumentName));
+      argumentNames.add(graph.addConstant(argumentNameConstant, closedWorld));
+    }
+    var argumentNamesInstruction =
+        new HLiteralList(argumentNames, commonMasks.extendableArrayType);
+    add(argumentNamesInstruction);
+
+    ConstantValue kindConstant =
+        backend.constantSystem.createInt(selector.invocationMirrorKind);
+
+    _pushStaticInvocation(
+        astAdapter.createInvocationMirror,
+        [
+          graph.addConstant(nameConstant, closedWorld),
+          graph.addConstantStringFromName(internalName, closedWorld),
+          graph.addConstant(kindConstant, closedWorld),
+          argumentsInstruction,
+          argumentNamesInstruction
+        ],
+        commonMasks.dynamicType);
+
+    _buildInvokeSuper(Selectors.noSuchMethod_, _containingClass(invocation),
+        noSuchMethod, <HInstruction>[pop()]);
+  }
+
+  HInstruction _buildInvokeSuper(Selector selector, ir.Class containingClass,
+      ir.Member interfaceTarget, List<HInstruction> arguments) {
     // TODO(efortuna): Add source information.
-    Selector selector = astAdapter.getSelector(invocation);
     HInstruction receiver = localsHandler.readThis();
-    ir.Class surroundingClass = _containingClass(invocation);
 
     List<HInstruction> inputs = <HInstruction>[];
-    if (astAdapter.isIntercepted(invocation)) {
+    if (astAdapter.isInterceptedSelector(selector)) {
       inputs.add(_interceptorFor(receiver));
     }
     inputs.add(receiver);
     inputs.addAll(arguments);
 
-    ir.Member interfaceTarget = invocation is ir.SuperMethodInvocation
-        ? (invocation as ir.SuperMethodInvocation).interfaceTarget
-        : (invocation as ir.SuperPropertyGet).interfaceTarget;
-
     HInstruction instruction = new HInvokeSuper(
         astAdapter.getMember(interfaceTarget),
-        astAdapter.getClass(surroundingClass),
+        astAdapter.getClass(containingClass),
         selector,
         inputs,
         astAdapter.returnTypeOf(interfaceTarget),
         null,
         isSetter: selector.isSetter || selector.isIndexSet);
     instruction.sideEffects =
         closedWorld.getSideEffectsOfSelector(selector, null);
     push(instruction);
     return instruction;
   }
 
   @override
   void visitSuperPropertyGet(ir.SuperPropertyGet propertyGet) {
-    _buildInvokeSuper(propertyGet, const <HInstruction>[]);
+    if (propertyGet.interfaceTarget == null) {
+      _generateSuperNoSuchMethod(propertyGet,
+          astAdapter.getSelector(propertyGet).name, const <HInstruction>[]);
+    } else {
+      _buildInvokeSuper(
+          astAdapter.getSelector(propertyGet),
+          _containingClass(propertyGet),
+          propertyGet.interfaceTarget, const <HInstruction>[]);
+    }
   }
 
   @override
   void visitSuperMethodInvocation(ir.SuperMethodInvocation invocation) {
     List<HInstruction> arguments = _visitArgumentsForStaticTarget(
         invocation.interfaceTarget.function, invocation.arguments);
-    _buildInvokeSuper(invocation, arguments);
+    _buildInvokeSuper(astAdapter.getSelector(invocation),
+        _containingClass(invocation), invocation.interfaceTarget, arguments);
   }
 
   @override
   void visitConstructorInvocation(ir.ConstructorInvocation invocation) {
     ir.Constructor target = invocation.target;
     // TODO(sra): For JS-interop targets, process arguments differently.
     List<HInstruction> arguments =
         _visitArgumentsForStaticTarget(target.function, invocation.arguments);
     TypeMask typeMask = new TypeMask.nonNullExact(
         astAdapter.getClass(target.enclosingClass), closedWorld);
@@ skipping 424 matching lines @@
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
             kernelBuilder.wrapStatementGraph(bodyGraph),
             exception,
             kernelBuilder.wrapStatementGraph(catchGraph),
             kernelBuilder.wrapStatementGraph(finallyGraph)),
         exitBlock);
     kernelBuilder.inTryStatement = previouslyInTryStatement;
   }
 }