[observe] use consistent comment style

pkg/observe/lib/transformer.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.
- */
+/// Code transform for @observable. The core transformation is relatively
+/// straightforward, and essentially like an editor refactoring.
 library observe.transformer;
 
 import 'dart:async';
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/parser.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:barback/barback.dart';
 import 'package:source_maps/refactor.dart';
 import 'package:source_maps/span.dart' show SourceFile;
 
-/**
- * A [Transformer] that replaces observables based on dirty-checking with an
- * implementation based on change notifications.
- *
- * The transformation adds hooks for field setters and notifies the observation
- * system of the change.
- */
+/// A [Transformer] that replaces observables based on dirty-checking with an
+/// implementation based on change notifications.
+///
+/// The transformation adds hooks for field setters and notifies the observation
+/// system of the change.
 class ObservableTransformer extends Transformer {
 
   final List<String> _files;
   ObservableTransformer([List<String> files]) : _files = files;
   ObservableTransformer.asPlugin(BarbackSettings settings)
       : _files = _readFiles(settings.configuration['files']);
 
   static List<String> _readFiles(value) {
     if (value == null) return null;
     var files = [];
@@ skipping 67 matching lines @@
       if (_hasObservable(declaration)) {
         logger.warning('Top-level fields can no longer be observable. '
             'Observable fields should be put in an observable objects.',
             span: _getSpan(sourceFile, declaration));
       }
     }
   }
   return code;
 }
 
-/** Parse [code] using analyzer. */
+/// Parse [code] using analyzer.
 CompilationUnit _parseCompilationUnit(String code) {
   var errorListener = new _ErrorCollector();
   var reader = new CharSequenceReader(code);
   var scanner = new Scanner(null, reader, errorListener);
   var token = scanner.tokenize();
   var parser = new Parser(null, errorListener);
   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` or `@published` annotation. */
+/// True if the node has the `@observable` or `@published` annotation.
 // TODO(jmesserly): it is not good to be hard coding Polymer support here.
 bool _hasObservable(AnnotatedNode node) =>
     node.metadata.any(_isObservableAnnotation);
 
 // 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 in analyzer, so it isn't feasible yet.
 bool _isObservableAnnotation(Annotation node) =>
     _isAnnotationContant(node, 'observable') ||
     _isAnnotationContant(node, 'published') ||
@@ skipping 112 matching lines @@
   if (!explicitObservable) _mixinObservable(cls, code);
 
   // Fix initializers, because they aren't allowed to call the setter.
   for (var member in cls.members) {
     if (member is ConstructorDeclaration) {
       _fixConstructor(member, code, instanceFields);
     }
   }
 }
 
-/** Adds "with ChangeNotifier" and associated implementation. */
+/// Adds "with ChangeNotifier" and associated implementation.
 void _mixinObservable(ClassDeclaration cls, TextEditTransaction code) {
   // Note: we need to be careful to put the with clause after extends, but
   // before implements clause.
   if (cls.withClause != null) {
     var pos = cls.withClause.end;
     code.edit(pos, pos, ', ChangeNotifier');
   } else if (cls.extendsClause != null) {
     var pos = cls.extendsClause.end;
     code.edit(pos, pos, ' with ChangeNotifier ');
   } else {
@@ skipping 154 matching lines @@
 
 Token _findFieldSeperator(Token token) {
   while (token != null) {
     if (token.type == TokenType.COMMA || token.type == TokenType.SEMICOLON) {
       break;
     }
     token = token.next;
   }
   return token;
 }