Rewrite constants evaluation and checks to avoid using 'is double'.

pkg/analyzer/lib/src/generated/ast.dart

 // Copyright (c) 2014, 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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.ast;
 
 import 'dart:collection';
@@ skipping 5043 matching lines @@
         }
       } else if (node.operator.type == TokenType.AMPERSAND_AMPERSAND) {
         // boolean or {@code null}
         if (leftOperand is bool && rightOperand is bool) {
           return leftOperand && rightOperand;
         }
       } else if (node.operator.type == TokenType.BANG_EQ) {
         // numeric, string, boolean, or {@code null}
         if (leftOperand is bool && rightOperand is bool) {
           return leftOperand != rightOperand;
-        } else if (leftOperand is int && rightOperand is int) {
-          return leftOperand != rightOperand;
-        } else if (leftOperand is double && rightOperand is double) {
+        } else if (leftOperand is num && rightOperand is num) {
           return leftOperand != rightOperand;
         } else if (leftOperand is String && rightOperand is String) {
           return leftOperand != rightOperand;
         }
       } else if (node.operator.type == TokenType.BAR) {
         // integer or {@code null}
         if (leftOperand is int && rightOperand is int) {
           return leftOperand | rightOperand;
         }
       } else if (node.operator.type == TokenType.BAR_BAR) {
         // boolean or {@code null}
         if (leftOperand is bool && rightOperand is bool) {
           return leftOperand || rightOperand;
         }
       } else if (node.operator.type == TokenType.CARET) {
         // integer or {@code null}
         if (leftOperand is int && rightOperand is int) {
           return leftOperand ^ rightOperand;
         }
       } else if (node.operator.type == TokenType.EQ_EQ) {
         // numeric, string, boolean, or {@code null}
         if (leftOperand is bool && rightOperand is bool) {
           return leftOperand == rightOperand;
-        } else if (leftOperand is int && rightOperand is int) {
-          return leftOperand == rightOperand;
-        } else if (leftOperand is double && rightOperand is double) {
+        } else if (leftOperand is num && rightOperand is num) {
           return leftOperand == rightOperand;
         } else if (leftOperand is String && rightOperand is String) {
           return leftOperand == rightOperand;
         }
       } else if (node.operator.type == TokenType.GT) {
         // numeric or {@code null}
-        if (leftOperand is int && rightOperand is int) {
-          return leftOperand.compareTo(rightOperand) > 0;
-        } else if (leftOperand is double && rightOperand is double) {
+        if (leftOperand is num && rightOperand is num) {
           return leftOperand.compareTo(rightOperand) > 0;
         }
       } else if (node.operator.type == TokenType.GT_EQ) {
         // numeric or {@code null}
-        if (leftOperand is int && rightOperand is int) {
-          return leftOperand.compareTo(rightOperand) >= 0;
-        } else if (leftOperand is double && rightOperand is double) {
+        if (leftOperand is num && rightOperand is num) {
           return leftOperand.compareTo(rightOperand) >= 0;
         }
       } else if (node.operator.type == TokenType.GT_GT) {
         // integer or {@code null}
         if (leftOperand is int && rightOperand is int) {
           return leftOperand >> rightOperand;
         }
       } else if (node.operator.type == TokenType.LT) {
         // numeric or {@code null}
-        if (leftOperand is int && rightOperand is int) {
-          return leftOperand.compareTo(rightOperand) < 0;
-        } else if (leftOperand is double && rightOperand is double) {
+        if (leftOperand is num && rightOperand is num) {
           return leftOperand.compareTo(rightOperand) < 0;
         }
       } else if (node.operator.type == TokenType.LT_EQ) {
         // numeric or {@code null}
-        if (leftOperand is int && rightOperand is int) {
-          return leftOperand.compareTo(rightOperand) <= 0;
-        } else if (leftOperand is double && rightOperand is double) {
+        if (leftOperand is num && rightOperand is num) {
           return leftOperand.compareTo(rightOperand) <= 0;
         }
       } else if (node.operator.type == TokenType.LT_LT) {
         // integer or {@code null}
         if (leftOperand is int && rightOperand is int) {
           return leftOperand << rightOperand;
         }
       } else if (node.operator.type == TokenType.MINUS) {
         // numeric or {@code null}
-        if (leftOperand is int && rightOperand is int) {
-          return leftOperand - rightOperand;
-        } else if (leftOperand is double && rightOperand is double) {
+        if (leftOperand is num && rightOperand is num) {
           return leftOperand - rightOperand;
         }
       } else if (node.operator.type == TokenType.PERCENT) {
         // numeric or {@code null}
-        if (leftOperand is int && rightOperand is int) {
+        if (leftOperand is num && rightOperand is num) {
           return leftOperand.remainder(rightOperand);
-        } else if (leftOperand is double && rightOperand is double) {
-          return leftOperand % rightOperand;
         }
       } else if (node.operator.type == TokenType.PLUS) {
         // numeric or {@code null}
-        if (leftOperand is int && rightOperand is int) {
-          return leftOperand + rightOperand;
-        } else if (leftOperand is double && rightOperand is double) {
+        if (leftOperand is num && rightOperand is num) {
           return leftOperand + rightOperand;
         }
       } else if (node.operator.type == TokenType.STAR) {
         // numeric or {@code null}
-        if (leftOperand is int && rightOperand is int) {
-          return leftOperand * rightOperand;
-        } else if (leftOperand is double && rightOperand is double) {
+        if (leftOperand is num && rightOperand is num) {
           return leftOperand * rightOperand;
         }
       } else if (node.operator.type == TokenType.SLASH) {
         // numeric or {@code null}
-        if (leftOperand is int && rightOperand is int) {
-          if (rightOperand != 0) {
-            return leftOperand ~/ rightOperand;
-          } else {
-            return leftOperand.toDouble() / rightOperand.toDouble();
-          }
-        } else if (leftOperand is double && rightOperand is double) {
+        if (leftOperand is num && rightOperand is num) {
           return leftOperand / rightOperand;
         }
       } else if (node.operator.type == TokenType.TILDE_SLASH) {
         // numeric or {@code null}
-        if (leftOperand is int && rightOperand is int) {
-          if (rightOperand != 0) {
-            return leftOperand ~/ rightOperand;
-          } else {
-            return 0;
-          }
-        } else if (leftOperand is double && rightOperand is double) {
+        if (leftOperand is num && rightOperand is num) {
           return leftOperand ~/ rightOperand;
         }
       } else {}
       break;
     }
     // TODO(brianwilkerson) This doesn't handle numeric conversions.
     return visitExpression(node);
   }
 
   @override
   Object visitBooleanLiteral(BooleanLiteral node) => node.value ? true : false;
 
   @override
   Object visitDoubleLiteral(DoubleLiteral node) => node.value;
 
   @override
   Object visitIntegerLiteral(IntegerLiteral node) => node.value;
 
   @override
   Object visitInterpolationExpression(InterpolationExpression node) {
     Object value = node.expression.accept(this);
-    if (value == null ||
-        value is bool ||
-        value is String ||
-        value is int ||
-        value is double) {
+    if (value == null || value is bool || value is String || value is num) {
       return value;
     }
     return NOT_A_CONSTANT;
   }
 
   @override
   Object visitInterpolationString(InterpolationString node) => node.value;
 
   @override
   Object visitListLiteral(ListLiteral node) {
@@ skipping 52 matching lines @@
         } else if (identical(operand, false)) {
           return true;
         }
       } else if (node.operator.type == TokenType.TILDE) {
         if (operand is int) {
           return ~operand;
         }
       } else if (node.operator.type == TokenType.MINUS) {
         if (operand == null) {
           return null;
-        } else if (operand is int) {
-          return -operand;
-        } else if (operand is double) {
+        } else if (operand is num) {
           return -operand;
         }
       } else {}
       break;
     }
     return NOT_A_CONSTANT;
   }
 
   @override
   Object visitPropertyAccess(PropertyAccess node) => _getConstantValue(null);
@@ skipping 14802 matching lines @@
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitYieldStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_expression, visitor);
   }
 }