1// Copyright 2011 the V8 project authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#ifndef V8_AST_VARIABLES_H_
6#define V8_AST_VARIABLES_H_
7
8#include "src/ast/ast-value-factory.h"
9#include "src/globals.h"
10#include "src/zone/zone.h"
11
12namespace v8 {
13namespace internal {
14
15// The AST refers to variables via VariableProxies - placeholders for the actual
16// variables. Variables themselves are never directly referred to from the AST,
17// they are maintained by scopes, and referred to from VariableProxies and Slots
18// after binding and variable allocation.
19class Variable final : public ZoneObject {
20 public:
21  Variable(Scope* scope, const AstRawString* name, VariableMode mode,
22           VariableKind kind, InitializationFlag initialization_flag,
23           MaybeAssignedFlag maybe_assigned_flag = kNotAssigned);
24
25  // The source code for an eval() call may refer to a variable that is
26  // in an outer scope about which we don't know anything (it may not
27  // be the script scope). scope() is NULL in that case. Currently the
28  // scope is only used to follow the context chain length.
29  Scope* scope() const { return scope_; }
30
31  // This is for adjusting the scope of temporaries used when desugaring
32  // parameter initializers.
33  void set_scope(Scope* scope) { scope_ = scope; }
34
35  Handle<String> name() const { return name_->string(); }
36  const AstRawString* raw_name() const { return name_; }
37  VariableMode mode() const { return VariableModeField::decode(bit_field_); }
38  bool has_forced_context_allocation() const {
39    return ForceContextAllocationField::decode(bit_field_);
40  }
41  void ForceContextAllocation() {
42    DCHECK(IsUnallocated() || IsContextSlot() ||
43           location() == VariableLocation::MODULE);
44    bit_field_ = ForceContextAllocationField::update(bit_field_, true);
45  }
46  bool is_used() { return IsUsedField::decode(bit_field_); }
47  void set_is_used() { bit_field_ = IsUsedField::update(bit_field_, true); }
48  MaybeAssignedFlag maybe_assigned() const {
49    return MaybeAssignedFlagField::decode(bit_field_);
50  }
51  void set_maybe_assigned() {
52    bit_field_ = MaybeAssignedFlagField::update(bit_field_, kMaybeAssigned);
53  }
54
55  int initializer_position() { return initializer_position_; }
56  void set_initializer_position(int pos) { initializer_position_ = pos; }
57
58  bool IsUnallocated() const {
59    return location() == VariableLocation::UNALLOCATED;
60  }
61  bool IsParameter() const { return location() == VariableLocation::PARAMETER; }
62  bool IsStackLocal() const { return location() == VariableLocation::LOCAL; }
63  bool IsStackAllocated() const { return IsParameter() || IsStackLocal(); }
64  bool IsContextSlot() const { return location() == VariableLocation::CONTEXT; }
65  bool IsLookupSlot() const { return location() == VariableLocation::LOOKUP; }
66  bool IsGlobalObjectProperty() const;
67
68  bool is_dynamic() const { return IsDynamicVariableMode(mode()); }
69  bool binding_needs_init() const {
70    DCHECK(initialization_flag() != kNeedsInitialization ||
71           IsLexicalVariableMode(mode()));
72    return initialization_flag() == kNeedsInitialization;
73  }
74  bool throw_on_const_assignment(LanguageMode language_mode) const {
75    return kind() != SLOPPY_FUNCTION_NAME_VARIABLE || is_strict(language_mode);
76  }
77
78  bool is_function() const { return kind() == FUNCTION_VARIABLE; }
79  bool is_this() const { return kind() == THIS_VARIABLE; }
80  bool is_sloppy_function_name() const {
81    return kind() == SLOPPY_FUNCTION_NAME_VARIABLE;
82  }
83
84  Variable* local_if_not_shadowed() const {
85    DCHECK(mode() == DYNAMIC_LOCAL && local_if_not_shadowed_ != NULL);
86    return local_if_not_shadowed_;
87  }
88
89  void set_local_if_not_shadowed(Variable* local) {
90    local_if_not_shadowed_ = local;
91  }
92
93  VariableLocation location() const {
94    return LocationField::decode(bit_field_);
95  }
96  VariableKind kind() const { return VariableKindField::decode(bit_field_); }
97  InitializationFlag initialization_flag() const {
98    return InitializationFlagField::decode(bit_field_);
99  }
100
101  int index() const { return index_; }
102
103  bool IsExport() const {
104    DCHECK_EQ(location(), VariableLocation::MODULE);
105    DCHECK_NE(index(), 0);
106    return index() > 0;
107  }
108
109  void AllocateTo(VariableLocation location, int index) {
110    DCHECK(IsUnallocated() ||
111           (this->location() == location && this->index() == index));
112    DCHECK_IMPLIES(location == VariableLocation::MODULE, index != 0);
113    bit_field_ = LocationField::update(bit_field_, location);
114    DCHECK_EQ(location, this->location());
115    index_ = index;
116  }
117
118  static InitializationFlag DefaultInitializationFlag(VariableMode mode) {
119    DCHECK(IsDeclaredVariableMode(mode));
120    return mode == VAR ? kCreatedInitialized : kNeedsInitialization;
121  }
122
123  typedef ThreadedList<Variable> List;
124
125 private:
126  Scope* scope_;
127  const AstRawString* name_;
128
129  // If this field is set, this variable references the stored locally bound
130  // variable, but it might be shadowed by variable bindings introduced by
131  // sloppy 'eval' calls between the reference scope (inclusive) and the
132  // binding scope (exclusive).
133  Variable* local_if_not_shadowed_;
134  Variable* next_;
135  int index_;
136  int initializer_position_;
137  uint16_t bit_field_;
138
139  class VariableModeField : public BitField16<VariableMode, 0, 3> {};
140  class VariableKindField
141      : public BitField16<VariableKind, VariableModeField::kNext, 3> {};
142  class LocationField
143      : public BitField16<VariableLocation, VariableKindField::kNext, 3> {};
144  class ForceContextAllocationField
145      : public BitField16<bool, LocationField::kNext, 1> {};
146  class IsUsedField
147      : public BitField16<bool, ForceContextAllocationField::kNext, 1> {};
148  class InitializationFlagField
149      : public BitField16<InitializationFlag, IsUsedField::kNext, 2> {};
150  class MaybeAssignedFlagField
151      : public BitField16<MaybeAssignedFlag, InitializationFlagField::kNext,
152                          2> {};
153  Variable** next() { return &next_; }
154  friend List;
155};
156}  // namespace internal
157}  // namespace v8
158
159#endif  // V8_AST_VARIABLES_H_
160