Test monotonicity of expression typings.

test/cctest/compiler/test-typer.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-
-// This tests the correctness of the typer.
-//
-// For simplicity, it currently only tests it on expression operators that have
-// a direct equivalent in C++.  Also, testing is currently limited to ranges as
-// input types.
-
-
 #include <functional>
 
 #include "src/compiler/node-properties-inl.h"
 #include "src/compiler/typer.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/compiler/graph-builder-tester.h"
+#include "test/cctest/test-types.h"
 
 using namespace v8::internal;
 using namespace v8::internal::compiler;
 
 
 
 class TyperTester : public HandleAndZoneScope, public GraphAndBuilders {
  public:
   TyperTester()
       : GraphAndBuilders(main_zone()),
+        types_(main_zone(), isolate()),
         typer_(main_zone()),
         javascript_(main_zone()) {
     Node* s = graph()->NewNode(common()->Start(3));
     graph()->SetStart(s);
     context_node_ = graph()->NewNode(common()->Parameter(2), graph()->start());
     rng_ = isolate()->random_number_generator();
 
     integers.push_back(0);
     integers.push_back(0);
     integers.push_back(-1);
@@ skipping 11 matching lines @@
     int32s.push_back(0);
     int32s.push_back(-1);
     int32s.push_back(+1);
     int32s.push_back(kMinInt);
     int32s.push_back(kMaxInt);
     for (int i = 0; i < 10; ++i) {
       int32s.push_back(rng_->NextInt());
     }
   }
 
+  Types<Type, Type*, Zone> types_;
   Typer typer_;
   JSOperatorBuilder javascript_;
   Node* context_node_;
   v8::base::RandomNumberGenerator* rng_;
   std::vector<double> integers;
   std::vector<double> int32s;
 
   Isolate* isolate() { return main_isolate(); }
   Graph* graph() { return main_graph_; }
   CommonOperatorBuilder* common() { return &main_common_; }
@@ skipping 84 matching lines @@
       Type::RangeType* r2 = RandomRange(true)->AsRange();
       Type* expected_type = TypeBinaryOp(op, r1, r2);
       int32_t x1 = static_cast<int32_t>(RandomInt(r1));
       int32_t x2 = static_cast<int32_t>(RandomInt(r2));
       double result_value = opfun(x1, x2);
       Type* result_type = Type::Constant(
           isolate()->factory()->NewNumber(result_value), main_zone());
       CHECK(result_type->Is(expected_type));
     }
   }
+
+  Type* RandomSubtype(Type* type) {
+    Type* subtype;
+    do {
+      subtype = types_.Fuzz();
+    } while (!subtype->Is(type));
+    return subtype;
+  }
+
+  void TestBinaryMonotonicity(const Operator* op) {
+    for (int i = 0; i < 50; ++i) {
+      Type* type1 = types_.Fuzz();
+      Type* type2 = types_.Fuzz();
+      Type* type = TypeBinaryOp(op, type1, type2);
+      Type* subtype1 = RandomSubtype(type1);;
+      Type* subtype2 = RandomSubtype(type2);;
+      Type* subtype = TypeBinaryOp(op, subtype1, subtype2);
+      CHECK(subtype->Is(type));
+    }
+  }
 };
 
 
 static int32_t shift_left(int32_t x, int32_t y) { return x << y; }
 static int32_t shift_right(int32_t x, int32_t y) { return x >> y; }
 static int32_t bit_or(int32_t x, int32_t y) { return x | y; }
 static int32_t bit_and(int32_t x, int32_t y) { return x & y; }
 static int32_t bit_xor(int32_t x, int32_t y) { return x ^ y; }
 
 
+//------------------------------------------------------------------------------
+// Soundness
+//   For simplicity, we currently only test soundness on expression operators
+//   that have a direct equivalent in C++.  Also, testing is currently limited
+//   to ranges as input types.
+
+
 TEST(TypeJSAdd) {
   TyperTester t;
   t.TestBinaryArithOp(t.javascript_.Subtract(), std::plus<double>());
 }
 
 
 TEST(TypeJSSubtract) {
   TyperTester t;
   t.TestBinaryArithOp(t.javascript_.Subtract(), std::minus<double>());
 }
@@ skipping 84 matching lines @@
   TyperTester t;
   t.TestBinaryCompareOp(t.javascript_.StrictEqual(), std::equal_to<double>());
 }
 
 
 TEST(TypeJSStrictNotEqual) {
   TyperTester t;
   t.TestBinaryCompareOp(
       t.javascript_.StrictNotEqual(), std::not_equal_to<double>());
 }
+
+
+//------------------------------------------------------------------------------
+// Monotonicity
+
+
+TEST(Monotonicity) {
+  TyperTester t;
+  #define TEST_TYPE(name, x, y, z) \
+      t.TestBinaryMonotonicity(t.javascript_.name());
+  SHARED_SIMPLE_BINOP_LIST(TEST_TYPE)
+  #undef TEST_TYPE
+}