Assert that we don't mix K and J elements

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;
 import '../common/names.dart';
@@ skipping 274 matching lines @@
     ClassEntity cls = _elementMap.getClass(constructedClass);
     InterfaceType thisType = _elementMap.elementEnvironment.getThisType(cls);
     _worldBuilder.forEachInstanceField(cls,
         (ClassEntity enclosingClass, FieldEntity member) {
       var value = fieldValues[member];
       assert(value != null, 'No value for field ${member}');
       constructorArguments.add(value);
     });
 
     // Create the runtime type information, if needed.
-    bool hasRtiInput = backend.rtiNeed.classNeedsRtiField(cls);
+    bool hasRtiInput = closedWorld.rtiNeed.classNeedsRtiField(cls);
     if (hasRtiInput) {
       // Read the values of the type arguments and create a HTypeInfoExpression
       // to set on the newly create object.
       List<HInstruction> typeArguments = <HInstruction>[];
       for (ir.DartType typeParameter
           in constructedClass.thisType.typeArguments) {
         HInstruction argument = localsHandler.readLocal(localsHandler
             .getTypeVariableAsLocal(_elementMap.getDartType(typeParameter)));
         typeArguments.add(argument);
       }
@@ skipping 44 matching lines @@
       // If there are locals that escape (i.e. mutated in closures), we pass the
       // box to the constructor.
       ClosureScope scopeData = closureDataLookup
           .getClosureScope(constructorElement.resolvedAst.node);
       if (scopeData.requiresContextBox) {
         bodyCallInputs.add(localsHandler.readLocal(scopeData.context));
       }
 
       // Pass type arguments.
       ir.Class currentClass = body.enclosingClass;
-      if (backend.rtiNeed.classNeedsRti(_elementMap.getClass(currentClass))) {
+      if (closedWorld.rtiNeed
+          .classNeedsRti(_elementMap.getClass(currentClass))) {
         for (ir.DartType typeParameter in currentClass.thisType.typeArguments) {
           HInstruction argument = localsHandler.readLocal(localsHandler
               .getTypeVariableAsLocal(_elementMap.getDartType(typeParameter)
                   as ResolutionTypeVariableType));
           bodyCallInputs.add(argument);
         }
       }
 
       _invokeConstructorBody(body, bodyCallInputs);
     }
@@ skipping 2009 matching lines @@
           generateUnsupportedError(
               invocation,
               '${function.enclosingClass.name}.${function.name} '
               'can only be used as a const constructor');
         }
         return;
       }
 
       // Factory constructors take type parameters; other static methods ignore
       // them.
-      if (backend.rtiNeed.classNeedsRti(function.enclosingClass)) {
+      if (closedWorld.rtiNeed.classNeedsRti(function.enclosingClass)) {
         _addTypeArguments(arguments, invocation.arguments);
       }
     }
 
     _pushStaticInvocation(function, arguments, typeMask);
   }
 
   void handleInvokeStaticForeign(
       ir.StaticInvocation invocation, ir.Procedure target) {
     String name = target.name.name;
@@ skipping 657 matching lines @@
       ConstantValue constant = _elementMap.getConstantValue(invocation);
       stack.add(graph.addConstant(constant, closedWorld));
       return;
     }
 
     // TODO(sra): For JS-interop targets, process arguments differently.
     List<HInstruction> arguments =
         _visitArgumentsForStaticTarget(target.function, invocation.arguments);
     ConstructorEntity constructor = _elementMap.getConstructor(target);
     ClassEntity cls = constructor.enclosingClass;
-    if (backend.rtiNeed.classNeedsRti(cls)) {
+    if (closedWorld.rtiNeed.classNeedsRti(cls)) {
       _addTypeArguments(arguments, invocation.arguments);
     }
     TypeMask typeMask = new TypeMask.nonNullExact(cls, closedWorld);
     InterfaceType type = _elementMap.createInterfaceType(
         target.enclosingClass, invocation.arguments.types);
     addImplicitInstantiation(type);
     _pushStaticInvocation(constructor, arguments, typeMask);
     removeImplicitInstantiation(type);
   }
 
@@ skipping 427 matching lines @@
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
             kernelBuilder.wrapStatementGraph(bodyGraph),
             exception,
             kernelBuilder.wrapStatementGraph(catchGraph),
             kernelBuilder.wrapStatementGraph(finallyGraph)),
         exitBlock);
     kernelBuilder.inTryStatement = previouslyInTryStatement;
   }
 }