Merge pull request #13 from dart-lang/strong_mode

fix strong mode errors, and a bunch of analyzer messages
diff --git a/lib/parser.dart b/lib/parser.dart
index 8692693..a715a9a 100644
--- a/lib/parser.dart
+++ b/lib/parser.dart
@@ -64,7 +64,7 @@
   analyze([tree], errors: errors, options: options);
 
   if (polyfill) {
-    var processCss = new PolyFill(messages, true);
+    var processCss = new PolyFill(messages);
     processCss.process(tree, includes: includes);
   }
 
@@ -430,6 +430,7 @@
     if (unaryOp != -1 || type != null || exprs.length > 0) {
       return new MediaQuery(unaryOp, type, exprs, _makeSpan(start));
     }
+    return null;
   }
 
   MediaExpression processMediaExpression([bool andOperator = false]) {
@@ -453,9 +454,9 @@
         }
       } else if (isChecked) {
         _warning("Missing media feature in media expression", _makeSpan(start));
-        return null;
       }
     }
+    return null;
   }
 
   /**
@@ -798,7 +799,6 @@
     _eat(TokenKind.LBRACE);
 
     List<TreeNode> productions = [];
-    List<TreeNode> declarations = [];
     var mixinDirective;
 
     var start = _peekToken.span;
@@ -984,6 +984,7 @@
       return new RuleSet(
           selectorGroup, processDeclarations(), selectorGroup.span);
     }
+    return null;
   }
 
   /**
@@ -1191,6 +1192,7 @@
     if (selectors.length > 0) {
       return new SelectorGroup(selectors, _makeSpan(start));
     }
+    return null;
   }
 
   /**
@@ -1602,6 +1604,7 @@
 
       return new AttributeSelector(attrName, op, value, _makeSpan(start));
     }
+    return null;
   }
 
   //  Declaration grammar:
@@ -1763,6 +1766,7 @@
     if (styleType != null) {
       return buildDartStyleNode(styleType, exprs, dartStyles);
     }
+    return null;
   }
 
   FontExpression _mergeFontStyles(FontExpression fontExpr, List dartStyles) {
@@ -1910,10 +1914,8 @@
           return processOneNumber(exprs, styleType);
         }
         break;
-      default:
-        // Don't handle it.
-        return null;
     }
+    return null;
   }
 
   // TODO(terry): Look at handling width of thin, thick, etc. any none numbers
@@ -1956,6 +1958,7 @@
           return new PaddingExpression(exprs.span, bottom: value);
       }
     }
+    return null;
   }
 
   /**
diff --git a/lib/src/analyzer.dart b/lib/src/analyzer.dart
index 4fdd833..fc27ceb 100644
--- a/lib/src/analyzer.dart
+++ b/lib/src/analyzer.dart
@@ -463,8 +463,8 @@
       } else if (currDef is MixinRulesetDirective && _anyRulesets(currDef)) {
         // currDef is MixinRulesetDirective
         MixinRulesetDirective mixinRuleset = currDef;
-        int index = mixinRuleset.rulesets.indexOf(node as dynamic);
-        mixinRuleset.rulesets.replaceRange(index, index + 1, [new NoOp()]);
+        int index = mixinRuleset.rulesets.indexOf(node);
+        mixinRuleset.rulesets.removeAt(index);
         _messages.warning(
             'Using declaration mixin ${node.name} as top-level mixin',
             node.span);
@@ -472,13 +472,12 @@
     } else {
       if (currDef is MixinRulesetDirective) {
         MixinRulesetDirective rulesetDirect = currDef as MixinRulesetDirective;
-        var index = 0;
-        rulesetDirect.rulesets.forEach((entry) {
+        rulesetDirect.rulesets.removeWhere((entry) {
           if (entry == node) {
-            rulesetDirect.rulesets.replaceRange(index, index + 1, [new NoOp()]);
             _messages.warning('Undefined mixin ${node.name}', node.span);
+            return true;
           }
-          index++;
+          return false;
         });
       }
     }
diff --git a/lib/src/polyfill.dart b/lib/src/polyfill.dart
index 9b682ce..b18abd1 100644
--- a/lib/src/polyfill.dart
+++ b/lib/src/polyfill.dart
@@ -10,7 +10,6 @@
  */
 class PolyFill {
   final Messages _messages;
-  final bool _warningsAsErrors;
   Map<String, VarDefinition> _allVarDefinitions =
       new Map<String, VarDefinition>();
 
@@ -21,7 +20,7 @@
    * CSS pseudo-elements 'name::custom-element' is mapped to the manged name
    * associated with the pseudo-element key.
    */
-  PolyFill(this._messages, this._warningsAsErrors);
+  PolyFill(this._messages);
 
   /**
    * Run the analyzer on every file that is a style sheet or any component that
@@ -227,7 +226,7 @@
   var expressions = varDef.expression as Expressions;
   for (var expr in expressions.expressions) {
     if (expr is VarUsage) {
-      var usageName = (expr as VarUsage).name;
+      var usageName = expr.name;
       var foundDef = varDefs[usageName];
 
       // If foundDef is unknown check if defaultValues; if it exist then resolve
@@ -236,7 +235,7 @@
         // We're either a VarUsage or terminal definition if in varDefs;
         // either way replace VarUsage with it's default value because the
         // VarDefinition isn't found.
-        var defaultValues = (expr as VarUsage).defaultValues;
+        var defaultValues = expr.defaultValues;
         var replaceExprs = expressions.expressions;
         assert(replaceExprs.length == 1);
         replaceExprs.replaceRange(0, 1, defaultValues);
diff --git a/lib/src/property.dart b/lib/src/property.dart
index 5d6dc14..c2cf776 100644
--- a/lib/src/property.dart
+++ b/lib/src/property.dart
@@ -278,10 +278,11 @@
           return new Hsla(args[0], args[1], args[2], args[3]).toHexArgbString();
         default:
           // Type not defined UnsupportedOperationException should have thrown.
-          assert(true);
+          assert(false);
           break;
       }
     }
+    return null;
   }
 
   static int hexToInt(String hex) => int.parse(hex, radix: 16);
@@ -785,6 +786,7 @@
 
   String get cssExpression {
     // TODO(terry): TBD
+    return null;
   }
 }
 
diff --git a/lib/src/tokenkind.dart b/lib/src/tokenkind.dart
index 617f062..27ccb4b 100644
--- a/lib/src/tokenkind.dart
+++ b/lib/src/tokenkind.dart
@@ -192,7 +192,7 @@
   static const int PSEUDO_CLASS_NAME = 705; // :pseudoClass
   static const int NEGATION = 706; // NOT
 
-  static const List<Map<int, String>> _DIRECTIVES = const [
+  static const List<Map<String, dynamic>> _DIRECTIVES = const [
     const {'type': TokenKind.DIRECTIVE_IMPORT, 'value': 'import'},
     const {'type': TokenKind.DIRECTIVE_MEDIA, 'value': 'media'},
     const {'type': TokenKind.DIRECTIVE_PAGE, 'value': 'page'},
@@ -218,13 +218,13 @@
     const {'type': TokenKind.DIRECTIVE_EXTEND, 'value': 'extend'},
   ];
 
-  static const List<Map<int, String>> MEDIA_OPERATORS = const [
+  static const List<Map<String, dynamic>> MEDIA_OPERATORS = const [
     const {'type': TokenKind.MEDIA_OP_ONLY, 'value': 'only'},
     const {'type': TokenKind.MEDIA_OP_NOT, 'value': 'not'},
     const {'type': TokenKind.MEDIA_OP_AND, 'value': 'and'},
   ];
 
-  static const List<Map<int, String>> MARGIN_DIRECTIVES = const [
+  static const List<Map<String, dynamic>> MARGIN_DIRECTIVES = const [
     const {
       'type': TokenKind.MARGIN_DIRECTIVE_TOPLEFTCORNER,
       'value': 'top-left-corner'
diff --git a/lib/src/tree.dart b/lib/src/tree.dart
index 5dad435..75e9629 100644
--- a/lib/src/tree.dart
+++ b/lib/src/tree.dart
@@ -197,6 +197,7 @@
       case TokenKind.NO_MATCH:
         return '';
     }
+    return null;
   }
 
   // Return the TokenKind for operator used by visitAttributeSelector.
@@ -215,6 +216,7 @@
       case TokenKind.SUBSTRING_MATCH:
         return 'SUBSTRING_MATCH';
     }
+    return null;
   }
 
   String valueToString() {
@@ -572,6 +574,7 @@
       case TokenKind.DIRECTIVE_O_KEYFRAMES:
         return '@-o-keyframes';
     }
+    return null;
   }
 
   KeyFrameDirective clone() {
@@ -676,7 +679,7 @@
 
 /** Support a Sass @mixin. See http://sass-lang.com for description. */
 class MixinRulesetDirective extends MixinDefinition {
-  final List<RuleSet> rulesets;
+  final List rulesets;
 
   MixinRulesetDirective(String name, List<VarDefinitionDirective> args,
       bool varArgs, this.rulesets, SourceSpan span)
diff --git a/lib/src/validate.dart b/lib/src/validate.dart
index d45cd95..e716e66 100644
--- a/lib/src/validate.dart
+++ b/lib/src/validate.dart
@@ -53,7 +53,6 @@
   // Validate the @{css expression} only .class and #elementId are valid inside
   // of @{...}.
   static template(List<Selector> selectors) {
-    var errorSelector; // signal which selector didn't match.
     bool found = false; // signal if a selector is matched.
     int matches = 0; // < 0 IdSelectors, > 0 ClassSelector
 
diff --git a/lib/visitor.dart b/lib/visitor.dart
index fa0f8d2..593e43a 100644
--- a/lib/visitor.dart
+++ b/lib/visitor.dart
@@ -13,99 +13,99 @@
 part 'src/tree_printer.dart';
 
 abstract class VisitorBase {
-  void visitCssComment(CssComment node);
-  void visitCommentDefinition(CommentDefinition node);
-  void visitStyleSheet(StyleSheet node);
-  void visitNoOp(NoOp node);
-  void visitTopLevelProduction(TopLevelProduction node);
-  void visitDirective(Directive node);
-  void visitMediaExpression(MediaExpression node);
-  void visitMediaQuery(MediaQuery node);
-  void visitMediaDirective(MediaDirective node);
-  void visitHostDirective(HostDirective node);
-  void visitPageDirective(PageDirective node);
-  void visitCharsetDirective(CharsetDirective node);
-  void visitImportDirective(ImportDirective node);
-  void visitKeyFrameDirective(KeyFrameDirective node);
-  void visitKeyFrameBlock(KeyFrameBlock node);
-  void visitFontFaceDirective(FontFaceDirective node);
-  void visitStyletDirective(StyletDirective node);
-  void visitNamespaceDirective(NamespaceDirective node);
-  void visitVarDefinitionDirective(VarDefinitionDirective node);
-  void visitMixinDefinition(MixinDefinition node);
-  void visitMixinRulesetDirective(MixinRulesetDirective node);
-  void visitMixinDeclarationDirective(MixinDeclarationDirective node);
-  void visitIncludeDirective(IncludeDirective node);
-  void visitContentDirective(ContentDirective node);
+  visitCssComment(CssComment node);
+  visitCommentDefinition(CommentDefinition node);
+  visitStyleSheet(StyleSheet node);
+  visitNoOp(NoOp node);
+  visitTopLevelProduction(TopLevelProduction node);
+  visitDirective(Directive node);
+  visitMediaExpression(MediaExpression node);
+  visitMediaQuery(MediaQuery node);
+  visitMediaDirective(MediaDirective node);
+  visitHostDirective(HostDirective node);
+  visitPageDirective(PageDirective node);
+  visitCharsetDirective(CharsetDirective node);
+  visitImportDirective(ImportDirective node);
+  visitKeyFrameDirective(KeyFrameDirective node);
+  visitKeyFrameBlock(KeyFrameBlock node);
+  visitFontFaceDirective(FontFaceDirective node);
+  visitStyletDirective(StyletDirective node);
+  visitNamespaceDirective(NamespaceDirective node);
+  visitVarDefinitionDirective(VarDefinitionDirective node);
+  visitMixinDefinition(MixinDefinition node);
+  visitMixinRulesetDirective(MixinRulesetDirective node);
+  visitMixinDeclarationDirective(MixinDeclarationDirective node);
+  visitIncludeDirective(IncludeDirective node);
+  visitContentDirective(ContentDirective node);
 
-  void visitRuleSet(RuleSet node);
-  void visitDeclarationGroup(DeclarationGroup node);
-  void visitMarginGroup(MarginGroup node);
-  void visitDeclaration(Declaration node);
-  void visitVarDefinition(VarDefinition node);
-  void visitIncludeMixinAtDeclaration(IncludeMixinAtDeclaration node);
-  void visitExtendDeclaration(ExtendDeclaration node);
-  void visitSelectorGroup(SelectorGroup node);
-  void visitSelector(Selector node);
-  void visitSimpleSelectorSequence(SimpleSelectorSequence node);
-  void visitSimpleSelector(SimpleSelector node);
-  void visitElementSelector(ElementSelector node);
-  void visitNamespaceSelector(NamespaceSelector node);
-  void visitAttributeSelector(AttributeSelector node);
-  void visitIdSelector(IdSelector node);
-  void visitClassSelector(ClassSelector node);
-  void visitPseudoClassSelector(PseudoClassSelector node);
-  void visitPseudoElementSelector(PseudoElementSelector node);
-  void visitPseudoClassFunctionSelector(PseudoClassFunctionSelector node);
-  void visitPseudoElementFunctionSelector(PseudoElementFunctionSelector node);
-  void visitNegationSelector(NegationSelector node);
-  void visitSelectorExpression(SelectorExpression node);
+  visitRuleSet(RuleSet node);
+  visitDeclarationGroup(DeclarationGroup node);
+  visitMarginGroup(MarginGroup node);
+  visitDeclaration(Declaration node);
+  visitVarDefinition(VarDefinition node);
+  visitIncludeMixinAtDeclaration(IncludeMixinAtDeclaration node);
+  visitExtendDeclaration(ExtendDeclaration node);
+  visitSelectorGroup(SelectorGroup node);
+  visitSelector(Selector node);
+  visitSimpleSelectorSequence(SimpleSelectorSequence node);
+  visitSimpleSelector(SimpleSelector node);
+  visitElementSelector(ElementSelector node);
+  visitNamespaceSelector(NamespaceSelector node);
+  visitAttributeSelector(AttributeSelector node);
+  visitIdSelector(IdSelector node);
+  visitClassSelector(ClassSelector node);
+  visitPseudoClassSelector(PseudoClassSelector node);
+  visitPseudoElementSelector(PseudoElementSelector node);
+  visitPseudoClassFunctionSelector(PseudoClassFunctionSelector node);
+  visitPseudoElementFunctionSelector(PseudoElementFunctionSelector node);
+  visitNegationSelector(NegationSelector node);
+  visitSelectorExpression(SelectorExpression node);
 
-  void visitUnicodeRangeTerm(UnicodeRangeTerm node);
-  void visitLiteralTerm(LiteralTerm node);
-  void visitHexColorTerm(HexColorTerm node);
-  void visitNumberTerm(NumberTerm node);
-  void visitUnitTerm(UnitTerm node);
-  void visitLengthTerm(LengthTerm node);
-  void visitPercentageTerm(PercentageTerm node);
-  void visitEmTerm(EmTerm node);
-  void visitExTerm(ExTerm node);
-  void visitAngleTerm(AngleTerm node);
-  void visitTimeTerm(TimeTerm node);
-  void visitFreqTerm(FreqTerm node);
-  void visitFractionTerm(FractionTerm node);
-  void visitUriTerm(UriTerm node);
-  void visitResolutionTerm(ResolutionTerm node);
-  void visitChTerm(ChTerm node);
-  void visitRemTerm(RemTerm node);
-  void visitViewportTerm(ViewportTerm node);
-  void visitFunctionTerm(FunctionTerm node);
-  void visitGroupTerm(GroupTerm node);
-  void visitItemTerm(ItemTerm node);
-  void visitIE8Term(IE8Term node);
-  void visitOperatorSlash(OperatorSlash node);
-  void visitOperatorComma(OperatorComma node);
-  void visitOperatorPlus(OperatorPlus node);
-  void visitOperatorMinus(OperatorMinus node);
-  void visitVarUsage(VarUsage node);
+  visitUnicodeRangeTerm(UnicodeRangeTerm node);
+  visitLiteralTerm(LiteralTerm node);
+  visitHexColorTerm(HexColorTerm node);
+  visitNumberTerm(NumberTerm node);
+  visitUnitTerm(UnitTerm node);
+  visitLengthTerm(LengthTerm node);
+  visitPercentageTerm(PercentageTerm node);
+  visitEmTerm(EmTerm node);
+  visitExTerm(ExTerm node);
+  visitAngleTerm(AngleTerm node);
+  visitTimeTerm(TimeTerm node);
+  visitFreqTerm(FreqTerm node);
+  visitFractionTerm(FractionTerm node);
+  visitUriTerm(UriTerm node);
+  visitResolutionTerm(ResolutionTerm node);
+  visitChTerm(ChTerm node);
+  visitRemTerm(RemTerm node);
+  visitViewportTerm(ViewportTerm node);
+  visitFunctionTerm(FunctionTerm node);
+  visitGroupTerm(GroupTerm node);
+  visitItemTerm(ItemTerm node);
+  visitIE8Term(IE8Term node);
+  visitOperatorSlash(OperatorSlash node);
+  visitOperatorComma(OperatorComma node);
+  visitOperatorPlus(OperatorPlus node);
+  visitOperatorMinus(OperatorMinus node);
+  visitVarUsage(VarUsage node);
 
-  void visitExpressions(Expressions node);
-  void visitBinaryExpression(BinaryExpression node);
-  void visitUnaryExpression(UnaryExpression node);
+  visitExpressions(Expressions node);
+  visitBinaryExpression(BinaryExpression node);
+  visitUnaryExpression(UnaryExpression node);
 
-  void visitIdentifier(Identifier node);
-  void visitWildcard(Wildcard node);
-  void visitThisOperator(ThisOperator node);
-  void visitNegation(Negation node);
+  visitIdentifier(Identifier node);
+  visitWildcard(Wildcard node);
+  visitThisOperator(ThisOperator node);
+  visitNegation(Negation node);
 
-  void visitDartStyleExpression(DartStyleExpression node);
-  void visitFontExpression(FontExpression node);
-  void visitBoxExpression(BoxExpression node);
-  void visitMarginExpression(MarginExpression node);
-  void visitBorderExpression(BorderExpression node);
-  void visitHeightExpression(HeightExpression node);
-  void visitPaddingExpression(PaddingExpression node);
-  void visitWidthExpression(WidthExpression node);
+  visitDartStyleExpression(DartStyleExpression node);
+  visitFontExpression(FontExpression node);
+  visitBoxExpression(BoxExpression node);
+  visitMarginExpression(MarginExpression node);
+  visitBorderExpression(BorderExpression node);
+  visitHeightExpression(HeightExpression node);
+  visitPaddingExpression(PaddingExpression node);
+  visitWidthExpression(WidthExpression node);
 }
 
 /** Base vistor class for the style sheet AST. */
@@ -120,33 +120,33 @@
     }
   }
 
-  void visitTree(StyleSheet tree) => visitStyleSheet(tree);
+  visitTree(StyleSheet tree) => visitStyleSheet(tree);
 
-  void visitStyleSheet(StyleSheet ss) {
+  visitStyleSheet(StyleSheet ss) {
     _visitNodeList(ss.topLevels);
   }
 
-  void visitNoOp(NoOp node) {}
+  visitNoOp(NoOp node) {}
 
-  void visitTopLevelProduction(TopLevelProduction node) {}
+  visitTopLevelProduction(TopLevelProduction node) {}
 
-  void visitDirective(Directive node) {}
+  visitDirective(Directive node) {}
 
-  void visitCssComment(CssComment node) {}
+  visitCssComment(CssComment node) {}
 
-  void visitCommentDefinition(CommentDefinition node) {}
+  visitCommentDefinition(CommentDefinition node) {}
 
-  void visitMediaExpression(MediaExpression node) {
+  visitMediaExpression(MediaExpression node) {
     visitExpressions(node.exprs);
   }
 
-  void visitMediaQuery(MediaQuery node) {
+  visitMediaQuery(MediaQuery node) {
     for (var mediaExpr in node.expressions) {
       visitMediaExpression(mediaExpr);
     }
   }
 
-  void visitMediaDirective(MediaDirective node) {
+  visitMediaDirective(MediaDirective node) {
     for (var mediaQuery in node.mediaQueries) {
       visitMediaQuery(mediaQuery);
     }
@@ -155,13 +155,13 @@
     }
   }
 
-  void visitHostDirective(HostDirective node) {
+  visitHostDirective(HostDirective node) {
     for (var ruleset in node.rulesets) {
       visitRuleSet(ruleset);
     }
   }
 
-  void visitPageDirective(PageDirective node) {
+  visitPageDirective(PageDirective node) {
     for (var declGroup in node._declsMargin) {
       if (declGroup is MarginGroup) {
         visitMarginGroup(declGroup);
@@ -171,285 +171,285 @@
     }
   }
 
-  void visitCharsetDirective(CharsetDirective node) {}
+  visitCharsetDirective(CharsetDirective node) {}
 
-  void visitImportDirective(ImportDirective node) {
+  visitImportDirective(ImportDirective node) {
     for (var mediaQuery in node.mediaQueries) {
       visitMediaQuery(mediaQuery);
     }
   }
 
-  void visitKeyFrameDirective(KeyFrameDirective node) {
+  visitKeyFrameDirective(KeyFrameDirective node) {
     visitIdentifier(node.name);
     _visitNodeList(node._blocks);
   }
 
-  void visitKeyFrameBlock(KeyFrameBlock node) {
+  visitKeyFrameBlock(KeyFrameBlock node) {
     visitExpressions(node._blockSelectors);
     visitDeclarationGroup(node._declarations);
   }
 
-  void visitFontFaceDirective(FontFaceDirective node) {
+  visitFontFaceDirective(FontFaceDirective node) {
     visitDeclarationGroup(node._declarations);
   }
 
-  void visitStyletDirective(StyletDirective node) {
+  visitStyletDirective(StyletDirective node) {
     _visitNodeList(node.rulesets);
   }
 
-  void visitNamespaceDirective(NamespaceDirective node) {}
+  visitNamespaceDirective(NamespaceDirective node) {}
 
-  void visitVarDefinitionDirective(VarDefinitionDirective node) {
+  visitVarDefinitionDirective(VarDefinitionDirective node) {
     visitVarDefinition(node.def);
   }
 
-  void visitMixinRulesetDirective(MixinRulesetDirective node) {
+  visitMixinRulesetDirective(MixinRulesetDirective node) {
     _visitNodeList(node.rulesets);
   }
 
-  void visitMixinDefinition(MixinDefinition node) {}
+  visitMixinDefinition(MixinDefinition node) {}
 
-  void visitMixinDeclarationDirective(MixinDeclarationDirective node) {
+  visitMixinDeclarationDirective(MixinDeclarationDirective node) {
     visitDeclarationGroup(node.declarations);
   }
 
-  void visitIncludeDirective(IncludeDirective node) {
+  visitIncludeDirective(IncludeDirective node) {
     for (var index = 0; index < node.args.length; index++) {
       var param = node.args[index];
       _visitNodeList(param);
     }
   }
 
-  void visitContentDirective(ContentDirective node) {
+  visitContentDirective(ContentDirective node) {
     // TODO(terry): TBD
   }
 
-  void visitRuleSet(RuleSet node) {
+  visitRuleSet(RuleSet node) {
     visitSelectorGroup(node._selectorGroup);
     visitDeclarationGroup(node._declarationGroup);
   }
 
-  void visitDeclarationGroup(DeclarationGroup node) {
+  visitDeclarationGroup(DeclarationGroup node) {
     _visitNodeList(node.declarations);
   }
 
-  void visitMarginGroup(MarginGroup node) => visitDeclarationGroup(node);
+  visitMarginGroup(MarginGroup node) => visitDeclarationGroup(node);
 
-  void visitDeclaration(Declaration node) {
+  visitDeclaration(Declaration node) {
     visitIdentifier(node._property);
     if (node._expression != null) node._expression.visit(this);
   }
 
-  void visitVarDefinition(VarDefinition node) {
+  visitVarDefinition(VarDefinition node) {
     visitIdentifier(node._property);
     if (node._expression != null) node._expression.visit(this);
   }
 
-  void visitIncludeMixinAtDeclaration(IncludeMixinAtDeclaration node) {
+  visitIncludeMixinAtDeclaration(IncludeMixinAtDeclaration node) {
     visitIncludeDirective(node.include);
   }
 
-  void visitExtendDeclaration(ExtendDeclaration node) {
+  visitExtendDeclaration(ExtendDeclaration node) {
     _visitNodeList(node.selectors);
   }
 
-  void visitSelectorGroup(SelectorGroup node) {
+  visitSelectorGroup(SelectorGroup node) {
     _visitNodeList(node.selectors);
   }
 
-  void visitSelector(Selector node) {
+  visitSelector(Selector node) {
     _visitNodeList(node.simpleSelectorSequences);
   }
 
-  void visitSimpleSelectorSequence(SimpleSelectorSequence node) {
+  visitSimpleSelectorSequence(SimpleSelectorSequence node) {
     node.simpleSelector.visit(this);
   }
 
-  void visitSimpleSelector(SimpleSelector node) => node._name.visit(this);
+  visitSimpleSelector(SimpleSelector node) => node._name.visit(this);
 
-  void visitNamespaceSelector(NamespaceSelector node) {
+  visitNamespaceSelector(NamespaceSelector node) {
     if (node._namespace != null) node._namespace.visit(this);
     if (node.nameAsSimpleSelector != null) {
       node.nameAsSimpleSelector.visit(this);
     }
   }
 
-  void visitElementSelector(ElementSelector node) => visitSimpleSelector(node);
+  visitElementSelector(ElementSelector node) => visitSimpleSelector(node);
 
-  void visitAttributeSelector(AttributeSelector node) {
+  visitAttributeSelector(AttributeSelector node) {
     visitSimpleSelector(node);
   }
 
-  void visitIdSelector(IdSelector node) => visitSimpleSelector(node);
+  visitIdSelector(IdSelector node) => visitSimpleSelector(node);
 
-  void visitClassSelector(ClassSelector node) => visitSimpleSelector(node);
+  visitClassSelector(ClassSelector node) => visitSimpleSelector(node);
 
-  void visitPseudoClassSelector(PseudoClassSelector node) =>
+  visitPseudoClassSelector(PseudoClassSelector node) =>
       visitSimpleSelector(node);
 
-  void visitPseudoElementSelector(PseudoElementSelector node) =>
+  visitPseudoElementSelector(PseudoElementSelector node) =>
       visitSimpleSelector(node);
 
-  void visitPseudoClassFunctionSelector(PseudoClassFunctionSelector node) =>
+  visitPseudoClassFunctionSelector(PseudoClassFunctionSelector node) =>
       visitSimpleSelector(node);
 
-  void visitPseudoElementFunctionSelector(PseudoElementFunctionSelector node) =>
+  visitPseudoElementFunctionSelector(PseudoElementFunctionSelector node) =>
       visitSimpleSelector(node);
 
-  void visitNegationSelector(NegationSelector node) =>
+  visitNegationSelector(NegationSelector node) =>
       visitSimpleSelector(node);
 
-  void visitSelectorExpression(SelectorExpression node) {
+  visitSelectorExpression(SelectorExpression node) {
     _visitNodeList(node.expressions);
   }
 
-  void visitUnicodeRangeTerm(UnicodeRangeTerm node) {}
+  visitUnicodeRangeTerm(UnicodeRangeTerm node) {}
 
-  void visitLiteralTerm(LiteralTerm node) {}
+  visitLiteralTerm(LiteralTerm node) {}
 
-  void visitHexColorTerm(HexColorTerm node) {}
+  visitHexColorTerm(HexColorTerm node) {}
 
-  void visitNumberTerm(NumberTerm node) {}
+  visitNumberTerm(NumberTerm node) {}
 
-  void visitUnitTerm(UnitTerm node) {}
+  visitUnitTerm(UnitTerm node) {}
 
-  void visitLengthTerm(LengthTerm node) {
+  visitLengthTerm(LengthTerm node) {
     visitUnitTerm(node);
   }
 
-  void visitPercentageTerm(PercentageTerm node) {
+  visitPercentageTerm(PercentageTerm node) {
     visitLiteralTerm(node);
   }
 
-  void visitEmTerm(EmTerm node) {
+  visitEmTerm(EmTerm node) {
     visitLiteralTerm(node);
   }
 
-  void visitExTerm(ExTerm node) {
+  visitExTerm(ExTerm node) {
     visitLiteralTerm(node);
   }
 
-  void visitAngleTerm(AngleTerm node) {
+  visitAngleTerm(AngleTerm node) {
     visitUnitTerm(node);
   }
 
-  void visitTimeTerm(TimeTerm node) {
+  visitTimeTerm(TimeTerm node) {
     visitUnitTerm(node);
   }
 
-  void visitFreqTerm(FreqTerm node) {
+  visitFreqTerm(FreqTerm node) {
     visitUnitTerm(node);
   }
 
-  void visitFractionTerm(FractionTerm node) {
+  visitFractionTerm(FractionTerm node) {
     visitLiteralTerm(node);
   }
 
-  void visitUriTerm(UriTerm node) {
+  visitUriTerm(UriTerm node) {
     visitLiteralTerm(node);
   }
 
-  void visitResolutionTerm(ResolutionTerm node) {
+  visitResolutionTerm(ResolutionTerm node) {
     visitUnitTerm(node);
   }
 
-  void visitChTerm(ChTerm node) {
+  visitChTerm(ChTerm node) {
     visitUnitTerm(node);
   }
 
-  void visitRemTerm(RemTerm node) {
+  visitRemTerm(RemTerm node) {
     visitUnitTerm(node);
   }
 
-  void visitViewportTerm(ViewportTerm node) {
+  visitViewportTerm(ViewportTerm node) {
     visitUnitTerm(node);
   }
 
-  void visitFunctionTerm(FunctionTerm node) {
+  visitFunctionTerm(FunctionTerm node) {
     visitLiteralTerm(node);
     visitExpressions(node._params);
   }
 
-  void visitGroupTerm(GroupTerm node) {
+  visitGroupTerm(GroupTerm node) {
     for (var term in node._terms) {
       term.visit(this);
     }
   }
 
-  void visitItemTerm(ItemTerm node) {
+  visitItemTerm(ItemTerm node) {
     visitNumberTerm(node);
   }
 
-  void visitIE8Term(IE8Term node) {}
+  visitIE8Term(IE8Term node) {}
 
-  void visitOperatorSlash(OperatorSlash node) {}
+  visitOperatorSlash(OperatorSlash node) {}
 
-  void visitOperatorComma(OperatorComma node) {}
+  visitOperatorComma(OperatorComma node) {}
 
-  void visitOperatorPlus(OperatorPlus node) {}
+  visitOperatorPlus(OperatorPlus node) {}
 
-  void visitOperatorMinus(OperatorMinus node) {}
+  visitOperatorMinus(OperatorMinus node) {}
 
-  void visitVarUsage(VarUsage node) {
+  visitVarUsage(VarUsage node) {
     _visitNodeList(node.defaultValues);
   }
 
-  void visitExpressions(Expressions node) {
+  visitExpressions(Expressions node) {
     _visitNodeList(node.expressions);
   }
 
-  void visitBinaryExpression(BinaryExpression node) {
+  visitBinaryExpression(BinaryExpression node) {
     // TODO(terry): TBD
-    throw UnimplementedError;
+    throw new UnimplementedError();
   }
 
-  void visitUnaryExpression(UnaryExpression node) {
+  visitUnaryExpression(UnaryExpression node) {
     // TODO(terry): TBD
-    throw UnimplementedError;
+    throw new UnimplementedError();
   }
 
-  void visitIdentifier(Identifier node) {}
+  visitIdentifier(Identifier node) {}
 
-  void visitWildcard(Wildcard node) {}
+  visitWildcard(Wildcard node) {}
 
-  void visitThisOperator(ThisOperator node) {}
+  visitThisOperator(ThisOperator node) {}
 
-  void visitNegation(Negation node) {}
+  visitNegation(Negation node) {}
 
-  void visitDartStyleExpression(DartStyleExpression node) {}
+  visitDartStyleExpression(DartStyleExpression node) {}
 
-  void visitFontExpression(FontExpression node) {
+  visitFontExpression(FontExpression node) {
     // TODO(terry): TBD
-    throw UnimplementedError;
+    throw new UnimplementedError();
   }
 
-  void visitBoxExpression(BoxExpression node) {
+  visitBoxExpression(BoxExpression node) {
     // TODO(terry): TBD
-    throw UnimplementedError;
+    throw new UnimplementedError();
   }
 
-  void visitMarginExpression(MarginExpression node) {
+  visitMarginExpression(MarginExpression node) {
     // TODO(terry): TBD
-    throw UnimplementedError;
+    throw new UnimplementedError();
   }
 
-  void visitBorderExpression(BorderExpression node) {
+  visitBorderExpression(BorderExpression node) {
     // TODO(terry): TBD
-    throw UnimplementedError;
+    throw new UnimplementedError();
   }
 
-  void visitHeightExpression(HeightExpression node) {
+  visitHeightExpression(HeightExpression node) {
     // TODO(terry): TB
-    throw UnimplementedError;
+    throw new UnimplementedError();
   }
 
-  void visitPaddingExpression(PaddingExpression node) {
+  visitPaddingExpression(PaddingExpression node) {
     // TODO(terry): TBD
-    throw UnimplementedError;
+    throw new UnimplementedError();
   }
 
-  void visitWidthExpression(WidthExpression node) {
+  visitWidthExpression(WidthExpression node) {
     // TODO(terry): TBD
-    throw UnimplementedError;
+    throw new UnimplementedError();
   }
 }