[strong] Declaration-after-use errors.

src/variables.h

Index: src/variables.h
diff --git a/src/variables.h b/src/variables.h
index 1adeb1f0f417cc0d8bcdf6a19a2f688f1195e477..f10ce36db779d2a11e1c074343e64dd6762fd316 100644
--- a/src/variables.h
+++ b/src/variables.h
@@ -18,7 +18,7 @@ namespace internal {
 
 class Variable: public ZoneObject {
  public:
-  enum Kind { NORMAL, THIS, NEW_TARGET, ARGUMENTS };
+  enum Kind { NORMAL, FUNCTION, THIS, NEW_TARGET, ARGUMENTS };

[arv (Not doing code reviews), 2015/02/23 14:45:55]

I find this change strange. How is FUNCTION related to the other ones?

[marja, 2015/02/24 13:29:35]

The previous NORMAL is split into NORMAL and FUNCTION, to distinguish
declarations like:

let x = 0; // NORMAL

from

function x() { } // FUNCTION

In addition:

let x = function() { ..} // NORMAL

This is needed so that we can make this work:

function foo() {
  bar; // ok
  bar2; // not ok
}

function bar() { }
let bar2 = 0;

... it's not necessary that this information is carried in the Kind; but it
seemed suitable since nothing checked for == NORMAL (only == THIS, ==
ARGUMENTS), so splitting NORMAL was feasible, and, I don't fully understand what
exactly this "Kind" is, except intuitively "it's what kind of a variable it is",
and for that, function seemed a suitable addition.

 
   enum Location {
     // Before and during variable allocation, a variable whose location is
@@ -49,7 +49,7 @@ class Variable: public ZoneObject {
 
   Variable(Scope* scope, const AstRawString* name, VariableMode mode,
            bool is_valid_ref, Kind kind, InitializationFlag initialization_flag,
-           MaybeAssignedFlag maybe_assigned_flag = kNotAssigned);
+           int position, MaybeAssignedFlag maybe_assigned_flag = kNotAssigned);
 
   // Printing support
   static const char* Mode2String(VariableMode mode);
@@ -65,6 +65,7 @@ class Variable: public ZoneObject {
   Handle<String> name() const { return name_->string(); }
   const AstRawString* raw_name() const { return name_; }
   VariableMode mode() const { return mode_; }
+  int position() const { return position_; }
   bool has_forced_context_allocation() const {
     return force_context_allocation_;
   }
@@ -98,6 +99,7 @@ class Variable: public ZoneObject {
     return initialization_flag_ == kNeedsInitialization;
   }
 
+  bool is_function() const { return kind_ == FUNCTION; }
   bool is_this() const { return kind_ == THIS; }
   bool is_new_target() const { return kind_ == NEW_TARGET; }
   bool is_arguments() const { return kind_ == ARGUMENTS; }
@@ -134,6 +136,7 @@ class Variable: public ZoneObject {
   const AstRawString* name_;
   VariableMode mode_;
   Kind kind_;
+  int position_;
   Location location_;
   int index_;
   int initializer_position_;