Step one towards stable error messages with details:

pkg/polymer/lib/src/build/import_inliner.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 inlines polymer-element definitions from html imports.
 library polymer.src.build.import_inliner;
 
 import 'dart:async';
 import 'dart:convert';
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:barback/barback.dart';
 import 'package:code_transformers/assets.dart';
+import 'package:code_transformers/messages/build_logger.dart';
 import 'package:path/path.dart' as path;
 import 'package:html5lib/dom.dart' show
     Document, DocumentFragment, Element, Node;
 import 'package:html5lib/dom_parsing.dart' show TreeVisitor;
 import 'package:source_maps/refactor.dart' show TextEditTransaction;
 import 'package:source_span/source_span.dart';
 
 import 'common.dart';
-import 'wrapped_logger.dart';
+import 'messages.dart';
 
 // TODO(sigmund): move to web_components package (dartbug.com/18037).
 class _HtmlInliner extends PolymerTransformer {
   final TransformOptions options;
   final Transform transform;
-  final TransformLogger logger;
+  final BuildLogger logger;
   final AssetId docId;
   final seen = new Set<AssetId>();
   final scriptIds = <AssetId>[];
   final extractedFiles = new Set<AssetId>();
   bool experimentalBootstrap = false;
 
   /// The number of extracted inline Dart scripts. Used as a counter to give
   /// unique-ish filenames.
   int inlineScriptCounter = 0;
 
   _HtmlInliner(TransformOptions options, Transform transform)
       : options = options,
         transform = transform,
-        logger = options.releaseMode ? transform.logger :
-            new WrappedLogger(transform, convertErrorsToWarnings: true),
+        logger = new BuildLogger(transform,
+            convertErrorsToWarnings: !options.releaseMode),
         docId = transform.primaryInput.id;
 
   Future apply() {
     seen.add(docId);
 
     Document document;
     bool changed = false;
 
-    return readPrimaryAsHtml(transform).then((doc) {
+    return readPrimaryAsHtml(transform, logger).then((doc) {
       document = doc;
       changed = new _UrlNormalizer(transform, docId, logger).visit(document)
         || changed;
       
       experimentalBootstrap = document.querySelectorAll('link').any((link) =>
           link.attributes['rel'] == 'import' &&
           link.attributes['href'] == POLYMER_EXPERIMENTAL_HTML);
       changed = _extractScripts(document) || changed;
       return _visitImports(document);
     }).then((importsFound) {
       changed = changed || importsFound;
       return _removeScripts(document);
     }).then((scriptsRemoved) {
       changed = changed || scriptsRemoved;
 
       var output = transform.primaryInput;
       if (changed) output = new Asset.fromString(docId, document.outerHtml);
       transform.addOutput(output);
 
       // We produce a secondary asset with extra information for later phases.
       transform.addOutput(new Asset.fromString(
           docId.addExtension('._data'),
           JSON.encode({
             'experimental_bootstrap': experimentalBootstrap,
             'script_ids': scriptIds,
           }, toEncodable: (id) => id.serialize())));
 
-      // 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();
       }
     });
   }
 
   /// Visits imports in [document] and add the imported documents to documents.
   /// Documents are added in the order they appear, transitive imports are added
   /// first.
   ///
   /// Returns `true` if and only if the document was changed and should be
   /// written out.
@@ skipping 53 matching lines @@
           tag == 'link' && (rel == 'stylesheet' || rel == 'import')) {
         // Move the node into the body, where its contents will be placed.
         doc.body.insertBefore(node, insertionPoint);
       }
     }
   }
 
   /// Loads an asset identified by [id], visits its imports and collects its
   /// html imports. Then inlines it into the main document.
   Future _inlineImport(AssetId id, Element link) {
-    return readAsHtml(id, transform).catchError((error) {
-      logger.error(
-          "Failed to inline html import: $error", asset: id,
+    return readAsHtml(id, transform, logger).catchError((error) {
+      logger.error(INLINE_IMPORT_FAIL.create({'error': error}),
           span: link.sourceSpan);
     }).then((doc) {
       if (doc == null) return false;
       new _UrlNormalizer(transform, id, logger).visit(doc);
       return _visitImports(doc).then((_) {
         // _UrlNormalizer already ensures there is a library name.
         _extractScripts(doc, injectLibraryName: false);
 
         // TODO(jmesserly): figure out how this is working in vulcanizer.
         // Do they produce a <body> tag with a <head> and <body> inside?
         var imported = new DocumentFragment();
         imported.nodes..addAll(doc.head.nodes)..addAll(doc.body.nodes);
         link.replaceWith(imported);
 
         // Make sure to grab any logs from the inlined import.
-        if (logger is WrappedLogger) {
-          return (logger as WrappedLogger).addLogFilesFromAsset(id);
-        }
+        return logger.addLogFilesFromAsset(id);
       });
     });
   }
 
   Future _inlineStylesheet(AssetId id, Element link) {
     return transform.readInputAsString(id).catchError((error) {
       // TODO(jakemac): Move this warning to the linter once we can make it run
       // always (see http://dartbug.com/17199). Then hide this error and replace
       // with a comment pointing to the linter error (so we don't double warn).
-      logger.warning(
-          "Failed to inline stylesheet: $error", asset: id,
+      logger.warning(INLINE_STYLE_FAIL.create({'error': error}),
           span: link.sourceSpan);
     }).then((css) {
       if (css == null) return null;
       css = new _UrlNormalizer(transform, id, logger).visitCss(css);
       var styleElement = new Element.tag('style')..text = css;
       // Copy over the extra attributes from the link tag to the style tag.
       // This adds support for no-shim, shim-shadowdom, etc.
       link.attributes.forEach((key, value) {
         if (!IGNORED_LINKED_STYLE_ATTRS.contains(key)) {
           styleElement.attributes[key] = value;
@@ skipping 19 matching lines @@
         // We check for extractedFiles because 'hasInput' below is only true for
         // assets that existed before this transformer runs (hasInput is false
         // for files created by [_extractScripts]).
         if (extractedFiles.contains(srcId)) {
           scriptIds.add(srcId);
           return true;
         }
 
         return transform.hasInput(srcId).then((exists) {
           if (!exists) {
-            logger.warning('Script file at "$src" not found.',
+            logger.warning(SCRIPT_FILE_NOT_FOUND.create({'url': src}),
               span: script.sourceSpan);
           } else {
             scriptIds.add(srcId);
           }
         });
       }
     }).then((_) => changed);
   }
 
   /// Split inline scripts into their own files. We need to do this for dart2js
@@ skipping 96 matching lines @@
   /// Counter used to ensure that every library name we inject is unique.
   int _count = 0;
 
   /// Path to the top level folder relative to the transform primaryInput.
   /// This should just be some arbitrary # of ../'s.
   final String topLevelPath;
 
   /// Whether or not the normalizer has changed something in the tree.
   bool changed = false;
 
-  final TransformLogger logger;
+  final BuildLogger logger;
 
   _UrlNormalizer(transform, this.sourceId, this.logger)
       : transform = transform,
         topLevelPath =
           '../' * (transform.primaryInput.id.path.split('/').length - 2);
 
   visit(Node node) {
     super.visit(node);
     return changed;
   }
 
   visitElement(Element node) {
     // TODO(jakemac): Support custom elements that extend html elements which
     // have url-like attributes. This probably means keeping a list of which
     // html elements support each url-like attribute.
     if (!isCustomTagName(node.localName)) {
       node.attributes.forEach((name, value) {
         if (_urlAttributes.contains(name)) {
           if (!name.startsWith('_') && value.contains(_BINDING_REGEX)) {
-            logger.warning(
-                'When using bindings with the "$name" attribute you may '
-                'experience errors in certain browsers. Please use the '
-                '"_$name" attribute instead. For more information, see '
-                'http://goo.gl/5av8cU', span: node.sourceSpan, asset: sourceId);
+            logger.warning(USE_UNDERSCORE_PREFIX.create({'name': name}),
+                span: node.sourceSpan, asset: sourceId);
           } else if (name.startsWith('_') && !value.contains(_BINDING_REGEX)) {
-            logger.warning(
-                'The "$name" attribute is only supported when using bindings. '
-                'Please change to the "${name.substring(1)}" attribute.',
+            logger.warning(DONT_USE_UNDERSCORE_PREFIX.create(
+                  {'name': name.substring(1)}),
                 span: node.sourceSpan, asset: sourceId);
           }
           if (value != '' && !value.trim().startsWith(_BINDING_REGEX)) {
             node.attributes[name] = _newUrl(value, node.sourceSpan);
             changed = changed || value != node.attributes[name];
           }
         }
       });
     }
     if (node.localName == 'style') {
@@ skipping 12 matching lines @@
 
   static final _URL = new RegExp(r'url\(([^)]*)\)', multiLine: true);
   static final _QUOTE = new RegExp('["\']', multiLine: true);
 
   /// Visit the CSS text and replace any relative URLs so we can inline it.
   // Ported from:
   // https://github.com/Polymer/vulcanize/blob/c14f63696797cda18dc3d372b78aa3378acc691f/lib/vulcan.js#L149
   // TODO(jmesserly): use csslib here instead? Parsing with RegEx is sadness.
   // Maybe it's reliable enough for finding URLs in CSS? I'm not sure.
   String visitCss(String cssText) {
-    var url = spanUrlFor(sourceId, transform);
+    var url = spanUrlFor(sourceId, transform, logger);
     var src = new SourceFile(cssText, url: url);
     return cssText.replaceAllMapped(_URL, (match) {
       // Extract the URL, without any surrounding quotes.
       var span = src.span(match.start, match.end);
       var href = match[1].replaceAll(_QUOTE, '');
       href = _newUrl(href, span);
       return 'url($href)';
     });
   }
 
   String visitInlineDart(String code) {
     var unit = parseDirectives(code, suppressErrors: true);
-    var file = new SourceFile(code, url: spanUrlFor(sourceId, transform));
+    var file = new SourceFile(code,
+        url: spanUrlFor(sourceId, transform, logger));
     var output = new TextEditTransaction(code, file);
     var foundLibraryDirective = false;
     for (Directive directive in unit.directives) {
       if (directive is UriBasedDirective) {
         var uri = directive.uri.stringValue;
         var span = _getSpan(file, directive.uri);
 
         var id = uriToAssetId(sourceId, uri, logger, span,
             errorOnAbsolute: false);
         if (id == null) continue;
@@ skipping 56 matching lines @@
     if (newPath.startsWith('lib/')) {
       return '${topLevelPath}packages/${id.package}/${newPath.substring(4)}';
     }
 
     if (newPath.startsWith('asset/')) {
       return '${topLevelPath}assets/${id.package}/${newPath.substring(6)}';
     }
 
     if (primaryId.package != id.package) {
       // Techincally we shouldn't get there
-      logger.error("don't know how to include $id from $primaryId", span: span);
+      logger.error(INTERNAL_ERROR_DONT_KNOW_HOW_TO_IMPORT.create({
+          'target': id, 'source': primaryId, 'extra': ''}), span: span);
       return href;
     }
 
     var builder = path.url;
     return builder.relative(builder.join('/', newPath),
         from: builder.join('/', builder.dirname(primaryId.path)));
   }
 }
 
 /// HTML attributes that expect a URL value.
@@ skipping 21 matching lines @@
 /// style tag except these ones.
 const IGNORED_LINKED_STYLE_ATTRS =
     const ['charset', 'href', 'href-lang', 'rel', 'rev'];
 
 /// Global RegExp objects.
 final _INVALID_LIB_CHARS_REGEX = new RegExp('[^a-z0-9_]');
 final _NUM_REGEX = new RegExp('[0-9]');
 final _BINDING_REGEX = new RegExp(r'(({{.*}})|(\[\[.*\]\]))');
 
 _getSpan(SourceFile file, AstNode node) => file.span(node.offset, node.end);