Remove Scope::scope_uses_this_ flag

src/preparser.h

 // 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.
 
 #ifndef V8_PREPARSER_H
 #define V8_PREPARSER_H
 
 #include "src/v8.h"
 
 #include "src/bailout-reason.h"
@@ skipping 2197 matching lines @@
       Consume(Token::THIS);
       if (is_strong(language_mode())) {
         // Constructors' usages of 'this' in strong mode are parsed separately.
         // TODO(rossberg): this does not work with arrow functions yet.
         if (i::IsConstructor(function_state_->kind())) {
           ReportMessage("strong_constructor_this");
           *ok = false;
           break;
         }
       }
-      scope_->RecordThisUsage();

[arv (Not doing code reviews), 2015/05/06 14:23:52]

It is not clear to me how this works now? Don't we use this information to
determine if we should introduce a binding for this? Maybe we always introduce a
this binding now (-arrows and eval)?

[wingo, 2015/05/06 14:37:42]

ThisExpression for the full parser will create an unresolved VariableProxy which
in Scope::Analyze() will be plugged to a Variable.  When that happens the
Variable itself, wherever it is declared, will be marked as used.  The variable
will also be marked as used if there is a nested direct eval(), though perhaps
those conditions are too conservative (see Scope::MustAllocate()).  Anyway, with
all of that, the flag is redundant.

       result = this->ThisExpression(scope_, factory(), beg_pos);
       break;
     }
 
     case Token::NULL_LITERAL:
     case Token::TRUE_LITERAL:
     case Token::FALSE_LITERAL:
       BindingPatternUnexpectedToken(classifier);
       Next();
       result =
@@ skipping 1005 matching lines @@
     ExpressionClassifier* classifier, bool* ok) {
   // InitializationExpression ::  (strong mode)
   //  'this' '.' IdentifierName '=' AssignmentExpression
   //  'this' '[' Expression ']' '=' AssignmentExpression
 
   if (fni_ != NULL) fni_->Enter();
 
   Consume(Token::THIS);
   int pos = position();
   function_state_->set_this_location(scanner()->location());
-  scope_->RecordThisUsage();
   ExpressionT this_expr = this->ThisExpression(scope_, factory(), pos);
 
   ExpressionT left = this->EmptyExpression();
   switch (peek()) {
     case Token::LBRACK: {
       Consume(Token::LBRACK);
       int pos = position();
       ExpressionT index = this->ParseExpression(true, classifier, CHECK_OK);
       left = factory()->NewProperty(this_expr, index, pos);
       if (fni_ != NULL) {
@@ skipping 585 matching lines @@
       *ok = false;
       return;
     }
     has_seen_constructor_ = true;
     return;
   }
 }
 } }  // v8::internal
 
 #endif  // V8_PREPARSER_H