Set and keep parent function of signature functions.

runtime/vm/parser.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/parser.h"
 #include "vm/flags.h"
 
 #ifndef DART_PRECOMPILED_RUNTIME
 
 #include "lib/invocation_mirror.h"
@@ skipping 2217 matching lines @@
     if (!var_seen && !final_seen) {
       // The parsed parameter type is actually the function result type.
       AbstractType& result_type =
           AbstractType::Handle(Z, parameter.type->raw());
 
       // In top-level and mixin functions, the source may be in a different
       // script than the script of the current class. However, we never reparse
       // signature functions (except typedef signature functions), therefore
       // we do not need to keep the correct script via a patch class. Use the
       // actual current class as owner of the signature function.
-      Function& signature_function =
-          Function::Handle(Z, Function::NewSignatureFunction(
-                                  current_class(), TokenPosition::kNoSource));
-      signature_function.set_parent_function(innermost_function());
+      Function& signature_function = Function::Handle(
+          Z,
+          Function::NewSignatureFunction(current_class(), innermost_function(),
+                                         TokenPosition::kNoSource));
       innermost_function_ = signature_function.raw();
 
       // Finish parsing the function type parameter.
       if (CurrentToken() == Token::kLT) {
         if (!FLAG_generic_method_syntax) {
           ReportError("generic function types not supported");
         }
         ParseTypeParameters(false);  // Not parameterizing class, but function.
       }
 
@@ skipping 3179 matching lines @@
   ASSERT(innermost_function().IsNull());
   if (use_function_type_syntax) {
     ExpectToken(Token::kASSIGN);
     ASSERT(result_type.IsNull());  // Not parsed yet.
     // Do not resolve types before the function type alias can be recognized as
     // a typedef class, so that correct promotion of function types can occur.
     const Type& function_type = Type::Handle(
         Z, ParseFunctionType(result_type, ClassFinalizer::kDoNotResolve));
     signature_function = function_type.signature();
   } else {
-    signature_function =
-        Function::NewSignatureFunction(function_type_alias, alias_name_pos);
+    signature_function = Function::NewSignatureFunction(
+        function_type_alias, Function::Handle(Z), alias_name_pos);
     innermost_function_ = signature_function.raw();
     ParamList params;
     // Parse the formal parameters of the function type.
     CheckToken(Token::kLPAREN, "formal parameter list expected");
     // Add implicit closure object parameter.
     params.AddFinalParameter(TokenPos(), &Symbols::ClosureParameter(),
                              &Object::dynamic_type());
     const bool allow_explicit_default_values = false;
     const bool evaluate_metadata = false;
     ParseFormalParameterList(use_function_type_syntax,
@@ skipping 7851 matching lines @@
       // It is too early to resolve the type here, since it can
       // refer to a not yet declared function type parameter.
       type = ParseType(ClassFinalizer::kDoNotResolve);
     }
   }
   if (!IsSymbol(Symbols::Function())) {
     ReportError("'Function' expected");
   }
   do {
     ConsumeToken();
-    const Function& signature_function =
-        Function::Handle(Z, Function::NewSignatureFunction(
-                                current_class(), TokenPosition::kNoSource));
-    signature_function.set_parent_function(innermost_function());
+    const Function& signature_function = Function::Handle(
+        Z, Function::NewSignatureFunction(current_class(), innermost_function(),
+                                          TokenPosition::kNoSource));
     innermost_function_ = signature_function.raw();
     signature_function.set_result_type(type);
     // Parse optional type parameters.
     if (CurrentToken() == Token::kLT) {
       if (!FLAG_generic_method_syntax) {
         ReportError("generic type arguments not supported.");
       }
       ParseTypeParameters(false);  // Not parameterizing class, but function.
     }
     ParamList params;
@@ skipping 2020 matching lines @@
                                                 TokenPosition* start,
                                                 TokenPosition* end) {
   UNREACHABLE();
   return false;
 }
 
 
 }  // namespace dart
 
 #endif  // DART_PRECOMPILED_RUNTIME