Fixing Polymer linter warnings error on transform changes

pkg/polymer/lib/src/build/linter.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.
 
 /**
  * Logic to validate that developers are correctly using Polymer constructs.
  * This is mainly used to produce warnings for feedback in the editor.
  */
 library polymer.src.build.linter;
 
@@ skipping 77 matching lines @@
     for (var tag in document.queryAll('link')) {
       if (tag.attributes['rel'] != 'import') continue;
       var href = tag.attributes['href'];
       var span = tag.sourceSpan;
       var id = resolve(sourceId, href, logger, span);
       if (id == null) continue;
       importIds.add(assetExists(id, transform).then((exists) {
         if (exists) return id;
         if (sourceId == transform.primaryInput.id) {
           logger.error('couldn\'t find imported asset "${id.path}" in package '
-              '"${id.package}".', span);
+              '"${id.package}".', span: span);
         }
       }));
     }
     return Future.wait(importIds);
   }
 
   void _addElements(Document document, TransformLogger logger,
       Map<String, _ElementSummary> elements) {
     for (var tag in document.queryAll('polymer-element')) {
       var name = tag.attributes['name'];
       if (name == null) continue;
       var extendsTag = tag.attributes['extends'];
       var span = tag.sourceSpan;
       var existing = elements[name];
       if (existing != null) {
 
         // Report warning only once.
         if (existing.hasConflict) continue;
         existing.hasConflict = true;
         logger.warning('duplicate definition for custom tag "$name".',
-          existing.span);
+          span: existing.span);
         logger.warning('duplicate definition for custom tag "$name" '
-          ' (second definition).', span);
+          ' (second definition).', span: span);
         continue;
       }
 
       elements[name] = new _ElementSummary(name, extendsTag, tag.sourceSpan);
     }
   }
 }
 
 /** A proxy of [Transform] that returns a different logger. */
 // TODO(sigmund): get rid of this when barback supports a better way to log
 // messages without printing them.
 class _LoggerInterceptor implements Transform, TransformLogger {
   final Transform _original;
   final List<String> _messages = [];
   final MessageFormatter _formatter;
 
   _LoggerInterceptor(this._original, MessageFormatter formatter)
       : _formatter = formatter == null ? consoleFormatter : formatter;
 
   TransformLogger get logger => this;
 
   noSuchMethod(Invocation m) => reflect(_original).delegate(m);
 
   // form TransformLogger:
-  void warning(String message, [Span span]) => _write('warning', message, span);
+  void warning(String message, {AssetId asset, Span span})
+      => _write('warning', message, span);
 
-  void error(String message, [Span span]) => _write('error', message, span);
+  void error(String message, {AssetId asset, Span span})
+      => _write('error', message, span);
 
   void _write(String kind, String message, Span span) {
     _messages.add(_formatter(kind, message, span));
   }
 }
 
 /**
  * Formatter that generates messages using a format that can be parsed
  * by tools, such as the Dart Editor, for reporting error messages.
  */
@@ skipping 84 matching lines @@
 
   /** Produce warnings for invalid link-rel tags. */
   void _validateLinkElement(Element node) {
     var rel = node.attributes['rel'];
     if (rel != 'import' && rel != 'stylesheet') return;
 
     var href = node.attributes['href'];
     if (href != null && href != '') return;
 
     // TODO(sigmund): warn also if href can't be resolved.
-    _logger.warning('link rel="$rel" missing href.', node.sourceSpan);
+    _logger.warning('link rel="$rel" missing href.', span: node.sourceSpan);
   }
 
   /** Produce warnings if using `<element>` instead of `<polymer-element>`. */
   void _validateElementElement(Element node) {
     _logger.warning('<element> elements are not supported, use'
-        ' <polymer-element> instead', node.sourceSpan);
+        ' <polymer-element> instead', span: node.sourceSpan);
   }
 
   /**
    * Produce warnings if using `<polymer-element>` in the wrong place or if the
    * definition is not complete.
    */
   void _validatePolymerElement(Element node) {
     if (_inPolymerElement) {
       _logger.error('Nested polymer element definitions are not allowed.',
-          node.sourceSpan);
+          span: node.sourceSpan);
       return;
     }
 
     var tagName = node.attributes['name'];
     var extendsTag = node.attributes['extends'];
 
     if (tagName == null) {
       _logger.error('Missing tag name of the custom element. Please include an '
           'attribute like \'name="your-tag-name"\'.',
-          node.sourceSpan);
+          span: node.sourceSpan);
     } else if (!_isCustomTag(tagName)) {
       _logger.error('Invalid name "$tagName". Custom element names must have '
           'at least one dash and can\'t be any of the following names: '
           '${_invalidTagNames.keys.join(", ")}.',
-          node.sourceSpan);
+          span: node.sourceSpan);
     }
 
     if (_elements[extendsTag] == null && _isCustomTag(extendsTag)) {
       _logger.warning('custom element with name "$extendsTag" not found.',
-          node.sourceSpan);
+          span: node.sourceSpan);
     }
 
     var attrs = node.attributes['attributes'];
     if (attrs != null) {
       var attrsSpan = node.attributeSpans['attributes'];
 
       // names='a b c' or names='a,b,c'
       // record each name for publishing
       for (var attr in attrs.split(attrs.contains(',') ? ',' : ' ')) {
         // remove excess ws
@@ skipping 24 matching lines @@
     var src = node.attributes['src'];
 
     if (scriptType == null) {
       if (src == null && _inPolymerElement) {
         // TODO(sigmund): revisit this check once we start interop with polymer
         // elements written in JS. Maybe we need to inspect the contents of the
         // script to find whether there is an import or something that indicates
         // that the code is indeed using Dart.
         _logger.warning('script tag in polymer element with no type will '
             'be treated as JavaScript. Did you forget type="application/dart"?',
-            node.sourceSpan);
+            span: node.sourceSpan);
       }
       if (src != null && src.endsWith('.dart')) {
         _logger.warning('script tag with .dart source file but no type will '
             'be treated as JavaScript. Did you forget type="application/dart"?',
-            node.sourceSpan);
+            span: node.sourceSpan);
       }
       return;
     }
 
     if (scriptType != 'application/dart') return;
 
     if (src != null) {
       if (!src.endsWith('.dart')) {
         _logger.warning('"application/dart" scripts should '
             'use the .dart file extension.',
-            node.sourceSpan);
+            span: node.sourceSpan);
       }
 
       if (node.innerHtml.trim() != '') {
         _logger.warning('script tag has "src" attribute and also has script '
-            'text.', node.sourceSpan);
+            'text.', span: node.sourceSpan);
       }
     }
   }
 
   /**
    * Produces warnings for misuses of on-foo event handlers, and for instanting
    * custom tags incorrectly.
    */
   void _validateNormalElement(Element node) {
     // Event handlers only allowed inside polymer-elements
@@ skipping 18 matching lines @@
     }
 
     if (customTagName == null || customTagName == 'polymer-element') return;
 
     var info = _elements[customTagName];
     if (info == null) {
       // TODO(jmesserly): this warning is wrong if someone is using raw custom
       // elements. Is there another way we can handle this warning that won't
       // generate false positives?
       _logger.warning('definition for Polymer element with tag name '
-          '"$customTagName" not found.', node.sourceSpan);
+          '"$customTagName" not found.', span: node.sourceSpan);
       return;
     }
 
     var baseTag = info.baseExtendsTag;
     if (baseTag != null && !hasIsAttribute) {
       _logger.warning(
           'custom element "$customTagName" extends from "$baseTag", but '
           'this tag will not include the default properties of "$baseTag". '
           'To fix this, either write this tag as <$baseTag '
           'is="$customTagName"> or remove the "extends" attribute from '
-          'the custom element declaration.', node.sourceSpan);
+          'the custom element declaration.', span: node.sourceSpan);
       return;
     }
 
     if (hasIsAttribute && baseTag == null) {
       _logger.warning(
           'custom element "$customTagName" doesn\'t declare any type '
           'extensions. To fix this, either rewrite this tag as '
           '<$customTagName> or add \'extends="$nodeTag"\' to '
-          'the custom element declaration.', node.sourceSpan);
+          'the custom element declaration.', span: node.sourceSpan);
       return;
     }
 
     if (hasIsAttribute && baseTag != nodeTag) {
       _logger.warning(
           'custom element "$customTagName" extends from "$baseTag". '
           'Did you mean to write <$baseTag is="$customTagName">?',
-          node.sourceSpan);
+          span: node.sourceSpan);
     }
   }
 
   /**
    * Validate an attribute on a custom-element. Returns true if valid.
    */
   bool _validateCustomAttributeName(String name, FileSpan span) {
     if (name.contains('-')) {
       var newName = toCamelCase(name);
       _logger.warning('PolymerElement no longer recognizes attribute names with '
           'dashes such as "$name". Use "$newName" or "${newName.toLowerCase()}" '
-          'instead (both forms are equivalent in HTML).', span);
+          'instead (both forms are equivalent in HTML).', span: span);
       return false;
     }
     return true;
   }
 
   /** Validate event handlers are used correctly. */
   void _validateEventHandler(Element node, String name, String value) {
     if (!name.startsWith('on-')) {
       _logger.warning('Event handler "$name" will be interpreted as an inline'
           ' JavaScript event handler. Use the form '
           'on-event-name="handlerName" if you want a Dart handler '
           'that will automatically update the UI based on model changes.',
-          node.attributeSpans[name]);
+          span: node.attributeSpans[name]);
       return;
     }
 
     if (!_inPolymerElement) {
       _logger.warning('Inline event handlers are only supported inside '
-          'declarations of <polymer-element>.', node.attributeSpans[name]);
+          'declarations of <polymer-element>.',
+          span: node.attributeSpans[name]);
     }
 
     var eventName = name.substring('on-'.length);
     if (eventName.contains('-')) {
       var newEvent = toCamelCase(eventName);
       _logger.warning('Invalid event name "$name". After the "on-" the event '
           'name should not use dashes. For example use "on-$newEvent" or '
           '"on-${newEvent.toLowerCase()}" (both forms are equivalent in HTML).',
-          node.attributeSpans[name]);
+          span: node.attributeSpans[name]);
     }
 
     if (value.contains('.') || value.contains('(')) {
       _logger.warning('Invalid event handler body "$value". Declare a method '
           'in your custom element "void handlerName(event, detail, target)" '
           'and use the form $name="handlerName".',
-          node.attributeSpans[name]);
+          span: node.attributeSpans[name]);
     }
   }
 }
 
 
 // These names have meaning in SVG or MathML, so they aren't allowed as custom
 // tags.
 var _invalidTagNames = const {
   'annotation-xml': '',
   'color-profile': '',
@@ skipping 10 matching lines @@
  * <https://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/custom/index.html#dfn-custom-element-name>
  */
 bool _isCustomTag(String name) {
   if (name == null || !name.contains('-')) return false;
   return !_invalidTagNames.containsKey(name);
 }
 
 final String _RED_COLOR = '\u001b[31m';
 final String _MAGENTA_COLOR = '\u001b[35m';
 final String _NO_COLOR = '\u001b[0m';