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

pkg/analyzer/test/generated/ast_test.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_test;
 
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 246 matching lines @@
   }
 
   void test_binary_bitXor() {
     Object value = _getConstantValue("74 ^ 42");
     EngineTestCase.assertInstanceOf((obj) => obj is int, int, value);
     expect(value as int, 74 ^ 42);
   }
 
   void test_binary_divide_double() {
     Object value = _getConstantValue("3.2 / 2.3");
-    EngineTestCase.assertInstanceOf((obj) => obj is double, double, value);
-    expect(value as double, 3.2 / 2.3);
+    expect(value, 3.2 / 2.3);
   }
 
   void test_binary_divide_integer() {
     Object value = _getConstantValue("3 / 2");
-    EngineTestCase.assertInstanceOf((obj) => obj is int, int, value);
-    expect(value as int, 1);
+    expect(value, 1.5);
   }
 
   void test_binary_equal_boolean() {
     Object value = _getConstantValue("true == false");
     expect(value, false);
   }
 
   void test_binary_equal_integer() {
     Object value = _getConstantValue("2 == 3");
     expect(value, false);
@@ skipping 45 matching lines @@
     expect(value, false);
   }
 
   void test_binary_logicalOr() {
     Object value = _getConstantValue("true || false");
     expect(value, true);
   }
 
   void test_binary_minus_double() {
     Object value = _getConstantValue("3.2 - 2.3");
-    EngineTestCase.assertInstanceOf((obj) => obj is double, double, value);
-    expect(value as double, 3.2 - 2.3);
+    expect(value, 3.2 - 2.3);
   }
 
   void test_binary_minus_integer() {
     Object value = _getConstantValue("3 - 2");
-    EngineTestCase.assertInstanceOf((obj) => obj is int, int, value);
-    expect(value as int, 1);
+    expect(value, 1);
   }
 
   void test_binary_notEqual_boolean() {
     Object value = _getConstantValue("true != false");
     expect(value, true);
   }
 
   void test_binary_notEqual_integer() {
     Object value = _getConstantValue("2 != 3");
     expect(value, true);
   }
 
   void test_binary_notEqual_invalidLeft() {
     Object value = _getConstantValue("a != 3");
     expect(value, ConstantEvaluator.NOT_A_CONSTANT);
   }
 
   void test_binary_notEqual_invalidRight() {
     Object value = _getConstantValue("2 != a");
     expect(value, ConstantEvaluator.NOT_A_CONSTANT);
   }
 
   void test_binary_notEqual_string() {
     Object value = _getConstantValue("'a' != 'b'");
     expect(value, true);
   }
 
   void test_binary_plus_double() {
     Object value = _getConstantValue("2.3 + 3.2");
-    EngineTestCase.assertInstanceOf((obj) => obj is double, double, value);
-    expect(value as double, 2.3 + 3.2);
+    expect(value, 2.3 + 3.2);
   }
 
   void test_binary_plus_integer() {
     Object value = _getConstantValue("2 + 3");
-    EngineTestCase.assertInstanceOf((obj) => obj is int, int, value);
-    expect(value as int, 5);
+    expect(value, 5);
   }
 
   void test_binary_remainder_double() {
     Object value = _getConstantValue("3.2 % 2.3");
-    EngineTestCase.assertInstanceOf((obj) => obj is double, double, value);
-    expect(value as double, 3.2 % 2.3);
+    expect(value, 3.2 % 2.3);
   }
 
   void test_binary_remainder_integer() {
     Object value = _getConstantValue("8 % 3");
-    EngineTestCase.assertInstanceOf((obj) => obj is int, int, value);
-    expect(value as int, 2);
+    expect(value, 2);
   }
 
   void test_binary_rightShift() {
     Object value = _getConstantValue("64 >> 2");
     EngineTestCase.assertInstanceOf((obj) => obj is int, int, value);
     expect(value as int, 16);
   }
 
   void test_binary_times_double() {
     Object value = _getConstantValue("2.3 * 3.2");
-    EngineTestCase.assertInstanceOf((obj) => obj is double, double, value);
-    expect(value as double, 2.3 * 3.2);
+    expect(value, 2.3 * 3.2);
   }
 
   void test_binary_times_integer() {
     Object value = _getConstantValue("2 * 3");
-    EngineTestCase.assertInstanceOf((obj) => obj is int, int, value);
-    expect(value as int, 6);
+    expect(value, 6);
   }
 
   void test_binary_truncatingDivide_double() {
     Object value = _getConstantValue("3.2 ~/ 2.3");
     EngineTestCase.assertInstanceOf((obj) => obj is int, int, value);
     expect(value as int, 1);
   }
 
   void test_binary_truncatingDivide_integer() {
     Object value = _getConstantValue("10 ~/ 3");
@@ skipping 31 matching lines @@
     expect(map["c"], "o");
   }
 
   void test_literal_null() {
     Object value = _getConstantValue("null");
     expect(value, null);
   }
 
   void test_literal_number_double() {
     Object value = _getConstantValue("3.45");
-    EngineTestCase.assertInstanceOf((obj) => obj is double, double, value);
-    expect(value as double, 3.45);
+    expect(value, 3.45);
   }
 
   void test_literal_number_integer() {
     Object value = _getConstantValue("42");
-    EngineTestCase.assertInstanceOf((obj) => obj is int, int, value);
-    expect(value as int, 42);
+    expect(value, 42);
   }
 
   void test_literal_string_adjacent() {
     Object value = _getConstantValue("'abc' 'def'");
     expect(value, "abcdef");
   }
 
   void test_literal_string_interpolation_invalid() {
     Object value = _getConstantValue("'a\${f()}c'");
     expect(value, ConstantEvaluator.NOT_A_CONSTANT);
@@ skipping 20 matching lines @@
     expect(value as int, ~42);
   }
 
   void test_unary_logicalNot() {
     Object value = _getConstantValue("!true");
     expect(value, false);
   }
 
   void test_unary_negated_double() {
     Object value = _getConstantValue("-42.3");
-    EngineTestCase.assertInstanceOf((obj) => obj is double, double, value);
-    expect(value as double, -42.3);
+    expect(value, -42.3);
   }
 
   void test_unary_negated_integer() {
     Object value = _getConstantValue("-42");
-    EngineTestCase.assertInstanceOf((obj) => obj is int, int, value);
-    expect(value as int, -42);
+    expect(value, -42);
   }
 
   Object _getConstantValue(String source) =>
       parseExpression(source).accept(new ConstantEvaluator());
 }
 
 @reflectiveTest
 class ConstructorDeclarationTest extends EngineTestCase {
   void test_firstTokenAfterCommentAndMetadata_all_inverted() {
     Token externalKeyword = TokenFactory.tokenFromKeyword(Keyword.EXTERNAL);
@@ skipping 633 matching lines @@
 
   void test_isQualified_inMethodInvocation_noTarget() {
     MethodInvocation invocation =
         AstFactory.methodInvocation2("test", [AstFactory.identifier3("arg0")]);
     SimpleIdentifier identifier = invocation.methodName;
     expect(identifier.isQualified, isFalse);
   }
 
   void test_isQualified_inMethodInvocation_withTarget() {
     MethodInvocation invocation = AstFactory.methodInvocation(
-        AstFactory.identifier3("target"), "test", [
-      AstFactory.identifier3("arg0")
-    ]);
+        AstFactory.identifier3("target"), "test",
+        [AstFactory.identifier3("arg0")]);
     SimpleIdentifier identifier = invocation.methodName;
     expect(identifier.isQualified, isTrue);
   }
 
   void test_isQualified_inPrefixedIdentifier_name() {
     SimpleIdentifier identifier = AstFactory.identifier3("test");
     AstFactory.identifier4("prefix", identifier);
     expect(identifier.isQualified, isTrue);
   }
 
@@ skipping 685 matching lines @@
           Keyword.VAR, [AstFactory.variableDeclaration("a")])
     ]));
   }
 
   void test_visitCompilationUnit_directive() {
     _assertSource("library l;",
         AstFactory.compilationUnit3([AstFactory.libraryDirective2("l")]));
   }
 
   void test_visitCompilationUnit_directive_declaration() {
-    _assertSource("library l; var a;", AstFactory.compilationUnit4([
-      AstFactory.libraryDirective2("l")
-    ], [
+    _assertSource("library l; var a;", AstFactory.compilationUnit4(
+        [AstFactory.libraryDirective2("l")], [
       AstFactory.topLevelVariableDeclaration2(
           Keyword.VAR, [AstFactory.variableDeclaration("a")])
     ]));
   }
 
   void test_visitCompilationUnit_empty() {
     _assertSource("", AstFactory.compilationUnit());
   }
 
   void test_visitCompilationUnit_script() {
     _assertSource(
         "!#/bin/dartvm", AstFactory.compilationUnit5("!#/bin/dartvm"));
   }
 
   void test_visitCompilationUnit_script_declaration() {
     _assertSource("!#/bin/dartvm var a;", AstFactory.compilationUnit6(
         "!#/bin/dartvm", [
       AstFactory.topLevelVariableDeclaration2(
           Keyword.VAR, [AstFactory.variableDeclaration("a")])
     ]));
   }
 
   void test_visitCompilationUnit_script_directive() {
     _assertSource("!#/bin/dartvm library l;", AstFactory.compilationUnit7(
         "!#/bin/dartvm", [AstFactory.libraryDirective2("l")]));
   }
 
   void test_visitCompilationUnit_script_directives_declarations() {
     _assertSource("!#/bin/dartvm library l; var a;", AstFactory
-        .compilationUnit8("!#/bin/dartvm", [
-      AstFactory.libraryDirective2("l")
-    ], [
+        .compilationUnit8("!#/bin/dartvm", [AstFactory.libraryDirective2("l")],
+            [
       AstFactory.topLevelVariableDeclaration2(
           Keyword.VAR, [AstFactory.variableDeclaration("a")])
     ]));
   }
 
   void test_visitConditionalExpression() {
     _assertSource("a ? b : c", AstFactory.conditionalExpression(
         AstFactory.identifier3("a"), AstFactory.identifier3("b"),
         AstFactory.identifier3("c")));
   }
@@ skipping 373 matching lines @@
     ]));
   }
 
   void test_visitForStatement_c() {
     _assertSource("for (; c;) {}", AstFactory.forStatement(
         null, AstFactory.identifier3("c"), null, AstFactory.block()));
   }
 
   void test_visitForStatement_cu() {
     _assertSource("for (; c; u) {}", AstFactory.forStatement(null,
-        AstFactory.identifier3("c"), [
-      AstFactory.identifier3("u")
-    ], AstFactory.block()));
+        AstFactory.identifier3("c"), [AstFactory.identifier3("u")],
+        AstFactory.block()));
   }
 
   void test_visitForStatement_e() {
     _assertSource("for (e;;) {}", AstFactory.forStatement(
         AstFactory.identifier3("e"), null, null, AstFactory.block()));
   }
 
   void test_visitForStatement_ec() {
     _assertSource("for (e; c;) {}", AstFactory.forStatement(
         AstFactory.identifier3("e"), AstFactory.identifier3("c"), null,
         AstFactory.block()));
   }
 
   void test_visitForStatement_ecu() {
     _assertSource("for (e; c; u) {}", AstFactory.forStatement(
-        AstFactory.identifier3("e"), AstFactory.identifier3("c"), [
-      AstFactory.identifier3("u")
-    ], AstFactory.block()));
+        AstFactory.identifier3("e"), AstFactory.identifier3("c"),
+        [AstFactory.identifier3("u")], AstFactory.block()));
   }
 
   void test_visitForStatement_eu() {
     _assertSource("for (e;; u) {}", AstFactory.forStatement(
-        AstFactory.identifier3("e"), null, [
-      AstFactory.identifier3("u")
-    ], AstFactory.block()));
+        AstFactory.identifier3("e"), null, [AstFactory.identifier3("u")],
+        AstFactory.block()));
   }
 
   void test_visitForStatement_i() {
     _assertSource("for (var i;;) {}", AstFactory.forStatement2(AstFactory
             .variableDeclarationList2(
                 Keyword.VAR, [AstFactory.variableDeclaration("i")]), null, null,
         AstFactory.block()));
   }
 
   void test_visitForStatement_ic() {
     _assertSource("for (var i; c;) {}", AstFactory.forStatement2(AstFactory
-        .variableDeclarationList2(Keyword.VAR, [
-      AstFactory.variableDeclaration("i")
-    ]), AstFactory.identifier3("c"), null, AstFactory.block()));
+            .variableDeclarationList2(
+                Keyword.VAR, [AstFactory.variableDeclaration("i")]),
+        AstFactory.identifier3("c"), null, AstFactory.block()));
   }
 
   void test_visitForStatement_icu() {
     _assertSource("for (var i; c; u) {}", AstFactory.forStatement2(AstFactory
-        .variableDeclarationList2(Keyword.VAR, [
-      AstFactory.variableDeclaration("i")
-    ]), AstFactory.identifier3("c"), [
-      AstFactory.identifier3("u")
-    ], AstFactory.block()));
+            .variableDeclarationList2(
+                Keyword.VAR, [AstFactory.variableDeclaration("i")]),
+        AstFactory.identifier3("c"), [AstFactory.identifier3("u")],
+        AstFactory.block()));
   }
 
   void test_visitForStatement_iu() {
     _assertSource("for (var i;; u) {}", AstFactory.forStatement2(AstFactory
-        .variableDeclarationList2(
-            Keyword.VAR, [AstFactory.variableDeclaration("i")]), null, [
-      AstFactory.identifier3("u")
-    ], AstFactory.block()));
+            .variableDeclarationList2(
+                Keyword.VAR, [AstFactory.variableDeclaration("i")]), null,
+        [AstFactory.identifier3("u")], AstFactory.block()));
   }
 
   void test_visitForStatement_u() {
     _assertSource("for (;; u) {}", AstFactory.forStatement(
         null, null, [AstFactory.identifier3("u")], AstFactory.block()));
   }
 
   void test_visitFunctionDeclaration_getter() {
     _assertSource("get f() {}", AstFactory.functionDeclaration(
         null, Keyword.GET, "f", AstFactory.functionExpression()));
@@ skipping 102 matching lines @@
         [AstFactory.typeName4("A"), AstFactory.typeName4("B")]));
   }
 
   void test_visitImplementsClause_single() {
     _assertSource("implements A",
         AstFactory.implementsClause([AstFactory.typeName4("A")]));
   }
 
   void test_visitImportDirective_combinator() {
     _assertSource("import 'a.dart' show A;", AstFactory.importDirective3(
-        "a.dart", null, [
-      AstFactory.showCombinator([AstFactory.identifier3("A")])
-    ]));
+        "a.dart", null,
+        [AstFactory.showCombinator([AstFactory.identifier3("A")])]));
   }
 
   void test_visitImportDirective_combinators() {
     _assertSource("import 'a.dart' show A hide B;", AstFactory.importDirective3(
         "a.dart", null, [
       AstFactory.showCombinator([AstFactory.identifier3("A")]),
       AstFactory.hideCombinator([AstFactory.identifier3("B")])
     ]));
   }
 
   void test_visitImportDirective_deferred() {
     _assertSource("import 'a.dart' deferred as p;",
         AstFactory.importDirective2("a.dart", true, "p"));
   }
 
   void test_visitImportDirective_minimal() {
     _assertSource(
         "import 'a.dart';", AstFactory.importDirective3("a.dart", null));
   }
 
   void test_visitImportDirective_prefix() {
     _assertSource(
         "import 'a.dart' as p;", AstFactory.importDirective3("a.dart", "p"));
   }
 
   void test_visitImportDirective_prefix_combinator() {
     _assertSource("import 'a.dart' as p show A;", AstFactory.importDirective3(
-        "a.dart", "p", [
-      AstFactory.showCombinator([AstFactory.identifier3("A")])
-    ]));
+        "a.dart", "p",
+        [AstFactory.showCombinator([AstFactory.identifier3("A")])]));
   }
 
   void test_visitImportDirective_prefix_combinators() {
     _assertSource("import 'a.dart' as p show A hide B;", AstFactory
         .importDirective3("a.dart", "p", [
       AstFactory.showCombinator([AstFactory.identifier3("A")]),
       AstFactory.hideCombinator([AstFactory.identifier3("B")])
     ]));
   }
 
@@ skipping 410 matching lines @@
     _assertSource("case a: {} {}", AstFactory.switchCase(
         AstFactory.identifier3("a"), [AstFactory.block(), AstFactory.block()]));
   }
 
   void test_visitSwitchCase_noLabels() {
     _assertSource("case a: {}", AstFactory.switchCase(
         AstFactory.identifier3("a"), [AstFactory.block()]));
   }
 
   void test_visitSwitchCase_singleLabel() {
-    _assertSource("l1: case a: {}", AstFactory.switchCase2([
-      AstFactory.label2("l1")
-    ], AstFactory.identifier3("a"), [AstFactory.block()]));
+    _assertSource("l1: case a: {}", AstFactory.switchCase2(
+        [AstFactory.label2("l1")], AstFactory.identifier3("a"),
+        [AstFactory.block()]));
   }
 
   void test_visitSwitchDefault_multipleLabels() {
     _assertSource("l1: l2: default: {}", AstFactory.switchDefault([
       AstFactory.label2("l1"),
       AstFactory.label2("l2")
     ], [AstFactory.block()]));
   }
 
   void test_visitSwitchDefault_multipleStatements() {
@@ skipping 57 matching lines @@
   void test_visitTryStatement_catches() {
     _assertSource("try {} on E {} on F {}", AstFactory.tryStatement2(
         AstFactory.block(), [
       AstFactory.catchClause3(AstFactory.typeName4("E")),
       AstFactory.catchClause3(AstFactory.typeName4("F"))
     ]));
   }
 
   void test_visitTryStatement_catchFinally() {
     _assertSource("try {} on E {} finally {}", AstFactory.tryStatement3(
-        AstFactory.block(), [
-      AstFactory.catchClause3(AstFactory.typeName4("E"))
-    ], AstFactory.block()));
+        AstFactory.block(),
+        [AstFactory.catchClause3(AstFactory.typeName4("E"))],
+        AstFactory.block()));
   }
 
   void test_visitTryStatement_finally() {
     _assertSource("try {} finally {}",
         AstFactory.tryStatement(AstFactory.block(), AstFactory.block()));
   }
 
   void test_visitTypeArgumentList_multiple() {
     _assertSource("<E, F>", AstFactory.typeArgumentList(
         [AstFactory.typeName4("E"), AstFactory.typeName4("F")]));
@@ skipping 191 matching lines @@
   static const List<WrapperKind> values = const [
     PREFIXED_LEFT,
     PREFIXED_RIGHT,
     PROPERTY_LEFT,
     PROPERTY_RIGHT,
     NONE
   ];
 
   const WrapperKind(String name, int ordinal) : super(name, ordinal);
 }