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

lib/src/common/declarations.dart

 library polymer.src.common.declarations;
 
 import 'package:reflectable/reflectable.dart';
+import '../../polymer_micro.dart';
 
-typedef bool _WhereFn(String name, DeclarationMirror declaration);
+typedef bool _DeclarationWhereFn(String name, DeclarationMirror declaration);

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

naming nit: maybe use Function or Callback instead of Fn (here and below).

Or, since this is just used once, you could inline this in the argument type.
For example:

  ..., {bool where(ClassMirror mirror)}) {
  ...

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

Opted for the inline type annotation, I forgot you could do that :P

+typedef bool _ClassWhereFn(ClassMirror mirror);
+
+List<ClassMirror> mixinsFor(
+    Type type, Reflectable reflectionClass, {_ClassWhereFn where}) {
+  var typeMirror = _reflect(type, reflectionClass);
+  var mixins = [];
+  var superClass = _getSuper(typeMirror);
+  while(superClass != null && superClass.reflectedType != PolymerElement) {

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

run formatter 

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

Done.

+    var mixin = superClass.mixin;
+    if (mixin != superClass && (where == null || where(mixin))) {
+      mixins.add(mixin);
+    }
+    superClass = _getSuper(superClass);
+  }
+  return mixins.reversed.toList();
+}
 
 Map<String, DeclarationMirror> declarationsFor(
-    Type type, Reflectable reflectionClass, {_WhereFn where}) {
-  var typeMirror;
-  try {
-    typeMirror = reflectionClass.reflectType(type);
-  } catch (e) {
-    throw 'type $type is missing the $reflectionClass annotation';
-  }
+    Type type, Reflectable reflectionClass, {_DeclarationWhereFn where}) {
+  var typeMirror = _reflect(type, reflectionClass);
   var declarations = {};
   var superClass = typeMirror;
-  while (superClass != null && superClass.reflectedType != Object) {
+  while (superClass != null && superClass.reflectedType != PolymerElement) {

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

just to double check - do we ever need to fetch something from the
PolymerElement class? or is it safe that we are skipping it? (In the past we
used to stop at HtmlElement instead)

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

Its fine to stop at PolymerElement, although I actually changed this to stop at 
the PolymerMixin mixin instead, but that is effectively the same thing.
Basically we just need all values that could possibly be used in a template.

     superClass.declarations.forEach((name, declaration) {
       if (declarations.containsKey(name)) return;
       if (where != null && !where(name, declaration)) return;
       declarations[name] = declaration;
     });
     superClass = _getSuper(superClass);
   }
   return declarations;
 }
 
+ClassMirror _reflect(Type type, Reflectable reflectionClass) {
+  try {
+    return reflectionClass.reflectType(type);
+  } catch (e) {
+    throw 'type $type is missing the $reflectionClass annotation';
+  }
+}
+
 ClassMirror _getSuper(ClassMirror clazz) {
   // Currently throws post-transform if superclass isn't annotated with a
   // [Reflectable] class.
   try {
     return clazz.superclass;
   } catch(e) {
     return null;
   }
 }
 
@@ skipping 17 matching lines @@
 bool isSetter(DeclarationMirror declaration) {
   return declaration is MethodMirror && declaration.isSetter;
 }
 
 bool hasSetter(MethodMirror getterDeclaration) {
   assert(getterDeclaration.isGetter);
   var owner = getterDeclaration.owner;
   assert(owner is LibraryMirror || owner is ClassMirror);
   return owner.declarations.containsKey('${getterDeclaration.simpleName}=');
 }