Handle NativeTypedArray in closed_world_from_dill_test

pkg/compiler/lib/src/kernel/element_map_impl.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.kernel.element_map;
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/names.dart' show Identifiers;
@@ skipping 100 matching lines @@
   bool checkFamily(Entity entity);
 
   DartTypes get types => _types;
 
   @override
   ElementEnvironment get elementEnvironment => _elementEnvironment;
 
   @override
   CommonElements get commonElements => _commonElements;
 
+  /// NativeBasicData is need for computation of the default super class.
+  NativeBasicData get nativeBasicData;
+
   FunctionEntity get _mainFunction {
     return _env.mainMethod != null ? _getMethod(_env.mainMethod) : null;
   }
 
   LibraryEntity get _mainLibrary {
     return _env.mainMethod != null
         ? _getLibrary(_env.mainMethod.enclosingLibrary)
         : null;
   }
 
@@ skipping 169 matching lines @@
         data.interfaces = const <InterfaceType>[];
       } else {
         InterfaceType processSupertype(ir.Supertype node) {
           InterfaceType supertype = _typeConverter.visitSupertype(node);
           IndexedClass superclass = supertype.element;
           ClassData superdata = _classData[superclass.classIndex];
           _ensureSupertypes(superclass, superdata);
           return supertype;
         }
 
-        data.supertype = processSupertype(node.supertype);
+        InterfaceType supertype = processSupertype(node.supertype);
+        if (supertype == _commonElements.objectType) {
+          ClassEntity defaultSuperclass =
+              _commonElements.getDefaultSuperclass(cls, nativeBasicData);
+          data.supertype = _elementEnvironment.getRawType(defaultSuperclass);
+        } else {
+          data.supertype = supertype;
+        }
         LinkBuilder<InterfaceType> linkBuilder =
             new LinkBuilder<InterfaceType>();
         if (node.mixedInType != null) {
           data.isMixinApplication = true;
           linkBuilder
               .addLast(data.mixedInType = processSupertype(node.mixedInType));
         } else {
           data.isMixinApplication = false;
         }
         node.implementedTypes.forEach((ir.Supertype supertype) {
@@ skipping 700 matching lines @@
 }
 
 /// Implementation of [KernelToElementMapForImpact] that only supports world
 /// impact computation.
 class KernelToElementMapForImpactImpl extends KernelToElementMapBase
     with
         KernelToElementMapForImpactMixin,
         ElementCreatorMixin,
         KElementCreatorMixin {
   native.BehaviorBuilder _nativeBehaviorBuilder;
+  FrontendStrategy _frontendStrategy;
 
-  KernelToElementMapForImpactImpl(
-      DiagnosticReporter reporter, Environment environment)
+  KernelToElementMapForImpactImpl(DiagnosticReporter reporter,
+      Environment environment, this._frontendStrategy)
       : super(reporter, environment);
 
   @override
   bool checkFamily(Entity entity) {
     assert(
         '$entity'.startsWith(kElementPrefix),
         failedAt(entity,
             "Unexpected entity $entity, expected family $kElementPrefix."));
     return true;
   }
 
+  @override
+  NativeBasicData get nativeBasicData => _frontendStrategy.nativeBasicData;
+
   /// Adds libraries in [program] to the set of libraries.
   ///
   /// The main method of the first program is used as the main method for the
   /// compilation.
   void addProgram(ir.Program program) {
     _env.addProgram(program);
   }
 
   @override
   native.BehaviorBuilder get nativeBehaviorBuilder =>
@@ skipping 734 matching lines @@
         // codegen world should be a strict subset of the resolution world and
         // creating elements for IR nodes should therefore not be needed.
         // Currently some are created purely for testing (like
         // `element == commonElements.foo`, where 'foo' might not be live).
         // Others are created because we do a
         // `elementEnvironment.forEachLibraryMember(...)` call on each emitted
         // library.
         ElementCreatorMixin
     implements
         KernelToWorldBuilder {
+  NativeBasicData nativeBasicData;
+
   JsKernelToElementMap(DiagnosticReporter reporter, Environment environment,
       KernelToElementMapForImpactImpl _elementMap)
       : super(reporter, environment) {
     _env = _elementMap._env;
     for (int libraryIndex = 0;
         libraryIndex < _elementMap._libraryEnvs.length;
         libraryIndex++) {
       LibraryEnv env = _elementMap._libraryEnvs[libraryIndex];
       LibraryData data = _elementMap._libraryData[libraryIndex];
       LibraryEntity oldLibrary = _elementMap._libraryList[libraryIndex];
@@ skipping 185 matching lines @@
       if (data.constructorBody != null) {
         f(data.constructorBody);
       }
     });
   }
 
   String getDeferredUri(ir.LibraryDependency node) {
     throw new UnimplementedError('JsKernelToElementMap.getDeferredUri');
   }
 }