OLD type

src/variables.h

 // Copyright 2011 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_VARIABLES_H_
 #define V8_VARIABLES_H_
 
 #include "src/ast-value-factory.h"
 #include "src/zone.h"
 
@@ skipping 112 matching lines @@
   void set_local_if_not_shadowed(Variable* local) {
     local_if_not_shadowed_ = local;
   }
 
   Location location() const { return location_; }
   int index() const { return index_; }
   InitializationFlag initialization_flag() const {
     return initialization_flag_;
   }
 
+  Handle<Type> type() const { return type_; }
+  void set_type(Handle<Type> type) { type_ = type; }
+
   void AllocateTo(Location location, int index) {
     location_ = location;
     index_ = index;
   }
 
   static int CompareIndex(Variable* const* v, Variable* const* w);
 
   void RecordStrongModeReference(int start_position, int end_position) {
     // Record the earliest reference to the variable. Used in error messages for
     // strong mode references to undeclared variables.
@@ skipping 29 matching lines @@
 
   // If this field is set, this variable references the stored locally bound
   // variable, but it might be shadowed by variable bindings introduced by
   // sloppy 'eval' calls between the reference scope (inclusive) and the
   // binding scope (exclusive).
   Variable* local_if_not_shadowed_;
 
   // Usage info.
   bool force_context_allocation_;  // set by variable resolver
   bool is_used_;
+  Handle<Type> type_;
   InitializationFlag initialization_flag_;
   MaybeAssignedFlag maybe_assigned_;
 };
 
 class ClassVariable : public Variable {
  public:
   ClassVariable(Scope* scope, const AstRawString* name, VariableMode mode,
                 InitializationFlag initialization_flag,
                 MaybeAssignedFlag maybe_assigned_flag = kNotAssigned,
                 int declaration_group_start = -1)
       : Variable(scope, name, mode, Variable::CLASS, initialization_flag,
                  maybe_assigned_flag),
         declaration_group_start_(declaration_group_start) {}
 
   int declaration_group_start() const { return declaration_group_start_; }
   void set_declaration_group_start(int declaration_group_start) {
     declaration_group_start_ = declaration_group_start;
   }
 
  private:
   // For classes we keep track of consecutive groups of delcarations. They are
   // needed for strong mode scoping checks. TODO(marja, rossberg): Implement
   // checks for functions too.
   int declaration_group_start_;
 };
 } }  // namespace v8::internal
 
 #endif  // V8_VARIABLES_H_