[kernel] Support for top-level generic functions.

runtime/vm/kernel_to_il.cc

 // Copyright (c) 2016, 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 <set>
 
 #include "vm/kernel_to_il.h"
 
 #include "vm/compiler.h"
 #include "vm/intermediate_language.h"
@@ skipping 776 matching lines @@
     ASSERT(type_arguments_field_offset != dart::Class::kNoTypeArguments);
 
     instructions += LoadLocal(scopes_->this_variable);
     instructions += LoadField(type_arguments_field_offset);
   } else {
     instructions += NullConstant();
   }
   return instructions;
 }
 
+// KERNEL_GENERIC_METHODS_UNDONE(sjindel): This seems to work for static

[jensj, 2017/08/11 06:24:55]

todo?

[sjindel, 2017/08/14 11:05:49]

Done.

+// top-level functions, but probably needs to be revisited when generic methods
+// are fully supported in kernel.
 Fragment FlowGraphBuilder::LoadFunctionTypeArguments() {
-  UNIMPLEMENTED();  // TODO(regis)
-  return Fragment(NULL);
+  Fragment instructions;
+  ASSERT(parsed_function_->function_type_arguments() != NULL);
+  instructions += LoadLocal(parsed_function_->function_type_arguments());
+  return instructions;
 }
 
 Fragment FlowGraphBuilder::InstantiateType(const AbstractType& type) {
   Value* function_type_args = Pop();
   Value* instantiator_type_args = Pop();
   InstantiateTypeInstr* instr = new (Z) InstantiateTypeInstr(
       TokenPosition::kNoSource, type, instantiator_type_args,
       function_type_args, GetNextDeoptId());
   Push(instr);
   return Fragment(instr);
@@ skipping 469 matching lines @@
       (function.name() == Symbols::ListFactory().raw())) {
     ASSERT(argument_count == 1 || argument_count == 2);
     return (argument_count == 1) ? kGrowableObjectArrayCid : kArrayCid;
   }
   return FactoryRecognizer::ResultCid(function);
 }
 
 Fragment FlowGraphBuilder::StaticCall(TokenPosition position,
                                       const Function& target,
                                       intptr_t argument_count,
-                                      const Array& argument_names) {
+                                      const Array& argument_names,
+                                      intptr_t type_args_count) {
   ArgumentArray arguments = GetArguments(argument_count);
-  const intptr_t kTypeArgsLen = 0;  // Generic static calls not yet supported.
   StaticCallInstr* call =
-      new (Z) StaticCallInstr(position, target, kTypeArgsLen, argument_names,
+      new (Z) StaticCallInstr(position, target, type_args_count, argument_names,
                               arguments, ic_data_array_, GetNextDeoptId());
   const intptr_t list_cid =
       GetResultCidOfListFactory(Z, target, argument_count);
   if (list_cid != kDynamicCid) {
     call->set_result_cid(list_cid);
     call->set_is_known_list_constructor(true);
   } else if (target.recognized_kind() != MethodRecognizer::kUnknown) {
     call->set_result_cid(MethodRecognizer::ResultCid(target));
   }
   Push(call);
@@ skipping 260 matching lines @@
   Value* value = stack_;
   stack_ = value->next_use();
   if (stack_ != NULL) stack_->set_previous_use(NULL);
 
   value->set_next_use(NULL);
   value->set_previous_use(NULL);
   value->definition()->ClearSSATempIndex();
   return value;
 }
 
+intptr_t FlowGraphBuilder::StackDepth() {

[jensj, 2017/08/11 06:24:55]

I don't think this method is actually used.

[sjindel, 2017/08/11 09:21:06]

It's not -- I found it useful for debugging, so I left it in for others.

[jensj, 2017/08/14 06:47:13]

While that's fine for developing, I don't think we want that in the landed code.
If everyone added unused but 'useful to me'-methods life probably wouldn't be
better.

[sjindel, 2017/08/14 11:05:50]

Done.

+  intptr_t depth = 0;
+  for (Value* value = stack_; value; value = value->next_use()) {
+    ++depth;
+  }
+  return depth;
+}
+
 Fragment FlowGraphBuilder::Drop() {
   ASSERT(stack_ != NULL);
   Fragment instructions;
   Definition* definition = stack_->definition();
   // The SSA renaming implementation doesn't like [LoadLocal]s without a
   // tempindex.
   if (definition->HasSSATemp() || definition->IsLoadLocal()) {
     instructions <<= new (Z) DropTempsInstr(1, NULL);
   } else {
     definition->ClearTempIndex();
@@ skipping 790 matching lines @@
   StreamingFlowGraphBuilder streaming_flow_graph_builder(
       &helper, zone_, script.kernel_data(), script.kernel_data_size());
   return streaming_flow_graph_builder.GetLineStartsFor(
       script.kernel_script_index());
 }
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)