[interpreter] VisitForTest for bytecode generator

test/cctest/test-func-name-inference.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 269 matching lines @@
   CheckFunctionName(script, "return 2", "");
   CheckFunctionName(script, "return 3", "");
 }
 
 
 TEST(MultipleFuncsConditional) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
 
   v8::Local<v8::Script> script = Compile(CcTest::isolate(),
-                                         "fun1 = 0 ?\n"
+                                         "var x = 0;\n"
+                                         "fun1 = x ?\n"
                                          "    function() { return 1; } :\n"
                                          "    function() { return 2; }");
   CheckFunctionName(script, "return 1", "fun1");
   CheckFunctionName(script, "return 2", "fun1");
 }
 
 
 TEST(MultipleFuncsInLiteral) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
 
   v8::Local<v8::Script> script =
       Compile(CcTest::isolate(),
+              "var x = 0;\n"

[rmcilroy, 2016/08/12 11:15:26]

Were these changes intended?

[klaasb, 2016/08/12 16:00:13]

I introduced these to keep the intention of these tests the same. With the
previous version with the new VisitForTest changes, one branch would get
optimized away and the test would fail.
This would need updating again, if we ever propagate constants via variables
while generating code.

[rmcilroy, 2016/08/15 09:37:11]

How does the test fail? It seems like the function name should still be inferred
correctly even if one of the branches is optimized away.

[klaasb, 2016/08/15 11:53:04]

If we skip generating bytecode for the branch, we never see the function literal
and also don't generate a SharedFunctionInfo.
CheckFunctionName tries to find the SharedFunctionInfo closest to and containing
"return 1", but only find the containing anonymous function.
As far as I understand, we don't need the SharedFunctionInfo and we should be
fine optimizing this. Is that correct?

This is just a simple fix for the test for now.
Though in general, these two tests will always depend on the optimizations we
do, unless we insert something unoptimizable/non-constant on which to branch.
How about Math.random()? It won't make these tests non-deterministic, since
they're not actually executed.

[rmcilroy, 2016/08/15 12:37:19]

Ahh I see, so it's not actually the function name inference which is incorrect,
just the test code that tries to extract the SFI at a particular source
position. It that case this looks fine, thanks for the explanation.

Re: future optimizations - we will never be able to do the optimizations you
suggest due to debugging (we need to have breakable source positions after the
local was updated) so that won't be an issue, this is fine as-is.

               "function MyClass() {}\n"
               "MyClass.prototype = {\n"
-              "  method1: 0 ? function() { return 1; } :\n"
+              "  method1: x ? function() { return 1; } :\n"
               "               function() { return 2; } }");
   CheckFunctionName(script, "return 1", "MyClass.method1");
   CheckFunctionName(script, "return 2", "MyClass.method1");
 }
 
 
 TEST(AnonymousInAnonymousClosure1) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
 
@@ skipping 215 matching lines @@
                                          "  };\n"
                                          "  var foo = 10;\n"
                                          "  function f() {\n"
                                          "    return wrapCode();\n"
                                          "  }\n"
                                          "  this.ref = f;\n"
                                          "})()");
   script->Run(CcTest::isolate()->GetCurrentContext()).ToLocalChecked();
   CheckFunctionName(script, "return 2012", "");
 }