Introduce boot.js: this finally makes it possible to load and run Todomvc

lib/src/observable_transform.dart

 // Copyright (c) 2013, 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.
 
 /**
  * Code transform for @observable. The core transformation is relatively
  * straightforward, and essentially like an editor refactoring. You can find the
  * core implementation in [transformClass], which is ultimately called by
  * [transformObservables], the entry point to this library.
  */
@@ skipping 68 matching lines @@
 
 void transformClass(ClassDeclaration cls, TextEditTransaction code,
     SourceFile file, Messages messages) {
 
   if (hasObservable(cls)) {
     messages.warning('@observable on a class no longer has any effect. '
         'It should be placed on individual fields.',
         _getSpan(file, cls));
   }
 
+  var declaresObservable = false;
+  if (cls.extendsClause != null) {
+    var id = cls.extendsClause.superclass.name;
+    if (id is PrefixedIdentifier) {

[Jennifer Messerly, 2013/07/30 00:56:12]

it's only used in 2 places but this might be a good candidate for a function:

SimpleIdentifier getSimpleIdentifier(Identifier id) =>
    id is PrefixedIdentifier ? id.identifier : id;

[Siggi Cherem (dart-lang), 2013/07/30 23:32:04]

Done.

+      id = id.identifier;
+    }
+    if (id.name == "ObservableBase") {
+      code.edit(id.offset, id.end, "ChangeNotifierBase");
+      declaresObservable = true;
+    } else if (id.name == "ChangeNotifierBase") {
+      declaresObservable = true;
+    }
+  }
+  if (!declaresObservable && cls.withClause != null) {
+    for (var type in cls.withClause.mixinTypes) {
+      var id = type.name;
+      if (id is PrefixedIdentifier) {
+        id = id.identifier;
+      }
+      if (id.name == "ObservableMixin") {
+        code.edit(id.offset, id.end, "ChangeNotifierMixin");
+        declaresObservable = true;
+        break;
+      } else if (id.name == "ChangeNotifierMixin") {
+        declaresObservable = true;
+        break;
+      }
+    }
+  }
+
   // Track fields that were transformed.
   var instanceFields = new Set<String>();
   var getters = new List<String>();
   var setters = new List<String>();
 
   for (var member in cls.members) {
     if (member is FieldDeclaration) {
       bool isStatic = hasKeyword(member.keyword, Keyword.STATIC);
       if (isStatic) {
         if (hasObservable(member)){
           messages.warning('Static fields can no longer be observable. '
               'Observable fields should be put in an observable objects.',
               _getSpan(file, member));
         }
         continue;
       }
       if (hasObservable(member)) {
+        if (!declaresObservable) {

[Jennifer Messerly, 2013/07/30 00:56:12]

I'm not sure this warning is correct. What if Observable* comes from somewhere
up the inheritance hierarchy? Or if someone chose to implement the Observable
interface themselves...

[Siggi Cherem (dart-lang), 2013/07/30 23:32:04]

Good point. Since we are not going to do a type analysis here, I am trying to
think of good heuristics of when to show this message.

If we want to show it only when we are sure, then we have to only do this when
there is no superclass, no mixin, and no observable interface.

However, I think it's going to be fairly common to have cases where people have
baseclasses/mixins but they are not doing things right. One heuristic to take is
that we'll report a warning in those cases, unless the interface is present. 

So if I have:

A implements Observable {
}
...

B extends A {
}

I'll see a warning in B, but if you write again B extends A implements
Observable, the warning goes away.

Thoughts?

[Jennifer Messerly, 2013/07/31 00:59:51]

Hmm, sounds a little better, but I get nervous any time we're issuing a warning
for valid code. For historical reasons we may see this incorrect usage for a
while, but anyone coming to Polymer.dart fresh is unlikely to make that mistake.

Other ideas:
* use type resolution
* turn it into a runtime diagnostic feature. We could make a "debugDataBinding"
function that scans the DOM for any bindings that have mutable fields. This
would also detect missing @observable or incorrect List usage, which are perhaps
even more common errors.

[Siggi Cherem (dart-lang), 2013/07/31 01:39:17]

good ideas, I'll think more about them. For now I changed this just to provide
errors when we know for sure.

+          messages.warning('Observable fields should be put in an observable'
+              ' objects. Please declare that this class extends from '
+              'ObservableBase or includes ObservableMixin.',
+              _getSpan(file, member));
+
+        }
         transformFields(member.fields, code, member.offset, member.end);
 
         var names = member.fields.variables.map((v) => v.name.name);
 
         getters.addAll(names);
         if (!_isReadOnly(member.fields)) {
           setters.addAll(names);
           instanceFields.addAll(names);
         }
       }
@@ skipping 145 matching lines @@
 $type __\$$name$initializer;
 $type get $name => __\$$name;
 set $name($type value) {
   __\$$name = notifyPropertyChange(const Symbol('$name'), __\$$name, value);
 }
 '''.replaceAll('\n', '\n$indent'));
   }
 
   code.edit(begin, end, '$replace');
 }