[Parser] Remove Variable::is_possibly_eval.

src/parsing/parser.cc

 // Copyright 2012 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/parsing/parser.h"
 
 #include <memory>
 
 #include "src/api.h"
 #include "src/ast/ast.h"
@@ skipping 770 matching lines @@
 
 
 Expression* ParserTraits::GetIterator(Expression* iterable,
                                       AstNodeFactory* factory, int pos) {
   Expression* iterator_symbol_literal =
       factory->NewSymbolLiteral("iterator_symbol", kNoSourcePosition);
   Expression* prop =
       factory->NewProperty(iterable, iterator_symbol_literal, pos);
   Zone* zone = parser_->zone();
   ZoneList<Expression*>* args = new (zone) ZoneList<Expression*>(0, zone);
-  return factory->NewCall(prop, args, pos);
+  return factory->NewCall(prop, args, pos, Call::NOT_EVAL);
 }
 
 
 Literal* ParserTraits::GetLiteralTheHole(int position,
                                          AstNodeFactory* factory) {
   return factory->NewTheHoleLiteral(kNoSourcePosition);
 }
 
 
 Expression* ParserTraits::ParseV8Intrinsic(bool* ok) {
@@ skipping 2390 matching lines @@
 //     %ThrowIteratorResultNotAnObject(result)
 Expression* Parser::BuildIteratorNextResult(Expression* iterator,
                                             Variable* result, int pos) {
   Expression* next_literal = factory()->NewStringLiteral(
       ast_value_factory()->next_string(), kNoSourcePosition);
   Expression* next_property =
       factory()->NewProperty(iterator, next_literal, kNoSourcePosition);
   ZoneList<Expression*>* next_arguments =
       new (zone()) ZoneList<Expression*>(0, zone());
   Expression* next_call =
-      factory()->NewCall(next_property, next_arguments, pos);
+      factory()->NewCall(next_property, next_arguments, pos, Call::NOT_EVAL);
   Expression* result_proxy = factory()->NewVariableProxy(result);
   Expression* left =
       factory()->NewAssignment(Token::ASSIGN, result_proxy, next_call, pos);
 
   // %_IsJSReceiver(...)
   ZoneList<Expression*>* is_spec_object_args =
       new (zone()) ZoneList<Expression*>(1, zone());
   is_spec_object_args->Add(left, zone());
   Expression* is_spec_object_call = factory()->NewCallRuntime(
       Runtime::kInlineIsJSReceiver, is_spec_object_args, pos);
@@ skipping 2338 matching lines @@
             const_cast<ZoneList<Expression*>*>(raw_strings), raw_idx, pos),
         zone());
 
     // Ensure hash is suitable as a Smi value
     Smi* hash_obj = Smi::cast(Internals::IntToSmi(static_cast<int>(hash)));
     args->Add(factory()->NewSmiLiteral(hash_obj->value(), pos), zone());
 
     Expression* call_site = factory()->NewCallRuntime(
         Context::GET_TEMPLATE_CALL_SITE_INDEX, args, start);
 
+    Call::PossiblyEval is_possibly_eval = CheckPossibleEvalCall(tag, scope());

[rmcilroy, 2016/08/11 21:27:59]

This call updates the scopes to record the eval call - I'm not sure if this is
safe here but doesn't seem to cause any issues on the test. Let me know if we
should do something else.

[adamk, 2016/08/11 21:42:31]

There used to be a call to CheckPossibleEvalCall here, but I removed it in
https://codereview.chromium.org/1580463003/. I wish I'd written a better CL
description, though, as I can't remember what caused me to make that change. My
guess is I was worried about the fact that this call only appears in the parser,
not preparser. So a function could get different "uses eval" bits when
preparsing than when doing full parsing. If you're going to add it back in, I
think it ought to also get set when preparsing.

Does anything fail if you leave this out, I'm curious? As noted in my CL, using
eval as a template tag is harmless: it's a call to a runtime function that
returns its argument.

[rmcilroy, 2016/08/12 09:18:20]

The reason I added this is that when I took it out the behavior of
Call::is_possibly_eval was different from Variable::is_possibly_eval for the
tests in mjsunit/es6/template.js. Taking it out doesn't seem to have anything to
fail though, so I've taken it out now.

+
     // Call TagFn
     ZoneList<Expression*>* call_args =
         new (zone()) ZoneList<Expression*>(expressions->length() + 1, zone());
     call_args->Add(call_site, zone());
     call_args->AddAll(*expressions, zone());
-    return factory()->NewCall(tag, call_args, pos);
+    return factory()->NewCall(tag, call_args, pos, is_possibly_eval);
   }
 }
 
 
 uint32_t Parser::ComputeTemplateLiteralHash(const TemplateLiteral* lit) {
   const ZoneList<Expression*>* raw_strings = lit->raw();
   int total = raw_strings->length();
   DCHECK(total);
 
   uint32_t running_hash = 0;
@@ skipping 692 matching lines @@
   Statement* call_next;
   {
     Expression* iterator_proxy = factory->NewVariableProxy(var_iterator);
     Expression* literal =
         factory->NewStringLiteral(avfactory->next_string(), nopos);
     Expression* next_property =
         factory->NewProperty(iterator_proxy, literal, nopos);
     Expression* input_proxy = factory->NewVariableProxy(var_input);
     auto args = new (zone) ZoneList<Expression*>(1, zone);
     args->Add(input_proxy, zone);
-    Expression* call = factory->NewCall(next_property, args, nopos);
+    Expression* call =
+        factory->NewCall(next_property, args, nopos, Call::NOT_EVAL);
     Expression* output_proxy = factory->NewVariableProxy(var_output);
     Expression* assignment =
         factory->NewAssignment(Token::ASSIGN, output_proxy, call, nopos);
     call_next = factory->NewExpressionStatement(assignment, nopos);
   }
 
 
   // if (!IS_RECEIVER(output)) %ThrowIterResultNotAnObject(output);
   Statement* validate_next_output;
   {
@@ skipping 780 matching lines @@
   node->Print(Isolate::Current());
 }
 #endif  // DEBUG
 
 #undef CHECK_OK
 #undef CHECK_OK_VOID
 #undef CHECK_FAILED
 
 }  // namespace internal
 }  // namespace v8