Constructor tear-off closures

runtime/vm/parser.h

 // 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.
 
 #ifndef VM_PARSER_H_
 #define VM_PARSER_H_
 
 #include "include/dart_api.h"
 
 #include "platform/assert.h"
@@ skipping 491 matching lines @@
   RawFunction* GetSuperFunction(intptr_t token_pos,
                                 const String& name,
                                 ArgumentListNode* arguments,
                                 bool resolve_getter,
                                 bool* is_no_such_method);
   AstNode* ParseSuperCall(const String& function_name);
   AstNode* ParseSuperFieldAccess(const String& field_name, intptr_t field_pos);
   AstNode* ParseSuperOperator();
   AstNode* BuildUnarySuperOperator(Token::Kind op, PrimaryNode* super);
 
+  static bool ParseFormalParameters(const Function& func, ParamList* params);
+
   static void SetupDefaultsForOptionalParams(const ParamList* params,
                                              Array* default_values);
   ClosureNode* CreateImplicitClosureNode(const Function& func,
                                          intptr_t token_pos,
                                          AstNode* receiver);
   static void AddFormalParamsToFunction(const ParamList* params,
                                         const Function& func);
   void AddFormalParamsToScope(const ParamList* params, LocalScope* scope);
 
   SequenceNode* ParseConstructor(const Function& func,
                                  Array* default_parameter_values);
   SequenceNode* ParseFunc(const Function& func,
                           Array* default_parameter_values);
 
   void ParseNativeFunctionBlock(const ParamList* params, const Function& func);
 
   SequenceNode* ParseInstanceGetter(const Function& func);
   SequenceNode* ParseInstanceSetter(const Function& func);
   SequenceNode* ParseStaticFinalGetter(const Function& func);
   SequenceNode* ParseStaticInitializer();
   SequenceNode* ParseMethodExtractor(const Function& func);
   SequenceNode* ParseNoSuchMethodDispatcher(const Function& func,
                                             Array* default_values);
   SequenceNode* ParseInvokeFieldDispatcher(const Function& func,
                                            Array* default_values);
   SequenceNode* ParseImplicitClosure(const Function& func,
                                      Array* default_values);
+  SequenceNode* ParseConstructorClosure(const Function& func,
+                                        Array* default_values);
 
   void BuildDispatcherScope(const Function& func,
                             const ArgumentsDescriptor& desc,
                             Array* default_values);
 
   void EnsureHasReturnStatement(SequenceNode* seq, intptr_t return_pos);
   void ChainNewBlock(LocalScope* outer_scope);
   void OpenBlock();
   void OpenLoopBlock();
   void OpenFunctionBlock(const Function& func);
@@ skipping 151 matching lines @@
   AstNode* ParseStringLiteral(bool allow_interpolation);
   String* ParseImportStringLiteral();
   AstNode* ParseCompoundLiteral();
   AstNode* ParseSymbolLiteral();
   AstNode* ParseListLiteral(intptr_t type_pos,
                             bool is_const,
                             const TypeArguments& type_arguments);
   AstNode* ParseMapLiteral(intptr_t type_pos,
                            bool is_const,
                            const TypeArguments& type_arguments);
+
+  RawFunction* BuildConstructorClosureFunction(const Function& ctr,
+                                               intptr_t token_pos);
   AstNode* ParseNewOperator(Token::Kind op_kind);
+  void ParseConstructorClosurization(Function* constructor,
+                                     TypeArguments* type_arguments);
 
   // An implicit argument, if non-null, is prepended to the returned list.
   ArgumentListNode* ParseActualParameters(ArgumentListNode* implicit_arguments,
                                           bool require_const);
   AstNode* ParseStaticCall(const Class& cls,
                            const String& method_name,
                            intptr_t ident_pos);
   AstNode* ParseInstanceCall(AstNode* receiver,
                              const String& method_name,
                              intptr_t ident_pos,
@@ skipping 150 matching lines @@
 
   // Indentation of parser trace.
   intptr_t trace_indent_;
 
   DISALLOW_COPY_AND_ASSIGN(Parser);
 };
 
 }  // namespace dart
 
 #endif  // VM_PARSER_H_