Implement const expressions for local variables

runtime/vm/scopes.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/scopes.h"
 
 #include "vm/ast.h"
 #include "vm/bit_vector.h"
 #include "vm/object.h"
 #include "vm/parser.h"
@@ skipping 442 matching lines @@
   // Create a descriptor for each referenced captured variable of enclosing
   // functions to preserve its name and its context allocation information.
   int captured_idx = 0;
   for (int i = 0; i < num_variables(); i++) {
     LocalVariable* variable = VariableAt(i);
     // Preserve the aliases of captured variables belonging to outer scopes.
     if (variable->owner()->function_level() != 1) {
       context_scope.SetTokenIndexAt(captured_idx, variable->token_pos());
       context_scope.SetNameAt(captured_idx, variable->name());
       context_scope.SetIsFinalAt(captured_idx, variable->is_final());
-      context_scope.SetTypeAt(captured_idx, variable->type());
+      context_scope.SetIsConstAt(captured_idx, variable->IsConst());
+      if (variable->IsConst()) {
+        context_scope.SetConstValueAt(captured_idx, *variable->ConstValue());
+      } else {
+        context_scope.SetTypeAt(captured_idx, variable->type());
+      }
       context_scope.SetContextIndexAt(captured_idx, variable->index());
       // Adjust the context level relative to the current context level,
       // since the context of the current scope will be at level 0 when
       // compiling the nested function.
       int adjusted_context_level =
           variable->owner()->context_level() - current_context_level;
       context_scope.SetContextLevelAt(captured_idx, adjusted_context_level);
       captured_idx++;
     }
   }
   ASSERT(context_scope.num_variables() == captured_idx);  // Verify count.
   return context_scope.raw();
 }
 
 
 LocalScope* LocalScope::RestoreOuterScope(const ContextScope& context_scope) {
   // The function level of the outer scope is one less than the function level
   // of the current function, which is 0.
   LocalScope* outer_scope = new LocalScope(NULL, -1, 0);
   // Add all variables as aliases to the outer scope.
   for (int i = 0; i < context_scope.num_variables(); i++) {
-    LocalVariable* variable =
-        new LocalVariable(context_scope.TokenIndexAt(i),
-                          String::ZoneHandle(context_scope.NameAt(i)),
-                          AbstractType::ZoneHandle(context_scope.TypeAt(i)));
+    LocalVariable* variable;
+    if (context_scope.IsConstAt(i)) {
+      variable = new LocalVariable(context_scope.TokenIndexAt(i),
+          String::ZoneHandle(context_scope.NameAt(i)),
+          AbstractType::ZoneHandle(Type::DynamicType()));
+      variable->SetConstValue(
+          Instance::ZoneHandle(context_scope.ConstValueAt(i)));
+    } else {
+      variable = new LocalVariable(context_scope.TokenIndexAt(i),
+          String::ZoneHandle(context_scope.NameAt(i)),
+          AbstractType::ZoneHandle(context_scope.TypeAt(i)));
+    }
     variable->set_is_captured();
     variable->set_index(context_scope.ContextIndexAt(i));
     if (context_scope.IsFinalAt(i)) {
       variable->set_is_final();
     }
     // Create a fake owner scope describing the index and context level of the
     // variable. Function level and loop level are unused (set to 0), since
     // context level has already been assigned.
     LocalScope* owner_scope = new LocalScope(NULL, 0, 0);
     owner_scope->set_context_level(context_scope.ContextLevelAt(i));
@@ skipping 10 matching lines @@
 
   // Create a ContextScope with space for kNumCapturedVars descriptors.
   const ContextScope& context_scope =
       ContextScope::Handle(ContextScope::New(kNumCapturedVars));
 
   // Create a descriptor for 'this' variable.
   const String& name = String::Handle(Symbols::This());
   context_scope.SetTokenIndexAt(0, func.token_pos());
   context_scope.SetNameAt(0, name);
   context_scope.SetIsFinalAt(0, true);
+  context_scope.SetIsConstAt(0, false);
   const AbstractType& type = AbstractType::Handle(func.ParameterTypeAt(0));
   context_scope.SetTypeAt(0, type);
   context_scope.SetContextIndexAt(0, 0);
   context_scope.SetContextLevelAt(0, 0);
   ASSERT(context_scope.num_variables() == kNumCapturedVars);  // Verify count.
   return context_scope.raw();
 }
 
 
 bool LocalVariable::Equals(const LocalVariable& other) const {
@@ skipping 22 matching lines @@
   } else {
     // Shift negative indexes so that the lowest one is 0 (they are still
     // non-positive).
     return fixed_parameter_count -
         (index() - ParsedFunction::kFirstLocalSlotIndex);
   }
 }
 
 
 }  // namespace dart