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 562 matching lines @@
   if ((node_sequence->length() == 0) ||
       !node_sequence->NodeAt(node_sequence->length() - 1)->IsReturnNode()) {
     // Add implicit return node.
     node_sequence->Add(new ReturnNode(parser.token_index_));
   }
   parsed_function->set_node_sequence(node_sequence);
 
   // The instantiator may be required at run time for generic type checks or
   // allocation of generic types.
   if (parser.current_class().IsParameterized() &&
-      (!parser.current_function().IsInStaticScope() ||
+      (!parser.current_function().is_static() ||
        parser.current_function().IsInFactoryScope())) {
     // In the case of a local function, only set the instantiator if the
     // receiver was captured.
     const bool kTestOnly = true;
     LocalVariable* receiver =
         parser.LookupReceiver(node_sequence->scope(),
                               kTestOnly);
     if (!parser.current_function().IsLocalFunction() ||
         ((receiver != NULL) && receiver->is_captured())) {
       parsed_function->set_instantiator(
@@ skipping 242 matching lines @@
       ParamList func_params;
       const bool no_explicit_default_values = false;
       ParseFormalParameterList(no_explicit_default_values, &func_params);
       // Change the name of the parameter type to be the signature of the
       // function type.
       // Note that the function type signature may involve parameters of a type
       // that is a type parameter of the enclosing class, so we parameterize the
       // signature with the type parameters of the enclosing class, if any.
       // TODO(regis): Revisit if this is not the right thing to do.
       const bool is_static =
-          current_function().IsNull() || current_function().IsInStaticScope();
+          current_function().IsNull() || current_function().is_static();
       const Function& signature_function = Function::Handle(
           Function::New(*parameter.name,
                         RawFunction::kSignatureFunction,
                         is_static,
                         /* is_const = */ false,
                         parameter.name_pos));
       signature_function.set_owner(current_class());
       signature_function.set_result_type(result_type);
       AddFormalParamsToFunction(&func_params, signature_function);
       const String& signature = String::Handle(signature_function.Signature());
@@ skipping 209 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.
-  AstNode* node;
   if (receiver == NULL) {
-    ASSERT(func.is_static());
-    node = new StaticImplicitClosureNode(token_pos, implicit_closure_function);
+    return new ImplicitStaticClosureNode(token_pos, implicit_closure_function);
   } else {
-    ASSERT(!func.is_static());
-    node = new ImplicitClosureNode(token_pos,
-                                   implicit_closure_function,
-                                   receiver);
+    return new ImplicitInstanceClosureNode(token_pos,
+                                          implicit_closure_function,
+                                          receiver);
   }
-  return node;
 }
 
 
 AstNode* Parser::ParseSuperFieldAccess(const String& field_name) {
   const intptr_t field_pos = token_index_;
   const Class& super_class = Class::Handle(current_class().SuperClass());
   if (super_class.IsNull()) {
     ErrorMsg("class '%s' does not have a superclass",
              String::Handle(current_class().Name()).ToCString());
   }
@@ skipping 311 matching lines @@
   if (IsLiteral("class")) {
     // Special case: implicit constructor. There is no source text to
     // parse. We just build the sequence node by hand.
     return MakeImplicitConstructor(func);
   }
 
   // Build local scope for function.
   OpenFunctionBlock(func);
 
   ParamList params;
+  // Static functions do not have a receiver, except constructors, which are
+  // passed the allocated but uninitialized instance to construct.
+  // An instance closure may capture and access the receiver, but via the
+  // context and not via the first formal parameter.
   // 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();
+  const bool has_receiver = !func.IsClosureFunction() &&
+      (!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 99 matching lines @@
     if (initialized_check_needed) {
       CheckConstFieldsInitialized(cls);
     }
   }
 
   if (current_block_->scope->function_level() > 0) {
     // We are parsing, but not compiling, a local function.
     // The instantiator may be required at run time for generic type checks or
     // allocation of generic types.
     if (current_class().IsParameterized() &&
-        (!current_function().IsInStaticScope() ||
+        (!current_function().is_static() ||
          current_function().IsInFactoryScope())) {
       // Make sure that the receiver of the enclosing instance function
       // (or implicit first parameter of an enclosing factory) is marked as
       // captured if type checks are enabled, because they may access the
       // receiver to instantiate types.
       if (FLAG_enable_type_checks) {
         CaptureReceiver();
       }
     }
   }
@@ skipping 1589 matching lines @@
   // Side effect of lookup captures the receiver variable.
   LocalVariable* receiver = LookupReceiver(current_block_->scope, kTestOnly);
   ASSERT(receiver != NULL);
 }
 
 
 AstNode* Parser::LoadReceiver(intptr_t token_pos) {
   // A nested function may access 'this', referring to the receiver of the
   // outermost enclosing function.
   // We should not be loading the receiver from a static scope.
-  ASSERT(!current_function().IsInStaticScope() ||
+  ASSERT(!current_function().is_static() ||
          current_function().IsInFactoryScope());
   const bool kTestOnly = false;
   LocalVariable* receiver = LookupReceiver(current_block_->scope, kTestOnly);
   if (receiver == NULL) {
     ErrorMsg(token_pos, "illegal access to 'this'");
   }
   return new LoadLocalNode(token_index_, *receiver);
 }
 
 
@@ skipping 2210 matching lines @@
       AstNode* array = left;
       if (left->IsPrimaryNode()) {
         PrimaryNode* primary = left->AsPrimaryNode();
         if (primary->primary().IsFunction()) {
           ErrorMsg(bracket_pos, "cannot apply index operator to function");
         } else if (primary->primary().IsClass()) {
           ErrorMsg(bracket_pos, "cannot apply index operator to class");
         } else if (primary->primary().IsString()) {
           // Primary is an unresolved name.
           String& name = String::CheckedZoneHandle(primary->primary().raw());
-          if (current_function().IsInStaticScope()) {
+          if (current_function().is_static()) {
             ErrorMsg(primary->token_index(),
                      "identifier '%s' is not declared in this scope",
                      name.ToCString());
           } else {
             // Treat as call to unresolved (instance) method.
             AstNode* receiver = LoadReceiver(primary->token_index());
             selector = ParseInstanceCall(receiver, name);
           }
         } else {
           // Internal parser error.
           UNREACHABLE();
         }
       }
       selector = new LoadIndexedNode(bracket_pos, array, index);
     } else if (CurrentToken() == Token::kLPAREN) {
       if (left->IsPrimaryNode()) {
         PrimaryNode* primary = left->AsPrimaryNode();
         const intptr_t primary_pos = primary->token_index();
         if (primary->primary().IsFunction()) {
           Function& func = Function::CheckedHandle(primary->primary().raw());
           String& func_name = String::ZoneHandle(func.name());
           if (func.is_static()) {
             // Parse static function call.
             Class& cls = Class::Handle(func.owner());
             selector = ParseStaticCall(cls, func_name, primary_pos);
           } else {
             // Dynamic function call on implicit "this" parameter.
-            if (current_function().IsInStaticScope()) {
+            if (current_function().is_static()) {
               ErrorMsg(primary_pos,
                        "Cannot access instance method '%s' "
                        "from static function",
                        func_name.ToCString());
             }
             selector = ParseInstanceCall(LoadReceiver(primary_pos), func_name);
           }
         } else if (primary->primary().IsString()) {
           // Primary is an unresolved name.
           String& name = String::CheckedZoneHandle(primary->primary().raw());
-          if (current_function().IsInStaticScope()) {
+          if (current_function().is_static()) {
             ErrorMsg(primary->token_index(),
                      "identifier '%s' is not declared in this scope",
                      name.ToCString());
           } else {
             // Treat as call to unresolved (instance) method.
             AstNode* receiver = LoadReceiver(primary->token_index());
             selector = ParseInstanceCall(receiver, name);
           }
         } else if (primary->primary().IsClass()) {
           ErrorMsg(left->token_index(),
@@ skipping 13 matching lines @@
         if (left->AsPrimaryNode()->primary().IsString()) {
           PrimaryNode* primary = left->AsPrimaryNode();
           const String& ident =
               String::CheckedZoneHandle(primary->primary().raw());
           // An unresolved identifier that is not followed by a selector token
           // . or [ or (.
           // If we are in a static method, this is an error.
           // If we are compiling an instance method, convert this into
           // a runtime lookup for a field (which may be defined in a
           // subclass.)
-          if (current_function().IsInStaticScope()) {
+          if (current_function().is_static()) {
             ErrorMsg(primary->token_index(),
                      "identifier '%s' is not declared in this scope",
                      ident.ToCString());
           } else {
             // Treat as call to unresolved (instance) field.
             AstNode* receiver = LoadReceiver(primary->token_index());
             postfix_expr = ParseInstanceFieldAccess(receiver, ident);
           }
         } else if (left->AsPrimaryNode()->primary().IsFunction()) {
           // Treat as implicit closure.
           PrimaryNode* primary = left->AsPrimaryNode();
           const Function& func =
               Function::CheckedZoneHandle(primary->primary().raw());
           const String& funcname = String::ZoneHandle(func.name());
           if (func.is_static()) {
             // Static function access.
             postfix_expr = CreateImplicitClosureNode(func,
                                                      primary->token_index(),
                                                      NULL);
           } else {
             // Instance function access.
-            if (current_function().IsInStaticScope() ||
+            if (current_function().is_static() ||
                 current_function().IsInFactoryScope()) {
               ErrorMsg(primary->token_index(),
                        "illegal use of method '%s'",
                        funcname.ToCString());
             }
             AstNode* receiver = LoadReceiver(primary->token_index());
             postfix_expr = ParseInstanceFieldAccess(receiver, funcname);
           }
         }
       }
@@ skipping 106 matching lines @@
   // A found name is treated as accessed and possibly marked as captured.
   const bool kTestOnly = false;
   return current_block_->scope->LookupVariable(ident, kTestOnly);
 }
 
 
 void Parser::CheckInstanceFieldAccess(intptr_t field_pos,
                                       const String& field_name) {
   // Fields are not accessible from a static function, except from a
   // constructor, which is considered as non-static by the compiler.
-  if (current_function().IsInStaticScope()) {
+  if (current_function().is_static()) {
     ErrorMsg(field_pos,
              "cannot access instance field '%s' from a static function",
              field_name.ToCString());
   }
 }
 
 
 void Parser::CheckTypeParameterReference(intptr_t type_parameter_pos,
                                          const String& type_parameter_name) {
   // Type parameters cannot be referred to from a static function, except from
   // a constructor or from a factory.
   // A constructor is considered as non-static by the compiler.
   if ((is_top_level_ &&
        (current_member_ != NULL) &&
        current_member_->has_static &&
        !current_member_->has_factory) ||
       (!current_function().IsNull() &&
-       current_function().IsInStaticScope() &&
+       current_function().is_static() &&
        !current_function().IsInFactoryScope())) {
     ErrorMsg(type_parameter_pos,
              "cannot refer to type parameter '%s' from a static function",
              type_parameter_name.ToCString());
   }
 }
 
 
 void Parser::RunStaticFieldInitializer(const Field& field) {
   ASSERT(field.is_static());
@@ skipping 286 matching lines @@
                                               qual_ident,
                                               kResolveIncludingImports);
   }
   if (var_or_field->IsPrimaryNode()) {
     PrimaryNode* primary = var_or_field->AsPrimaryNode();
     if (primary->primary().IsString()) {
       // We got an unresolved name. If we are compiling a static
       // method, this is an error. In an instance method, we convert
       // the unresolved name to an instance field access, since a
       // subclass might define a field with this name.
-      if (current_function().IsInStaticScope()) {
+      if (current_function().is_static()) {
         ErrorMsg(ident_pos, "identifier '%s' is not declared in this scope",
                  ident.ToCString());
       } else {
         // Treat as call to unresolved instance field.
         var_or_field = CallGetter(ident_pos, LoadReceiver(ident_pos), ident);
       }
     } else if (primary->primary().IsFunction()) {
       ErrorMsg(ident_pos, "illegal reference to method '%s'",
                ident.ToCString());
     } else {
@@ skipping 702 matching lines @@
       primary = ParseCompoundLiteral();
     } else {
       primary = ParseNewOperator();
     }
   } else if (CurrentToken() == Token::kLT ||
              CurrentToken() == Token::kLBRACK ||
              CurrentToken() == Token::kINDEX ||
              CurrentToken() == Token::kLBRACE) {
     primary = ParseCompoundLiteral();
   } else if (CurrentToken() == Token::kSUPER) {
-    if (current_function().IsInStaticScope()) {
+    if (current_function().is_static()) {
       ErrorMsg("cannot access superclass from static method");
     } else if (current_function().IsLocalFunction()) {
       ErrorMsg("cannot access superclass from local function");
     }
     ConsumeToken();
     if (CurrentToken() == Token::kPERIOD) {
       ConsumeToken();
       const String& ident = *ExpectIdentifier("identifier expected");
       if (CurrentToken() == Token::kLPAREN) {
         primary = ParseSuperCall(ident);
@@ skipping 264 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart