Cleanup some ambiguous and incorrect types and disable a case that in analyzer.dart that seems like…

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 1188 matching lines @@
   //   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),
         super(DartStyleExpression.fontStyle, span);
 
-  FontExpression merged(FontExpression newFontExpr) {
-    if (this.isFont && newFontExpr.isFont) {
+  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)
-      : super(DartStyleExpression.fontStyle, span),
-        font = new Font.merge(x.font, y.font);
+      : 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);
 
   visit(VisitorBase visitor) => visitor.visitFontExpression(this);
 }
 
 abstract class BoxExpression extends DartStyleExpression {
   final BoxEdge box;
 
   BoxExpression(int styleType, SourceSpan span, this.box)
       : super(styleType, span);
 
-  /*
-   * Merges give 2 DartStyleExpression (or derived from DartStyleExpression,
-   * e.g., FontExpression, etc.) will merge if the two expressions are of the
-   * same property name (implies same exact type e.g, FontExpression).
-   */
-  merged(BoxExpression newDartExpr);
-
   visit(VisitorBase visitor) => visitor.visitBoxExpression(this);
 
   String get formattedBoxEdge {
     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));
 
   MarginExpression.boxEdge(SourceSpan span, BoxEdge box)
       : super(DartStyleExpression.marginStyle, span, box);
 
-  merged(MarginExpression newMarginExpr) {
-    if (this.isMargin && newMarginExpr.isMargin) {
+  merged(DartStyleExpression newMarginExpr) {
+    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) {
@@ skipping 13 matching lines @@
 
 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));
 
   BorderExpression.boxEdge(SourceSpan span, BoxEdge box)
       : super(DartStyleExpression.borderStyle, span, box);
 
-  merged(BorderExpression newBorderExpr) {
-    if (this.isBorder && newBorderExpr.isBorder) {
+  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) {
@@ skipping 11 matching lines @@
 
   visit(VisitorBase visitor) => visitor.visitBorderExpression(this);
 }
 
 class HeightExpression extends DartStyleExpression {
   final height;
 
   HeightExpression(SourceSpan span, this.height)
       : super(DartStyleExpression.heightStyle, span);
 
-  merged(HeightExpression newHeightExpr) {
-    if (this.isHeight && newHeightExpr.isHeight) {
+  merged(DartStyleExpression newHeightExpr) {
+    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(WidthExpression newWidthExpr) {
-    if (this.isWidth && newWidthExpr.isWidth) {
+  merged(DartStyleExpression newWidthExpr) {
+    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));
 
   PaddingExpression.boxEdge(SourceSpan span, BoxEdge box)
       : super(DartStyleExpression.paddingStyle, span, box);
 
-  merged(PaddingExpression newPaddingExpr) {
-    if (this.isPadding && newPaddingExpr.isPadding) {
+  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));
 
   PaddingExpression clone() =>
       new PaddingExpression(span, top: box.top, right: box.right,
       bottom: box.bottom, left: box.left);
   visit(VisitorBase visitor) => visitor.visitPaddingExpression(this);
 }