Work around for private names in mixin applications.

lib/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.
 
 library rasta.kernel_visitor;
 
 import 'package:kernel/ast.dart' as ir;
 
 import 'package:kernel/frontend/accessors.dart' show
     Accessor,
@@ skipping 289 matching lines @@
           currentElement.enclosingClass.asInstanceOf(superclass);
       // Once we have [supertype], we know how to substitute S with T: the type
       // arguments of [supertype] corresponds to T, and the type variables of
       // its element correspond to S.
       type = type.subst(
           supertype.typeArguments, supertype.element.typeVariables);
     }
     return kernel.typeToIr(type);
   }
 
+  // TODO(ahe): Hack. Fix dart2js instead.
+  ir.Name nameToIrName(Name name) {
+    assert(
+        !name.isPrivate ||
+        name.library.implementation == currentElement.library.implementation);
+    return kernel.irName(name.text, currentElement);
+  }
+
   List<ir.DartType> computeTypesFromTypes(NodeList nodes, {int expected}) {
     if (expected == null) {
       throw "[expected] is null";
     }
     List<ir.DartType> types = new List<ir.DartType>(expected);
     Iterator<Node> iterator = nodes?.iterator;
     for (int i = 0; i < expected; i++) {
       TypeAnnotation type = null;
       if (iterator != null && iterator.moveNext()) {
         type = iterator.current;
@@ skipping 10 matching lines @@
 
   ir.DartType computeTypeFromTypes(NodeList node) {
     return computeTypesFromTypes(node, expected: 1).single;
   }
 
   ir.MethodInvocation buildInvokeSelector(
       ir.Expression receiver,
       Selector selector,
       ir.Arguments arguments) {
     return new ir.MethodInvocation(
-        receiver, kernel.nameToIrName(selector.memberName), arguments);
+        receiver, nameToIrName(selector.memberName), arguments);
   }
 
   ir.MethodInvocation buildCall(
       ir.Expression receiver,
       CallStructure callStructure,
       NodeList arguments) {
     return buildInvokeSelector(
         receiver, callStructure.callSelector, buildArguments(arguments));
   }
 
@@ skipping 933 matching lines @@
     return new ir.InvalidExpression();
   }
 
   @override
   ir.PropertyGet visitDynamicPropertyGet(
       Send node,
       Node receiver,
       Name name,
       _) {
     return new ir.PropertyGet(
-        visitForValue(receiver), kernel.nameToIrName(name));
+        visitForValue(receiver), nameToIrName(name));
   }
 
   @override
   ir.MethodInvocation visitDynamicPropertyInvoke(
       Send node,
       Node receiver,
       NodeList arguments,
       Selector selector,
       _) {
     return buildInvokeSelector(
         visitForValue(receiver), selector, buildArguments(arguments));
   }
 
   @override
   ir.Expression handleDynamicCompounds(
       Send node,
       Node receiver,
       Name name,
       CompoundRhs rhs,
       _) {
     ir.Expression receiverNode = receiver == null
         ? new ir.ThisExpression() : visitForValue(receiver);
     return buildCompound(
-        PropertyAccessor.make(receiverNode, kernel.nameToIrName(name)), rhs);
+        PropertyAccessor.make(receiverNode, nameToIrName(name)), rhs);
   }
 
   @override
   ir.PropertySet visitDynamicPropertySet(
       SendSet node,
       Node receiver,
       Name name,
       Node rhs,
       _) {
     ir.Expression value = visitForValue(rhs);
     return new ir.PropertySet(
-        visitForValue(receiver), kernel.nameToIrName(name), value);
+        visitForValue(receiver), nameToIrName(name), value);
   }
 
   @override
   ir.Expression handleDynamicSetIfNulls(
       Send node,
       Node receiver,
       Name name,
       Node rhs,
       _) {
-    ir.Name irName = kernel.nameToIrName(name);
+    ir.Name irName = nameToIrName(name);
     Accessor accessor = (receiver == null)
         ? new ThisPropertyAccessor(irName)
         : PropertyAccessor.make(visitForValue(receiver), irName);
     return accessor.buildNullAwareAssignment(
         visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
   ir.TypeLiteral visitDynamicTypeLiteralGet(
       Send node,
@@ skipping 219 matching lines @@
       ConstructorElement constructor,
       InterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       _) {
     return buildConstructorInvoke(node, isConst: false);
   }
 
   Accessor buildNullAwarePropertyAccessor(Node receiver, Name name) {
     return new NullAwarePropertyAccessor(
-        visitForValue(receiver), kernel.nameToIrName(name));
+        visitForValue(receiver), nameToIrName(name));
   }
 
   @override
   ir.Expression visitIfNotNullDynamicPropertyGet(
       Send node,
       Node receiver,
       Name name,
       _) {
     return buildNullAwarePropertyAccessor(receiver, name).buildSimpleRead();
   }
@@ skipping 1126 matching lines @@
   @override
   ir.MethodInvocation visitThisInvoke(
       Send node,
       NodeList arguments,
       CallStructure callStructure,
       _) {
     return buildCall(new ir.ThisExpression(), callStructure, arguments);
   }
 
   Accessor buildThisPropertyAccessor(Name name) {
-    return new ThisPropertyAccessor(kernel.nameToIrName(name));
+    return new ThisPropertyAccessor(nameToIrName(name));
   }
 
   @override
   ir.Expression visitThisPropertyGet(Send node, Name name, _) {
     return buildThisPropertyAccessor(name).buildSimpleRead();
   }
 
   @override
   ir.MethodInvocation visitThisPropertyInvoke(
       Send node,
@@ skipping 292 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)";
   }
 }