Process generic function type arguments in more places (function type tests,

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 41 matching lines @@
 // committed to the current version.
 DEFINE_FLAG(bool,
             conditional_directives,
             true,
             "Enable conditional directives");
 DEFINE_FLAG(bool,
             generic_method_syntax,
             true,
             "Enable generic function syntax.");
 DEFINE_FLAG(bool,
-            generic_method_semantics,
-            false,
-            "Enable generic function semantics (not yet supported).");
-DEFINE_FLAG(bool,
             initializing_formal_access,
             true,
             "Make initializing formal parameters visible in initializer list.");
 DEFINE_FLAG(bool,
             warn_super,
             false,
             "Warning if super initializer not last in initializer list.");
 DEFINE_FLAG(
     bool,
     await_is_keyword,
     false,
     "await and yield are treated as proper keywords in synchronous code.");
 DEFINE_FLAG(bool,
             assert_initializer,
             false,
             "Allow asserts in initializer lists.");
 
+DECLARE_FLAG(bool, reify_generic_functions);
 DECLARE_FLAG(bool, profile_vm);
 DECLARE_FLAG(bool, trace_service);
 DECLARE_FLAG(bool, ignore_patch_signature_mismatch);
 
 // Quick access to the current thread, isolate and zone.
 #define T (thread())
 #define I (isolate())
 #define Z (zone())
 
 // Quick synthetic token position.
@@ skipping 1082 matching lines @@
                                                          kTestOnly);
     } else {
       instantiator = parser.LookupReceiver(node_sequence->scope(), kTestOnly);
     }
     if (!parser.current_function().IsLocalFunction() ||
         ((instantiator != NULL) && instantiator->is_captured())) {
       parsed_function->set_instantiator(instantiator);
     }
   }
   // ParseFunc has recorded the generic function type arguments variable.
-  ASSERT(!FLAG_generic_method_semantics ||
+  ASSERT(!FLAG_reify_generic_functions ||
          !parser.current_function().IsGeneric() ||
          (parsed_function->function_type_arguments() != NULL));
 }
 
 
 RawObject* Parser::ParseMetadata(const Field& meta_data) {
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     Thread* thread = Thread::Current();
     StackZone stack_zone(thread);
@@ skipping 2261 matching lines @@
 
   if (func.IsGenerativeConstructor()) {
     SequenceNode* statements = ParseConstructor(func);
     last_used_try_index_ = saved_try_index;
     return statements;
   }
 
   ASSERT(!func.IsGenerativeConstructor());
   OpenFunctionBlock(func);  // Build local scope for function.
 
-  if (FLAG_generic_method_semantics && func.IsGeneric()) {
+  if (FLAG_reify_generic_functions && func.IsGeneric()) {
     // Lookup function type arguments variable in parent function scope, if any.
     if (func.HasGenericParent()) {
       const String* variable_name = &Symbols::FunctionTypeArgumentsVar();
       LocalVariable* parent_type_arguments =
           current_block_->scope->LookupVariable(*variable_name, true);
       ASSERT(parent_type_arguments != NULL);
       // TODO(regis): It may be too early to capture parent_type_arguments here.
       // In case it is never used, we could save capturing and concatenating.
       current_block_->scope->CaptureVariable(parent_type_arguments);
       parsed_function_->set_parent_type_arguments(parent_type_arguments);
@@ skipping 2045 matching lines @@
       for (intptr_t i = 0; i < index; i++) {
         existing_type_parameter ^= type_parameters_array.At(i)->raw();
         existing_type_parameter_name = existing_type_parameter.name();
         if (existing_type_parameter_name.Equals(type_parameter_name)) {
           ReportError(type_parameter_pos, "duplicate type parameter '%s'",
                       type_parameter_name.ToCString());
         }
       }
       if ((CurrentToken() == Token::kEXTENDS) ||
           (!parameterizing_class && (CurrentToken() == Token::kSUPER))) {
+        const bool is_lower_bound = CurrentToken() == Token::kSUPER;
         ConsumeToken();
-        // TODO(regis): Handle 'super' differently than 'extends'.
         // A bound may refer to the owner of the type parameter it applies to,
         // i.e. to the class or function currently being parsed.
         // Postpone resolution in order to avoid resolving the owner and its
         // type parameters, as they are not fully parsed yet.
         type_parameter_bound = ParseType(ClassFinalizer::kDoNotResolve);
+        if (is_lower_bound) {
+          // TODO(regis): Handle 'super' differently than 'extends' if lower
+          // bounds make it in the final specification and if run time support
+          // for lower bounds is required.
+          // For now, we parse but ignore lower bounds and only support upper
+          // bounds.
+          type_parameter_bound = I->object_store()->object_type();
+        }
       } else {
         type_parameter_bound = I->object_store()->object_type();
       }
       // Note that we cannot yet calculate the final index of a function type
       // parameter, because we may not have parsed the parent function yet.
       type_parameter = TypeParameter::New(
           parameterizing_class ? current_class() : Class::Handle(Z),
           parameterizing_class ? Function::Handle(Z) : innermost_function(),
           index, type_parameter_name, type_parameter_bound, declaration_pos);
       type_parameters_array.Add(
@@ skipping 1340 matching lines @@
     body = found_func.raw();
     body_closure_name = body.name();
   } else {
     // Create the closure containing the body of this generator function.
     String& generator_name = String::Handle(Z, innermost_function().name());
     body_closure_name =
         Symbols::NewFormatted(T, "<%s_sync_body>", generator_name.ToCString());
     body = Function::NewClosureFunction(body_closure_name, innermost_function(),
                                         func_pos);
     body.set_is_generated_body(true);
+    // TODO(regis): Handle generic generator function.
     body.set_result_type(Object::dynamic_type());
     is_new_closure = true;
   }
 
   ParamList closure_params;
   AddSyncGenClosureParameters(&closure_params);
 
   if (is_new_closure) {
     // Add the parameters to the newly created closure.
     AddFormalParamsToFunction(&closure_params, body);
@@ skipping 108 matching lines @@
   } else {
     // Create the closure containing the body of this async function.
     const String& async_func_name =
         String::Handle(Z, innermost_function().name());
     String& closure_name =
         String::Handle(Z, Symbols::NewFormatted(T, "<%s_async_body>",
                                                 async_func_name.ToCString()));
     closure = Function::NewClosureFunction(closure_name, innermost_function(),
                                            async_func_pos);
     closure.set_is_generated_body(true);
+    // TODO(regis): Handle generic async function.
     closure.set_result_type(Object::dynamic_type());
     is_new_closure = true;
   }
   // Create the parameter list for the async body closure.
   ParamList closure_params;
   AddAsyncClosureParameters(&closure_params);
   if (is_new_closure) {
     // Add the parameters to the newly created closure.
     AddFormalParamsToFunction(&closure_params, closure);
     ResolveSignature(closure);
@@ skipping 116 matching lines @@
   } else {
     // Create the closure containing the body of this async generator function.
     const String& async_generator_name =
         String::Handle(Z, innermost_function().name());
     const String& closure_name = String::Handle(
         Z, Symbols::NewFormatted(T, "<%s_async_gen_body>",
                                  async_generator_name.ToCString()));
     closure = Function::NewClosureFunction(closure_name, innermost_function(),
                                            async_func_pos);
     closure.set_is_generated_body(true);
+    // TODO(regis): Handle generic async generator function.
     closure.set_result_type(Object::dynamic_type());
     is_new_closure = true;
   }
 
   ParamList closure_params;
   AddAsyncGenClosureParameters(&closure_params);
 
   if (is_new_closure) {
     // Add the parameters to the newly created closure.
     AddFormalParamsToFunction(&closure_params, closure);
@@ skipping 561 matching lines @@
                                     ? &Symbols::TypeArgumentsParameter()
                                     : &Symbols::This();
   current_block_->scope->CaptureVariable(
       current_block_->scope->LookupVariable(*variable_name, true));
 }
 
 
 void Parser::CaptureFunctionTypeArguments() {
   ASSERT(InGenericFunctionScope());
   ASSERT(FunctionLevel() > 0);
-  if (!FLAG_generic_method_semantics) {
+  if (!FLAG_reify_generic_functions) {
     return;
   }
   const String* variable_name = &Symbols::FunctionTypeArgumentsVar();
   current_block_->scope->CaptureVariable(
       current_block_->scope->LookupVariable(*variable_name, true));
 }
 
 
 void Parser::CaptureAllInstantiators() {
   if (IsInstantiatorRequired()) {
@@ skipping 4133 matching lines @@
                   "from static function",
                   name.ToCString());
     }
     if (FunctionLevel() > 0) {
       // Make sure that the class instantiator is captured.
       CaptureInstantiator();
     }
     type_parameter ^= CanonicalizeType(type_parameter);
   } else {
     ASSERT(type_parameter.IsFunctionTypeParameter());
-    if (!FLAG_generic_method_semantics) {
+    if (!FLAG_reify_generic_functions) {
       Type& type = Type::ZoneHandle(Z, Type::DynamicType());
       return new (Z) TypeNode(primary_pos, type);
     }
     if (FunctionLevel() > 0) {
       // Make sure that the parent function type arguments are captured.
       CaptureFunctionTypeArguments();
     }
   }
   ASSERT(type_parameter.IsFinalized());
   ASSERT(!type_parameter.IsMalformed());
@@ skipping 488 matching lines @@
           // A type parameter cannot be parameterized, so make the type
           // malformed if type arguments have previously been parsed.
           if (type->arguments() != TypeArguments::null()) {
             *type = ClassFinalizer::NewFinalizedMalformedType(
                 Error::Handle(Z),  // No previous error.
                 script_, type_parameter.token_pos(),
                 "type parameter '%s' cannot be parameterized",
                 String::Handle(Z, type_parameter.name()).ToCString());
             return;
           }
-          if (FLAG_generic_method_semantics) {
+          if (FLAG_reify_generic_functions) {
             ASSERT(!type_parameter.IsMalformed());
             *type = type_parameter.raw();
           } else {
             *type = Type::DynamicType();
           }
           return;
         }
       }
       // Then check if the type is a class type parameter.
       const TypeParameter& type_parameter = TypeParameter::Handle(
@@ skipping 585 matching lines @@
   ResolveIdentInLocalScope(ident_pos, ident, &resolved, &resolved_func_level);
   if (InGenericFunctionScope()) {
     intptr_t type_param_func_level = FunctionLevel();
     const TypeParameter& type_parameter =
         TypeParameter::ZoneHandle(Z, innermost_function().LookupTypeParameter(
                                          ident, &type_param_func_level));
     if (!type_parameter.IsNull()) {
       if ((resolved == NULL) || (resolved_func_level < type_param_func_level)) {
         // The identifier is a function type parameter, possibly shadowing
         // 'resolved'.
-        if (!FLAG_generic_method_semantics) {
+        if (!FLAG_reify_generic_functions) {
           Type& type = Type::ZoneHandle(Z, Type::DynamicType());
           return new (Z) TypeNode(ident_pos, type);
         }
         ASSERT(type_parameter.IsFinalized());
         ASSERT(!type_parameter.IsMalformed());
         return new (Z) TypeNode(ident_pos, type_parameter);
       }
     }
   }
   if (resolved == NULL) {
@@ skipping 827 matching lines @@
   ParseFormalParameters(ctr, &params);
   // Per language spec, the type of the closure parameters is dynamic.
   // Replace the types parsed from the constructor.
   params.EraseParameterTypes();
 
   closure = Function::NewClosureFunction(closure_name, innermost_function(),
                                          token_pos);
   closure.set_is_generated_body(true);
   closure.set_is_debuggable(false);
   closure.set_is_visible(false);
+  // TODO(regis): Verify that the closure cannot be generic.
   closure.set_result_type(Object::dynamic_type());
   AddFormalParamsToFunction(&params, closure);
   ResolveSignature(closure);
 
   // Finalize function type.
   Type& signature_type = Type::Handle(Z, closure.SignatureType());
   signature_type ^= CanonicalizeType(signature_type);
   closure.SetSignatureType(signature_type);
   // Finalization would be premature when top-level parsing.
   ASSERT(!is_top_level_);
@@ skipping 1290 matching lines @@
     const ArgumentListNode& function_args,
     const LocalVariable* temp_for_last_arg,
     bool is_super_invocation) {
   UNREACHABLE();
   return NULL;
 }
 
 }  // namespace dart
 
 #endif  // DART_PRECOMPILED_RUNTIME