Step one towards stable error messages with details:

pkg/polymer/lib/src/build/script_compactor.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.
 
 /// Transfomer that combines multiple dart script tags into a single one.
 library polymer.src.build.script_compactor;
 
 import 'dart:async';
 import 'dart:convert';
 
 import 'package:html5lib/dom.dart' show Document, Element, Text;
 import 'package:html5lib/dom_parsing.dart';
 import 'package:html5lib/parser.dart' show parseFragment;
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart' hide Element;
 import 'package:analyzer/src/generated/element.dart' as analyzer show Element;
 import 'package:barback/barback.dart';
+import 'package:code_transformers/messages/build_logger.dart';
 import 'package:path/path.dart' as path;
 import 'package:source_span/source_span.dart';
 import 'package:smoke/codegen/generator.dart';
 import 'package:smoke/codegen/recorder.dart';
 import 'package:code_transformers/resolver.dart';
 import 'package:code_transformers/src/dart_sdk.dart';
 import 'package:template_binding/src/mustache_tokens.dart' show MustacheTokens;
 
 import 'package:polymer_expressions/expression.dart' as pe;
 import 'package:polymer_expressions/parser.dart' as pe;
 import 'package:polymer_expressions/visitor.dart' as pe;
 
+import 'common.dart';
 import 'import_inliner.dart' show ImportInliner; // just for docs.
-import 'common.dart';
-import 'wrapped_logger.dart';
+import 'messages.dart';
 
 /// Combines Dart script tags into a single script tag, and creates a new Dart
 /// file that calls the main function of each of the original script tags.
 ///
 /// This transformer assumes that all script tags point to external files. To
 /// support script tags with inlined code, use this transformer after running
 /// [ImportInliner] on an earlier phase.
 ///
 /// Internally, this transformer will convert each script tag into an import
 /// statement to a library, and then uses `initPolymer` (see polymer.dart)  to
@@ skipping 58 matching lines @@
   }
 
   Future apply(Transform transform) =>
       new _ScriptCompactor(transform, options, resolvers).apply();
 }
 
 /// Helper class mainly use to flatten the async code.
 class _ScriptCompactor extends PolymerTransformer {
   final TransformOptions options;
   final Transform transform;
-  final TransformLogger logger;
+  final BuildLogger logger;
   final AssetId docId;
   final AssetId bootstrapId;
 
   /// HTML document parsed from [docId].
   Document document;
 
   /// List of ids for each Dart entry script tag (the main tag and any tag
   /// included on each custom element definition).
   List<AssetId> entryLibraries;
 
@@ skipping 17 matching lines @@
   Resolver resolver;
 
   /// Code generator used to create the static initialization for smoke.
   final generator = new SmokeCodeGenerator();
 
   _SubExpressionVisitor expressionVisitor;
 
   _ScriptCompactor(Transform transform, options, this.resolvers)
       : transform = transform,
         options = options,
-        logger = options.releaseMode ? transform.logger :
-          new WrappedLogger(transform, convertErrorsToWarnings: true),
+        logger = new BuildLogger(
+            transform, convertErrorsToWarnings: !options.releaseMode),
         docId = transform.primaryInput.id,
         bootstrapId = transform.primaryInput.id.addExtension('_bootstrap.dart');
 
   Future apply() =>
       _loadDocument()
       .then(_loadEntryLibraries)
       .then(_processHtml)
       .then(_emitNewEntrypoint)
       .then((_) {
-        // Write out the logs collected by our [WrappedLogger].
-        if (options.injectBuildLogsInOutput && logger is WrappedLogger) {
-          return (logger as WrappedLogger).writeOutput();
-        }
+        // Write out the logs collected by our [BuildLogger].
+        if (options.injectBuildLogsInOutput) return logger.writeOutput();
       });
 
   /// Loads the primary input as an html document.
   Future _loadDocument() =>
-      readPrimaryAsHtml(transform).then((doc) { document = doc; });
+      readPrimaryAsHtml(transform, logger).then((doc) { document = doc; });
 
   /// Populates [entryLibraries] as a list containing the asset ids of each
   /// library loaded on a script tag. The actual work of computing this is done
   /// in an earlier phase and emited in the `entrypoint._data` asset.
   Future _loadEntryLibraries(_) =>
       transform.readInputAsString(docId.addExtension('._data')).then((data) {
         var map = JSON.decode(data);
         experimentalBootstrap = map['experimental_bootstrap'];
         entryLibraries = map['script_ids']
               .map((id) => new AssetId.deserialize(id))
               .toList();
+        return Future.forEach(entryLibraries, logger.addLogFilesFromAsset);
       });
 
   /// Removes unnecessary script tags, and identifies the main entry point Dart
   /// script tag (if any).
   void _processHtml(_) {
     for (var tag in document.querySelectorAll('script')) {
       var src = tag.attributes['src'];
       if (src == 'packages/polymer/boot.js') {
         tag.remove();
         continue;
       }
       if (tag.attributes['type'] == 'application/dart') {
-        logger.warning('unexpected script. The '
-          'ScriptCompactor transformer should run after running the '
-          'ImportInliner', span: tag.sourceSpan);
+        logger.warning(INTERNAL_ERROR_UNEXPECTED_SCRIPT, span: tag.sourceSpan);
       }
     }
   }
 
   /// Emits the main HTML and Dart bootstrap code for the application. If there
   /// were not Dart entry point files, then this simply emits the original HTML.
   Future _emitNewEntrypoint(_) {
     // If we don't find code, there is nothing to do.
     if (entryLibraries.isEmpty) return null;
     return _initResolver()
@@ skipping 75 matching lines @@
     // Check whether the class has a @CustomTag annotation. Typically we expect
     // a single @CustomTag, but it's possible to have several.
     var tagNames = [];
     for (var meta in cls.node.metadata) {
       var tagName = _extractTagName(meta, cls);
       if (tagName != null) tagNames.add(tagName);
     }
 
     if (cls.isPrivate && tagNames.isNotEmpty) {
       var name = tagNames.first;
-      logger.error('@CustomTag is not currently supported on private classes:'
-          ' $name. Consider making this class public, or create a '
-          'public initialization method marked with `@initMethod` that calls '
-          '`Polymer.register($name, ${cls.name})`.',
+      logger.error(PRIVATE_CUSTOM_TAG.create(
+              {'name': name, 'class': cls.name}),
           span: _spanForNode(cls, cls.node.name));
       return;
     }
 
     // Include #registerCallback if it exists. Note that by default lookupMember
     // and query will also add the corresponding getters and setters.
     recorder.lookupMember(cls, 'registerCallback');
 
     // Include methods that end with *Changed.
     recorder.runQuery(cls, new QueryOptions(
@@ skipping 61 matching lines @@
   }
 
   /// Extract the first argument of an annotation and validate that it's type is
   /// String. For instance, return "bar" from `@Foo("bar")`.
   String _extractFirstAnnotationArgument(Annotation meta, String name,
       analyzer.Element context) {
 
     // Read argument from the AST
     var args = meta.arguments.arguments;
     if (args == null || args.length == 0) {
-      logger.warning('Missing argument in @$name annotation',
+      logger.warning(MISSING_ANNOTATION_ARGUMENT.create({'name': name}),
           span: _spanForNode(context, meta));
       return null;
     }
 
     var lib = context;
     while (lib is! LibraryElement) lib = lib.enclosingElement;
     var res = resolver.evaluateConstant(lib, args[0]);
     if (!res.isValid || res.value.type != types.stringType) {
-      logger.warning('The parameter to @$name seems to be invalid.',
+      logger.warning(INVALID_ANNOTATION_ARGUMENT.create({'name': name}),
           span: _spanForNode(context, args[0]));
       return null;
     }
     return res.value.stringValue;
   }
 
   /// Adds the top-level [function] as an initalizer if it's marked with
   /// `@initMethod`.
   _processFunction(FunctionElement function, AssetId id) {
     bool initMethodFound = false;
     for (var meta in function.metadata) {
       var e = meta.element;
       if (e is PropertyAccessorElement &&
           e.variable == types.initMethodElement) {
         initMethodFound = true;
         break;
       }
     }
     if (!initMethodFound) return;
     if (function.isPrivate) {
-      logger.error('@initMethod is no longer supported on private '
-          'functions: ${function.displayName}',
+      logger.error(PRIVATE_INIT_METHOD.create({'name': function.displayName}),
           span: _spanForNode(function, function.node.name));
       return;
     }
     initializers.add(new _InitMethodInitializer(id, function.displayName));
   }
 
   /// Process members that are annotated with `@ComputedProperty` and records
   /// the accessors of their expressions.
   _processComputedExpressions(List<analyzer.Element> computed) {
     var constructor = types.computedPropertyElement.constructors.first;
@@ skipping 47 matching lines @@
 
     // Include initializers to switch from mirrors_loader to static_loader.
     if (!initializers.isEmpty) {
       code.writeln();
       for (var init in initializers) {
         var initCode = init.asCode(prefixes[init.assetId]);
         code.write("      $initCode,\n");
       }
       code.writeln('    ]);');
     } else {
-      if (experimentalBootstrap) logger.warning(NO_INITIALIZERS_ERROR);
+      if (experimentalBootstrap) logger.warning(NO_INITIALIZATION);
       code.writeln(']);');
     }
     if (!experimentalBootstrap) {
       code.writeln('  i${entryLibraries.length - 1}.main();');
     }
 
     // End of main().
     code.writeln('}');
     transform.addOutput(new Asset.fromString(bootstrapId, code.toString()));
 
@@ skipping 44 matching lines @@
   String asCode(String prefix) =>
       "() => Polymer.register('$tagName', $prefix.$typeName)";
 }
 
 const MAIN_HEADER = """
 library app_bootstrap;
 
 import 'package:polymer/polymer.dart';
 """;
 
-const NO_INITIALIZERS_ERROR =
-    'No polymer initializers were found. Make sure to either '
-    'annotate your polymer elements with @CustomTag or include a '
-    'top level method annotated with @initMethod that registers your '
-    'elements. Both annotations are defined in the polymer library ('
-    'package:polymer/polymer.dart).';
 
 /// An html visitor that:
 ///   * finds all polymer expressions and records the getters and setters that
 ///     will be needed to evaluate them at runtime.
 ///   * extracts all attributes declared in the `attribute` attributes of
 ///     polymer elements.
 class _HtmlExtractor extends TreeVisitor {
   final Map<String, List<String>> publishedAttributes;
   final SmokeCodeGenerator generator;
   final _SubExpressionVisitor expressionVisitor;
-  final TransformLogger logger;
+  final BuildLogger logger;
   bool _inTemplate = false;
 
   _HtmlExtractor(this.logger, this.generator, this.publishedAttributes,
       this.expressionVisitor);
 
   void visitElement(Element node) {
     if (_inTemplate) _processNormalElement(node);
     if (node.localName == 'polymer-element') {
       _processPolymerElement(node);
       _processNormalElement(node);
@@ skipping 52 matching lines @@
         _addExpression(exp, isEvent, isTwoWay, node.sourceSpan);
       }
     });
   }
 
   void _addExpression(String stringExpression, bool inEvent, bool isTwoWay,
       SourceSpan span) {
 
     if (inEvent) {
       if (stringExpression.startsWith('@')) {
-        logger.warning('event bindings with @ are no longer supported',
-            span: span);
+        logger.warning(AT_EXPRESSION_REMOVED, span: span);
         return;
       }
 
       if (stringExpression == '') return;
       if (stringExpression.startsWith('_')) {
-        logger.warning('private symbols cannot be used in event handlers',
-            span: span);
+        logger.warning(NO_PRIVATE_EVENT_HANDLERS, span: span);
         return;
       }
       generator.addGetter(stringExpression);
       generator.addSymbol(stringExpression);
     }
     expressionVisitor.run(pe.parse(stringExpression), isTwoWay, span);
   }
 }
 
 /// A polymer-expression visitor that records every getter and setter that will
 /// be needed to evaluate a single expression at runtime.
 class _SubExpressionVisitor extends pe.RecursiveVisitor {
   final SmokeCodeGenerator generator;
-  final TransformLogger logger;
+  final BuildLogger logger;
   bool _includeSetter;
   SourceSpan _currentSpan;
 
   _SubExpressionVisitor(this.generator, this.logger);
 
   /// Visit [exp], and record getters and setters that are needed in order to
   /// evaluate it at runtime. [includeSetter] is only true if this expression
   /// occured in a context where it could be updated, for example in two-way
   /// bindings such as `<input value={{exp}}>`.
   void run(pe.Expression exp, bool includeSetter, span) {
     _currentSpan = span;
     _includeSetter = includeSetter;
     visit(exp);
   }
 
   /// Adds a getter and symbol for [name], and optionally a setter.
   _add(String name) {
     if (name.startsWith('_')) {
-      logger.warning('private symbols are not supported', span: _currentSpan);
+      logger.warning(NO_PRIVATE_SYMBOLS_IN_BINDINGS, span: _currentSpan);
       return;
     }
     generator.addGetter(name);
     generator.addSymbol(name);
     if (_includeSetter) generator.addSetter(name);
   }
 
   void preVisitExpression(e) {
     // For two-way bindings the outermost expression may be updated, so we need
     // both the getter and the setter, but we only need the getter for
@@ skipping 171 matching lines @@
   for (var c in combinators) {
     if (c is ShowElementCombinator) {
       var show = c.shownNames.toSet();
       elements.retainWhere((e) => show.contains(e.displayName));
     } else if (c is HideElementCombinator) {
       var hide = c.hiddenNames.toSet();
       elements.removeWhere((e) => hide.contains(e.displayName));
     }
   }
 }