[strong] Disallow implicit conversions for binary arithmetic operations

test/unittests/compiler/scheduler-unittest.cc

 // Copyright 2015 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/access-builder.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/graph.h"
 #include "src/compiler/graph-visualizer.h"
 #include "src/compiler/js-operator.h"
 #include "src/compiler/node.h"
@@ skipping 637 matching lines @@
 
 
 TEST_F(SchedulerTest, BuildScheduleIfSplit) {
   graph()->SetStart(graph()->NewNode(common()->Start(3)));
 
   Node* p1 = graph()->NewNode(common()->Parameter(0), graph()->start());
   Node* p2 = graph()->NewNode(common()->Parameter(1), graph()->start());
   Node* p3 = graph()->NewNode(common()->Parameter(2), graph()->start());
   Node* p4 = graph()->NewNode(common()->Parameter(3), graph()->start());
   Node* p5 = graph()->NewNode(common()->Parameter(4), graph()->start());
-  Node* cmp = graph()->NewNode(js()->LessThanOrEqual(), p1, p2, p3,
-                               graph()->start(), graph()->start());
+  Node* cmp = graph()->NewNode(js()->LessThanOrEqual(LanguageMode::SLOPPY), p1,
+                               p2, p3, graph()->start(), graph()->start());
   Node* branch = graph()->NewNode(common()->Branch(), cmp, graph()->start());
   Node* true_branch = graph()->NewNode(common()->IfTrue(), branch);
   Node* false_branch = graph()->NewNode(common()->IfFalse(), branch);
 
   Node* ret1 =
       graph()->NewNode(common()->Return(), p4, graph()->start(), true_branch);
   Node* ret2 =
       graph()->NewNode(common()->Return(), p5, graph()->start(), false_branch);
   Node* merge = graph()->NewNode(common()->Merge(2), ret1, ret2);
   graph()->SetEnd(graph()->NewNode(common()->End(), merge));
@@ skipping 21 matching lines @@
   USE(n39);
   op = common()->Merge(2);
   Node* n37 = graph()->NewNode(op, nil, nil);
   USE(n37);
   op = common()->Return();
   Node* n29 = graph()->NewNode(op, nil, nil, nil);
   USE(n29);
   op = common()->Return();
   Node* n36 = graph()->NewNode(op, nil, nil, nil);
   USE(n36);
-  op = js()->Add();
+  op = js()->Add(LanguageMode::SLOPPY);
   Node* n27 = graph()->NewNode(op, nil, nil, nil, nil, nil, nil, nil);
   USE(n27);
   op = common()->IfSuccess();
   Node* n28 = graph()->NewNode(op, nil);
   USE(n28);
-  op = js()->Subtract();
+  op = js()->Subtract(LanguageMode::SLOPPY);
   Node* n34 = graph()->NewNode(op, nil, nil, nil, nil, nil, nil, nil);
   USE(n34);
   op = common()->IfSuccess();
   Node* n35 = graph()->NewNode(op, nil);
   USE(n35);
-  op = js()->Subtract();
+  op = js()->Subtract(LanguageMode::SLOPPY);
   Node* n25 = graph()->NewNode(op, nil, nil, nil, nil, nil, nil, nil);
   USE(n25);
   op = common()->Parameter(4);
   Node* n5 = graph()->NewNode(op, nil);
   USE(n5);
   op = common()->Parameter(5);
   Node* n7 = graph()->NewNode(op, nil);
   USE(n7);
   op = common()->FrameState(JS_FRAME, BailoutId(-1),
                             OutputFrameStateCombine::Ignore());
   Node* n13 = graph()->NewNode(op, nil, nil, nil, nil, nil);
   USE(n13);
   op = common()->IfSuccess();
   Node* n26 = graph()->NewNode(op, nil);
   USE(n26);
-  op = js()->Multiply();
+  op = js()->Multiply(LanguageMode::SLOPPY);
   Node* n32 = graph()->NewNode(op, nil, nil, nil, nil, nil, nil, nil);
   USE(n32);
   op = common()->Parameter(1);
   Node* n2 = graph()->NewNode(op, nil);
   USE(n2);
   op = common()->IfSuccess();
   Node* n33 = graph()->NewNode(op, nil);
   USE(n33);
-  op = js()->Subtract();
+  op = js()->Subtract(LanguageMode::SLOPPY);
   Node* n23 = graph()->NewNode(op, nil, nil, nil, nil, nil, nil, nil);
   USE(n23);
   op = common()->IfSuccess();
   Node* n24 = graph()->NewNode(op, nil);
   USE(n24);
   op = common()->Start(4);
   Node* n0 = graph()->NewNode(op);
   USE(n0);
   op = common()->StateValues(0);
   Node* n11 = graph()->NewNode(op);
   USE(n11);
   op = common()->NumberConstant(0);
   Node* n12 = graph()->NewNode(op);
   USE(n12);
   op = common()->HeapConstant(unique_constant);
   Node* n6 = graph()->NewNode(op);
   USE(n6);
   op = common()->Parameter(3);
   Node* n4 = graph()->NewNode(op, nil);
   USE(n4);
-  op = js()->LessThan();
+  op = js()->LessThan(LanguageMode::SLOPPY);
   Node* n15 = graph()->NewNode(op, nil, nil, nil, nil, nil, nil);
   USE(n15);
   op = common()->IfFalse();
   Node* n31 = graph()->NewNode(op, nil);
   USE(n31);
-  op = js()->Add();
+  op = js()->Add(LanguageMode::SLOPPY);
   Node* n19 = graph()->NewNode(op, nil, nil, nil, nil, nil, nil, nil);
   USE(n19);
-  op = js()->Multiply();
+  op = js()->Multiply(LanguageMode::SLOPPY);
   Node* n21 = graph()->NewNode(op, nil, nil, nil, nil, nil, nil, nil);
   USE(n21);
   op = common()->IfSuccess();
   Node* n22 = graph()->NewNode(op, nil);
   USE(n22);
   op = common()->Parameter(2);
   Node* n3 = graph()->NewNode(op, nil);
   USE(n3);
   op = js()->StackCheck();
   Node* n9 = graph()->NewNode(op, nil, nil, nil, nil);
@@ skipping 127 matching lines @@
   Node* nil = graph()->NewNode(common()->Dead());
   op = common()->End();
   Node* n34 = graph()->NewNode(op, nil);
   USE(n34);
   op = common()->Return();
   Node* n32 = graph()->NewNode(op, nil, nil, nil);
   USE(n32);
   op = common()->Phi(kMachAnyTagged, 2);
   Node* n13 = graph()->NewNode(op, nil, nil, nil);
   USE(n13);
-  op = js()->LessThan();
+  op = js()->LessThan(LanguageMode::SLOPPY);
   Node* n16 = graph()->NewNode(op, nil, nil, nil, nil, nil, nil);
   USE(n16);
   op = common()->IfFalse();
   Node* n22 = graph()->NewNode(op, nil);
   USE(n22);
   op = common()->Parameter(1);
   Node* n2 = graph()->NewNode(op, nil);
   USE(n2);
-  op = js()->Add();
+  op = js()->Add(LanguageMode::SLOPPY);
   Node* n29 = graph()->NewNode(op, nil, nil, nil, nil, nil, nil, nil);
   USE(n29);
   op = common()->Loop(2);
   Node* n12 = graph()->NewNode(op, nil, nil);
   USE(n12);
   op = common()->Parameter(2);
   Node* n3 = graph()->NewNode(op, nil);
   USE(n3);
   op = common()->Parameter(3);
   Node* n5 = graph()->NewNode(op, nil);
@@ skipping 139 matching lines @@
   Node* nil = graph()->NewNode(common()->Dead());
   op = common()->End();
   Node* n71 = graph()->NewNode(op, nil);
   USE(n71);
   op = common()->Return();
   Node* n69 = graph()->NewNode(op, nil, nil, nil);
   USE(n69);
   op = common()->Phi(kMachAnyTagged, 2);
   Node* n53 = graph()->NewNode(op, nil, nil, nil);
   USE(n53);
-  op = js()->LessThan();
+  op = js()->LessThan(LanguageMode::SLOPPY);
   Node* n55 = graph()->NewNode(op, nil, nil, nil, nil, nil, nil);
   USE(n55);
   op = common()->IfFalse();
   Node* n61 = graph()->NewNode(op, nil);
   USE(n61);
   op = common()->Phi(kMachAnyTagged, 2);
   Node* n14 = graph()->NewNode(op, nil, nil, nil);
   USE(n14);
-  op = js()->Add();
+  op = js()->Add(LanguageMode::SLOPPY);
   Node* n66 = graph()->NewNode(op, nil, nil, nil, nil, nil, nil, nil);
   USE(n66);
   op = common()->Loop(2);
   Node* n52 = graph()->NewNode(op, nil, nil);
   USE(n52);
   op = common()->Parameter(2);
   Node* n3 = graph()->NewNode(op, nil);
   USE(n3);
   op = common()->Parameter(4);
   Node* n6 = graph()->NewNode(op, nil);
   USE(n6);
   op = common()->FrameState(JS_FRAME, BailoutId(-1),
                             OutputFrameStateCombine::Ignore());
   Node* n12 = graph()->NewNode(op, nil, nil, nil, nil, nil);
   USE(n12);
   op = common()->EffectPhi(2);
   Node* n54 = graph()->NewNode(op, nil, nil, nil);
   USE(n54);
   op = common()->Branch();
   Node* n58 = graph()->NewNode(op, nil, nil);
   USE(n58);
   op = common()->Parameter(1);
   Node* n2 = graph()->NewNode(op, nil);
   USE(n2);
-  op = js()->Add();
+  op = js()->Add(LanguageMode::SLOPPY);
   Node* n31 = graph()->NewNode(op, nil, nil, nil, nil, nil, nil, nil);
   USE(n31);
   op = common()->Loop(2);
   Node* n13 = graph()->NewNode(op, nil, nil);
   USE(n13);
   op = common()->NumberConstant(2);
   Node* n65 = graph()->NewNode(op);
   USE(n65);
   op = js()->StackCheck();
   Node* n63 = graph()->NewNode(op, nil, nil, nil, nil);
@@ skipping 12 matching lines @@
   USE(n0);
   op = common()->StateValues(0);
   Node* n10 = graph()->NewNode(op);
   USE(n10);
   op = common()->NumberConstant(0);
   Node* n11 = graph()->NewNode(op);
   USE(n11);
   op = common()->HeapConstant(unique_constant);
   Node* n5 = graph()->NewNode(op);
   USE(n5);
-  op = js()->LessThan();
+  op = js()->LessThan(LanguageMode::SLOPPY);
   Node* n18 = graph()->NewNode(op, nil, nil, nil, nil, nil, nil);
   USE(n18);
   op = js()->ToBoolean();
   Node* n57 = graph()->NewNode(op, nil, nil);
   USE(n57);
   op = common()->IfSuccess();
   Node* n56 = graph()->NewNode(op, nil);
   USE(n56);
   op = js()->ToNumber();
   Node* n28 = graph()->NewNode(op, nil, nil, nil, nil, nil);
@@ skipping 30 matching lines @@
   USE(n8);
   op = common()->Branch();
   Node* n39 = graph()->NewNode(op, nil, nil);
   USE(n39);
   op = js()->ToBoolean();
   Node* n20 = graph()->NewNode(op, nil, nil);
   USE(n20);
   op = common()->IfSuccess();
   Node* n19 = graph()->NewNode(op, nil);
   USE(n19);
-  op = js()->LessThan();
+  op = js()->LessThan(LanguageMode::SLOPPY);
   Node* n36 = graph()->NewNode(op, nil, nil, nil, nil, nil, nil);
   USE(n36);
   op = common()->IfTrue();
   Node* n22 = graph()->NewNode(op, nil);
   USE(n22);
   op = js()->ToBoolean();
   Node* n38 = graph()->NewNode(op, nil, nil);
   USE(n38);
   op = common()->IfSuccess();
   Node* n37 = graph()->NewNode(op, nil);
   USE(n37);
   op = common()->Phi(kMachAnyTagged, 2);
   Node* n34 = graph()->NewNode(op, nil, nil, nil);
   USE(n34);
   op = common()->EffectPhi(2);
   Node* n35 = graph()->NewNode(op, nil, nil, nil);
   USE(n35);
   op = common()->Loop(2);
   Node* n33 = graph()->NewNode(op, nil, nil);
   USE(n33);
   op = common()->Phi(kMachAnyTagged, 2);
   Node* n15 = graph()->NewNode(op, nil, nil, nil);
   USE(n15);
-  op = js()->Add();
+  op = js()->Add(LanguageMode::SLOPPY);
   Node* n48 = graph()->NewNode(op, nil, nil, nil, nil, nil, nil, nil);
   USE(n48);
   op = common()->IfSuccess();
   Node* n32 = graph()->NewNode(op, nil);
   USE(n32);
   op = common()->IfSuccess();
   Node* n49 = graph()->NewNode(op, nil);
   USE(n49);
   op = common()->Parameter(3);
   Node* n4 = graph()->NewNode(op, nil);
@@ skipping 176 matching lines @@
   //   }
   //   return a + d;
   // }
   Node* nil = graph()->NewNode(common()->Dead());
   op = common()->End();
   Node* n86 = graph()->NewNode(op, nil);
   USE(n86);
   op = common()->Return();
   Node* n84 = graph()->NewNode(op, nil, nil, nil);
   USE(n84);
-  op = js()->Add();
+  op = js()->Add(LanguageMode::SLOPPY);
   Node* n82 = graph()->NewNode(op, nil, nil, nil, nil, nil, nil, nil);
   USE(n82);
   op = common()->IfSuccess();
   Node* n83 = graph()->NewNode(op, nil);
   USE(n83);
   op = common()->Phi(kMachAnyTagged, 2);
   Node* n15 = graph()->NewNode(op, nil, nil, nil);
   USE(n15);
   op = common()->Phi(kMachAnyTagged, 2);
   Node* n17 = graph()->NewNode(op, nil, nil, nil);
   USE(n17);
   op = common()->Parameter(4);
   Node* n6 = graph()->NewNode(op, nil);
   USE(n6);
   op = common()->FrameState(JS_FRAME, BailoutId(-1),
                             OutputFrameStateCombine::Ignore());
   Node* n12 = graph()->NewNode(op, nil, nil, nil, nil, nil);
   USE(n12);
-  op = js()->LessThan();
+  op = js()->LessThan(LanguageMode::SLOPPY);
   Node* n19 = graph()->NewNode(op, nil, nil, nil, nil, nil, nil);
   USE(n19);
   op = common()->IfFalse();
   Node* n25 = graph()->NewNode(op, nil);
   USE(n25);
   op = common()->Parameter(1);
   Node* n2 = graph()->NewNode(op, nil);
   USE(n2);
   op = common()->Phi(kMachAnyTagged, 2);
   Node* n35 = graph()->NewNode(op, nil, nil, nil);
@@ skipping 18 matching lines @@
   USE(n5);
   op = common()->Parameter(2);
   Node* n3 = graph()->NewNode(op, nil);
   USE(n3);
   op = common()->EffectPhi(2);
   Node* n18 = graph()->NewNode(op, nil, nil, nil);
   USE(n18);
   op = common()->Branch();
   Node* n22 = graph()->NewNode(op, nil, nil);
   USE(n22);
-  op = js()->Add();
+  op = js()->Add(LanguageMode::SLOPPY);
   Node* n32 = graph()->NewNode(op, nil, nil, nil, nil, nil, nil, nil);
   USE(n32);
-  op = js()->Add();
+  op = js()->Add(LanguageMode::SLOPPY);
   Node* n64 = graph()->NewNode(op, nil, nil, nil, nil, nil, nil, nil);
   USE(n64);
   op = common()->Loop(2);
   Node* n34 = graph()->NewNode(op, nil, nil);
   USE(n34);
   op = common()->IfSuccess();
   Node* n9 = graph()->NewNode(op, nil);
   USE(n9);
   op = common()->Merge(2);
   Node* n72 = graph()->NewNode(op, nil, nil);
   USE(n72);
-  op = js()->Add();
+  op = js()->Add(LanguageMode::SLOPPY);
   Node* n78 = graph()->NewNode(op, nil, nil, nil, nil, nil, nil, nil);
   USE(n78);
   op = js()->StackCheck();
   Node* n8 = graph()->NewNode(op, nil, nil, nil, nil);
   USE(n8);
   op = common()->EffectPhi(2);
   Node* n80 = graph()->NewNode(op, nil, nil, nil);
   USE(n80);
   op = js()->ToBoolean();
   Node* n21 = graph()->NewNode(op, nil, nil);
@@ skipping 57 matching lines @@
   USE(n74);
   op = common()->EffectPhi(2);
   Node* n57 = graph()->NewNode(op, nil, nil, nil);
   USE(n57);
   op = common()->Merge(2);
   Node* n45 = graph()->NewNode(op, nil, nil);
   USE(n45);
   op = common()->IfTrue();
   Node* n23 = graph()->NewNode(op, nil);
   USE(n23);
-  op = js()->Add();
+  op = js()->Add(LanguageMode::SLOPPY);
   Node* n50 = graph()->NewNode(op, nil, nil, nil, nil, nil, nil, nil);
   USE(n50);
   op = common()->IfSuccess();
   Node* n51 = graph()->NewNode(op, nil);
   USE(n51);
   op = common()->Branch();
   Node* n55 = graph()->NewNode(op, nil, nil);
   USE(n55);
   op = js()->ToBoolean();
   Node* n69 = graph()->NewNode(op, nil, nil);
   USE(n69);
   op = common()->IfSuccess();
   Node* n68 = graph()->NewNode(op, nil);
   USE(n68);
-  op = js()->LessThan();
+  op = js()->LessThan(LanguageMode::SLOPPY);
   Node* n38 = graph()->NewNode(op, nil, nil, nil, nil, nil, nil);
   USE(n38);
   op = common()->IfFalse();
   Node* n44 = graph()->NewNode(op, nil);
   USE(n44);
   op = common()->IfTrue();
   Node* n56 = graph()->NewNode(op, nil);
   USE(n56);
   op = js()->ToNumber();
   Node* n48 = graph()->NewNode(op, nil, nil, nil, nil, nil);
@@ skipping 248 matching lines @@
   Node* nil = graph()->NewNode(common()->Dead());
   op = common()->End();
   Node* n34 = graph()->NewNode(op, nil);
   USE(n34);
   op = common()->Return();
   Node* n32 = graph()->NewNode(op, nil, nil, nil);
   USE(n32);
   op = common()->Phi(kMachAnyTagged, 2);
   Node* n14 = graph()->NewNode(op, nil, nil, nil);
   USE(n14);
-  op = js()->LessThan();
+  op = js()->LessThan(LanguageMode::SLOPPY);
   Node* n17 = graph()->NewNode(op, nil, nil, nil, nil, nil, nil);
   USE(n17);
   op = common()->IfFalse();
   Node* n23 = graph()->NewNode(op, nil);
   USE(n23);
   op = common()->Parameter(1);
   Node* n2 = graph()->NewNode(op, nil);
   USE(n2);
-  op = js()->Add();
+  op = js()->Add(LanguageMode::SLOPPY);
   Node* n29 = graph()->NewNode(op, nil, nil, nil, nil, nil, nil, nil);
   USE(n29);
   op = common()->Loop(2);
   Node* n13 = graph()->NewNode(op, nil, nil);
   USE(n13);
   op = common()->Parameter(2);
   Node* n3 = graph()->NewNode(op, nil);
   USE(n3);
   op = common()->Parameter(4);
   Node* n6 = graph()->NewNode(op, nil);
   USE(n6);
   op = common()->FrameState(JS_FRAME, BailoutId(-1),
                             OutputFrameStateCombine::Ignore());
   Node* n12 = graph()->NewNode(op, nil, nil, nil, nil, nil);
   USE(n12);
   op = common()->EffectPhi(2);
   Node* n15 = graph()->NewNode(op, nil, nil, nil);
   USE(n15);
   op = common()->Branch();
   Node* n20 = graph()->NewNode(op, nil, nil);
   USE(n20);
   op = common()->Start(3);
   Node* n0 = graph()->NewNode(op);
   USE(n0);
-  op = js()->Add();
+  op = js()->Add(LanguageMode::SLOPPY);
   Node* n27 = graph()->NewNode(op, nil, nil, nil, nil, nil, nil, nil);
   USE(n27);
   op = common()->IfSuccess();
   Node* n28 = graph()->NewNode(op, nil);
   USE(n28);
   op = common()->IfSuccess();
   Node* n9 = graph()->NewNode(op, nil);
   USE(n9);
   op = common()->IfSuccess();
   Node* n30 = graph()->NewNode(op, nil);
@@ skipping 543 matching lines @@
   Node* end = graph()->NewNode(common()->End(), ret);
 
   graph()->SetEnd(end);
 
   ComputeAndVerifySchedule(16);
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8