Revert "Generate native class metadata as a JavaScript AST."

sdk/lib/_internal/compiler/implementation/js_backend/native_emitter.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.
 
 part of js_backend;
 
 class NativeEmitter {
 
   CodeEmitterTask emitter;
   CodeBuffer nativeBuffer;
@@ skipping 303 matching lines @@
     // The sets could be much smaller if we could make assumptions about the
     // cls tags of other classes (which are constructor names or part of the
     // result of Object.protocls.toString).  For example, if objects that are
     // Dart objects could be easily excluded, then we might be able to simplify
     // the test, replacing dozens of HTMLxxxElement classes with the regexp
     // /HTML.*Element/.
 
     // Temporary variables for common substrings.
     List<String> varNames = <String>[];
     // var -> expression
-    Map<String, js.Expression> varDefns = <String, js.Expression>{};
+    Map<String, String> varDefns = <String, String>{};
     // tag -> expression (a string or a variable)
-    Map<ClassElement, js.Expression> tagDefns =
-        new Map<ClassElement, js.Expression>();
+    Map<ClassElement, String> tagDefns = new Map<ClassElement, String>();
 
     String makeExpression(ClassElement classElement) {
       // Expression fragments for this set of cls keys.
-      List<js.Expression> expressions = <js.Expression>[];
+      List<String> expressions = <String>[];
       // TODO: Remove if cls is abstract.
       List<String> subtags = [toNativeName(classElement)];
       void walk(ClassElement cls) {
         for (final ClassElement subclass in getDirectSubclasses(cls)) {
           ClassElement tag = subclass;
           String existing = tagDefns[tag];
           if (existing == null) {
             subtags.add(toNativeName(tag));
             walk(subclass);
           } else {
             if (varDefns.containsKey(existing)) {
               expressions.add(existing);
             } else {
-              String varName = 'v${varNames.length}_${tag.name.slowToString()}';
+              String varName = 'v${varNames.length}/*${tag}*/';
               varNames.add(varName);
               varDefns[varName] = existing;
-              tagDefns[tag] = new js.VariableUse(varName);
-              expressions.add(new js.VariableUse(varName));
+              tagDefns[tag] = varName;
+              expressions.add(varName);
             }
           }
         }
       }
       walk(classElement);
-      if (!subtags.isEmpty) {
-        expressions.add(
-            new js.LiteralString("'${Strings.join(subtags, '|')}'"));
-      }
-      js.Expression expression;
+      String constantPart = "'${Strings.join(subtags, '|')}'";
+      if (constantPart != "''") expressions.add(constantPart);
+      String expression;
       if (expressions.length == 1) {
         expression = expressions[0];
       } else {
-        js.Expression array = new js.ArrayInitializer.from(expressions);
-        expression = new js.Call(
-            new js.PropertyAccess.field(array, 'join'),
-            [new js.LiteralString("'|'")]);
+        expression = "[${Strings.join(expressions, ',')}].join('|')";
       }
       return expression;
     }
 
     for (final ClassElement classElement in dispatchClasses) {
       tagDefns[classElement] = makeExpression(classElement);
     }
 
     // Write out a thunk that builds the metadata.
     if (!tagDefns.isEmpty) {
-      List<js.Statement> statements = <js.Statement>[];
-      List<js.Expression> initializations = <js.Expression>[];
+      nativeBuffer.add('(function(){\n');
+
       for (final String varName in varNames) {
-        initializations.add(
-            new js.VariableInitialization(
-                new js.VariableDeclaration(varName),
-                varDefns[varName]));
+        nativeBuffer.add('  var ${varName} = ${varDefns[varName]};\n');
       }
 
-      statements.add(
-          new js.ExpressionStatement(
-              new js.VariableDeclarationList(initializations)));
+      nativeBuffer.add('  var table = [\n');
+      nativeBuffer.add(
+          '    // [dynamic-dispatch-tag, '
+          'tags of classes implementing dynamic-dispatch-tag]');
+      bool needsComma = false;
+      List<String> entries = <String>[];
+      for (final ClassElement cls in dispatchClasses) {
+        String clsName = toNativeName(cls);
+        entries.add("\n    ['$clsName', ${tagDefns[cls]}]");
+      }
+      nativeBuffer.add(Strings.join(entries, ','));
+      nativeBuffer.add('];\n');
+      nativeBuffer.add('$dynamicSetMetadataName(table);\n');
 
-      // [table] is a list of lists, each inner list of the form:
-      //   [dynamic-dispatch-tag, tags-of-classes-implementing-dispatch-tag]
-      // E.g.
-      //   [['Node', 'Text|HTMLElement|HTMLDivElement|...'], ...]
-      js.Expression table =
-          new js.ArrayInitializer.from(
-              dispatchClasses.map((cls) =>
-                  new js.ArrayInitializer.from([
-                      new js.LiteralString("'${toNativeName(cls)}'"),
-                      tagDefns[cls]])));
-
-      //  $.dynamicSetMetadata(table);
-      statements.add(
-          new js.ExpressionStatement(
-              new js.Call(
-                  new js.VariableUse(dynamicSetMetadataName),
-                  [table])));
-
-      //  (function(){statements})();
-      nativeBuffer.add(
-          js.prettyPrint(
-              new js.ExpressionStatement(
-                  new js.Call(new js.Fun([], new js.Block(statements)), [])),
-              compiler));
+      nativeBuffer.add('})();\n');
     }
   }
 
   bool isSupertypeOfNativeClass(Element element) {
     if (element.isTypeVariable()) {
       compiler.cancel("Is check for type variable", element: element);
       return false;
     }
     if (element.computeType(compiler).unalias(compiler) is FunctionType) {
       // The element type is a function type either directly or through
@@ skipping 73 matching lines @@
         if (!first) targetBuffer.add(",\n");
         targetBuffer.add(" $name: $function");
         first = false;
       });
       targetBuffer.add("\n});\n\n");
     }
     targetBuffer.add(nativeBuffer);
     targetBuffer.add('\n');
   }
 }