Update charted to 0.4.8 and roll

packages/csslib/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:
 /////////////////////////////////////////////////////////////////////////
 
@@ skipping 102 matching lines @@
       [int combinator = TokenKind.COMBINATOR_NONE])
       : 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;
+  bool get isCombinatorDeep => combinator == TokenKind.COMBINATOR_DEEP;
+  bool get isCombinatorShadowPiercingDescendant =>
+      combinator == TokenKind.COMBINATOR_SHADOW_PIERCING_DESCENDANT;
 
-  String get _combinatorToString => isCombinatorDescendant
-      ? ' '
-      : isCombinatorPlus
-          ? ' + '
-          : isCombinatorGreater ? ' > ' : isCombinatorTilde ? ' ~ ' : '';
+  String get _combinatorToString {
+    switch (combinator) {
+      case TokenKind.COMBINATOR_SHADOW_PIERCING_DESCENDANT:
+        return ' >>> ';
+      case TokenKind.COMBINATOR_DEEP:
+        return ' /deep/ ';
+      case TokenKind.COMBINATOR_DESCENDANT:
+        return ' ';
+      case TokenKind.COMBINATOR_GREATER:
+        return ' > ';
+      case TokenKind.COMBINATOR_PLUS:
+        return ' + ';
+      case TokenKind.COMBINATOR_TILDE:
+        return ' ~ ';
+      default:
+        return '';
+    }
+  }
 
   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 137 matching lines @@
   PseudoClassSelector(Identifier name, SourceSpan span) : super(name, span);
   visit(VisitorBase visitor) => visitor.visitPseudoClassSelector(this);
 
   PseudoClassSelector clone() => new PseudoClassSelector(_name, span);
 
   String toString() => ":$name";
 }
 
 // ::pseudoElement
 class PseudoElementSelector extends SimpleSelector {
-  PseudoElementSelector(Identifier name, SourceSpan span) : super(name, span);
+  // If true, this is a CSS2.1 pseudo-element with only a single ':'.
+  final bool isLegacy;
+
+  PseudoElementSelector(Identifier name, SourceSpan span,
+      {this.isLegacy: false})
+      : super(name, span);
   visit(VisitorBase visitor) => visitor.visitPseudoElementSelector(this);
 
   PseudoElementSelector clone() => new PseudoElementSelector(_name, span);
 
-  String toString() => "::$name";
+  String toString() => "${isLegacy ? ':' : '::'}$name";
 }
 
-// :pseudoClassFunction(expression)
+// :pseudoClassFunction(argument)
 class PseudoClassFunctionSelector extends PseudoClassSelector {
-  final SelectorExpression expression;
+  final TreeNode _argument; // Selector, SelectorExpression
 
-  PseudoClassFunctionSelector(Identifier name, this.expression, SourceSpan span)
+  PseudoClassFunctionSelector(Identifier name, this._argument, SourceSpan span)
       : super(name, span);
 
   PseudoClassFunctionSelector clone() =>
-      new PseudoClassFunctionSelector(_name, expression, span);
+      new PseudoClassFunctionSelector(_name, _argument, span);
+
+  TreeNode get argument => _argument;
+  Selector get selector => _argument as Selector;
+  SelectorExpression get expression => _argument as SelectorExpression;
 
   visit(VisitorBase visitor) => visitor.visitPseudoClassFunctionSelector(this);
 }
 
 // ::pseudoElementFunction(expression)
 class PseudoElementFunctionSelector extends PseudoElementSelector {
   final SelectorExpression expression;
 
   PseudoElementFunctionSelector(
       Identifier name, this.expression, SourceSpan span)
@@ skipping 90 matching lines @@
 class Directive extends TreeNode {
   Directive(SourceSpan span) : super(span);
 
   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 DocumentDirective extends Directive {
+  final List<LiteralTerm> functions;
+  final List<TreeNode> groupRuleBody;
+
+  DocumentDirective(this.functions, this.groupRuleBody, SourceSpan span)
+      : super(span);
+
+  DocumentDirective clone() {
+    var clonedFunctions = <LiteralTerm>[];
+    for (var function in functions) {
+      clonedFunctions.add(function.clone());
+    }
+    var clonedGroupRuleBody = <TreeNode>[];
+    for (var rule in groupRuleBody) {
+      clonedGroupRuleBody.add(rule.clone());
+    }
+    return new DocumentDirective(clonedFunctions, clonedGroupRuleBody, span);
+  }
+
+  visit(VisitorBase visitor) => visitor.visitDocumentDirective(this);
+}
+
+class SupportsDirective extends Directive {
+  final SupportsCondition condition;
+  final List<TreeNode> groupRuleBody;
+
+  SupportsDirective(this.condition, this.groupRuleBody, SourceSpan span)
+      : super(span);
+
+  SupportsDirective clone() {
+    var clonedCondition = condition.clone();
+    var clonedGroupRuleBody = <TreeNode>[];
+    for (var rule in groupRuleBody) {
+      clonedGroupRuleBody.add(rule.clone());
+    }
+    return new SupportsDirective(clonedCondition, clonedGroupRuleBody, span);
+  }
+
+  visit(VisitorBase visitor) => visitor.visitSupportsDirective(this);
+}
+
+abstract class SupportsCondition extends TreeNode {
+  SupportsCondition(SourceSpan span) : super(span);
+}
+
+class SupportsConditionInParens extends SupportsCondition {
+  /// A [Declaration] or nested [SupportsCondition].
+  final TreeNode condition;
+
+  SupportsConditionInParens(Declaration declaration, SourceSpan span)
+      : condition = declaration,
+        super(span);
+
+  SupportsConditionInParens.nested(SupportsCondition condition, SourceSpan span)
+      : condition = condition,
+        super(span);
+
+  SupportsConditionInParens clone() =>
+      new SupportsConditionInParens(condition.clone(), span);
+
+  visit(VisitorBase visitor) => visitor.visitSupportsConditionInParens(this);
+}
+
+class SupportsNegation extends SupportsCondition {
+  final SupportsConditionInParens condition;
+
+  SupportsNegation(this.condition, SourceSpan span) : super(span);
+
+  SupportsNegation clone() => new SupportsNegation(condition.clone(), span);
+
+  visit(VisitorBase visitor) => visitor.visitSupportsNegation(this);
+}
+
+class SupportsConjunction extends SupportsCondition {
+  final List<SupportsConditionInParens> conditions;
+
+  SupportsConjunction(this.conditions, SourceSpan span) : super(span);
+
+  SupportsConjunction clone() {
+    var clonedConditions = <SupportsCondition>[];
+    for (var condition in conditions) {
+      clonedConditions.add(condition.clone());
+    }
+    return new SupportsConjunction(clonedConditions, span);
+  }
+
+  visit(VisitorBase visitor) => visitor.visitSupportsConjunction(this);
+}
+
+class SupportsDisjunction extends SupportsCondition {
+  final List<SupportsConditionInParens> conditions;
+
+  SupportsDisjunction(this.conditions, SourceSpan span) : super(span);
+
+  SupportsDisjunction clone() {
+    var clonedConditions = <SupportsCondition>[];
+    for (var condition in conditions) {
+      clonedConditions.add(condition.clone());
+    }
+    return new SupportsDisjunction(clonedConditions, span);
+  }
+
+  visit(VisitorBase visitor) => visitor.visitSupportsDisjunction(this);
+}
+
+class ViewportDirective extends Directive {
+  final String name;
+  final DeclarationGroup declarations;
+
+  ViewportDirective(this.name, this.declarations, SourceSpan span)
+      : super(span);
+
+  ViewportDirective clone() =>
+      new ViewportDirective(name, declarations.clone(), span);
+
+  visit(VisitorBase visitor) => visitor.visitViewportDirective(this);
+}
+
 class ImportDirective extends Directive {
   /** import name specified. */
   final String import;
 
   /** Any media queries for this import. */
   final List<MediaQuery> mediaQueries;
 
   ImportDirective(this.import, this.mediaQueries, SourceSpan span)
       : super(span);
 
   ImportDirective clone() {
-    var cloneMediaQueries = [];
+    var cloneMediaQueries = <MediaQuery>[];
     for (var mediaQuery in mediaQueries) {
       cloneMediaQueries.add(mediaQuery.clone());
     }
     return new ImportDirective(import, cloneMediaQueries, span);
   }
 
   visit(VisitorBase visitor) => visitor.visitImportDirective(this);
 }
 
 /**
@@ skipping 41 matching lines @@
       : 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() {
-    var cloneExpressions = [];
+    var cloneExpressions = <MediaExpression>[];
     for (var expr in expressions) {
       cloneExpressions.add(expr.clone());
     }
     return new MediaQuery(_mediaUnary, _mediaType, cloneExpressions, span);
   }
+
   visit(VisitorBase visitor) => visitor.visitMediaQuery(this);
 }
 
 class MediaDirective extends Directive {
   final List<MediaQuery> mediaQueries;
   final List<RuleSet> rulesets;
 
   MediaDirective(this.mediaQueries, this.rulesets, SourceSpan span)
       : super(span);
 
   MediaDirective clone() {
-    var cloneQueries = [];
+    var cloneQueries = <MediaQuery>[];
     for (var mediaQuery in mediaQueries) {
       cloneQueries.add(mediaQuery.clone());
     }
-    var cloneRulesets = [];
+    var cloneRulesets = <RuleSet>[];
     for (var ruleset in rulesets) {
       cloneRulesets.add(ruleset.clone());
     }
     return new MediaDirective(cloneQueries, cloneRulesets, span);
   }
 
   visit(VisitorBase visitor) => visitor.visitMediaDirective(this);
 }
 
 class HostDirective extends Directive {
   final List<RuleSet> rulesets;
 
   HostDirective(this.rulesets, SourceSpan span) : super(span);
 
   HostDirective clone() {
-    var cloneRulesets = [];
+    var cloneRulesets = <RuleSet>[];
     for (var ruleset in rulesets) {
       cloneRulesets.add(ruleset.clone());
     }
     return new HostDirective(cloneRulesets, span);
   }
 
   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 clone() {
-    var cloneDeclsMargin = [];
+    var cloneDeclsMargin = <DeclarationGroup>[];
     for (var declMargin in _declsMargin) {
       cloneDeclsMargin.add(declMargin.clone());
     }
     return new PageDirective(_ident, _pseudoPage, cloneDeclsMargin, span);
   }
 
   visit(VisitorBase visitor) => visitor.visitPageDirective(this);
 
   bool get hasIdent => _ident != null && _ident.length > 0;
   bool get hasPseudoPage => _pseudoPage != null && _pseudoPage.length > 0;
@@ skipping 38 matching lines @@
     return null;
   }
 
   KeyFrameDirective clone() {
     var cloneBlocks = [];
     for (var block in _blocks) {
       cloneBlocks.add(block.clone());
     }
     return new KeyFrameDirective(_keyframeName, cloneBlocks, span);
   }
+
   visit(VisitorBase visitor) => visitor.visitKeyFrameDirective(this);
 }
 
 class KeyFrameBlock extends Expression {
   final Expressions _blockSelectors;
   final DeclarationGroup _declarations;
 
   KeyFrameBlock(this._blockSelectors, this._declarations, SourceSpan span)
       : super(span);
 
@@ skipping 16 matching lines @@
   final String dartClassName;
   final List<RuleSet> rulesets;
 
   StyletDirective(this.dartClassName, this.rulesets, SourceSpan span)
       : super(span);
 
   bool get isBuiltIn => false;
   bool get isExtension => true;
 
   StyletDirective clone() {
-    var cloneRulesets = [];
+    var cloneRulesets = <RuleSet>[];
     for (var ruleset in rulesets) {
       cloneRulesets.add(ruleset.clone());
     }
     return new StyletDirective(dartClassName, cloneRulesets, span);
   }
 
   visit(VisitorBase visitor) => visitor.visitStyletDirective(this);
 }
 
 class NamespaceDirective extends Directive {
@@ skipping 19 matching lines @@
   VarDefinitionDirective(this.def, SourceSpan span) : super(span);
 
   VarDefinitionDirective clone() =>
       new VarDefinitionDirective(def.clone(), span);
 
   visit(VisitorBase visitor) => visitor.visitVarDefinitionDirective(this);
 }
 
 class MixinDefinition extends Directive {
   final String name;
-  final List definedArgs;
+  final List<TreeNode> definedArgs;
   final bool varArgs;
 
   MixinDefinition(this.name, this.definedArgs, this.varArgs, SourceSpan span)
       : super(span);
 
   MixinDefinition clone() {
-    var cloneDefinedArgs = [];
+    var cloneDefinedArgs = <TreeNode>[];
     for (var definedArg in definedArgs) {
       cloneDefinedArgs.add(definedArg.clone());
     }
     return new MixinDefinition(name, cloneDefinedArgs, varArgs, span);
   }
 
   visit(VisitorBase visitor) => visitor.visitMixinDefinition(this);
 }
 
 /** Support a Sass @mixin. See http://sass-lang.com for description. */
 class MixinRulesetDirective extends MixinDefinition {
-  final List rulesets;
+  final List<TreeNode> rulesets;
 
-  MixinRulesetDirective(String name, List<VarDefinitionDirective> args,
-      bool varArgs, this.rulesets, SourceSpan span)
+  MixinRulesetDirective(String name, List<TreeNode> args, bool varArgs,
+      this.rulesets, SourceSpan span)
       : super(name, args, varArgs, span);
 
   MixinRulesetDirective clone() {
-    var clonedArgs = [];
+    var clonedArgs = <VarDefinition>[];
     for (var arg in definedArgs) {
       clonedArgs.add(arg.clone());
     }
-    var clonedRulesets = [];
+    var clonedRulesets = <TreeNode>[];
     for (var ruleset in rulesets) {
       clonedRulesets.add(ruleset.clone());
     }
     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)
+  MixinDeclarationDirective(String name, List<TreeNode> args, bool varArgs,
+      this.declarations, SourceSpan span)
       : super(name, args, varArgs, span);
 
   MixinDeclarationDirective clone() {
-    var clonedArgs = [];
+    var clonedArgs = <TreeNode>[];
     for (var arg in definedArgs) {
       clonedArgs.add(arg.clone());
     }
     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;
+  final List<List<Expression>> args;
 
   IncludeDirective(this.name, this.args, SourceSpan span) : super(span);
 
   IncludeDirective clone() {
-    var cloneArgs = [];
+    var cloneArgs = <List<Expression>>[];
     for (var arg in args) {
-      for (var term in arg) {
-        cloneArgs.add(term.clone());
-      }
+      cloneArgs.add(arg.map((term) => term.clone()).toList());
     }
     return new IncludeDirective(name, cloneArgs, span);
   }
 
   visit(VisitorBase visitor) => visitor.visitIncludeDirective(this);
 }
 
 /** To support SASS @content. */
 class ContentDirective extends Directive {
   ContentDirective(SourceSpan span) : super(span);
@@ skipping 22 matching lines @@
       {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,
-      important: important);
+  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.
@@ skipping 39 matching lines @@
   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;
+  final List<TreeNode> 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.
 
-  MarginGroup(this.margin_sym, List<Declaration> decls, SourceSpan span)
+  MarginGroup(this.margin_sym, List<TreeNode> decls, SourceSpan span)
       : super(decls, span);
   MarginGroup clone() =>
-      new MarginGroup(margin_sym, super.clone() as dynamic, span);
+      new MarginGroup(margin_sym, super.clone().declarations, 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() {
-    var clonedValues = [];
+    var clonedValues = <Expression>[];
     for (var expr in defaultValues) {
       clonedValues.add(expr.clone());
     }
     return new VarUsage(name, clonedValues, span);
   }
 
   visit(VisitorBase visitor) => visitor.visitVarUsage(this);
 }
 
 class OperatorSlash extends Expression {
@@ skipping 263 matching lines @@
     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);
 
@@ skipping 46 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})
+  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),
+            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;
   }
 
   /**
@@ skipping 37 matching lines @@
       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 &&
         newMarginExpr.isMargin) {
       return new MarginExpression.merge(this, newMarginExpr);
     }
@@ skipping 15 matching lines @@
   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) {
       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)
       : 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);
 
   visit(VisitorBase visitor) => visitor.visitBorderExpression(this);
 }
 
 class HeightExpression extends DartStyleExpression {
   final height;
 
@@ skipping 31 matching lines @@
   }
 
   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 &&
         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)
       : 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);
   visit(VisitorBase visitor) => visitor.visitPaddingExpression(this);
 }