pkg/csslib: formatting

lib/src/tree.dart

 // Copyright (c) 2012, 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.
 
 part of csslib.visitor;
 
 /////////////////////////////////////////////////////////////////////////
 // CSS specific types:
 /////////////////////////////////////////////////////////////////////////
 
 class Identifier extends TreeNode {
   String name;
 
-  Identifier(this.name, SourceSpan span): super(span);
+  Identifier(this.name, SourceSpan span) : super(span);
 
   Identifier clone() => new Identifier(name, span);
 
   visit(VisitorBase visitor) => visitor.visitIdentifier(this);
 
   String toString() => name;
 }
 
 class Wildcard extends TreeNode {
-  Wildcard(SourceSpan span): super(span);
+  Wildcard(SourceSpan span) : super(span);
   Wildcard clone() => new Wildcard(span);
   visit(VisitorBase visitor) => visitor.visitWildcard(this);
 
   String get name => '*';
 }
 
 class ThisOperator extends TreeNode {
-  ThisOperator(SourceSpan span): super(span);
+  ThisOperator(SourceSpan span) : super(span);
   ThisOperator clone() => new ThisOperator(span);
   visit(VisitorBase visitor) => visitor.visitThisOperator(this);
 
   String get name => '&';
 }
 
 class Negation extends TreeNode {
-  Negation(SourceSpan span): super(span);
+  Negation(SourceSpan span) : super(span);
   Negation clone() => new Negation(span);
   visit(VisitorBase visitor) => visitor.visitNegation(this);
 
   String get name => 'not';
 }
 
 // /*  ....   */
 class CssComment extends TreeNode {
   final String comment;
 
-  CssComment(this.comment, SourceSpan span): super(span);
+  CssComment(this.comment, SourceSpan span) : super(span);
   CssComment clone() => new CssComment(comment, span);
   visit(VisitorBase visitor) => visitor.visitCssComment(this);
 }
 
 // CDO/CDC (Comment Definition Open <!-- and Comment Definition Close -->).
 class CommentDefinition extends CssComment {
-  CommentDefinition(String comment, SourceSpan span): super(comment, span);
+  CommentDefinition(String comment, SourceSpan span) : super(comment, span);
   CommentDefinition clone() => new CommentDefinition(comment, span);
   visit(VisitorBase visitor) => visitor.visitCommentDefinition(this);
 }
 
 class SelectorGroup extends TreeNode {
   final List<Selector> selectors;
 
-  SelectorGroup(this.selectors, SourceSpan span): super(span);
+  SelectorGroup(this.selectors, SourceSpan span) : super(span);
 
   SelectorGroup clone() => new SelectorGroup(selectors, span);
 
   visit(VisitorBase visitor) => visitor.visitSelectorGroup(this);
 }
 
 class Selector extends TreeNode {
   final List<SimpleSelectorSequence> simpleSelectorSequences;
 
   Selector(this.simpleSelectorSequences, SourceSpan span) : super(span);
 
   void add(SimpleSelectorSequence seq) => simpleSelectorSequences.add(seq);
 
   int get length => simpleSelectorSequences.length;
 
   Selector clone() {
-    var simpleSequences = simpleSelectorSequences
-        .map((ss) => ss.clone())
-        .toList();
+    var simpleSequences =
+        simpleSelectorSequences.map((ss) => ss.clone()).toList();
 
     return new Selector(simpleSequences, span);
   }
 
   visit(VisitorBase visitor) => visitor.visitSelector(this);
 }
 
 class SimpleSelectorSequence extends TreeNode {
   /** +, >, ~, NONE */
   int combinator;
   final SimpleSelector simpleSelector;
 
   SimpleSelectorSequence(this.simpleSelector, SourceSpan span,
       [int combinator = TokenKind.COMBINATOR_NONE])
-      : combinator = combinator, super(span);
+      : combinator = combinator,
+        super(span);
 
   bool get isCombinatorNone => combinator == TokenKind.COMBINATOR_NONE;
   bool get isCombinatorPlus => combinator == TokenKind.COMBINATOR_PLUS;
   bool get isCombinatorGreater => combinator == TokenKind.COMBINATOR_GREATER;
   bool get isCombinatorTilde => combinator == TokenKind.COMBINATOR_TILDE;
   bool get isCombinatorDescendant =>
       combinator == TokenKind.COMBINATOR_DESCENDANT;
 
-  String get _combinatorToString =>
-      isCombinatorDescendant ? ' ' :
-          isCombinatorPlus ? ' + ' :
-              isCombinatorGreater ? ' > ' :
-                  isCombinatorTilde ? ' ~ ' : '';
+  String get _combinatorToString => isCombinatorDescendant
+      ? ' '
+      : isCombinatorPlus
+          ? ' + '
+          : isCombinatorGreater ? ' > ' : isCombinatorTilde ? ' ~ ' : '';
 
   SimpleSelectorSequence clone() =>
       new SimpleSelectorSequence(simpleSelector, span, combinator);
 
   visit(VisitorBase visitor) => visitor.visitSimpleSelectorSequence(this);
 
   String toString() => simpleSelector.name;
 }
 
 /* All other selectors (element, #id, .class, attribute, pseudo, negation,
@@ skipping 18 matching lines @@
   ElementSelector(name, SourceSpan span) : super(name, span);
   visit(VisitorBase visitor) => visitor.visitElementSelector(this);
 
   ElementSelector clone() => new ElementSelector(_name, span);
 
   String toString() => name;
 }
 
 // namespace|element
 class NamespaceSelector extends SimpleSelector {
-  final _namespace;           // null, Wildcard or Identifier
+  final _namespace; // null, Wildcard or Identifier
 
   NamespaceSelector(this._namespace, var name, SourceSpan span)
       : super(name, span);
 
   String get namespace =>
       _namespace is Wildcard ? '*' : _namespace == null ? '' : _namespace.name;
 
   bool get isNamespaceWildcard => _namespace is Wildcard;
 
   SimpleSelector get nameAsSimpleSelector => _name;
 
   NamespaceSelector clone() => new NamespaceSelector(_namespace, "", span);
 
   visit(VisitorBase visitor) => visitor.visitNamespaceSelector(this);
 
   String toString() => "$namespace|${nameAsSimpleSelector.name}";
 }
 
 // [attr op value]
 class AttributeSelector extends SimpleSelector {
   final int _op;
   final _value;
 
-  AttributeSelector(Identifier name, this._op, this._value,
-      SourceSpan span) : super(name, span);
+  AttributeSelector(Identifier name, this._op, this._value, SourceSpan span)
+      : super(name, span);
 
   int get operatorKind => _op;
 
   get value => _value;
 
   String matchOperator() {
     switch (_op) {
-    case TokenKind.EQUALS:
-      return '=';
-    case TokenKind.INCLUDES:
-      return '~=';
-    case TokenKind.DASH_MATCH:
-      return '|=';
-    case TokenKind.PREFIX_MATCH:
-      return '^=';
-    case TokenKind.SUFFIX_MATCH:
-      return '\$=';
-    case TokenKind.SUBSTRING_MATCH:
-      return '*=';
-    case TokenKind.NO_MATCH:
-      return '';
+      case TokenKind.EQUALS:
+        return '=';
+      case TokenKind.INCLUDES:
+        return '~=';
+      case TokenKind.DASH_MATCH:
+        return '|=';
+      case TokenKind.PREFIX_MATCH:
+        return '^=';
+      case TokenKind.SUFFIX_MATCH:
+        return '\$=';
+      case TokenKind.SUBSTRING_MATCH:
+        return '*=';
+      case TokenKind.NO_MATCH:
+        return '';
     }
   }
 
   // Return the TokenKind for operator used by visitAttributeSelector.
   String matchOperatorAsTokenString() {
     switch (_op) {
-    case TokenKind.EQUALS:
-      return 'EQUALS';
-    case TokenKind.INCLUDES:
-      return 'INCLUDES';
-    case TokenKind.DASH_MATCH:
-      return 'DASH_MATCH';
-    case TokenKind.PREFIX_MATCH:
-      return 'PREFIX_MATCH';
-    case TokenKind.SUFFIX_MATCH:
-      return 'SUFFIX_MATCH';
-    case TokenKind.SUBSTRING_MATCH:
-      return 'SUBSTRING_MATCH';
+      case TokenKind.EQUALS:
+        return 'EQUALS';
+      case TokenKind.INCLUDES:
+        return 'INCLUDES';
+      case TokenKind.DASH_MATCH:
+        return 'DASH_MATCH';
+      case TokenKind.PREFIX_MATCH:
+        return 'PREFIX_MATCH';
+      case TokenKind.SUFFIX_MATCH:
+        return 'SUFFIX_MATCH';
+      case TokenKind.SUBSTRING_MATCH:
+        return 'SUBSTRING_MATCH';
     }
   }
 
   String valueToString() {
     if (_value != null) {
       if (_value is Identifier) {
         return _value.name;
       } else {
         return '"${_value}"';
       }
@@ skipping 50 matching lines @@
 // :pseudoClassFunction(expression)
 class PseudoClassFunctionSelector extends PseudoClassSelector {
   final SelectorExpression expression;
 
   PseudoClassFunctionSelector(Identifier name, this.expression, SourceSpan span)
       : super(name, span);
 
   PseudoClassFunctionSelector clone() =>
       new PseudoClassFunctionSelector(_name, expression, span);
 
-  visit(VisitorBase visitor) =>
-      visitor.visitPseudoClassFunctionSelector(this);
+  visit(VisitorBase visitor) => visitor.visitPseudoClassFunctionSelector(this);
 }
 
 // ::pseudoElementFunction(expression)
 class PseudoElementFunctionSelector extends PseudoElementSelector {
   final SelectorExpression expression;
 
-  PseudoElementFunctionSelector(Identifier name, this.expression,
-          SourceSpan span)
+  PseudoElementFunctionSelector(
+      Identifier name, this.expression, SourceSpan span)
       : super(name, span);
 
   PseudoElementFunctionSelector clone() =>
       new PseudoElementFunctionSelector(_name, expression, span);
 
   visit(VisitorBase visitor) =>
       visitor.visitPseudoElementFunctionSelector(this);
 }
 
 class SelectorExpression extends TreeNode {
   final List<Expression> expressions;
 
-  SelectorExpression(this.expressions, SourceSpan span): super(span);
+  SelectorExpression(this.expressions, SourceSpan span) : super(span);
 
   SelectorExpression clone() {
     return new SelectorExpression(
         expressions.map((e) => e.clone()).toList(), span);
   }
 
   visit(VisitorBase visitor) => visitor.visitSelectorExpression(this);
 }
 
 // :NOT(negation_arg)
@@ skipping 60 matching lines @@
     var cloneDeclarationGroup = _declarationGroup.clone();
     return new RuleSet(cloneSelectorGroup, cloneDeclarationGroup, span);
   }
 
   visit(VisitorBase visitor) => visitor.visitRuleSet(this);
 }
 
 class Directive extends TreeNode {
   Directive(SourceSpan span) : super(span);
 
-  bool get isBuiltIn => true;       // Known CSS directive?
-  bool get isExtension => false;    // SCSS extension?
+  bool get isBuiltIn => true; // Known CSS directive?
+  bool get isExtension => false; // SCSS extension?
 
   Directive clone() => new Directive(span);
   visit(VisitorBase visitor) => visitor.visitDirective(this);
 }
 
 class ImportDirective extends Directive {
   /** import name specified. */
   final String import;
 
   /** Any media queries for this import. */
@@ skipping 15 matching lines @@
 
 /**
  *  MediaExpression grammar:
  *    '(' S* media_feature S* [ ':' S* expr ]? ')' S*
  */
 class MediaExpression extends TreeNode {
   final bool andOperator;
   final Identifier _mediaFeature;
   final Expressions exprs;
 
-  MediaExpression(this.andOperator, this._mediaFeature, this.exprs,
-          SourceSpan span)
+  MediaExpression(
+      this.andOperator, this._mediaFeature, this.exprs, SourceSpan span)
       : super(span);
 
   String get mediaFeature => _mediaFeature.name;
 
   MediaExpression clone() {
     var clonedExprs = exprs.clone();
     return new MediaExpression(andOperator, _mediaFeature, clonedExprs, span);
   }
 
   visit(VisitorBase visitor) => visitor.visitMediaExpression(this);
 }
 
 /**
  * MediaQuery grammar:
  *    : [ONLY | NOT]? S* media_type S* [ AND S* media_expression ]*
  *    | media_expression [ AND S* media_expression ]*
  *   media_type
  *    : IDENT
  *   media_expression
  *    : '(' S* media_feature S* [ ':' S* expr ]? ')' S*
  *   media_feature
  *    : IDENT
  */
 class MediaQuery extends TreeNode {
   /** not, only or no operator. */
   final int _mediaUnary;
   final Identifier _mediaType;
   final List<MediaExpression> expressions;
 
-  MediaQuery(this._mediaUnary, this._mediaType, this.expressions,
-          SourceSpan span)
+  MediaQuery(
+      this._mediaUnary, this._mediaType, this.expressions, SourceSpan span)
       : super(span);
 
   bool get hasMediaType => _mediaType != null;
   String get mediaType => _mediaType.name;
 
   bool get hasUnary => _mediaUnary != -1;
   String get unary =>
       TokenKind.idToValue(TokenKind.MEDIA_OPERATORS, _mediaUnary).toUpperCase();
 
   MediaQuery clone() {
@@ skipping 42 matching lines @@
   }
 
   visit(VisitorBase visitor) => visitor.visitHostDirective(this);
 }
 
 class PageDirective extends Directive {
   final String _ident;
   final String _pseudoPage;
   final List<DeclarationGroup> _declsMargin;
 
-  PageDirective(this._ident, this._pseudoPage, this._declsMargin,
-      SourceSpan span) : super(span);
+  PageDirective(
+      this._ident, this._pseudoPage, this._declsMargin, SourceSpan span)
+      : super(span);
 
   PageDirective clone() {
     var cloneDeclsMargin = [];
     for (var declMargin in _declsMargin) {
       cloneDeclsMargin.add(declMargin.clone());
     }
     return new PageDirective(_ident, _pseudoPage, cloneDeclsMargin, span);
   }
 
   visit(VisitorBase visitor) => visitor.visitPageDirective(this);
@@ skipping 12 matching lines @@
 
 class KeyFrameDirective extends Directive {
   /*
    * Either @keyframe or keyframe prefixed with @-webkit-, @-moz-, @-ms-, @-o-.
    */
   final int _keyframeName;
   final name;
   final List<KeyFrameBlock> _blocks;
 
   KeyFrameDirective(this._keyframeName, this.name, SourceSpan span)
-      : _blocks = [], super(span);
+      : _blocks = [],
+        super(span);
 
   add(KeyFrameBlock block) {
     _blocks.add(block);
   }
 
   String get keyFrameName {
     switch (_keyframeName) {
       case TokenKind.DIRECTIVE_KEYFRAMES:
       case TokenKind.DIRECTIVE_MS_KEYFRAMES:
         return '@keyframes';
-      case TokenKind.DIRECTIVE_WEB_KIT_KEYFRAMES: return '@-webkit-keyframes';
-      case TokenKind.DIRECTIVE_MOZ_KEYFRAMES: return '@-moz-keyframes';
-      case TokenKind.DIRECTIVE_O_KEYFRAMES: return '@-o-keyframes';
+      case TokenKind.DIRECTIVE_WEB_KIT_KEYFRAMES:
+        return '@-webkit-keyframes';
+      case TokenKind.DIRECTIVE_MOZ_KEYFRAMES:
+        return '@-moz-keyframes';
+      case TokenKind.DIRECTIVE_O_KEYFRAMES:
+        return '@-o-keyframes';
     }
   }
 
   KeyFrameDirective clone() {
     var cloneBlocks = [];
     for (var block in _blocks) {
       cloneBlocks.add(block.clone());
     }
     return new KeyFrameDirective(_keyframeName, cloneBlocks, span);
   }
@@ skipping 20 matching lines @@
   FontFaceDirective clone() =>
       new FontFaceDirective(_declarations.clone(), span);
   visit(VisitorBase visitor) => visitor.visitFontFaceDirective(this);
 }
 
 class StyletDirective extends Directive {
   final String dartClassName;
   final List<RuleSet> rulesets;
 
   StyletDirective(this.dartClassName, this.rulesets, SourceSpan span)
-     : super(span);
+      : super(span);
 
   bool get isBuiltIn => false;
   bool get isExtension => true;
 
   StyletDirective clone() {
     var cloneRulesets = [];
     for (var ruleset in rulesets) {
       cloneRulesets.add(ruleset.clone());
     }
     return new StyletDirective(dartClassName, cloneRulesets, span);
@@ skipping 47 matching lines @@
   }
 
   visit(VisitorBase visitor) => visitor.visitMixinDefinition(this);
 }
 
 /** Support a Sass @mixin. See http://sass-lang.com for description. */
 class MixinRulesetDirective extends MixinDefinition {
   final List<RuleSet> rulesets;
 
   MixinRulesetDirective(String name, List<VarDefinitionDirective> args,
-      bool varArgs, this.rulesets, SourceSpan span) :
-      super(name, args, varArgs, span);
+      bool varArgs, this.rulesets, SourceSpan span)
+      : super(name, args, varArgs, span);
 
   MixinRulesetDirective clone() {
     var clonedArgs = [];
     for (var arg in definedArgs) {
       clonedArgs.add(arg.clone());
     }
     var clonedRulesets = [];
     for (var ruleset in rulesets) {
       clonedRulesets.add(ruleset.clone());
     }
-    return new MixinRulesetDirective(name, clonedArgs, varArgs, clonedRulesets,
-        span);
+    return new MixinRulesetDirective(
+        name, clonedArgs, varArgs, clonedRulesets, span);
   }
 
   visit(VisitorBase visitor) => visitor.visitMixinRulesetDirective(this);
 }
 
 class MixinDeclarationDirective extends MixinDefinition {
   final DeclarationGroup declarations;
 
-  MixinDeclarationDirective(String name, List<VarDefinitionDirective>  args,
-      bool varArgs, this.declarations, SourceSpan span) :
-      super(name, args, varArgs, span);
+  MixinDeclarationDirective(String name, List<VarDefinitionDirective> args,
+      bool varArgs, this.declarations, SourceSpan span)
+      : super(name, args, varArgs, span);
 
   MixinDeclarationDirective clone() {
     var clonedArgs = [];
     for (var arg in definedArgs) {
       clonedArgs.add(arg.clone());
     }
-    return new MixinDeclarationDirective(name, clonedArgs, varArgs,
-        declarations.clone(), span);
+    return new MixinDeclarationDirective(
+        name, clonedArgs, varArgs, declarations.clone(), span);
   }
 
   visit(VisitorBase visitor) => visitor.visitMixinDeclarationDirective(this);
 }
 
 /** To support consuming a SASS mixin @include. */
 class IncludeDirective extends Directive {
   final String name;
   final List<List<TreeNode>> args;
 
@@ skipping 30 matching lines @@
    * IE CSS hacks that can only be read by a particular IE version.
    *   7 implies IE 7 or older property (e.g., *background: blue;)
    *   Note:  IE 8 or older property (e.g., background: green\9;) is handled
    *          by IE8Term in declaration expression handling.
    *   Note:  IE 6 only property with a leading underscore is a valid IDENT
    *          since an ident can start with underscore (e.g., _background: red;)
    */
   final bool isIE7;
 
   Declaration(this._property, this._expression, this.dartStyle, SourceSpan span,
-              {important: false, ie7: false})
-      : this.important = important, this.isIE7 = ie7, super(span);
+      {important: false, ie7: false})
+      : this.important = important,
+        this.isIE7 = ie7,
+        super(span);
 
   String get property => isIE7 ? '*${_property.name}' : _property.name;
   Expression get expression => _expression;
 
   bool get hasDartStyle => dartStyle != null;
 
-  Declaration clone() =>
-      new Declaration(_property.clone(), _expression.clone(), dartStyle, span,
+  Declaration clone() => new Declaration(
+      _property.clone(), _expression.clone(), dartStyle, span,
       important: important);
 
   visit(VisitorBase visitor) => visitor.visitDeclaration(this);
 }
 
 // TODO(terry): Consider 2 kinds of VarDefinitions static at top-level and
 //              dynamic when in a declaration.  Currently, Less syntax
 //              '@foo: expression' and 'var-foo: expression' in a declaration
 //              are statically resolved. Better solution, if @foo or var-foo
 //              are top-level are then statically resolved and var-foo in a
 //              declaration group (surrounded by a selector) would be dynamic.
 class VarDefinition extends Declaration {
   bool badUsage = false;
 
   VarDefinition(Identifier definedName, Expression expr, SourceSpan span)
       : super(definedName, expr, null, span);
 
   String get definedName => _property.name;
 
-  VarDefinition clone() =>
-      new VarDefinition(_property.clone(),
-      expression != null ? expression.clone() : null, span);
+  VarDefinition clone() => new VarDefinition(
+      _property.clone(), expression != null ? expression.clone() : null, span);
 
   visit(VisitorBase visitor) => visitor.visitVarDefinition(this);
 }
 
 /**
  * Node for usage of @include mixin[(args,...)] found in a declaration group
  * instead of at a ruleset (toplevel) e.g.,
  * div {
  *   @include mixin1;
  * }
  */
 class IncludeMixinAtDeclaration extends Declaration {
   final IncludeDirective include;
 
   IncludeMixinAtDeclaration(this.include, SourceSpan span)
       : super(null, null, null, span);
 
   IncludeMixinAtDeclaration clone() =>
       new IncludeMixinAtDeclaration(include.clone(), span);
 
-  visit(VisitorBase visitor) =>
-      visitor.visitIncludeMixinAtDeclaration(this);
+  visit(VisitorBase visitor) => visitor.visitIncludeMixinAtDeclaration(this);
 }
 
 class ExtendDeclaration extends Declaration {
   final List<TreeNode> selectors;
 
-  ExtendDeclaration(this.selectors, SourceSpan span) :
-      super(null, null, null, span);
+  ExtendDeclaration(this.selectors, SourceSpan span)
+      : super(null, null, null, span);
 
   ExtendDeclaration clone() {
     var newSelector = selectors.map((s) => s.clone()).toList();
     return new ExtendDeclaration(newSelector, span);
   }
 
   visit(VisitorBase visitor) => visitor.visitExtendDeclaration(this);
 }
 
 class DeclarationGroup extends TreeNode {
   /** Can be either Declaration or RuleSet (if nested selector). */
   final List declarations;
 
   DeclarationGroup(this.declarations, SourceSpan span) : super(span);
 
   DeclarationGroup clone() {
     var clonedDecls = declarations.map((d) => d.clone()).toList();
     return new DeclarationGroup(clonedDecls, span);
   }
 
   visit(VisitorBase visitor) => visitor.visitDeclarationGroup(this);
 }
 
 class MarginGroup extends DeclarationGroup {
-  final int margin_sym;       // TokenType for for @margin sym.
+  final int margin_sym; // TokenType for for @margin sym.
 
   MarginGroup(this.margin_sym, List<Declaration> decls, SourceSpan span)
       : super(decls, span);
   MarginGroup clone() =>
-    new MarginGroup(margin_sym, super.clone() as dynamic, span);
+      new MarginGroup(margin_sym, super.clone() as dynamic, span);
   visit(VisitorBase visitor) => visitor.visitMarginGroup(this);
 }
 
 class VarUsage extends Expression {
   final String name;
   final List<Expression> defaultValues;
 
   VarUsage(this.name, this.defaultValues, SourceSpan span) : super(span);
 
   VarUsage clone() {
@@ skipping 73 matching lines @@
 
   visit(VisitorBase visitor) => visitor.visitUnitTerm(this);
 
   String unitToString() => TokenKind.unitToString(unit);
 
   String toString() => '$text${unitToString()}';
 }
 
 class LengthTerm extends UnitTerm {
   LengthTerm(value, String t, SourceSpan span,
-      [int unit = TokenKind.UNIT_LENGTH_PX]) : super(value, t, span, unit) {
+      [int unit = TokenKind.UNIT_LENGTH_PX])
+      : super(value, t, span, unit) {
     assert(this.unit == TokenKind.UNIT_LENGTH_PX ||
         this.unit == TokenKind.UNIT_LENGTH_CM ||
         this.unit == TokenKind.UNIT_LENGTH_MM ||
         this.unit == TokenKind.UNIT_LENGTH_IN ||
         this.unit == TokenKind.UNIT_LENGTH_PT ||
         this.unit == TokenKind.UNIT_LENGTH_PC);
   }
   LengthTerm clone() => new LengthTerm(value, text, span, unit);
   visit(VisitorBase visitor) => visitor.visitLengthTerm(this);
 }
@@ skipping 11 matching lines @@
 }
 
 class ExTerm extends LiteralTerm {
   ExTerm(value, String t, SourceSpan span) : super(value, t, span);
   ExTerm clone() => new ExTerm(value, text, span);
   visit(VisitorBase visitor) => visitor.visitExTerm(this);
 }
 
 class AngleTerm extends UnitTerm {
   AngleTerm(var value, String t, SourceSpan span,
-    [int unit = TokenKind.UNIT_LENGTH_PX]) : super(value, t, span, unit) {
+      [int unit = TokenKind.UNIT_LENGTH_PX])
+      : super(value, t, span, unit) {
     assert(this.unit == TokenKind.UNIT_ANGLE_DEG ||
         this.unit == TokenKind.UNIT_ANGLE_RAD ||
         this.unit == TokenKind.UNIT_ANGLE_GRAD ||
         this.unit == TokenKind.UNIT_ANGLE_TURN);
   }
 
   AngleTerm clone() => new AngleTerm(value, text, span, unit);
   visit(VisitorBase visitor) => visitor.visitAngleTerm(this);
 }
 
 class TimeTerm extends UnitTerm {
   TimeTerm(var value, String t, SourceSpan span,
-    [int unit = TokenKind.UNIT_LENGTH_PX]) : super(value, t, span, unit) {
+      [int unit = TokenKind.UNIT_LENGTH_PX])
+      : super(value, t, span, unit) {
     assert(this.unit == TokenKind.UNIT_ANGLE_DEG ||
         this.unit == TokenKind.UNIT_TIME_MS ||
         this.unit == TokenKind.UNIT_TIME_S);
   }
 
   TimeTerm clone() => new TimeTerm(value, text, span, unit);
   visit(VisitorBase visitor) => visitor.visitTimeTerm(this);
 }
 
 class FreqTerm extends UnitTerm {
   FreqTerm(var value, String t, SourceSpan span,
-    [int unit = TokenKind.UNIT_LENGTH_PX]) : super(value, t, span, unit) {
+      [int unit = TokenKind.UNIT_LENGTH_PX])
+      : super(value, t, span, unit) {
     assert(unit == TokenKind.UNIT_FREQ_HZ || unit == TokenKind.UNIT_FREQ_KHZ);
   }
 
   FreqTerm clone() => new FreqTerm(value, text, span, unit);
   visit(VisitorBase visitor) => visitor.visitFreqTerm(this);
 }
 
 class FractionTerm extends LiteralTerm {
   FractionTerm(var value, String t, SourceSpan span) : super(value, t, span);
 
   FractionTerm clone() => new FractionTerm(value, text, span);
   visit(VisitorBase visitor) => visitor.visitFractionTerm(this);
 }
 
 class UriTerm extends LiteralTerm {
   UriTerm(String value, SourceSpan span) : super(value, value, span);
 
   UriTerm clone() => new UriTerm(value, span);
   visit(VisitorBase visitor) => visitor.visitUriTerm(this);
 }
 
 class ResolutionTerm extends UnitTerm {
   ResolutionTerm(var value, String t, SourceSpan span,
-    [int unit = TokenKind.UNIT_LENGTH_PX]) : super(value, t, span, unit) {
+      [int unit = TokenKind.UNIT_LENGTH_PX])
+      : super(value, t, span, unit) {
     assert(unit == TokenKind.UNIT_RESOLUTION_DPI ||
         unit == TokenKind.UNIT_RESOLUTION_DPCM ||
         unit == TokenKind.UNIT_RESOLUTION_DPPX);
   }
 
   ResolutionTerm clone() => new ResolutionTerm(value, text, span, unit);
   visit(VisitorBase visitor) => visitor.visitResolutionTerm(this);
 }
 
 class ChTerm extends UnitTerm {
   ChTerm(var value, String t, SourceSpan span,
-    [int unit = TokenKind.UNIT_LENGTH_PX]) : super(value, t, span, unit) {
+      [int unit = TokenKind.UNIT_LENGTH_PX])
+      : super(value, t, span, unit) {
     assert(unit == TokenKind.UNIT_CH);
   }
 
   ChTerm clone() => new ChTerm(value, text, span, unit);
   visit(VisitorBase visitor) => visitor.visitChTerm(this);
 }
 
 class RemTerm extends UnitTerm {
   RemTerm(var value, String t, SourceSpan span,
-    [int unit = TokenKind.UNIT_LENGTH_PX]) : super(value, t, span, unit) {
+      [int unit = TokenKind.UNIT_LENGTH_PX])
+      : super(value, t, span, unit) {
     assert(unit == TokenKind.UNIT_REM);
   }
 
   RemTerm clone() => new RemTerm(value, text, span, unit);
   visit(VisitorBase visitor) => visitor.visitRemTerm(this);
 }
 
 class ViewportTerm extends UnitTerm {
   ViewportTerm(var value, String t, SourceSpan span,
-    [int unit = TokenKind.UNIT_LENGTH_PX]) : super(value, t, span, unit) {
+      [int unit = TokenKind.UNIT_LENGTH_PX])
+      : super(value, t, span, unit) {
     assert(unit == TokenKind.UNIT_VIEWPORT_VW ||
         unit == TokenKind.UNIT_VIEWPORT_VH ||
         unit == TokenKind.UNIT_VIEWPORT_VMIN ||
         unit == TokenKind.UNIT_VIEWPORT_VMAX);
   }
 
   ViewportTerm clone() => new ViewportTerm(value, text, span, unit);
   visit(VisitorBase visitor) => visitor.visitViewportTerm(this);
 }
 
 /** Type to signal a bad hex value for HexColorTerm.value. */
-class BAD_HEX_VALUE { }
+class BAD_HEX_VALUE {}
 
 class HexColorTerm extends LiteralTerm {
   HexColorTerm(var value, String t, SourceSpan span) : super(value, t, span);
 
   HexColorTerm clone() => new HexColorTerm(value, text, span);
   visit(VisitorBase visitor) => visitor.visitHexColorTerm(this);
 }
 
 class FunctionTerm extends LiteralTerm {
   final Expressions _params;
@@ skipping 12 matching lines @@
  */
 class IE8Term extends LiteralTerm {
   IE8Term(SourceSpan span) : super('\\9', '\\9', span);
   IE8Term clone() => new IE8Term(span);
   visit(VisitorBase visitor) => visitor.visitIE8Term(this);
 }
 
 class GroupTerm extends Expression {
   final List<LiteralTerm> _terms;
 
-  GroupTerm(SourceSpan span) : _terms =  [], super(span);
+  GroupTerm(SourceSpan span)
+      : _terms = [],
+        super(span);
 
   void add(LiteralTerm term) {
     _terms.add(term);
   }
 
   GroupTerm clone() => new GroupTerm(span);
   visit(VisitorBase visitor) => visitor.visitGroupTerm(this);
 }
 
 class ItemTerm extends NumberTerm {
   ItemTerm(var value, String t, SourceSpan span) : super(value, t, span);
 
   ItemTerm clone() => new ItemTerm(value, text, span);
   visit(VisitorBase visitor) => visitor.visitItemTerm(this);
 }
 
 class Expressions extends Expression {
   final List<Expression> expressions = [];
 
-  Expressions(SourceSpan span): super(span);
+  Expressions(SourceSpan span) : super(span);
 
   void add(Expression expression) {
     expressions.add(expression);
   }
 
   Expressions clone() {
     var clonedExprs = new Expressions(span);
     for (var expr in expressions) {
       clonedExprs.add(expr.clone());
     }
     return clonedExprs;
   }
   visit(VisitorBase visitor) => visitor.visitExpressions(this);
 }
 
 class BinaryExpression extends Expression {
   final Token op;
   final Expression x;
   final Expression y;
 
-  BinaryExpression(this.op, this.x, this.y, SourceSpan span): super(span);
+  BinaryExpression(this.op, this.x, this.y, SourceSpan span) : super(span);
 
   BinaryExpression clone() =>
       new BinaryExpression(op, x.clone(), y.clone(), span);
   visit(VisitorBase visitor) => visitor.visitBinaryExpression(this);
 }
 
 class UnaryExpression extends Expression {
   final Token op;
   final Expression self;
 
-  UnaryExpression(this.op, this.self, SourceSpan span): super(span);
+  UnaryExpression(this.op, this.self, SourceSpan span) : super(span);
 
   UnaryExpression clone() => new UnaryExpression(op, self.clone(), span);
   visit(VisitorBase visitor) => visitor.visitUnaryExpression(this);
 }
 
 abstract class DartStyleExpression extends TreeNode {
   static const int unknownType = 0;
   static const int fontStyle = 1;
   static const int marginStyle = 2;
   static const int borderStyle = 3;
@@ skipping 27 matching lines @@
   visit(VisitorBase visitor) => visitor.visitDartStyleExpression(this);
 }
 
 class FontExpression extends DartStyleExpression {
   final Font font;
 
   //   font-style font-variant font-weight font-size/line-height font-family
   // TODO(terry): Only px/pt for now need to handle all possible units to
   //              support calc expressions on units.
   FontExpression(SourceSpan span, {dynamic size, List<String> family,
-      int weight, String style, String variant, LineHeight lineHeight}) :
-        font = new Font(size : size is LengthTerm ? size.value : size,
-            family: family, weight: weight, style: style, variant: variant,
-            lineHeight: lineHeight),
+      int weight, String style, String variant, LineHeight lineHeight})
+      : font = new Font(
+          size: size is LengthTerm ? size.value : size,
+          family: family,
+          weight: weight,
+          style: style,
+          variant: variant,
+          lineHeight: lineHeight),
         super(DartStyleExpression.fontStyle, span);
 
   FontExpression merged(DartStyleExpression newFontExpr) {
     if (newFontExpr is FontExpression && this.isFont && newFontExpr.isFont) {
       return new FontExpression.merge(this, newFontExpr);
     }
     return null;
   }
 
   /**
    * Merge the two FontExpression and return the result.
    */
   factory FontExpression.merge(FontExpression x, FontExpression y) {
     return new FontExpression._merge(x, y, y.span);
   }
 
   FontExpression._merge(FontExpression x, FontExpression y, SourceSpan span)
       : font = new Font.merge(x.font, y.font),
         super(DartStyleExpression.fontStyle, span);
 
-  FontExpression clone() =>
-    new FontExpression(span, size: font.size, family: font.family,
-        weight: font.weight, style: font.style, variant: font.variant,
-        lineHeight: font.lineHeight);
+  FontExpression clone() => new FontExpression(span,
+      size: font.size,
+      family: font.family,
+      weight: font.weight,
+      style: font.style,
+      variant: font.variant,
+      lineHeight: font.lineHeight);
 
   visit(VisitorBase visitor) => visitor.visitFontExpression(this);
 }
 
 abstract class BoxExpression extends DartStyleExpression {
   final BoxEdge box;
 
   BoxExpression(int styleType, SourceSpan span, this.box)
       : super(styleType, span);
 
   visit(VisitorBase visitor) => visitor.visitBoxExpression(this);
 
   String get formattedBoxEdge {
-    if (box.top == box.left && box.top == box.bottom &&
-        box.top== box.right) {
+    if (box.top == box.left && box.top == box.bottom && box.top == box.right) {
       return '.uniform(${box.top})';
     } else {
       var left = box.left == null ? 0 : box.left;
       var top = box.top == null ? 0 : box.top;
       var right = box.right == null ? 0 : box.right;
       var bottom = box.bottom == null ? 0 : box.bottom;
       return '.clockwiseFromTop($top,$right,$bottom,$left)';
     }
   }
 }
 
 class MarginExpression extends BoxExpression {
   // TODO(terry): Does auto for margin need to be exposed to Dart UI framework?
   /** Margin expression ripped apart. */
   MarginExpression(SourceSpan span, {num top, num right, num bottom, num left})
       : super(DartStyleExpression.marginStyle, span,
-              new BoxEdge(left, top, right, bottom));
+          new BoxEdge(left, top, right, bottom));
 
   MarginExpression.boxEdge(SourceSpan span, BoxEdge box)
       : super(DartStyleExpression.marginStyle, span, box);
 
   merged(DartStyleExpression newMarginExpr) {
-    if (newMarginExpr is MarginExpression && this.isMargin &&
+    if (newMarginExpr is MarginExpression &&
+        this.isMargin &&
         newMarginExpr.isMargin) {
       return new MarginExpression.merge(this, newMarginExpr);
     }
 
     return null;
   }
 
   /**
    * Merge the two MarginExpressions and return the result.
    */
   factory MarginExpression.merge(MarginExpression x, MarginExpression y) {
     return new MarginExpression._merge(x, y, y.span);
   }
 
-  MarginExpression._merge(MarginExpression x, MarginExpression y,
-          SourceSpan span)
+  MarginExpression._merge(
+      MarginExpression x, MarginExpression y, SourceSpan span)
       : super(x._styleType, span, new BoxEdge.merge(x.box, y.box));
 
-  MarginExpression clone() =>
-      new MarginExpression(span, top: box.top, right: box.right,
-      bottom: box.bottom, left: box.left);
+  MarginExpression clone() => new MarginExpression(span,
+      top: box.top, right: box.right, bottom: box.bottom, left: box.left);
 
   visit(VisitorBase visitor) => visitor.visitMarginExpression(this);
 }
 
 class BorderExpression extends BoxExpression {
   /** Border expression ripped apart. */
   BorderExpression(SourceSpan span, {num top, num right, num bottom, num left})
       : super(DartStyleExpression.borderStyle, span,
-              new BoxEdge(left, top, right, bottom));
+          new BoxEdge(left, top, right, bottom));
 
   BorderExpression.boxEdge(SourceSpan span, BoxEdge box)
       : super(DartStyleExpression.borderStyle, span, box);
 
   merged(DartStyleExpression newBorderExpr) {
-    if (newBorderExpr is BorderExpression && this.isBorder && newBorderExpr.isBorder) {
+    if (newBorderExpr is BorderExpression &&
+        this.isBorder &&
+        newBorderExpr.isBorder) {
       return new BorderExpression.merge(this, newBorderExpr);
     }
 
     return null;
   }
 
   /**
    * Merge the two BorderExpression and return the result.
    */
   factory BorderExpression.merge(BorderExpression x, BorderExpression y) {
     return new BorderExpression._merge(x, y, y.span);
   }
 
-  BorderExpression._merge(BorderExpression x, BorderExpression y,
-      SourceSpan span)
+  BorderExpression._merge(
+      BorderExpression x, BorderExpression y, SourceSpan span)
       : super(DartStyleExpression.borderStyle, span,
-              new BoxEdge.merge(x.box, y.box));
+          new BoxEdge.merge(x.box, y.box));
 
-  BorderExpression clone() =>
-      new BorderExpression(span, top: box.top, right: box.right,
-      bottom: box.bottom, left: box.left);
+  BorderExpression clone() => new BorderExpression(span,
+      top: box.top, right: box.right, bottom: box.bottom, left: box.left);
 
   visit(VisitorBase visitor) => visitor.visitBorderExpression(this);
 }
 
 class HeightExpression extends DartStyleExpression {
   final height;
 
   HeightExpression(SourceSpan span, this.height)
       : super(DartStyleExpression.heightStyle, span);
 
   merged(DartStyleExpression newHeightExpr) {
-    if (newHeightExpr is DartStyleExpression && this.isHeight && newHeightExpr.isHeight) {
+    if (newHeightExpr is DartStyleExpression &&
+        this.isHeight &&
+        newHeightExpr.isHeight) {
       return newHeightExpr;
     }
 
     return null;
   }
 
   HeightExpression clone() => new HeightExpression(span, height);
   visit(VisitorBase visitor) => visitor.visitHeightExpression(this);
 }
 
 class WidthExpression extends DartStyleExpression {
   final width;
 
   WidthExpression(SourceSpan span, this.width)
       : super(DartStyleExpression.widthStyle, span);
 
   merged(DartStyleExpression newWidthExpr) {
-    if (newWidthExpr is WidthExpression && this.isWidth &&
+    if (newWidthExpr is WidthExpression &&
+        this.isWidth &&
         newWidthExpr.isWidth) {
       return newWidthExpr;
     }
 
     return null;
   }
 
   WidthExpression clone() => new WidthExpression(span, width);
   visit(VisitorBase visitor) => visitor.visitWidthExpression(this);
 }
 
 class PaddingExpression extends BoxExpression {
   /** Padding expression ripped apart. */
   PaddingExpression(SourceSpan span, {num top, num right, num bottom, num left})
       : super(DartStyleExpression.paddingStyle, span,
-              new BoxEdge(left, top, right, bottom));
+          new BoxEdge(left, top, right, bottom));
 
   PaddingExpression.boxEdge(SourceSpan span, BoxEdge box)
       : super(DartStyleExpression.paddingStyle, span, box);
 
   merged(DartStyleExpression newPaddingExpr) {
-    if (newPaddingExpr is PaddingExpression && this.isPadding &&
+    if (newPaddingExpr is PaddingExpression &&
+        this.isPadding &&
         newPaddingExpr.isPadding) {
       return new PaddingExpression.merge(this, newPaddingExpr);
     }
 
     return null;
   }
 
   /**
    * Merge the two PaddingExpression and return the result.
    */
   factory PaddingExpression.merge(PaddingExpression x, PaddingExpression y) {
     return new PaddingExpression._merge(x, y, y.span);
   }
 
-  PaddingExpression._merge(PaddingExpression x, PaddingExpression y,
-          SourceSpan span)
+  PaddingExpression._merge(
+      PaddingExpression x, PaddingExpression y, SourceSpan span)
       : super(DartStyleExpression.paddingStyle, span,
-            new BoxEdge.merge(x.box, y.box));
+          new BoxEdge.merge(x.box, y.box));
 
-  PaddingExpression clone() =>
-      new PaddingExpression(span, top: box.top, right: box.right,
-      bottom: box.bottom, left: box.left);
+  PaddingExpression clone() => new PaddingExpression(span,
+      top: box.top, right: box.right, bottom: box.bottom, left: box.left);
   visit(VisitorBase visitor) => visitor.visitPaddingExpression(this);
 }