[Turbofan] Introduce OtherNumberConstant.

test/unittests/compiler/typed-optimization-unittest.cc

 // Copyright 2016 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.
 
 #include "src/compiler/typed-optimization.h"
 #include "src/code-factory.h"
 #include "src/compilation-dependencies.h"
 #include "src/compiler/access-builder.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/js-operator.h"
@@ skipping 70 matching lines @@
   JSOperatorBuilder* javascript() { return &javascript_; }
 
  private:
   JSOperatorBuilder javascript_;
   CompilationDependencies deps_;
 };
 
 TEST_F(TypedOptimizationTest, ParameterWithMinusZero) {
   {
     Reduction r = Reduce(
-        Parameter(Type::Constant(factory()->minus_zero_value(), zone())));
+        Parameter(Type::NewConstant(factory()->minus_zero_value(), zone())));
     ASSERT_TRUE(r.Changed());
     EXPECT_THAT(r.replacement(), IsNumberConstant(-0.0));
   }
   {
     Reduction r = Reduce(Parameter(Type::MinusZero()));
     ASSERT_TRUE(r.Changed());
     EXPECT_THAT(r.replacement(), IsNumberConstant(-0.0));
   }
   {
-    Reduction r = Reduce(Parameter(
-        Type::Union(Type::MinusZero(),
-                    Type::Constant(factory()->NewNumber(0), zone()), zone())));
+    Reduction r = Reduce(Parameter(Type::Union(
+        Type::MinusZero(), Type::NewConstant(factory()->NewNumber(0), zone()),
+        zone())));
     EXPECT_FALSE(r.Changed());
   }
 }
 
 TEST_F(TypedOptimizationTest, ParameterWithNull) {
   Handle<HeapObject> null = factory()->null_value();
   {
-    Reduction r = Reduce(Parameter(Type::Constant(null, zone())));
+    Reduction r = Reduce(Parameter(Type::NewConstant(null, zone())));
     ASSERT_TRUE(r.Changed());
     EXPECT_THAT(r.replacement(), IsHeapConstant(null));
   }
   {
     Reduction r = Reduce(Parameter(Type::Null()));
     ASSERT_TRUE(r.Changed());
     EXPECT_THAT(r.replacement(), IsHeapConstant(null));
   }
 }
 
 TEST_F(TypedOptimizationTest, ParameterWithNaN) {
   const double kNaNs[] = {-std::numeric_limits<double>::quiet_NaN(),
                           std::numeric_limits<double>::quiet_NaN(),
                           std::numeric_limits<double>::signaling_NaN()};
   TRACED_FOREACH(double, nan, kNaNs) {
     Handle<Object> constant = factory()->NewNumber(nan);
-    Reduction r = Reduce(Parameter(Type::Constant(constant, zone())));
+    Reduction r = Reduce(Parameter(Type::NewConstant(constant, zone())));
     ASSERT_TRUE(r.Changed());
     EXPECT_THAT(r.replacement(), IsNumberConstant(IsNaN()));
   }
   {
     Reduction r =
-        Reduce(Parameter(Type::Constant(factory()->nan_value(), zone())));
+        Reduce(Parameter(Type::NewConstant(factory()->nan_value(), zone())));
     ASSERT_TRUE(r.Changed());
     EXPECT_THAT(r.replacement(), IsNumberConstant(IsNaN()));
   }
   {
     Reduction r = Reduce(Parameter(Type::NaN()));
     ASSERT_TRUE(r.Changed());
     EXPECT_THAT(r.replacement(), IsNumberConstant(IsNaN()));
   }
 }
 
 TEST_F(TypedOptimizationTest, ParameterWithPlainNumber) {
   TRACED_FOREACH(double, value, kFloat64Values) {
     Handle<Object> constant = factory()->NewNumber(value);
-    Reduction r = Reduce(Parameter(Type::Constant(constant, zone())));
+    Reduction r = Reduce(Parameter(Type::NewConstant(constant, zone())));
     ASSERT_TRUE(r.Changed());
     EXPECT_THAT(r.replacement(), IsNumberConstant(value));
   }
   TRACED_FOREACH(double, value, kIntegerValues) {
     Reduction r = Reduce(Parameter(Type::Range(value, value, zone())));
     ASSERT_TRUE(r.Changed());
     EXPECT_THAT(r.replacement(), IsNumberConstant(value));
   }
 }
 
 TEST_F(TypedOptimizationTest, ParameterWithUndefined) {
   Handle<HeapObject> undefined = factory()->undefined_value();
   {
     Reduction r = Reduce(Parameter(Type::Undefined()));
     ASSERT_TRUE(r.Changed());
     EXPECT_THAT(r.replacement(), IsHeapConstant(undefined));
   }
   {
-    Reduction r = Reduce(Parameter(Type::Constant(undefined, zone())));
+    Reduction r = Reduce(Parameter(Type::NewConstant(undefined, zone())));
     ASSERT_TRUE(r.Changed());
     EXPECT_THAT(r.replacement(), IsHeapConstant(undefined));
   }
 }
 
 TEST_F(TypedOptimizationTest, JSToBooleanWithFalsish) {
   Node* input = Parameter(
       Type::Union(
           Type::MinusZero(),
           Type::Union(
               Type::NaN(),
               Type::Union(
                   Type::Null(),
                   Type::Union(
                       Type::Undefined(),
                       Type::Union(
                           Type::Undetectable(),
-                          Type::Union(
-                              Type::Constant(factory()->false_value(), zone()),
-                              Type::Range(0.0, 0.0, zone()), zone()),
+                          Type::Union(Type::NewConstant(
+                                          factory()->false_value(), zone()),
+                                      Type::Range(0.0, 0.0, zone()), zone()),
                           zone()),
                       zone()),
                   zone()),
               zone()),
           zone()),
       0);
   Node* context = Parameter(Type::Any(), 1);
   Reduction r = Reduce(graph()->NewNode(
       javascript()->ToBoolean(ToBooleanHint::kAny), input, context));
   ASSERT_TRUE(r.Changed());
   EXPECT_THAT(r.replacement(), IsFalseConstant());
 }
 
 TEST_F(TypedOptimizationTest, JSToBooleanWithTruish) {
   Node* input = Parameter(
       Type::Union(
-          Type::Constant(factory()->true_value(), zone()),
+          Type::NewConstant(factory()->true_value(), zone()),
           Type::Union(Type::DetectableReceiver(), Type::Symbol(), zone()),
           zone()),
       0);
   Node* context = Parameter(Type::Any(), 1);
   Reduction r = Reduce(graph()->NewNode(
       javascript()->ToBoolean(ToBooleanHint::kAny), input, context));
   ASSERT_TRUE(r.Changed());
   EXPECT_THAT(r.replacement(), IsTrueConstant());
 }
 
 TEST_F(TypedOptimizationTest, JSToBooleanWithNonZeroPlainNumber) {
   Node* input = Parameter(Type::Range(1, V8_INFINITY, zone()), 0);
   Node* context = Parameter(Type::Any(), 1);
   Reduction r = Reduce(graph()->NewNode(
       javascript()->ToBoolean(ToBooleanHint::kAny), input, context));
   ASSERT_TRUE(r.Changed());
   EXPECT_THAT(r.replacement(), IsTrueConstant());
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8