Eagerly create local var descriptors for artificially created methods (they cannot be regularly par…

runtime/vm/compiler.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/compiler.h"
 
 #include "vm/assembler.h"
 
 #include "vm/ast_printer.h"
 #include "vm/block_scheduler.h"
@@ skipping 1116 matching lines @@
   UNREACHABLE();
   return Error::null();
 }
 
 
 void Compiler::ComputeLocalVarDescriptors(const Code& code) {
   ASSERT(!code.is_optimized());
   const Function& function = Function::Handle(code.function());
   ParsedFunction* parsed_function = new ParsedFunction(
       Thread::Current(), Function::ZoneHandle(function.raw()));
-  LocalVarDescriptors& var_descs = LocalVarDescriptors::Handle();
-  if (function.IsIrregexpFunction()) {
-    UNREACHABLE();  // Special parsing needed, not yet implemented.
-  } else {
-    Parser::ParseFunction(parsed_function);
-    parsed_function->AllocateVariables();
-    var_descs =
-        parsed_function->node_sequence()->scope()->GetVarDescriptors(function);
-  }
+  LocalVarDescriptors& var_descs =
+      LocalVarDescriptors::Handle(code.var_descriptors());
+  ASSERT(var_descs.IsNull());
+  // IsIrregexpFunction have eager var descriptors generation.
+  ASSERT(!function.IsIrregexpFunction());
+  // Parser should not produce any errors, therefore no LongJumpScope needed.
+  Parser::ParseFunction(parsed_function);
+  parsed_function->AllocateVariables();
+  var_descs = parsed_function->node_sequence()->scope()->
+      GetVarDescriptors(function);
+  ASSERT(!var_descs.IsNull());
   code.set_var_descriptors(var_descs);
 }
 
 
 RawError* Compiler::CompileAllFunctions(const Class& cls) {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   Error& error = Error::Handle(zone);
   Array& functions = Array::Handle(zone, cls.functions());
   Function& func = Function::Handle(zone);
@@ skipping 31 matching lines @@
           return error.raw();
         }
         func.ClearCode();
       }
     }
   }
   return error.raw();
 }
 
 
+static void CreateLocalVarDescriptors(const ParsedFunction& parsed_function) {
+  const Function& func = parsed_function.function();
+  LocalVarDescriptors& var_descs = LocalVarDescriptors::Handle();
+  var_descs = parsed_function.node_sequence()->scope()->GetVarDescriptors(func);
+  Code::Handle(func.unoptimized_code()).set_var_descriptors(var_descs);
+}
+
+
 RawObject* Compiler::EvaluateStaticInitializer(const Field& field) {
   ASSERT(field.is_static());
   // The VM sets the field's value to transiton_sentinel prior to
   // evaluating the initializer value.
   ASSERT(field.value() == Object::transition_sentinel().raw());
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     Isolate* const isolate = Isolate::Current();
     StackZone zone(isolate);
     ParsedFunction* parsed_function =
         Parser::ParseStaticFieldInitializer(field);
 
     parsed_function->AllocateVariables();
     // Non-optimized code generator.
     DartCompilationPipeline pipeline;
     CompileParsedFunctionHelper(&pipeline,
                                 parsed_function,
                                 false,
                                 Isolate::kNoDeoptId);
+    // Eagerly create local var descriptors.
+    CreateLocalVarDescriptors(*parsed_function);
 
     // Invoke the function to evaluate the expression.
     const Function& initializer = parsed_function->function();
     const Object& result = PassiveObject::Handle(
         DartEntry::InvokeFunction(initializer, Object::empty_array()));
     return result.raw();
   } else {
     Isolate* const isolate = Isolate::Current();
     StackZone zone(isolate);
     const Error& error =
@@ skipping 49 matching lines @@
         parsed_function->current_context_var());
     parsed_function->AllocateVariables();
 
     // Non-optimized code generator.
     DartCompilationPipeline pipeline;
     CompileParsedFunctionHelper(&pipeline,
                                 parsed_function,
                                 false,
                                 Isolate::kNoDeoptId);
 
+    // Eagerly create local var descriptors.
+    CreateLocalVarDescriptors(*parsed_function);
     const Object& result = PassiveObject::Handle(
         DartEntry::InvokeFunction(func, Object::empty_array()));
     return result.raw();
   } else {
     Thread* const thread = Thread::Current();
     Isolate* const isolate = thread->isolate();
     const Object& result =
       PassiveObject::Handle(isolate->object_store()->sticky_error());
     isolate->object_store()->clear_sticky_error();
     return result.raw();
   }
   UNREACHABLE();
   return Object::null();
 }
 
 }  // namespace dart