Perform MixinFullResolution before baseline test.

pkg/compiler/lib/src/kernel/kernel_visitor.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.md file.
 
 import 'package:kernel/ast.dart' as ir;
 import 'package:kernel/frontend/accessors.dart'
     show
         Accessor,
         IndexAccessor,
         NullAwarePropertyAccessor,
         PropertyAccessor,
         ReadOnlyAccessor,
         StaticAccessor,
         SuperIndexAccessor,
         SuperPropertyAccessor,
         ThisPropertyAccessor,
         VariableAccessor,
         buildIsNull,
         makeBinary,
         makeLet,
         makeOrReuseVariable;
+import 'package:kernel/transformations/flags.dart';
 
 import '../common.dart';
 import '../constants/expressions.dart'
     show
         BoolFromEnvironmentConstantExpression,
         ConstantExpression,
         ConstructedConstantExpression,
         IntFromEnvironmentConstantExpression,
         StringFromEnvironmentConstantExpression,
         TypeConstantExpression;
@@ skipping 144 matching lines @@
         UnavailableVisitor,
         UnresolvedVisitor,
         KernelError
     implements
         SemanticVisitor,
         SemanticSendVisitor,
         SemanticDeclarationVisitor {
   TreeElements elements;
   AstElement currentElement;
   final Kernel kernel;
+  int transformerFlags = 0;
 
   final Map<JumpTarget, ir.LabeledStatement> continueTargets =
       <JumpTarget, ir.LabeledStatement>{};
 
   final Map<JumpTarget, ir.SwitchCase> continueSwitchTargets =
       <JumpTarget, ir.SwitchCase>{};
 
   final Map<JumpTarget, ir.LabeledStatement> breakTargets =
       <JumpTarget, ir.LabeledStatement>{};
 
@@ skipping 1991 matching lines @@
 
   @override
   ir.InvocationExpression visitStringFromEnvironmentConstructorInvoke(
       NewExpression node, StringFromEnvironmentConstantExpression constant, _) {
     return buildConstructorInvoke(node, isConst: true);
   }
 
   @override
   ir.SuperMethodInvocation visitSuperBinary(Send node, FunctionElement function,
       BinaryOperator operator, Node argument, _) {
+    transformerFlags |= TransformerFlag.superCalls;
     return new ir.SuperMethodInvocation(
         kernel.irName(operator.selectorName, currentElement),
         new ir.Arguments(<ir.Expression>[visitForValue(argument)]),
         kernel.functionToIr(function));
   }
 
   @override
   ir.Expression visitSuperCompoundIndexSet(
       SendSet node,
       MethodElement getter,
@@ skipping 20 matching lines @@
     if (kernel.isSyntheticError(superConstructor)) {
       // TODO(ahe): Semantic visitor shouldn't call in this case.
       return new ir.InvalidInitializer();
     }
     return new ir.SuperInitializer(
         kernel.functionToIr(superConstructor), buildArguments(arguments));
   }
 
   ir.SuperMethodInvocation buildSuperEquals(
       FunctionElement function, Node argument) {
+    transformerFlags |= TransformerFlag.superCalls;
     return new ir.SuperMethodInvocation(
         kernel.irName(function.name, function),
         new ir.Arguments(<ir.Expression>[visitForValue(argument)],
             types: null, named: null),
         kernel.functionToIr(function));
   }
 
   @override
   ir.SuperMethodInvocation visitSuperEquals(
       Send node, FunctionElement function, Node argument, _) {
@@ skipping 59 matching lines @@
   }
 
   @override
   ir.Expression visitSuperFieldSet(
       SendSet node, FieldElement field, Node rhs, _) {
     return buildSuperPropertyAccessor(field)
         .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
   Accessor buildSuperPropertyAccessor(Element getter, [Element setter]) {
+    transformerFlags |= TransformerFlag.superCalls;
     if (setter == null &&
         getter.isField &&
         !getter.isFinal &&
         !getter.isConst) {
       setter = getter;
     }
     Element element = getter ?? setter;
     return new SuperPropertyAccessor(
         kernel.irName(element.name, element),
         (getter == null) ? null : kernel.elementToIr(getter),
@@ skipping 80 matching lines @@
         .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
   ir.Expression visitSuperMethodGet(Send node, MethodElement method, _) {
     return buildSuperPropertyAccessor(method).buildSimpleRead();
   }
 
   ir.SuperMethodInvocation buildSuperMethodInvoke(
       MethodElement method, NodeList arguments) {
+    transformerFlags |= TransformerFlag.superCalls;
     return new ir.SuperMethodInvocation(kernel.irName(method.name, method),
         buildArguments(arguments), kernel.functionToIr(method));
   }
 
   @override
   ir.SuperMethodInvocation visitSuperMethodIncompatibleInvoke(
       Send node,
       MethodElement method,
       NodeList arguments,
       CallStructure callStructure,
@@ skipping 39 matching lines @@
   @override
   ir.Expression visitSuperSetterSet(
       SendSet node, FunctionElement setter, Node rhs, _) {
     return buildSuperPropertyAccessor(null, setter)
         .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
   ir.SuperMethodInvocation visitSuperUnary(
       Send node, UnaryOperator operator, FunctionElement function, _) {
+    transformerFlags |= TransformerFlag.superCalls;
     return new ir.SuperMethodInvocation(kernel.irName(function.name, function),
         new ir.Arguments.empty(), kernel.functionToIr(function));
   }
 
   @override
   ir.Initializer visitThisConstructorInvoke(
       Send node,
       ConstructorElement thisConstructor,
       NodeList arguments,
       CallStructure callStructure,
@@ skipping 282 matching lines @@
       : this(null, true, node, initializers);
 
   accept(ir.Visitor v) => throw "unsupported";
 
   visitChildren(ir.Visitor v) => throw "unsupported";
 
   String toString() {
     return "IrFunction($kind, $isConstructor, $node, $initializers)";
   }
 }