First cut at behaviors. This just implements the lifecycle methodsportion. We may get the rest for …

lib/src/common/polymer_descriptor.dart

 // Copyright (c) 2014, 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 polymer.src.micro.properties;
 
 import 'dart:js';
 import 'package:reflectable/reflectable.dart';
+import 'behavior.dart';
 import 'declarations.dart';
 import 'js_proxy.dart';
 import 'property.dart';
 import 'event_handler.dart';
 import 'listen.dart';
 import 'observe.dart';
 import 'polymer_register.dart';
 
 /// Creates a javascript object which can be passed to polymer js to register
 /// an element, given a dart [Type] and a [PolymerRegister] annotation.
 JsObject createPolymerDescriptor(Type type, PolymerRegister annotation) {
   var object = {
     'is': annotation.tagName,
     'extends': annotation.extendsTag,
     'hostAttributes': annotation.hostAttributes,
-    'properties': buildPropertiesObject(type),
+    'properties': _buildPropertiesObject(type),
     'observers': _buildObserversObject(type),
     'listeners': _buildListenersObject(type),
+    'behaviors': _buildBehaviorsList(type),
     '__isPolymerDart__': true,
   };
   _setupLifecycleMethods(type, object);
   _setupEventHandlerMethods(type, object);
 
   return new JsObject.jsify(object);
 }
 
 /// Custom js object containing some helper methods for dart.
 final JsObject _polymerDart = context['Polymer']['Dart'];
 
 /// Returns a list of [DeclarationMirror]s for all fields annotated as a
 /// [Property].
 Map<String, DeclarationMirror> propertyDeclarationsFor(Type type) {
   return declarationsFor(type, jsProxyReflectable, where: (name, declaration) {
     if (isRegularMethod(declaration) || isSetter(declaration)) return false;
     return declaration.metadata.any((d) => d is Property);
   });
 }
 
 // Set up the `properties` descriptor object.
-Map buildPropertiesObject(Type type) {
+Map _buildPropertiesObject(Type type) {
   var declarations = propertyDeclarationsFor(type);
   var properties = {};
   declarations.forEach((String name, DeclarationMirror declaration) {
     // Build a properties object for this property.
     properties[name] = _getPropertyInfoForType(type, declaration);
   });
   return properties;
 }
 
 /// All @Observe annotated methods.
@@ skipping 122 matching lines @@
       var instanceMirror = jsProxyReflectable.reflect(dartInstance);
       return jsValue(instanceMirror.invokeGetter(declaration.simpleName));
     }),
   };
   if (isFinal) {
     property['readOnly'] = true;
   }
   return property;
 }
 
+/// List of [JsObjects]s representing the behaviors for an element.
+List<JsObject> _buildBehaviorsList(Type type) {
+  var behaviors = <JsObject>[];
+
+  isBehavior(instance) => instance is BehaviorInterface;
+
+  var interfaces = mixinsFor(type, jsProxyReflectable,

[Siggi Cherem (dart-lang), 2015/08/12 22:43:15]

Seems like we are visiting each behavior annotation twice. I wonder if it's
worth adding a "forEach" besides the current query APIs so you can do some extra
work while walking up the chain:

mixinForEach(type, jsProxyReflectable, (mixin) {
  BehaviorAnnotation meta = mixin.metadata.firstWhere(isBehavior,
      orElse: () => null);
  if (meta != null) behaviors.add(meta.getBehavior(mixin.reflectedType));
});

WDYT?

[jakemac, 2015/08/13 17:50:45]

I didn't add mixinForEach, but I did modify it to only check the annotations
once using similar logic.

+      where: (ClassMirror mixin) => mixin.metadata.any(isBehavior));
+  for (var interface in interfaces) {
+    behaviors.add(
+        (interface.metadata.firstWhere(isBehavior) as BehaviorInterface)
+            .getBehavior(interface.reflectedType));
+  }
+
+  return behaviors.isEmpty ? null : behaviors;
+}
+
 /// Given a [Type] return the [JsObject] representation of that type.
 /// TODO(jakemac): Make this more robust, specifically around Lists.
 dynamic jsType(Type type) {
   var typeString = '$type';
   if (typeString.startsWith('JsArray<')) typeString = 'List';
   if (typeString.startsWith('List<')) typeString = 'List';
   if (typeString.startsWith('Map<')) typeString = 'Map';
   switch (typeString) {
     case 'int':
     case 'double':
     case 'num':
       return context['Number'];
     case 'bool':
       return context['Boolean'];
     case 'List':
     case 'JsArray':
       return context['Array'];
     case 'DateTime':
       return context['Date'];
     case 'String':
       return context['String'];
     case 'Map':
     case 'JsObject':
       return context['Object'];
     default:
       // Just return the Dart type
       return type;
   }
 }