Assert that we don't mix K and J elements

pkg/compiler/lib/src/closure.dart

 // Copyright (c) 2012, 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 'common/names.dart' show Identifiers;
 import 'common/resolution.dart' show ParsingContext, Resolution;
 import 'common/tasks.dart' show CompilerTask, Measurer;
 import 'common.dart';
 import 'compiler.dart' show Compiler;
 import 'constants/expressions.dart';
 import 'elements/elements.dart';
 import 'elements/entities.dart';
 import 'elements/entity_utils.dart' as utils;
 import 'elements/modelx.dart'
     show BaseFunctionElementX, ClassElementX, ElementX;
 import 'elements/resolution_types.dart';
 import 'elements/types.dart';
 import 'elements/visitor.dart' show ElementVisitor;
 import 'js_backend/js_backend.dart' show JavaScriptBackend;
+import 'js_backend/runtime_types.dart';
 import 'resolution/tree_elements.dart' show TreeElements;
 import 'package:front_end/src/fasta/scanner.dart' show Token;
 import 'tree/tree.dart';
 import 'util/util.dart';
 import 'world.dart' show ClosedWorldRefiner;
 
 // TODO(johnniwinther,efortuna): Split [ClosureConversionTask] from
 // [ClosureDataLookup].
 abstract class ClosureConversionTask<T> extends CompilerTask
     implements ClosureDataLookup<T> {
@@ skipping 831 matching lines @@
   // The closureData of the currentFunctionElement.
   ClosureClassMap closureData;
 
   bool insideClosure = false;
 
   ClosureTranslator(this.compiler, this.closedWorldRefiner, this.elements,
       this.closureMappingCache, this.closureInfo);
 
   DiagnosticReporter get reporter => compiler.reporter;
 
+  RuntimeTypesNeed get rtiNeed => closedWorldRefiner.closedWorld.rtiNeed;
+
   /// Generate a unique name for the [id]th closure field, with proposed name
   /// [name].
   ///
   /// The result is used as the name of [ClosureFieldElement]s, and must
   /// therefore be unique to avoid breaking an invariant in the element model
   /// (classes cannot declare multiple fields with the same name).
   ///
   /// Also, the names should be distinct from real field names to prevent
   /// clashes with selectors for those fields.
   ///
@@ skipping 313 matching lines @@
       } else {
         useTypeVariableAsLocal(typeVariable);
       }
     });
   }
 
   void analyzeType(ResolutionDartType type) {
     // TODO(johnniwinther): Find out why this can be null.
     if (type == null) return;
     if (outermostElement.isClassMember &&
-        compiler.backend.rtiNeed
-            .classNeedsRti(outermostElement.enclosingClass)) {
+        rtiNeed.classNeedsRti(outermostElement.enclosingClass)) {
       if (outermostElement.isConstructor || outermostElement.isField) {
         analyzeTypeVariables(type);
       } else if (outermostElement.isInstanceMember) {
         if (type.containsTypeVariables) {
           registerNeedsThis();
         }
       }
     }
   }
 
@@ skipping 172 matching lines @@
 
     insideClosure = outermostElement != null;
     LocalFunctionElement closure;
     executableContext = element;
     bool needsRti = false;
     if (insideClosure) {
       closure = element;
       closures.add(closure);
       closureData = globalizeClosure(node, closure);
       needsRti = compiler.options.enableTypeAssertions ||
-          compiler.backend.rtiNeed.localFunctionNeedsRti(closure);
+          rtiNeed.localFunctionNeedsRti(closure);
     } else {
       outermostElement = element;
       ThisLocal thisElement = null;
       if (element.isInstanceMember || element.isGenerativeConstructor) {
         MemberElement member = element;
         thisElement = new ThisLocal(member);
       }
       closureData = new ClosureClassMap(null, null, null, thisElement);
       if (element is MethodElement) {
         needsRti = compiler.options.enableTypeAssertions ||
-            compiler.backend.rtiNeed.methodNeedsRti(element);
+            rtiNeed.methodNeedsRti(element);
       }
     }
     closureMappingCache[element] = closureData;
     closureMappingCache[element.declaration] = closureData;
     if (closureData.callMethod != null) {
       closureMappingCache[closureData.callMethod] = closureData;
     }
 
     inNewScope(node, () {
       // If the method needs RTI, or checked mode is set, we need to
@@ skipping 105 matching lines @@
 ///
 /// Move the below classes to a JS model eventually.
 ///
 abstract class JSEntity implements MemberEntity {
   Local get declaredEntity;
 }
 
 abstract class PrivatelyNamedJSEntity implements JSEntity {
   Entity get rootOfScope;
 }