dart2js: Dot-separated field-and-super descriptor string in class definitions.

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 117 matching lines @@
     }
     if (needsSetter) {
       var setterString = "this." + field + " = v;";
       prototype["set\$" + field] = new Function("v", setterString);
     }
     return field;
   }""";
   }
 
   String get defineClassFunction {
-    // First the class name, then the super class name, followed by the fields
-    // (in an array) and the members (inside an Object literal).
+    // First the class name, then the field names in an array and the members
+    // (inside an Object literal).
     // The caller can also pass in the constructor as a function if needed.
     //
     // Example:
-    // defineClass("A", "B", ["x", "y"], {
+    // defineClass("A", ["x", "y"], {

[karlklose, 2012/11/30 11:43:34]

Shouldn't this be
  defineClass("A":"B@x.y", {
?

[erikcorry, 2012/11/30 12:05:57]

No, this is called from finishClassesFunction, where we have separated the field
names out into parts.

[ngeoffray, 2012/11/30 12:11:46]

So where is B in defineClass now?

[erikcorry, 2012/11/30 12:20:02]

We don't need the superclass here, so it's nowhere.

     //  foo$1: function(y) {
     //   print(this.x + y);
     //  },
     //  bar$2: function(t, v) {
     //   this.x = t - v;
     //  },
     // });
     return """
 function(cls, fields, prototype) {
   var generateGetterSetter = $generateGetterSetterFunction;
@@ skipping 53 matching lines @@
     //    constructor.
     // For engines where we have access to the '__proto__' we can manipulate
     // the object literal directly. For other engines we have to create a new
     // object and copy over the members.
     return '''
 function(collectedClasses) {
   var hasOwnProperty = Object.prototype.hasOwnProperty;
   for (var cls in collectedClasses) {
     if (hasOwnProperty.call(collectedClasses, cls)) {
       var desc = collectedClasses[cls];
-'''/* If the class does not have any declared fields (in the ''
-      property of the description), then provide an empty list of fields. */'''
-      $isolatePropertiesName[cls] = $defineClassName(cls, desc[''] || [], desc);
-      if (desc['super'] !== "") $pendingClassesName[cls] = desc['super'];
+'''/* Get the superclass and the fields in the format Super@field1.field2 from
+      the null-string property on the descriptor. */'''
+      var s = desc[''].split('@'), supr = s[0];
+      var fields = s[1] == '' ? [] : s[1].split('.');
+      $isolatePropertiesName[cls] = $defineClassName(cls, fields, desc);
+      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. */'''
@@ skipping 10 matching lines @@
     if ($supportsProtoName) {
       prototype.__proto__ = superConstructor.prototype;
       prototype.constructor = constructor;
     } else {
       function tmp() {};
       tmp.prototype = superConstructor.prototype;
       var newPrototype = new tmp();
       constructor.prototype = newPrototype;
       newPrototype.constructor = constructor;
       for (var member in prototype) {
-        if (member == '' || member == 'super') continue;
+        if (!member) continue;  '''/* if (member == '') */'''

[ngeoffray, 2012/11/30 12:11:46]

What is this comment about?

[erikcorry, 2012/11/30 12:20:02]

The comment shows the intent, the actual code does the same, but is more
compact.

         if (hasOwnProperty.call(prototype, member)) {
           newPrototype[member] = prototype[member];
         }
       }
     }
   }
   for (var cls in pendingClasses) finishClass(cls);
 }''';
   }
 
@@ skipping 557 matching lines @@
     buffer.add("$setterName: function(v) { "
         "this.$fieldName = $helperName(v$additionalArgument); }");
   }
 
   void emitClassConstructor(ClassElement classElement, CodeBuffer buffer) {
     /* Do nothing. */
   }
 
   void emitClassFields(ClassElement classElement,
                        CodeBuffer buffer,
-                       bool emitEndingComma) {
+                       { String superClass: "",
+                         bool isNative: false,
+                         bool emitEndingComma: false}) {

[ngeoffray, 2012/11/30 12:11:46]

Please don't put emitEndingComma optional. Other methods that have the same
parameter don't have it optional and I prefer to keep it consistent.

[erikcorry, 2012/11/30 12:20:02]

I'll revert this in a later CL.

+    assert(!isNative || superClass != "");
     bool isFirstField = true;
+    bool isAnythingOutput = false;
+    if (!isNative) {
+      buffer.add('"":"$superClass@');
+      isAnythingOutput = true;
+    }
     visitClassFields(classElement, (Element member,
                                     String name,
                                     bool needsGetter,
                                     bool needsSetter,
                                     bool needsCheckedSetter) {
-
       if (!getterAndSetterCanBeImplementedByFieldSpec(
           member, name, needsGetter, needsSetter)) {
         return;
       }
-
-      if (isFirstField) {
-        buffer.add('"": [');
-        isFirstField = false;
-      } else {
-        buffer.add(", ");
+      if (!isNative || needsCheckedSetter || needsGetter || needsSetter) {
+        if (isFirstField) {
+          isFirstField = false;
+          if (!isAnythingOutput) {
+            buffer.add('"":"');
+            isAnythingOutput = true;
+          }
+        } else {
+          buffer.add(".");
+        }
+        buffer.add('$name');
+        if (needsGetter && needsSetter) {
+          buffer.add(GETTER_SETTER_SUFFIX);
+        } else if (needsGetter) {
+          buffer.add(GETTER_SUFFIX);
+        } else if (needsSetter) {
+          buffer.add(SETTER_SUFFIX);
+        }
       }
-      buffer.add('"$name');
-      if (needsGetter && needsSetter) {
-        buffer.add(GETTER_SETTER_SUFFIX);
-      } else if (needsGetter) {
-        buffer.add(GETTER_SUFFIX);
-      } else if (needsSetter) {
-        buffer.add(SETTER_SUFFIX);
-      }
+    });
+    if (isAnythingOutput) {
       buffer.add('"');
-    });
-    if (!isFirstField) {
-      // There was at least one field.
-      buffer.add(']');
       if (emitEndingComma) {
         buffer.add(',');
       }
     }
   }
 
   /** Each getter/setter must be prefixed with a ",\n ". */
   void emitClassGettersSetters(ClassElement classElement,
                                CodeBuffer buffer,
                                bool emitLeadingComma) {
@@ skipping 69 matching lines @@
     needsDefineClass = true;
     String className = namer.getName(classElement);
     ClassElement superclass = classElement.superclass;
     String superName = "";
     if (superclass != null) {
       superName = namer.getName(superclass);
     }
 
     buffer.add('$classesCollector.$className = {');
     emitClassConstructor(classElement, buffer);
-    emitClassFields(classElement, buffer, true);
+    emitClassFields(classElement, buffer, superClass: superName,
+                    isNative: false, emitEndingComma: false);
     // TODO(floitsch): the emitInstanceMember should simply always emit a ',\n'.
     // That does currently not work because the native classes have a different
     // syntax.
-    buffer.add('\n "super": "$superName"');
-    emitClassGettersSetters(classElement, buffer, true);
+    emitClassGettersSetters(classElement, buffer, false);
     emitInstanceMembers(classElement, buffer, true);
     buffer.add('\n};\n\n');
   }
 
   void emitInterceptorMethods(
       void defineInstanceMember(String name, StringBuffer memberBuffer)) {
     JavaScriptBackend backend = compiler.backend;
     // Emit forwarders for the ObjectInterceptor class. We need to
     // emit all possible sends on intercepted methods.
     for (Selector selector in backend.usedInterceptors) {
@@ skipping 187 matching lines @@
       // in case it is used in spawnFunction.
       String fieldName = namer.STATIC_CLOSURE_NAME_NAME;
       buffer.add('$fieldAccess.$fieldName = "$staticName";\n');
     }
   }
 
   void emitBoundClosureClassHeader(String mangledName,
                                    String superName,
                                    String extraArgument,
                                    CodeBuffer buffer) {
-    extraArgument = extraArgument.isEmpty ? '' : ", '$extraArgument'";
+    extraArgument = extraArgument.isEmpty ? '' : ".$extraArgument";
     buffer.add("""
 $classesCollector.$mangledName = {'':
-['self'$extraArgument, 'target'],
-'super': '$superName',
+\"$superName@self$extraArgument.target\",
 """);
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [member] must be a declaration element.
    */
   void emitDynamicFunctionGetter(FunctionElement member,
                                  DefineMemberFunction defineInstanceMember) {
@@ skipping 638 matching lines @@
 const String HOOKS_API_USAGE = """
 // Generated by dart2js, the Dart to JavaScript compiler.
 // 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].
 """;