Support inlining of calls where type arguments are passed to generic 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 293 matching lines @@
   deferred_prefixes_->Add(&LibraryPrefix::ZoneHandle(Z, prefix.raw()));
 }
 
 
 void ParsedFunction::AllocateVariables() {
   ASSERT(!function().IsIrregexpFunction());
   LocalScope* scope = node_sequence()->scope();
   const intptr_t num_fixed_params = function().num_fixed_parameters();
   const intptr_t num_opt_params = function().NumOptionalParameters();
   const intptr_t num_params = num_fixed_params + num_opt_params;
+  const intptr_t type_args_slot = function().IsGeneric() ? 1 : 0;
+
   // Compute start indices to parameters and locals, and the number of
   // parameters to copy.
   if (num_opt_params == 0) {
     // Parameter i will be at fp[kParamEndSlotFromFp + num_params - i] and
     // local variable j will be at fp[kFirstLocalSlotFromFp - j].
     first_parameter_index_ = kParamEndSlotFromFp + num_params;
     first_stack_local_index_ = kFirstLocalSlotFromFp;
     num_copied_params_ = 0;
   } else {
     // Parameter i will be at fp[kFirstLocalSlotFromFp - i] and local variable
     // j will be at fp[kFirstLocalSlotFromFp - num_params - j].
     first_parameter_index_ = kFirstLocalSlotFromFp;
     first_stack_local_index_ = first_parameter_index_ - num_params;
     num_copied_params_ = num_params;
   }
 
   // Allocate parameters and local variables, either in the local frame or
   // in the context(s).
   bool found_captured_variables = false;
   int next_free_frame_index = scope->AllocateVariables(
-      first_parameter_index_, num_params, first_stack_local_index_, NULL,
-      &found_captured_variables);
+      first_parameter_index_, num_params, type_args_slot,
+      first_stack_local_index_, NULL, &found_captured_variables);
 
   // Frame indices are relative to the frame pointer and are decreasing.
   ASSERT(next_free_frame_index <= first_stack_local_index_);
   num_stack_locals_ = first_stack_local_index_ - next_free_frame_index;
 }
 
 
 struct CatchParamDesc {
   CatchParamDesc()
       : token_pos(TokenPosition::kNoSource),
@@ skipping 1416 matching lines @@
       load_receiver, NULL);
 
   ReturnNode* return_node = new ReturnNode(ident_pos, closure);
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
 
 void Parser::BuildDispatcherScope(const Function& func,
                                   const ArgumentsDescriptor& desc) {
+  if (desc.TypeArgsLen() > 0) {
+    // TODO(regis): Make func generic.
+    UNIMPLEMENTED();
+  }
   ParamList params;
   // Receiver first.
   TokenPosition token_pos = func.token_pos();
   params.AddReceiver(ReceiverType(current_class()), token_pos);
   // Remaining positional parameters.
   intptr_t i = 1;
   for (; i < desc.PositionalCount(); ++i) {
     ParamDesc p;
     char name[64];
     OS::SNPrint(name, 64, ":p%" Pd, i);
@@ skipping 84 matching lines @@
 SequenceNode* Parser::ParseInvokeFieldDispatcher(const Function& func) {
   TRACE_PARSER("ParseInvokeFieldDispatcher");
   ASSERT(func.IsInvokeFieldDispatcher());
   TokenPosition token_pos = func.token_pos();
   ASSERT(func.token_pos() == TokenPosition::kMinSource);
   ASSERT(current_class().raw() == func.Owner());
 
   const Array& args_desc = Array::Handle(Z, func.saved_args_desc());
   ArgumentsDescriptor desc(args_desc);
   ASSERT(desc.Count() > 0);
+  if (desc.TypeArgsLen() > 0) {
+    ASSERT(func.IsGeneric());
+    // TODO(regis): Pass type argument vector.
+    UNIMPLEMENTED();
+  }
 
   // Set up scope for this function.
   BuildDispatcherScope(func, desc);
 
   // Receiver is local 0.
   LocalScope* scope = current_block_->scope;
   ArgumentListNode* no_args = new ArgumentListNode(token_pos);
   LoadLocalNode* receiver = new LoadLocalNode(token_pos, scope->VariableAt(0));
 
   const Class& closure_cls =
@@ skipping 3806 matching lines @@
       }
       types.Add(&AbstractType::ZoneHandle(Z, type.raw()));
     } while (CurrentToken() == Token::kCOMMA);
     Token::Kind token = CurrentToken();
     if ((token == Token::kGT) || (token == Token::kSHR)) {
       ConsumeRightAngleBracket();
     } else {
       ReportError("right angle bracket expected");
     }
     if (finalization != ClassFinalizer::kIgnore) {
-      return NewTypeArguments(types);
+      TypeArguments& type_args = TypeArguments::Handle(NewTypeArguments(types));
+      if (finalization == ClassFinalizer::kCanonicalize) {
+        type_args = type_args.Canonicalize();
+      }
+      return type_args.raw();
     }
   }
   return TypeArguments::null();
 }
 
 
 // Parse interface list and add to class cls.
 void Parser::ParseInterfaceList(const Class& cls) {
   TRACE_PARSER("ParseInterfaceList");
   ASSERT(CurrentToken() == Token::kIMPLEMENTS);
@@ skipping 6846 matching lines @@
         }
         *type = type_parameter.raw();
         return;
       }
     }
   }
   // Resolve type arguments, if any.
   if (type->arguments() != TypeArguments::null()) {
     const TypeArguments& arguments =
         TypeArguments::Handle(Z, type->arguments());
-    const intptr_t num_arguments = arguments.Length();
-    AbstractType& type_argument = AbstractType::Handle(Z);
-    for (intptr_t i = 0; i < num_arguments; i++) {
-      type_argument = arguments.TypeAt(i);
-      ResolveType(&type_argument);
-      arguments.SetTypeAt(i, type_argument);
+    // Already resolved if canonical.
+    if (!arguments.IsCanonical()) {
+      const intptr_t num_arguments = arguments.Length();
+      AbstractType& type_argument = AbstractType::Handle(Z);
+      for (intptr_t i = 0; i < num_arguments; i++) {
+        type_argument = arguments.TypeAt(i);
+        ResolveType(&type_argument);
+        arguments.SetTypeAt(i, type_argument);
+      }
     }
   }
   if (type->IsFunctionType()) {
     const Function& signature =
         Function::Handle(Z, Type::Cast(*type).signature());
     Type& signature_type = Type::Handle(Z, signature.SignatureType());
     if (signature_type.raw() != type->raw()) {
       ResolveType(&signature_type);
     } else {
       ResolveSignature(signature);
@@ skipping 2729 matching lines @@
                                                 TokenPosition* start,
                                                 TokenPosition* end) {
   UNREACHABLE();
   return false;
 }
 
 
 }  // namespace dart
 
 #endif  // DART_PRECOMPILED_RUNTIME