Reducing the amount of code we generate in the compiler: We still continue

lib/src/html_css_fixup.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.
 
 library html_css_fixup;
 
 import 'dart:json' as json;
 
 import 'package:csslib/parser.dart' as css;
 import 'package:csslib/visitor.dart';
 import 'package:html5lib/dom.dart';
 import 'package:html5lib/dom_parsing.dart';
 
 import 'compiler.dart';
 import 'emitters.dart';
 import 'info.dart';
 import 'messages.dart';
 import 'options.dart';
 import 'paths.dart';
 import 'utils.dart';
 
-/**
- * Helper function returns [true] if CSS polyfill is on and component has a
- * scoped style tag.
- */
-bool useCssPolyfill(CompilerOptions opts, ComponentInfo component) =>
-    opts.processCss && component.scoped;
+/** Enum for type of polyfills supported. */
+class CssPolyfillKind {
+  final index;
+  const CssPolyfillKind(this.index);
+
+  /** Emit CSS selectors as seen (no polyfill). */
+  static const NO_POLYFILL = const CssPolyfillKind(0);
+
+  /** Emit CSS selectors scoped to the "is" attribute of the component. */
+  static const SCOPED_POLYFILL = const CssPolyfillKind(1);
+
+  /** Emit CSS selectors mangled. */
+  static const MANGLED_POLYFILL = const CssPolyfillKind(2);
+
+  static CssPolyfillKind of(CompilerOptions options, ComponentInfo component) {
+    if (!options.processCss || !component.scoped) return NO_POLYFILL;
+    if (options.mangleCss) return MANGLED_POLYFILL;
+    if (!component.hasAuthorStyles && !hasCssReset) return MANGLED_POLYFILL;
+    return SCOPED_POLYFILL;
+  }
+}
+
 
 /**
  *  If processCss is enabled, prefix any component's HTML attributes for id or
  *  class to reference the mangled CSS class name or id.
  */
-void fixupHtmlCss(FileInfo fileInfo, CompilerOptions options,
-                  CssPolyfillKind polyfillKind(ComponentInfo component)) {
+void fixupHtmlCss(FileInfo fileInfo, CompilerOptions options) {
   // Walk the HTML tree looking for class names or id that are in our parsed
   // stylesheet selectors and making those CSS classes and ids unique to that
   // component.
   if (options.verbose) {
     print("  CSS fixup ${path.basename(fileInfo.inputUrl.resolvedPath)}");
   }
   for (var component in fileInfo.declaredComponents) {
     // Mangle class names and element ids in the HTML to match the stylesheet.
     // TODO(terry): Allow more than one style sheet per component.
     if (component.styleSheets.length == 1) {
       // For components only 1 stylesheet allowed.
       var styleSheet = component.styleSheets[0];
-      var prefix = polyfillKind(component) == CssPolyfillKind.MANGLED_POLYFILL ?
-          component.tagName : null;
+      var prefix = CssPolyfillKind.of(options, component) ==
+          CssPolyfillKind.MANGLED_POLYFILL ?  component.tagName : null;
 
       // List of referenced #id and .class in CSS.
       var knownCss = new IdClassVisitor()..visitTree(styleSheet);
       // Prefix all id and class refs in CSS selectors and HTML attributes.
       new _ScopedStyleRenamer(knownCss, prefix, options.debugCss)
-          .visit(component.elementNode);
+          .visit(component.element);
     }
   }
 }
 
 /** Build list of every CSS class name and id selector in a stylesheet. */
 class IdClassVisitor extends Visitor {
   final Set<String> classes = new Set();
   final Set<String> ids = new Set();
 
   void visitClassSelector(ClassSelector node) {
     classes.add(node.name);
   }
 
   void visitIdSelector(IdSelector node) {
     ids.add(node.name);
   }
 }
 
 /** Build the Dart map of managled class/id names and component tag name. */
 Map _createCssSimpleSelectors(IdClassVisitor visitedCss, ComponentInfo info,
-    bool mangleNames) {
+    CssPolyfillKind kind) {
+  bool mangleNames = kind == CssPolyfillKind.MANGLED_POLYFILL;
   Map selectors = {};
   if (visitedCss != null) {
     for (var cssClass in visitedCss.classes) {
       selectors['.$cssClass'] =
           mangleNames ? '${info.tagName}_$cssClass' : cssClass;
     }
     for (var id in visitedCss.ids) {
       selectors['#$id'] = mangleNames ? '${info.tagName}_$id' : id;
     }
   }
 
   // Add tag name selector x-comp == [is="x-comp"].
   var componentName = info.tagName;
   selectors['$componentName'] = '[is="$componentName"]';
 
   return selectors;
 }
 
 /**
  * Return a map of simple CSS selectors (class and id selectors) as a Dart map
  * definition.
  */
-String createCssSelectorsExpression(ComponentInfo info, bool mangled) {
+String createCssSelectorsExpression(ComponentInfo info, CssPolyfillKind kind) {
   var cssVisited = new IdClassVisitor();
 
   // For components only 1 stylesheet allowed.
   if (!info.styleSheets.isEmpty && info.styleSheets.length == 1) {
     var styleSheet = info.styleSheets[0];
     cssVisited..visitTree(styleSheet);
   }
 
-  return json.stringify(_createCssSimpleSelectors(cssVisited, info, mangled));
+  return json.stringify(_createCssSimpleSelectors(cssVisited, info, kind));
 }
 
 // TODO(terry): Need to handle other selectors than IDs/classes like tag name
 //              e.g., DIV { color: red; }
 // TODO(terry): Would be nice if we didn't need to mangle names; requires users
 //              to be careful in their code and makes it more than a "polyfill".
 //              Maybe mechanism that generates CSS class name for scoping.  This
 //              would solve tag name selectors (see above TODO).
 /**
  * Fix a component's HTML to implement scoped stylesheets.
@@ skipping 420 matching lines @@
   /** List of @imports found. */
   List<UrlInfo> imports = [];
 
   CssStyleTag(this._packageRoot, this._info, this._inputUrl, this._messages,
       this._options);
 
   void visitElement(Element node) {
     // Don't process any style tags inside of element if we're processing a
     // FileInfo.  The style tags inside of a component defintion will be
     // processed when _info is a ComponentInfo.
-    if (node.tagName == 'element' && _info is FileInfo) return;
+    if (node.tagName == 'polymer-element' && _info is FileInfo) return;
     if (node.tagName == 'style') {
       // Parse the contents of the scoped style tag.
       var styleSheet = parseCss(node.nodes.single.value, _messages, _options);
       if (styleSheet != null) {
         _info.styleSheets.add(styleSheet);
 
         // TODO(terry): Check on scoped attribute there's a rumor that styles
         //              might always be scoped in a component.
         // TODO(terry): May need to handle multiple style tags some with scoped
         //              and some without for now first style tag determines how
         //              CSS is emitted.
         if (node.attributes.containsKey('scoped') && _info is ComponentInfo) {
           (_info as ComponentInfo).scoped = true;
         }
 
         // Find all imports return list of @imports in this style tag.
         var urlInfos = findImportsInStyleSheet(styleSheet, _packageRoot,
             _inputUrl, _messages);
         imports.addAll(urlInfos);
       }
     }
     super.visitElement(node);
   }
 }