[turbofan] Remove unused Type parameter from ReferenceEqual.

src/compiler/js-typed-lowering.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.
 
 #include "src/compiler/js-typed-lowering.h"
 
 #include "src/code-factory.h"
 #include "src/compilation-dependencies.h"
 #include "src/compiler/access-builder.h"
 #include "src/compiler/js-graph.h"
@@ skipping 648 matching lines @@
 }
 
 Reduction JSTypedLowering::ReduceJSEqualTypeOf(Node* node, bool invert) {
   HeapObjectBinopMatcher m(node);
   if (m.left().IsJSTypeOf() && m.right().HasValue() &&
       m.right().Value()->IsString()) {
     Node* replacement;
     Node* input = m.left().InputAt(0);
     Handle<String> value = Handle<String>::cast(m.right().Value());
     if (String::Equals(value, factory()->boolean_string())) {
-      replacement = graph()->NewNode(
-          common()->Select(MachineRepresentation::kTagged),
-          graph()->NewNode(simplified()->ReferenceEqual(Type::Any()), input,
-                           jsgraph()->TrueConstant()),
-          jsgraph()->TrueConstant(),
-          graph()->NewNode(simplified()->ReferenceEqual(Type::Any()), input,
-                           jsgraph()->FalseConstant()));
+      replacement =
+          graph()->NewNode(common()->Select(MachineRepresentation::kTagged),
+                           graph()->NewNode(simplified()->ReferenceEqual(),
+                                            input, jsgraph()->TrueConstant()),
+                           jsgraph()->TrueConstant(),
+                           graph()->NewNode(simplified()->ReferenceEqual(),
+                                            input, jsgraph()->FalseConstant()));
     } else if (String::Equals(value, factory()->function_string())) {
       replacement = graph()->NewNode(simplified()->ObjectIsCallable(), input);
     } else if (String::Equals(value, factory()->number_string())) {
       replacement = graph()->NewNode(simplified()->ObjectIsNumber(), input);
     } else if (String::Equals(value, factory()->string_string())) {
       replacement = graph()->NewNode(simplified()->ObjectIsString(), input);
     } else if (String::Equals(value, factory()->undefined_string())) {
       replacement = graph()->NewNode(
           common()->Select(MachineRepresentation::kTagged),
-          graph()->NewNode(simplified()->ReferenceEqual(Type::Any()), input,
+          graph()->NewNode(simplified()->ReferenceEqual(), input,
                            jsgraph()->NullConstant()),
           jsgraph()->FalseConstant(),
           graph()->NewNode(simplified()->ObjectIsUndetectable(), input));
     } else {
       return NoChange();
     }
     if (invert) {
       replacement = graph()->NewNode(simplified()->BooleanNot(), replacement);
     }
     ReplaceWithValue(node, replacement);
     return Replace(replacement);
   }
   return NoChange();
 }
 
 Reduction JSTypedLowering::ReduceJSEqual(Node* node, bool invert) {
   Reduction const reduction = ReduceJSEqualTypeOf(node, invert);
   if (reduction.Changed()) return reduction;
 
   JSBinopReduction r(this, node);
 
   if (r.BothInputsAre(Type::String())) {
     return r.ChangeToPureOperator(simplified()->StringEqual(), invert);
   }
   if (r.BothInputsAre(Type::Boolean())) {
-    return r.ChangeToPureOperator(simplified()->ReferenceEqual(Type::Boolean()),
-                                  invert);
+    return r.ChangeToPureOperator(simplified()->ReferenceEqual(), invert);
   }
   if (r.BothInputsAre(Type::Receiver())) {
-    return r.ChangeToPureOperator(
-        simplified()->ReferenceEqual(Type::Receiver()), invert);
+    return r.ChangeToPureOperator(simplified()->ReferenceEqual(), invert);
   }
   if (r.OneInputIs(Type::Undetectable())) {
     RelaxEffectsAndControls(node);
     node->RemoveInput(r.LeftInputIs(Type::Undetectable()) ? 0 : 1);
     node->TrimInputCount(1);
     NodeProperties::ChangeOp(node, simplified()->ObjectIsUndetectable());
     if (invert) {
       // Insert an boolean not to invert the value.
       Node* value = graph()->NewNode(simplified()->BooleanNot(), node);
       node->ReplaceUses(value);
@@ skipping 36 matching lines @@
       Node* replacement = jsgraph()->BooleanConstant(invert);
       ReplaceWithValue(node, replacement);
       return Replace(replacement);
     }
   }
 
   Reduction const reduction = ReduceJSEqualTypeOf(node, invert);
   if (reduction.Changed()) return reduction;
 
   if (r.OneInputIs(the_hole_type_)) {
-    return r.ChangeToPureOperator(simplified()->ReferenceEqual(the_hole_type_),
-                                  invert);
+    return r.ChangeToPureOperator(simplified()->ReferenceEqual(), invert);
   }
   if (r.OneInputIs(Type::Undefined())) {
-    return r.ChangeToPureOperator(
-        simplified()->ReferenceEqual(Type::Undefined()), invert);
+    return r.ChangeToPureOperator(simplified()->ReferenceEqual(), invert);
   }
   if (r.OneInputIs(Type::Null())) {
-    return r.ChangeToPureOperator(simplified()->ReferenceEqual(Type::Null()),
-                                  invert);
+    return r.ChangeToPureOperator(simplified()->ReferenceEqual(), invert);
   }
   if (r.OneInputIs(Type::Boolean())) {
-    return r.ChangeToPureOperator(simplified()->ReferenceEqual(Type::Boolean()),
-                                  invert);
+    return r.ChangeToPureOperator(simplified()->ReferenceEqual(), invert);
   }
   if (r.OneInputIs(Type::Object())) {
-    return r.ChangeToPureOperator(simplified()->ReferenceEqual(Type::Object()),
-                                  invert);
+    return r.ChangeToPureOperator(simplified()->ReferenceEqual(), invert);
   }
   if (r.OneInputIs(Type::Receiver())) {
-    return r.ChangeToPureOperator(
-        simplified()->ReferenceEqual(Type::Receiver()), invert);
+    return r.ChangeToPureOperator(simplified()->ReferenceEqual(), invert);
   }
   if (r.BothInputsAre(Type::Unique())) {
-    return r.ChangeToPureOperator(simplified()->ReferenceEqual(Type::Unique()),
-                                  invert);
+    return r.ChangeToPureOperator(simplified()->ReferenceEqual(), invert);
   }
   if (r.BothInputsAre(Type::String())) {
     return r.ChangeToPureOperator(simplified()->StringEqual(), invert);
   }
 
   NumberOperationHint hint;
   if (r.BothInputsAre(Type::Signed32()) ||
       r.BothInputsAre(Type::Unsigned32())) {
     return r.ChangeToPureOperator(simplified()->NumberEqual(), invert);
   } else if (r.GetCompareNumberOperationHint(&hint)) {
@@ skipping 495 matching lines @@
       prototype, context, frame_state, effect, control);
 
   control = graph()->NewNode(common()->IfFalse(), branch_is_proxy);
 
   Node* object_prototype = effect = graph()->NewNode(
       simplified()->LoadField(AccessBuilder::ForMapPrototype()),
       loop_object_map, loop_effect, control);
 
   // If not, check if object prototype is the null prototype.
   Node* null_proto =
-      graph()->NewNode(simplified()->ReferenceEqual(r.right_type()),
-                       object_prototype, jsgraph()->NullConstant());
+      graph()->NewNode(simplified()->ReferenceEqual(), object_prototype,
+                       jsgraph()->NullConstant());
   Node* branch_null_proto = graph()->NewNode(
       common()->Branch(BranchHint::kFalse), null_proto, control);
   Node* if_null_proto = graph()->NewNode(common()->IfTrue(), branch_null_proto);
   Node* e_null_proto = effect;
 
   control = graph()->NewNode(common()->IfFalse(), branch_null_proto);
 
   // Check if object prototype is equal to function prototype.
-  Node* eq_proto =
-      graph()->NewNode(simplified()->ReferenceEqual(r.right_type()),
-                       object_prototype, prototype);
+  Node* eq_proto = graph()->NewNode(simplified()->ReferenceEqual(),
+                                    object_prototype, prototype);
   Node* branch_eq_proto =
       graph()->NewNode(common()->Branch(BranchHint::kFalse), eq_proto, control);
   Node* if_eq_proto = graph()->NewNode(common()->IfTrue(), branch_eq_proto);
   Node* e_eq_proto = effect;
 
   control = graph()->NewNode(common()->IfFalse(), branch_eq_proto);
 
   Node* load_object_map = effect =
       graph()->NewNode(simplified()->LoadField(AccessBuilder::ForMap()),
                        object_prototype, effect, control);
@@ skipping 96 matching lines @@
             javascript()->LoadContext(0, Context::GLOBAL_PROXY_INDEX, true),
             native_context, native_context, effect);
       }
     } else if (!receiver_type->Maybe(Type::NullOrUndefined()) ||
                mode == ConvertReceiverMode::kNotNullOrUndefined) {
       receiver = effect =
           graph()->NewNode(javascript()->ToObject(), receiver, context,
                            frame_state, effect, control);
     } else {
       // Check {receiver} for undefined.
-      Node* check0 =
-          graph()->NewNode(simplified()->ReferenceEqual(receiver_type),
-                           receiver, jsgraph()->UndefinedConstant());
+      Node* check0 = graph()->NewNode(simplified()->ReferenceEqual(), receiver,
+                                      jsgraph()->UndefinedConstant());
       Node* branch0 = graph()->NewNode(common()->Branch(BranchHint::kFalse),
                                        check0, control);
       Node* if_true0 = graph()->NewNode(common()->IfTrue(), branch0);
       Node* if_false0 = graph()->NewNode(common()->IfFalse(), branch0);
 
       // Check {receiver} for null.
-      Node* check1 =
-          graph()->NewNode(simplified()->ReferenceEqual(receiver_type),
-                           receiver, jsgraph()->NullConstant());
+      Node* check1 = graph()->NewNode(simplified()->ReferenceEqual(), receiver,
+                                      jsgraph()->NullConstant());
       Node* branch1 = graph()->NewNode(common()->Branch(BranchHint::kFalse),
                                        check1, if_false0);
       Node* if_true1 = graph()->NewNode(common()->IfTrue(), branch1);
       Node* if_false1 = graph()->NewNode(common()->IfFalse(), branch1);
 
       // Convert {receiver} using ToObject.
       Node* if_convert = if_false1;
       Node* econvert = effect;
       Node* rconvert;
       {
@@ skipping 230 matching lines @@
   Node* key = effect = graph()->NewNode(
       simplified()->LoadElement(AccessBuilder::ForFixedArrayElement()),
       cache_array, index, effect, control);
 
   // Load the map of the {receiver}.
   Node* receiver_map = effect =
       graph()->NewNode(simplified()->LoadField(AccessBuilder::ForMap()),
                        receiver, effect, control);
 
   // Check if the expected map still matches that of the {receiver}.
-  Node* check0 = graph()->NewNode(simplified()->ReferenceEqual(Type::Any()),
-                                  receiver_map, cache_type);
+  Node* check0 = graph()->NewNode(simplified()->ReferenceEqual(), receiver_map,
+                                  cache_type);
   Node* branch0 =
       graph()->NewNode(common()->Branch(BranchHint::kTrue), check0, control);
 
   Node* if_true0 = graph()->NewNode(common()->IfTrue(), branch0);
   Node* etrue0;
   Node* vtrue0;
   {
     // Don't need filtering since expected map still matches that of the
     // {receiver}.
     etrue0 = effect;
@@ skipping 409 matching lines @@
 }
 
 
 CompilationDependencies* JSTypedLowering::dependencies() const {
   return dependencies_;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8