Handle instantiation of native classes in closed_world2_test

pkg/compiler/lib/src/resolution/resolution_strategy.dart

 // Copyright (c) 2017, 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.
 
 library dart2js.resolution_strategy;
 
 import '../common.dart';
 import '../common_elements.dart';
 import '../common/resolution.dart';
 import '../common/tasks.dart';
 import '../compiler.dart';
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../elements/resolution_types.dart';
 import '../environment.dart';
 import '../frontend_strategy.dart';
+import '../js_backend/native_data.dart';
 import '../library_loader.dart';
 import '../native/resolver.dart';
-import '../js_backend/native_data.dart';
 import '../serialization/task.dart';
 import '../patch_parser.dart';
 import '../resolved_uri_translator.dart';
 import '../universe/call_structure.dart';
 
 /// [FrontendStrategy] that loads '.dart' files and creates a resolved element
 /// model using the resolver.
 class ResolutionFrontEndStrategy implements FrontEndStrategy {
   final Compiler _compiler;
   final ElementEnvironment elementEnvironment;
@@ skipping 19 matching lines @@
         deserializer,
         patchResolverFunc,
         patchParser,
         environment,
         reporter,
         measurer);
   }
 
   AnnotationProcessor get annotationProcesser =>
       _annotationProcessor ??= new _ElementAnnotationProcessor(_compiler);
+
+  @override
+  NativeClassResolver createNativeClassResolver(
+      NativeBasicData nativeBasicData) {
+    return new ResolutionNativeClassResolver(
+        _compiler.resolution,
+        _compiler.reporter,
+        elementEnvironment,
+        _compiler.commonElements,
+        nativeBasicData);
+  }
 }
 
 /// An element environment base on a [Compiler].
 class _CompilerElementEnvironment implements ElementEnvironment {
   final Compiler _compiler;
 
   _CompilerElementEnvironment(this._compiler);
 
   LibraryProvider get _libraryProvider => _compiler.libraryLoader;
   Resolution get _resolution => _compiler.resolution;
@@ skipping 85 matching lines @@
       ClassElement cls, void f(ClassElement declarer, MemberElement member)) {
     cls.ensureResolved(_resolution);
     cls.forEachMember((ClassElement declarer, MemberElement member) {
       if (member.isSynthesized) return;
       if (member.isMalformed) return;
       f(declarer, member);
     }, includeSuperAndInjectedMembers: true);
   }
 
   @override
-  ClassEntity getSuperClass(ClassElement cls) => cls.superclass;
+  ClassEntity getSuperClass(ClassElement cls) {
+    cls.ensureResolved(_resolution);
+    return cls.superclass;
+  }
 
   @override
   void forEachSupertype(
       ClassElement cls, void f(ResolutionInterfaceType supertype)) {
     cls.allSupertypes
         .forEach((ResolutionInterfaceType supertype) => f(supertype));
   }
 
   @override
   void forEachMixin(ClassElement cls, void f(ClassElement mixin)) {
@@ skipping 141 matching lines @@
     library.forEachLocalMember((Element element) {
       if (element.isClass) {
         ClassElement cls = element;
         if (checkJsInteropAnnotation(element)) {
           nativeBasicDataBuilder.markAsJsInteropClass(cls);
         }
       }
     });
   }
 }