Null diff to AST based version of finishClasses.

dart/sdk/lib/_internal/compiler/implementation/js_backend/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;
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
@@ skipping 271 matching lines @@
 function(collectedClasses) {
   var hasOwnProperty = Object.prototype.hasOwnProperty;
   for (var cls in collectedClasses) {
     if (hasOwnProperty.call(collectedClasses, cls)) {
       var desc = collectedClasses[cls];
 '''/* The 'fields' are either a constructor function or a string encoding
       fields, constructor and superclass.  Get the superclass and the fields
       in the format Super;field1,field2 from the null-string property on the
       descriptor. */'''
       var fields = desc[''], supr;
-      if (typeof fields == 'string') {
-        var s = fields.split(';'); supr = s[0];
-        fields = s[1] == '' ? [] : s[1].split(',');
+      if (typeof fields == "string") {
+        var s = fields.split(";");
+        supr = s[0];
+        fields = s[1] == "" ? [] : s[1].split(",");
       } else {
-        supr = desc['super'];
+        supr = desc.super;
       }
       $isolatePropertiesName[cls] = $defineClassName(cls, fields, desc);
-      if (supr) $pendingClassesName[cls] = supr;
+      if (supr)
+        $pendingClassesName[cls] = supr;
     }
   }
   var pendingClasses = $pendingClassesName;
 '''/* FinishClasses can be called multiple times. This means that we need to
       clear the pendingClasses property. */'''
   $pendingClassesName = {};
   var finishedClasses = {};
   function finishClass(cls) {
 '''/* Opera does not support 'getOwnPropertyNames'. Therefore we use
       hasOwnProperty instead. */'''
     var hasOwnProperty = Object.prototype.hasOwnProperty;
-    if (hasOwnProperty.call(finishedClasses, cls)) return;
+    if (hasOwnProperty.call(finishedClasses, cls))
+      return;
     finishedClasses[cls] = true;
     var superclass = pendingClasses[cls];
 '''/* The superclass is only false (empty string) for Dart's Object class. */'''
-    if (!superclass) return;
+    if (!superclass)
+      return;
     finishClass(superclass);
     var constructor = $isolatePropertiesName[cls];
     var superConstructor = $isolatePropertiesName[superclass];
     var prototype = constructor.prototype;
     if ($supportsProtoName) {
       prototype.__proto__ = superConstructor.prototype;
       prototype.constructor = constructor;
     } else {
-      function tmp() {};
+      function tmp() {
+      }
       tmp.prototype = superConstructor.prototype;
       var newPrototype = new tmp();
       constructor.prototype = newPrototype;
       newPrototype.constructor = constructor;
       for (var member in prototype) {
-        if (!member) continue;  '''/* Short version of: if (member == '') */'''
+        if (!member)
+          continue;'''/* Short version of: if (member == '') */'''
+
         if (hasOwnProperty.call(prototype, member)) {
           newPrototype[member] = prototype[member];
         }
       }
     }
   }
-  for (var cls in pendingClasses) finishClass(cls);
+  for (var cls in pendingClasses) {
+    finishClass(cls);
+  }
 }''';
   }
 
   String get finishIsolateConstructorFunction {
     String isolate = namer.isolateName;
     // We replace the old Isolate function with a new one that initializes
     // all its field with the initial (and often final) value of all globals.
     // This has two advantages:
     //   1. the properties are in the object itself (thus avoiding to go through
     //      the prototype when looking up globals.
@@ skipping 2001 matching lines @@
 """;
 const String HOOKS_API_USAGE = """
 // The code supports the following hooks:
 // dartPrint(message)   - if this function is defined it is called
 //                        instead of the Dart [print] method.
 // dartMainRunner(main) - if this function is defined, the Dart [main]
 //                        method will not be invoked directly.
 //                        Instead, a closure that will invoke [main] is
 //                        passed to [dartMainRunner].
 """;