Inline allocation of implicit closures.

runtime/vm/parser.cc

 // Copyright (c) 2011, 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/parser.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 1056 matching lines @@
   return super_op;
 }
 
 
 AstNode* Parser::CreateImplicitClosureNode(const Function& func,
                                            intptr_t token_pos,
                                            AstNode* receiver) {
   Function& implicit_closure_function =
       Function::ZoneHandle(func.ImplicitClosureFunction());
   ASSERT(!implicit_closure_function.IsNull());
-  ASSERT(implicit_closure_function.is_static());  // TODO(regis): For now.
+  ASSERT(func.is_static() == implicit_closure_function.is_static());
   AstNode* node;
   if (receiver == NULL) {
     ASSERT(func.is_static());
     node = new StaticImplicitClosureNode(token_pos, implicit_closure_function);
   } else {
     ASSERT(!func.is_static());
     node = new ImplicitClosureNode(token_pos,
                                    implicit_closure_function,
                                    receiver);
   }
@@ skipping 325 matching lines @@
     return MakeImplicitConstructor(func);
   }
 
   // Build local scope for function.
   OpenFunctionBlock(func);
 
   ParamList params;
   // The first parameter of a factory is the TypeArguments vector of the type
   // of the instance to be allocated. We name this hidden parameter 'this'.
   const bool has_receiver =
-      !func.is_static() || func.IsConstructor() || func.IsFactory();
+      !func.IsClosureFunction() &&

[siva, 2011/10/11 21:00:46]

Maybe we should append to the comment as to why
func.IsClosureFunction() needs to be in this list.

I am not sure I understand the advantage you are getting by not treating all
closure functions as static the way you had before. The assertions and closure
type could have still been gotten using the parent_function.

[regis, 2011/10/11 23:40:19]

I added a comment.
I prefer that is_static() reflects the static scope or instance scope of the
closure. This should make instantiation of generic closure types clearer
(upcoming cl). I felt that using is_static() to indicate the presence of a
receiver as first formal parameter was not quite correct. An instance closure
has access to the captured receiver, but via the context.

While writing this, I realized that we do not need Function::IsInStaticScope()
anymore. Removed.

+      (!func.is_static() || func.IsConstructor() || func.IsFactory());
   const bool are_implicitly_final = func.is_const() && func.IsConstructor();
   const bool allow_explicit_default_values = true;
   ASSERT(CurrentToken() == Token::kLPAREN);
   if (has_receiver) {
     params.AddReceiver(token_index_);
   }
   if (are_implicitly_final) {
     params.SetImplicitlyFinal();
   }
   ParseFormalParameterList(allow_explicit_default_values, &params);
@@ skipping 5495 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart