Create the JavaScript constructor dynamically.

lib/compiler/implementation/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.
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
 class ClosureInvocationElement extends FunctionElement {
   ClosureInvocationElement(SourceString name,
@@ skipping 35 matching lines @@
   String get finishClassesName()
       => '${namer.ISOLATE}.\$finishClasses';
   String get finishIsolateConstructorName()
       => '${namer.ISOLATE}.\$finishIsolateConstructor';
   String get pendingClassesName()
       => '${namer.ISOLATE}.\$pendingClasses';
   String get isolatePropertiesName()
       => '${namer.ISOLATE}.${namer.ISOLATE_PROPERTIES}';
 
   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).
+    // The caller can also pass in the constructor as a function if needed.

[ngeoffray, 2012/05/07 09:42:30]

Who needs that?

[floitsch, 2012/05/07 12:42:08]

This is in preparation for a future CL. The idea is, that if there is only one
Dart constructor, than we don't need to have a separate JavaScript constructor
but can merge the two.

+    //
     // Example:
-    // defineClass("A", "B",
-    // function(x) {          /* The JavaScript constructor. */
-    //   this.x = x;
-    // }, {                   /* The members inside an Object literal. */
+    // defineClass("A", "B", ["x", "y"], {
     //  foo$1: function(y) {
     //   print(this.x + y);
     //  },
     //  bar$2: function(t, v) {
     //   this.x = t - v;
     //  },
     // });
     return """
-function(cls, superclass, constructor, prototype) {
+function(cls, superclass, fields, prototype) {
+  var constructor;
+  if (typeof fields == 'function') {

[ngeoffray, 2012/05/07 09:42:30]

Since we control the emission, why do we need to support this?

[floitsch, 2012/05/07 12:42:08]

If you prefer I can remove the code for now. (it's just 2 lines after all...)

[ngeoffray, 2012/05/07 12:54:25]

It's fine if you keep it but make sure you'll use it.

+    constructor = fields;
+  } else {
+    var str = "(function " + cls + "(";
+    var body = "";
+    for (var i = 0; i < fields.length; i++) {
+      if (i != 0) str += ", ";
+      str += fields[i];
+      body += "this." + fields[i] + " = " + fields[i] + ";\\n";
+    }
+    str += ") {" + body + "})";
+    constructor = eval(str);
+  }
   $isolatePropertiesName[cls] = constructor;
   constructor.prototype = prototype;
   if (superclass !== "") {
     $pendingClassesName[cls] = superclass;
   }
 }""";
   }
 
   String get finishClassesFunction() {
     // 'defineClass' does not require the classes to be constructed in order.
@@ skipping 270 matching lines @@
             : namer.getName(member);
         defineInstanceMember(getterName, "function() { return this.$name; }");
       }
     } else {
       compiler.internalError('unexpected kind: "${member.kind}"',
                              element: member);
     }
     emitExtraAccessors(member, defineInstanceMember);
   }
 
-  bool generateFieldInits(ClassElement classElement,
-                          StringBuffer argumentsBuffer,
-                          StringBuffer bodyBuffer) {
-    bool isFirst = true;
-    void generateFieldInit(ClassElement enclosingClass, Element member) {
-      // TODO(floitsch): make sure there are no name clashes.
-      String className = namer.getName(enclosingClass);
-      if (!isFirst) argumentsBuffer.add(', ');
-      isFirst = false;
-      String memberName = namer.instanceFieldName(member.getLibrary(),
-                                                  member.name);
-      String parameter;
-      if (classElement === enclosingClass) {
-        parameter = memberName;
-      } else {
-        parameter = '${className}_$memberName';
-      }
-      argumentsBuffer.add(parameter);
-      bodyBuffer.add('  this.$memberName = $parameter;\n');
+  List<String> generateFieldList(ClassElement classElement) {
+    List<String> result = <String>[];
+    void addField(ClassElement enclosingClass, Element member) {
+      result.add(namer.instanceFieldName(member.getLibrary(), member.name));
     }
 
-    classElement.forEachInstanceField(generateFieldInit,
+    classElement.forEachInstanceField(addField,
                                       includeBackendMembers: true,
                                       includeSuperMembers: true);
+    return result;
   }
 
   void generateClass(ClassElement classElement, StringBuffer buffer) {
     needsDefineClass = true;
 
     if (classElement.isNative()) {
       nativeEmitter.generateNativeClass(classElement);
       return;
     } else {
       // TODO(ngeoffray): Instead of switching between buffer, we
       // should create code sections, and decide where to emit them at
       // the end.
       buffer = mainBuffer;
     }
 
     String className = namer.getName(classElement);
     ClassElement superclass = classElement.superclass;
     String superName = "";
     if (superclass !== null) {
       superName = namer.getName(superclass);
     }
     String constructorName = namer.safeName(classElement.name.slowToString());
     buffer.add('$defineClassName("$className", "$superName", ');
-    buffer.add('function $constructorName(');
-    StringBuffer bodyBuffer = new StringBuffer();
     // If the class is never instantiated we still need to set it up for
-    // inheritance purposes, but we can leave its JavaScript constructor empty.
-    if (compiler.universe.instantiatedClasses.contains(classElement)) {
-      generateFieldInits(classElement, buffer, bodyBuffer);
+    // inheritance purposes, but we can simplify its JavaScript constructor.
+    if (!compiler.universe.instantiatedClasses.contains(classElement)) {
+      buffer.add("[]");
+    } else {
+      List<String> fields = generateFieldList(classElement);
+      buffer.add('[');
+      for (int i = 0; i < fields.length; i++) {
+        if (i != 0) buffer.add(", ");
+        buffer.add('"${fields[i]}"');
+      }
+      buffer.add(']');
     }
-    buffer.add(') {\n');
-    buffer.add(bodyBuffer);
-    buffer.add(' }, ');
-
-    buffer.add('{\n');
+    buffer.add(', {\n');
 
     void defineInstanceMember(String name, String value) {
       buffer.add(' $name: $value,\n');
     }
 
     classElement.forEachMember(includeBackendMembers: true,
                                f: (ClassElement enclosing, Element member) {
       if (member.isInstanceMember()) {
         addInstanceMember(member, defineInstanceMember);
       }
@@ skipping 464 matching lines @@
       mainBuffer.add('function init() {\n');
       mainBuffer.add('  $isolateProperties = {};\n');
       addDefineClassAndFinishClassFunctionsIfNecessary(mainBuffer);
       emitFinishIsolateConstructor(mainBuffer);
       mainBuffer.add('}\n');
       compiler.assembledCode = mainBuffer.toString();
     });
     return compiler.assembledCode;
   }
 }