Step one towards stable error messages with details:

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.
 library observe.transformer;
 
 import 'dart:async';
 
 import 'package:analyzer/analyzer.dart';
 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:code_transformers/messages/build_logger.dart';
 import 'package:source_maps/refactor.dart';
 import 'package:source_span/source_span.dart';
 
+import 'src/messages.dart';
+
 /// 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 bool releaseMode;
   final List<String> _files;
-  ObservableTransformer([List<String> files]) : _files = files;
+  ObservableTransformer([List<String> files, bool releaseMode])
+      : _files = files, releaseMode = releaseMode == true;
   ObservableTransformer.asPlugin(BarbackSettings settings)
-      : _files = _readFiles(settings.configuration['files']);
+      : _files = _readFiles(settings.configuration['files']),
+        releaseMode = settings.mode == BarbackMode.RELEASE;
 
   static List<String> _readFiles(value) {
     if (value == null) return null;
     var files = [];
     bool error;
     if (value is List) {
       files = value;
       error = value.any((e) => e is! String);
     } else if (value is String) {
       files = [value];
@@ skipping 18 matching lines @@
       // Do a quick string check to determine if this is this file even
       // plausibly might need to be transformed. If not, we can avoid an
       // expensive parse.
       if (!observableMatcher.hasMatch(content)) return;
 
       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(content, url: url);
+      var logger = new BuildLogger(transform,
+          convertErrorsToWarnings: !releaseMode);
       var transaction = _transformCompilationUnit(
-          content, sourceFile, transform.logger);
-      if (!transaction.hasEdits) {
-        transform.addOutput(transform.primaryInput);
-        return;
+          content, sourceFile, logger);
+      if (transaction.hasEdits) {
+        var printer = transaction.commit();
+        // TODO(sigmund): emit source maps when barback supports it (see
+        // dartbug.com/12340)
+        printer.build(url);
+        transform.addOutput(new Asset.fromString(id, printer.text));
       }
-      var printer = transaction.commit();
-      // TODO(sigmund): emit source maps when barback supports it (see
-      // dartbug.com/12340)
-      printer.build(url);
-      transform.addOutput(new Asset.fromString(id, printer.text));
+      return logger.writeOutput();
     });
   }
 }
 
 TextEditTransaction _transformCompilationUnit(
-    String inputCode, SourceFile sourceFile, TransformLogger logger) {
+    String inputCode, SourceFile sourceFile, BuildLogger logger) {
   var unit = parseCompilationUnit(inputCode, suppressErrors: true);
   var code = new TextEditTransaction(inputCode, sourceFile);
   for (var directive in unit.directives) {
     if (directive is LibraryDirective && _hasObservable(directive)) {
-      logger.warning('@observable on a library no longer has any effect. '
-          'It should be placed on individual fields.',
+      logger.warning(noObservableOnLibrary,
           span: _getSpan(sourceFile, directive));
       break;
     }
   }
 
   for (var declaration in unit.declarations) {
     if (declaration is ClassDeclaration) {
       _transformClass(declaration, code, sourceFile, logger);
     } else if (declaration is TopLevelVariableDeclaration) {
       if (_hasObservable(declaration)) {
-        logger.warning('Top-level fields can no longer be observable. '
-            'Observable fields should be put in an observable objects.',
+        logger.warning(noObservableOnTopLevel,
             span: _getSpan(sourceFile, declaration));
       }
     }
   }
   return code;
 }
 
 _getSpan(SourceFile file, AstNode node) => file.span(node.offset, node.end);
 
 /// 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') ||
     _isAnnotationType(node, 'ObservableProperty') ||
     _isAnnotationType(node, 'PublishedProperty');
 
 bool _isAnnotationContant(Annotation m, String name) =>
     m.name.name == name && m.constructorName == null && m.arguments == null;
 
 bool _isAnnotationType(Annotation m, String name) => m.name.name == name;
 
 void _transformClass(ClassDeclaration cls, TextEditTransaction code,
-    SourceFile file, TransformLogger logger) {
+    SourceFile file, BuildLogger logger) {
 
   if (_hasObservable(cls)) {
-    logger.warning('@observable on a class no longer has any effect. '
-        'It should be placed on individual fields.',
-        span: _getSpan(file, cls));
+    logger.warning(noObservableOnClass, span: _getSpan(file, cls));
   }
 
   // We'd like to track whether observable was declared explicitly, otherwise
   // report a warning later below. Because we don't have type analysis (only
   // syntactic understanding of the code), we only report warnings that are
   // known to be true.
   var explicitObservable = false;
   var implicitObservable = false;
   if (cls.extendsClause != null) {
     var id = _getSimpleIdentifier(cls.extendsClause.superclass.name);
@@ skipping 36 matching lines @@
 
   var declaresObservable = explicitObservable || implicitObservable;
 
   // Track fields that were transformed.
   var instanceFields = new Set<String>();
 
   for (var member in cls.members) {
     if (member is FieldDeclaration) {
       if (member.isStatic) {
         if (_hasObservable(member)){
-          logger.warning('Static fields can no longer be observable. '
-              'Observable fields should be put in an observable objects.',
+          logger.warning(noObservableOnStaticField,
               span: _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 '
-              'Observable, includes Observable, or implements '
-              'Observable.',
+          logger.warning(requireObservableInterface,
               span: _getSpan(file, member));
         }
         _transformFields(file, member, code, logger);
 
         var names = member.fields.variables.map((v) => v.name.name);
 
         if (!_isReadOnly(member.fields)) instanceFields.addAll(names);
       }
     }
   }
@@ skipping 88 matching lines @@
 
   code.edit(offset, offset, inserted);
 }
 
 bool _isReadOnly(VariableDeclarationList fields) {
   return _hasKeyword(fields.keyword, Keyword.CONST) ||
       _hasKeyword(fields.keyword, Keyword.FINAL);
 }
 
 void _transformFields(SourceFile file, FieldDeclaration member,
-    TextEditTransaction code, TransformLogger logger) {
+    TextEditTransaction code, BuildLogger logger) {
 
   final fields = member.fields;
   if (_isReadOnly(fields)) return;
 
   // 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.',
           span: _getSpan(file, field));
@@ skipping 76 matching lines @@
     token = token.next;
   }
   return token;
 }
 
 // TODO(sigmund): remove hard coded Polymer support (@published). The proper way
 // to do this would be to switch to use the analyzer to resolve whether
 // annotations are subtypes of ObservableProperty.
 final observableMatcher =
     new RegExp("@(published|observable|PublishedProperty|ObservableProperty)");