small refactor to move JsPeer code out of _finishClassDef

lib/src/codegen/js_codegen.dart

 // Copyright (c) 2015, 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.
 
 library dev_compiler.src.codegen.js_codegen;
 
 import 'dart:collection' show HashSet, HashMap;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
@@ skipping 259 matching lines @@
     var type = node.element.type;
     if (_pendingClasses.remove(node.element) == null) return null;
 
     var name = type.name;
     var result = js.statement('let # = dart.typedef(#, () => #);', [
       new JS.Identifier(name),
       js.string(name, "'"),
       _emitTypeName(node.element.type, lowerTypedef: true)
     ]);
 
-    return _finishClassDef(type, result, null);
+    return _finishClassDef(type, result);
   }
 
   @override
   JS.Expression visitTypeName(TypeName node) => _emitTypeName(node.type);
 
   @override
   JS.Statement visitClassTypeAlias(ClassTypeAlias node) {
     // If we've already emitted this class, skip it.
     var type = node.element.type;
     if (_pendingClasses.remove(node.element) == null) return null;
 
     var name = node.name.name;
     var heritage =
         js.call('dart.mixin(#)', [_visitList(node.withClause.mixinTypes)]);
     var classDecl = new JS.ClassDeclaration(
         new JS.ClassExpression(new JS.Identifier(name), heritage, []));
 
-    return _finishClassDef(type, classDecl, null);
+    return _finishClassDef(type, classDecl);
   }
 
   JS.Statement _emitJsType(String dartClassName, DartObjectImpl jsName) {
     var jsTypeName = getConstantField(jsName, 'name', types.stringType);
 
     if (jsTypeName != null && jsTypeName != dartClassName) {
       // We export the JS type as if it was a Dart type. For example this allows
       // `dom.InputElement` to actually be HTMLInputElement.
       // TODO(jmesserly): if we had the JsName on the Element, we could just
       // generate it correctly when we refer to it.
@@ skipping 24 matching lines @@
         (member.isStatic ? staticFields : fields).add(member);
       }
     }
 
     var classExpr = new JS.ClassExpression(new JS.Identifier(type.name),
         _classHeritage(node), _emitClassMethods(node, ctors, fields));
 
     var body =
         _finishClassMembers(classElem, classExpr, ctors, fields, staticFields);
 
+    var result = _finishClassDef(type, body);
+
     var jsPeer = getAnnotationValue(node, _isJsPeerInterface);
-    String jsPeerName = null;
     if (jsPeer != null) {
-      jsPeerName = getConstantField(jsPeer, 'name', types.stringType);
+      var jsPeerName = getConstantField(jsPeer, 'name', types.stringType);
+      if (jsPeerName != null) {
+        // TODO(jmesserly): this copies the dynamic members.
+        // Probably fine for objects coming from JS, but not if we actually
+        // want to support construction of instances with generic types other
+        // than dynamic. See issue #154 for Array and List<E> related bug.
+        var copyMembers = js.statement(
+          'dart.copyProperties(dart.global.#.prototype, #.prototype);', [

[Jennifer Messerly, 2015/04/23 17:05:43]

hmmm, it occurs to me we should assert !_lazyClass if we reach this point, as
this will cause the type name to be evaluated eagerly.

[Jacob, 2015/04/23 17:09:14]

make it so.

+          _propertyName(jsPeerName),
+          classElem.name
+        ]);
+        return _statement([result, copyMembers]);
+      }
     }
-
-    return _finishClassDef(type, body, jsPeerName);
+    return result;
   }
 
   @override
   JS.Statement visitEnumDeclaration(EnumDeclaration node) =>
       _unimplementedCall("Unimplemented enum: $node").toStatement();
 
   /// Given a class element and body, complete the class declaration.
   /// This handles generic type parameters, laziness (in library-cycle cases),
   /// and ensuring dependencies are loaded first.
-  JS.Statement _finishClassDef(
-      ParameterizedType type, JS.Statement body, String jsPeerName) {
+  JS.Statement _finishClassDef(ParameterizedType type, JS.Statement body) {
     var name = type.name;
     var genericName = '$name\$';
 
     JS.Statement genericDef;
     JS.Expression genericInst;
     if (type.typeParameters.isNotEmpty) {
       genericDef = _emitGenericClassDef(type, body);
       var target = genericName;
       if (_needQualifiedName(type.element)) {
         target = js.call('#.#', [_exportsVar, genericName]);
@@ skipping 38 matching lines @@
     var classDefs = <JS.Statement>[];
     if (type is InterfaceType) {
       _emitClassIfNeeded(classDefs, type.superclass);
       for (var m in type.element.mixins) {
         _emitClassIfNeeded(classDefs, m);
       }
     } else if (type is FunctionType) {
       _emitClassIfNeeded(classDefs, types.functionType);
     }
     classDefs.add(body);
-    if (jsPeerName != null) {
-      classDefs.add(js.statement(
-          'dart.copyProperties(dart.global.#.prototype, #.prototype);', [
-        _propertyName(jsPeerName),
-        name
-      ]));
-    }
     return _statement(classDefs);
   }
 
   void _emitClassIfNeeded(List<JS.Statement> defs, DartType base) {
     // We can only emit classes from this library.
     if (base.element.library != currentLibrary) return;
 
     var baseNode = _pendingClasses[base.element];
     if (baseNode != null) defs.add(visitClassDeclaration(baseNode));
   }
@@ skipping 199 matching lines @@
           var init = _visit(field.initializer);
           if (init == null) init = new JS.LiteralNull();
           body.add(js.statement('#.# = #;', [name, fieldName, init]));
         } else {
           lazyStatics.add(field);
         }
       }
     }
     var lazy = _emitLazyFields(new JS.Identifier(name), lazyStatics);
     if (lazy != null) body.add(lazy);
-
     return _statement(body);
   }
 
   JS.Statement _overrideField(FieldElement e) {
     var cls = e.enclosingElement;
     return js.statement('dart.virtualField(#, #)', [
       cls.name,
       _emitMemberName(e.name, type: cls.type)
     ]);
   }
@@ skipping 1804 matching lines @@
 // TODO(jmesserly): validate the library. See issue #135.
 bool _isJsNameAnnotation(DartObjectImpl value) => value.type.name == 'JsName';
 
 bool _isJsPeerInterface(DartObjectImpl value) =>
     value.type.name == 'JsPeerInterface';
 
 // TODO(jacobr): we would like to do something like the following
 // but we don't have summary support yet.
 // bool _supportJsExtensionMethod(AnnotatedNode node) =>
 //    _getAnnotation(node, "SupportJsExtensionMethod") != null;