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();
+  LocalVarDescriptors& var_descs =
+      LocalVarDescriptors::Handle(code.var_descriptors());
+  ASSERT(var_descs.IsNull());

[hausner, 2015/05/07 16:45:29]

This would fail for regexp function, right? They have eagerly precomputed var
descriptors.
Either move this assertion to the else branch or move the IsIrregexpFunction()
check to the beginning of this function.

[srdjan, 2015/05/07 18:57:55]

This method should not be called if local var descriptor exists already, only if
GetLocalVarDescriptors determines that one is needed. Converted
IsIrregexpFunction to an assert

   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);
+    LongJumpScope jump;
+    if (setjmp(*jump.Set()) == 0) {
+      Parser::ParseFunction(parsed_function);
+      parsed_function->AllocateVariables();
+      var_descs = parsed_function->node_sequence()->scope()->
+          GetVarDescriptors(function);
+    } else {
+      UNREACHABLE();

[hausner, 2015/05/07 16:45:29]

Why is the setjmp needed if there is never an exception?

[srdjan, 2015/05/07 18:57:55]

Removed. Was useful for debugging as an error in Parser created a mess. Added
comment.

+    }
   }
   code.set_var_descriptors(var_descs);

[hausner, 2015/05/07 16:45:29]

ASSERT here that the computed var_descs are not null?

[srdjan, 2015/05/07 18:57:56]

Done.

 }
 
 
 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);
   // Class dynamic lives in the vm isolate. Its array fields cannot be set to
@@ skipping 30 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