Fixes to get Swarm demo working again.

frog/gen.dart

 // Copyright (c) 2011, 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.
 
 /**
  * Top level generator object for writing code and keeping track of
  * dependencies.
  *
  * Should have two compilation models, but only one implemented so far.
  *
  * 1. Do a top-level resolution of all types and their members.
  * 2. Start from main and walk the call-graph compiling members as needed.
  * 2a. That includes compiling overriding methods and calling methods by
  *     selector when invoked on var.
  * 3. Spit out all required code.
  */
 class WorldGenerator {
   MethodMember main;
   CodeWriter writer;
+  CodeWriter _mixins;
   Map<String, GlobalValue> globals;
   CoreJs corejs;
   bool _inheritsGenerated = false;
 
   WorldGenerator(this.main, this.writer): globals = {}, corejs = new CoreJs();
 
   run() {
     var metaGen = new MethodGenerator(main, null);
     var mainCall = main.invoke(metaGen, null, null, Arguments.EMPTY);
     main.declaringType.markUsed();
@@ skipping 15 matching lines @@
           new Arguments(null, [main._get(metaGen, main.definition, null)]));
     }
 
     writeTypes(world.coreimpl);
     writeTypes(world.corelib);
 
     // Write the main library. This will cause all libraries to be written in
     // the topographic sort order.
     writeTypes(main.declaringType.library);
 
+    // Write out any inherited concrete members.
+    if (_mixins != null) writer.write(_mixins.text);
+
     _writeGlobals();
     writer.writeln('${mainCall.code};');
   }
 
   GlobalValue globalForStaticField(FieldMember field, Value fieldValue,
       List<Value> dependencies) {
     var fullname = "${field.declaringType.jsname}.${field.jsname}";
     if (!globals.containsKey(fullname)) {
       globals[fullname] = new GlobalValue.fromStatic(
           field, fieldValue, dependencies);
@@ skipping 120 matching lines @@
 
       for (var c in type.constructors.getValues()) {
         if (c.generator != null && c != standardConstructor) {
           c.generator.writeDefinition(writer, null);
         }
       }
     }
 
     if (!type.isTop) {
       if (type is ConcreteType) {
+        ConcreteType c = type;
         _ensureInheritsHelper();
-        writer.writeln(
-            '\$inherits(${type.jsname}, ${type.genericType.jsname});');
+        writer.writeln('\$inherits(${c.jsname}, ${c.genericType.jsname});');
+
+        // Mixin members from concrete specializations of base types too.
+        // TODO(jmesserly): emit this sooner instead of at the end.
+        // But it needs to come after we've emitted both types.
+        // TODO(jmesserly): HACK: using _parent instead of parent so we don't
+        // try to inherit things that we didn't actually use.
+        for (var p = c._parent; p is ConcreteType; p = p._parent) {
+          _ensureInheritMembersHelper();
+          _mixins.writeln('\$inheritsMembers(${c.jsname}, ${p.jsname});');
+        }
       } else if (!type.isNativeType) {
         if (type.parent != null && !type.parent.isObject) {
           _ensureInheritsHelper();
           writer.writeln('\$inherits(${type.jsname}, ${type.parent.jsname});');
         }
       }
     }
 
     // Concrete types (like List<String>) will have this already defined on
     // their prototype from the generic type (like List)
@@ skipping 63 matching lines @@
     child.prototype.__proto__ = parent.prototype;
   } else {
     function tmp() {};
     tmp.prototype = parent.prototype;
     child.prototype = new tmp();
     child.prototype.constructor = child;
   }
 }""");
   }
 
+  /**
+   * Generates the $inheritsMembers function when it's first used.
+   * This is used to mix in specialized generic members from the base class.
+   */
+  _ensureInheritMembersHelper() {
+    if (_mixins != null) return;
+    _mixins = new CodeWriter();
+    _mixins.comment('// ********** Generic Type Inheritance **************');
+    _mixins.writeln(@"""
+/** Implements extends for generic types. */
+function $inheritsMembers(child, parent) {
+  child = child.prototype;
+  parent = parent.prototype;
+  Object.getOwnPropertyNames(parent).forEach(function(name) {

[Jennifer Messerly, 2011/11/18 18:51:29]

Not sure if it makes sense to do this on the JS side. This is inspired by
traitjs, but simpler because we don't need to worry about conflict resolution,
enumerable/non-enumerable, etc.

I tried doing it in both the JS side and directly emitting the right assignments
in gen.dart--this version was smaller code, because I didn't need to duplicate
the logic from _writeType, _writeMethod, _writeField, _writeProperty, etc.

+    if (typeof(child[name]) == 'undefined') child[name] = parent[name];
+  });
+}""");
+  }
+
   _writeDynamicStubs(Type type) {
     if (type.varStubs != null) {
       for (var stub in orderValuesByKeys(type.varStubs)) {
         stub.generate(writer);
       }
     }
   }
 
   _writeStaticField(FieldMember field) {
     // Final static fields must be constants which will be folded and inlined.
@@ skipping 489 matching lines @@
           var optional = "['" + Strings.join(optNames, "', '") + "']";
           defWriter.writeln('${start}${meth.jsname}.\$optional = $optional');
         }
       }
     }
   }
 
   writeBody() {
     var initializers = null;
     var initializedFields = null; // to check that final fields are initialized
+    var allMembers = null;
     if (method.isConstructor) {
       initializers = [];
       initializedFields = new Set();
-      for (var f in world.gen._orderValues(method.declaringType.getAllMembers())) {
-        if (f is FieldMember && !f.isStatic) {
+      allMembers = world.gen._orderValues(method.declaringType.getAllMembers());
+      for (var f in allMembers) {
+        if (f.isField && !f.isStatic) {

[Jennifer Messerly, 2011/11/18 18:51:29]

these can be ConcreteMembers too

           var cv = f.computeValue();
           if (cv != null) {
             initializers.add('this.${f.jsname} = ${cv.code}');
             initializedFields.add(f.name);
           }
         }
       }
     }
 
     // Collects parameters for writing signature in the future.
@@ skipping 104 matching lines @@
           world.error(
               'no initialization allowed on redirecting constructors',
               init.span);
         }
         initializedFields = null;
       }
     }
 
     // check that initialization was correct
     if (initializedFields != null) {
-      for (var name in method.declaringType.members.getKeys()) {
-        var member = method.declaringType.members[name];
-        if (member is FieldMember && member.isFinal && !member.isStatic
-            && !initializedFields.contains(name)) {
-          world.error('Field "${name}" is final and was not initialized',
+      for (var member in allMembers) {

[Jennifer Messerly, 2011/11/18 18:51:29]

this fixes an inconsistency: the loop above was using getAllMembers, but this
one wasn't.

+        if (member.isField && member.isFinal && !member.isStatic
+            && !initializedFields.contains(member.name)) {
+          world.error('Field "${member.name}" is final and was not initialized',
               method.definition.span);
         }
       }
     }
 
     visitStatementsInBlock(body);
   }
 
   /**
    * Calls another constructor (super, super.name, this, this.name).  Returns
@@ skipping 1350 matching lines @@
       result.add(new Value(world.varType, '\$$i', null, /*needsTemp:*/false));
     }
     for (int i = bareCount; i < length; i++) {
       var name = getName(i);
       if (name == null) name = '\$$i';
       result.add(new Value(world.varType, name, null, /*needsTemp:*/false));
     }
     return new Arguments(nodes, result);
   }
 }