Use JS backend in serialization_analysis_test

pkg/compiler/lib/src/native/enqueue.dart

 // Copyright (c) 2014, 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 'dart:collection' show Queue;
 
 import '../common.dart';
 import '../common/backend_api.dart' show
     ForeignResolver;
 import '../common/registry.dart' show
@@ skipping 218 matching lines @@
     nativeClasses.forEach(walkPotentialSubclasses);
 
     nativeClasses.addAll(nativeClassesAndSubclasses);
     unusedClasses.addAll(nativeClassesAndSubclasses);
   }
 
   /**
    * Returns the source string of the class named in the extends clause, or
    * `null` if there is no extends clause.
    */
-  String findExtendsNameOfClass(BaseClassElementX classElement) {
+  String findExtendsNameOfClass(ClassElement classElement) {
+    if (classElement.isResolved) {
+      ClassElement superClass = classElement.superclass;
+      while (superClass != null) {
+        if (!superClass.isUnnamedMixinApplication) {
+          return superClass.name;
+        }
+        superClass = superClass.superclass;
+      }
+      return null;
+    }
+
     //  "class B extends A ... {}"  --> "A"
     //  "class B extends foo.A ... {}"  --> "A"
     //  "class B<T> extends foo.A<T,T> with M1, M2 ... {}"  --> "A"
 
     // We want to avoid calling classElement.parseNode on every class.  Doing so
     // will slightly increase parse time and size and cause compiler errors and
     // warnings to me emitted in more unused code.
 
     // An alternative to this code is to extend the API of ClassElement to
     // expose the name of the extended element.
@@ skipping 111 matching lines @@
 
   void flushQueue() {
     if (flushing) return;
     flushing = true;
     while (!queue.isEmpty) {
       (queue.removeFirst())();
     }
     flushing = false;
   }
 
-  processClass(BaseClassElementX classElement, cause) {
+  processClass(ClassElement classElement, cause) {
     // TODO(ahe): Fix this assertion to work in incremental compilation.
     assert(compiler.hasIncrementalSupport ||
            !registeredClasses.contains(classElement));
 
     bool firstTime = registeredClasses.isEmpty;
     pendingClasses.remove(classElement);
     registeredClasses.add(classElement);
 
     // TODO(ahe): Is this really a global dependency?
     classElement.ensureResolved(resolution);
@@ skipping 339 matching lines @@
         superclass,
         () => <ClassElement>[]);
     directSubtypes.add(cls);
   }
 
   void logSummary(log(message)) {
     log('Compiled ${registeredClasses.length} native classes, '
         '${unusedClasses.length} native classes omitted.');
   }
 }