Implement const expressions for local variables

runtime/vm/scopes.h

Index: runtime/vm/scopes.h
===================================================================
--- runtime/vm/scopes.h	(revision 14690)
+++ runtime/vm/scopes.h	(working copy)
@@ -28,6 +28,7 @@
       name_(name),
       owner_(NULL),
       type_(type),
+      const_value_(NULL),
       is_final_(false),
       is_captured_(false),
       is_invisible_(false),
@@ -71,6 +72,20 @@
     is_invisible_ = value;
   }
 
+  bool IsConst() const {
+    return const_value_ != NULL;
+  }
+
+  void SetConstValue(const Instance& value) {
+    ASSERT(value.IsZoneHandle());
+    const_value_ = &value;

[siva, 2012/11/08 20:30:01]

'value' is zone allocated and stored here. Will this
always be available. I am wondering of a case where
we return a closure and compilation of the closure
happens much later, the original zone could have
been destroyed and is not available anymore.

[hausner, 2012/11/09 00:10:21]

Local variable objects and scopes are only alive during the compilation of a
single function. Thus, the pointer to the Zone handle goes away with the zone.

Similarly, we already store a reference to a zone handle for the variable's name
and type. I didn't want to use a reference to a handle, but a pointer instead,
because I don't want to allocate a handle for each non-const variable.
 
On 2012/11/08 20:30:01, siva wrote:

+  }
+
+  const Instance* ConstValue() const {
+    ASSERT(IsConst());
+    return const_value_;
+  }
+
   bool Equals(const LocalVariable& other) const;
 
   // Map the frame index to a bit-vector index.  Assumes the variable is
@@ -88,6 +103,8 @@
 
   const AbstractType& type_;  // Declaration type of local variable.
 
+  const Instance* const_value_;   // NULL or compile-time const value.
+
   bool is_final_;  // If true, this variable is readonly.
   bool is_captured_;  // If true, this variable lives in the context, otherwise
                       // in the stack frame.