fix observe transform to preserve metadata

pkg/observe/lib/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.
  */
 library observe.transform;
 
@@ skipping 16 matching lines @@
  */
 class ObservableTransformer extends Transformer {
 
   Future<bool> isPrimary(Asset input) {
     if (input.id.extension != '.dart') return new Future.value(false);
     // Note: technically we should parse the file to find accurately the
     // observable annotation, but that seems expensive. It would require almost
     // as much work as applying the transform. We rather have some false
     // positives here, and then generate no outputs when we apply this
     // transform.
-    return input.readAsString().then((c) => c.contains("@observable"));
+    return input.readAsString().then(
+      (c) => c.contains("@observable") || c.contains("@published"));
   }
 
   Future apply(Transform transform) {
     return transform.primaryInput.readAsString().then((content) {
       var id = transform.primaryInput.id;
       // TODO(sigmund): improve how we compute this url
       var url = id.path.startsWith('lib/')
             ? 'package:${id.package}/${id.path.substring(4)}' : id.path;
       var sourceFile = new SourceFile.text(url, content);
       var transaction = _transformCompilationUnit(
@@ skipping 47 matching lines @@
   return parser.parseCompilationUnit(token);
 }
 
 class _ErrorCollector extends AnalysisErrorListener {
   final errors = <AnalysisError>[];
   onError(error) => errors.add(error);
 }
 
 _getSpan(SourceFile file, ASTNode node) => file.span(node.offset, node.end);
 
-/** True if the node has the `@observable` annotation. */
-bool _hasObservable(AnnotatedNode node) => _hasAnnotation(node, 'observable');
+/** True if the node has the `@observable` or `@published` annotation. */
+// TODO(jmesserly): it is not good to be hard coding these. We should do a
+// resolve and do a proper ObservableProperty subtype check. However resolve
+// is very expensive in analyzer_experimental, so it isn't feasible yet.
+bool _hasObservable(AnnotatedNode node) =>
+    _hasAnnotation(node, 'observable') || _hasAnnotation(node, 'published');
 
 bool _hasAnnotation(AnnotatedNode node, String name) {
   // TODO(jmesserly): this isn't correct if the annotation has been imported
   // with a prefix, or cases like that. We should technically be resolving, but
   // that is expensive.
   return node.metadata.any((m) => m.name.name == name &&
       m.constructorName == null && m.arguments == null);
 }
 
 void _transformClass(ClassDeclaration cls, TextEditTransaction code,
@@ skipping 10 matching lines @@
   // syntactic understanding of the code), we only report warnings that are
   // known to be true.
   var declaresObservable = false;
   if (cls.extendsClause != null) {
     var id = _getSimpleIdentifier(cls.extendsClause.superclass.name);
     if (id.name == 'ObservableBase') {
       code.edit(id.offset, id.end, 'ChangeNotifierBase');
       declaresObservable = true;
     } else if (id.name == 'ChangeNotifierBase') {
       declaresObservable = true;
-    } else if (id.name != 'PolymerElement' && id.name != 'CustomElement'
+    } else if (id.name != 'HtmlElement' && id.name != 'CustomElement'
         && id.name != 'Object') {
       // TODO(sigmund): this is conservative, consider using type-resolution to
       // improve this check.
       declaresObservable = true;
     }
   }
 
   if (cls.withClause != null) {
     for (var type in cls.withClause.mixinTypes) {
       var id = _getSimpleIdentifier(type.name);
@@ skipping 28 matching lines @@
       if (member.isStatic) {
         if (_hasObservable(member)){
           logger.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) {
-          logger.warning('Observable fields should be put in an observable'
-              ' objects. Please declare that this class extends from '
+          logger.warning('Observable fields should be put in an observable '
+              'objects. Please declare that this class extends from '
               'ObservableBase, includes ObservableMixin, or implements '
               'Observable.',
               _getSpan(file, member));
-
         }
-        _transformFields(member.fields, code, member.offset, member.end);
+        _transformFields(file, member, code, logger);
 
         var names = member.fields.variables.map((v) => v.name.name);
 
         getters.addAll(names);
         if (!_isReadOnly(member.fields)) {
           setters.addAll(names);
           instanceFields.addAll(names);
         }
       }
     }
@@ skipping 78 matching lines @@
   }
 
   code.edit(offset, offset, inserted);
 }
 
 bool _isReadOnly(VariableDeclarationList fields) {
   return _hasKeyword(fields.keyword, Keyword.CONST) ||
       _hasKeyword(fields.keyword, Keyword.FINAL);
 }
 
-void _transformFields(VariableDeclarationList fields, TextEditTransaction code,
-    int begin, int end) {
+void _transformFields(SourceFile file, FieldDeclaration member,
+    TextEditTransaction code, TransformLogger logger) {
 
+  final fields = member.fields;
   if (_isReadOnly(fields)) return;
 
-  var indent = guessIndent(code.original, begin);
-  var replace = new StringBuffer();
+  // Private fields aren't supported:
+  for (var field in fields.variables) {
+    final name = field.name.name;
+    if (Identifier.isPrivateName(name)) {
+      logger.warning('Cannot make private field $name observable.',
+          _getSpan(file, field));
+      return;
+    }
+  }
 
   // Unfortunately "var" doesn't work in all positions where type annotations
   // are allowed, such as "var get name". So we use "dynamic" instead.
   var type = 'dynamic';
   if (fields.type != null) {
     type = _getOriginalCode(code, fields.type);
+  } else if (_hasKeyword(fields.keyword, Keyword.VAR)) {
+    // Replace 'var' with 'dynamic'
+    code.edit(fields.keyword.offset, fields.keyword.end, type);
   }
 
-  for (var field in fields.variables) {
-    var initializer = '';
-    if (field.initializer != null) {
-      initializer = ' = ${_getOriginalCode(code, field.initializer)}';
-    }
+  // Note: the replacements here are a bit subtle. It needs to support multiple
+  // fields declared via the same @observable, as well as preserving newlines.
+  // (Preserving newlines is important because it allows the generated code to
+  // be debugged without needing a source map.)
+  //
+  // For example:
+  //
+  //     @observable
+  //     @otherMetaData
+  //         Foo
+  //             foo = 1, bar = 2,
+  //             baz;
+  //
+  // Will be transformed into something like:
+  //
+  //     @observable
+  //     @OtherMetaData()
+  //         Foo
+  //             get foo => __foo; Foo __foo = 1; set foo ...; ... bar ...
+  //             @observable @OtherMetaData() Foo get baz => __baz; Foo baz; ...
+  //
+  // Metadata is moved to the getter.
 
-    var name = field.name.name;
-
-    // TODO(jmesserly): should we generate this one one line, so source maps
-    // don't break?
-    if (replace.length > 0) replace.write('\n\n$indent');
-    replace.write('''
-$type __\$$name$initializer;
-$type get $name => __\$$name;
-set $name($type value) {
-  __\$$name = notifyPropertyChange(const Symbol('$name'), __\$$name, value);
-}
-'''.replaceAll('\n', '\n$indent'));
+  String metadata = '';
+  if (fields.variables.length > 1) {
+    metadata = member.metadata
+      .map((m) => _getOriginalCode(code, m))
+      .join(' ');
   }
 
-  code.edit(begin, end, '$replace');
+  for (int i = 0; i < fields.variables.length; i++) {
+    final field = fields.variables[i];
+    final name = field.name.name;
+
+    var beforeInit = 'get $name => __\$$name; $type __\$$name';
+
+    // The first field is expanded differently from subsequent fields, because
+    // we can reuse the metadata and type annotation.
+    if (i > 0) beforeInit = '$metadata $type $beforeInit';
+
+    code.edit(field.name.offset, field.name.end, beforeInit);
+
+    // Replace comma with semicolon
+    final end = _findFieldSeperator(field.endToken.next);
+    if (end.type == TokenType.COMMA) code.edit(end.offset, end.end, ';');
+
+    code.edit(end.end, end.end, ' set $name($type value) { '
+        '__\$$name = notifyPropertyChange(#$name, __\$$name, value); }');
+  }
 }
+
+Token _findFieldSeperator(Token token) {
+  while (token != null) {
+    if (token.type == TokenType.COMMA || token.type == TokenType.SEMICOLON) {
+      break;
+    }
+    token = token.next;
+  }
+  return token;
+}