Pass a second type argument vector to all type instantiation calls in the VM.

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 <map>

[zra, 2017/04/07 17:36:31]

It looks like this is not used.

[regis, 2017/04/11 04:23:08]

Removed

 #include <set>
 #include <string>

[zra, 2017/04/07 17:36:31]

ditto

[regis, 2017/04/11 04:23:08]

I can compile with <string> removed, but git cl upload complains. I put it back.

 
 #include "vm/kernel_to_il.h"
 
 #include "vm/compiler.h"
 #include "vm/intermediate_language.h"
 #include "vm/kernel_reader.h"
 #include "vm/kernel_binary_flowgraph.h"
 #include "vm/longjump.h"
 #include "vm/method_recognizer.h"
 #include "vm/object_store.h"
@@ skipping 2129 matching lines @@
 
     instructions += LoadLocal(scopes_->this_variable);
     instructions += LoadField(type_arguments_field_offset);
   } else {
     instructions += NullConstant();
   }
   return instructions;
 }
 
 
+Fragment FlowGraphBuilder::LoadFunctionTypeArguments() {
+  UNIMPLEMENTED();  // TODO(regis)
+  return Fragment(NULL);
+}
+
+
 Fragment FlowGraphBuilder::InstantiateType(const AbstractType& type) {
-  InstantiateTypeInstr* instr = new (Z)
-      InstantiateTypeInstr(TokenPosition::kNoSource, type, Pop(),
-                           NULL);  // TODO(regis): Pop function type arguments.
+  Value* function_type_args = Pop();
+  Value* instantiator_type_args = Pop();
+  InstantiateTypeInstr* instr =
+      new (Z) InstantiateTypeInstr(TokenPosition::kNoSource, type,
+                                   instantiator_type_args, function_type_args);
   Push(instr);
   return Fragment(instr);
 }
 
 
 Fragment FlowGraphBuilder::InstantiateTypeArguments(
     const TypeArguments& type_arguments) {
+  Value* function_type_args = Pop();
+  Value* instantiator_type_args = Pop();
   InstantiateTypeArgumentsInstr* instr = new (Z) InstantiateTypeArgumentsInstr(
-      TokenPosition::kNoSource, type_arguments, *active_class_.klass, Pop(),
-      NULL);  // TODO(regis): Pop function type arguments.
+      TokenPosition::kNoSource, type_arguments, *active_class_.klass,
+      instantiator_type_args, function_type_args);
   Push(instr);
   return Fragment(instr);
 }
 
 
 Fragment FlowGraphBuilder::TranslateInstantiatedTypeArguments(
     const TypeArguments& type_arguments) {
   Fragment instructions;
 
   if (type_arguments.IsNull() || type_arguments.IsInstantiated()) {
@@ skipping 12 matching lines @@
       // This is for example the case here:
       //     class Foo<T> {
       //       newList() => new List<T>();
       //     }
       // We just use the type argument vector from the [Foo] object and pass it
       // directly to the `new List<T>()` factory constructor.
       instructions += LoadInstantiatorTypeArguments();
     } else {
       // Otherwise we need to resolve [TypeParameterType]s in the type
       // expression based on the current instantiator type argument vector.
-      instructions += LoadInstantiatorTypeArguments();
+      if (!type_arguments.IsInstantiated(kCurrentClass)) {
+        instructions += LoadInstantiatorTypeArguments();
+      } else {
+        instructions += NullConstant();
+      }
+      if (!type_arguments.IsInstantiated(kCurrentFunction)) {
+        instructions += LoadFunctionTypeArguments();
+      } else {
+        instructions += NullConstant();
+      }
       instructions += InstantiateTypeArguments(type_arguments);
     }
   }
   return instructions;
 }
 
 
 Fragment FlowGraphBuilder::AllocateContext(int size) {
   AllocateContextInstr* allocate =
       new (Z) AllocateContextInstr(TokenPosition::kNoSource, size);
@@ skipping 1593 matching lines @@
   Push(instr);
   return Fragment(instr);
 }
 
 
 Fragment FlowGraphBuilder::AssertAssignable(const dart::AbstractType& dst_type,
                                             const dart::String& dst_name) {
   Fragment instructions;
   Value* value = Pop();
 
-  instructions += LoadInstantiatorTypeArguments();
-  Value* type_args = Pop();
+  if (!dst_type.IsInstantiated(kCurrentClass)) {
+    instructions += LoadInstantiatorTypeArguments();
+  } else {
+    instructions += NullConstant();
+  }
+  Value* instantiator_type_args = Pop();
 
-  AssertAssignableInstr* instr = new (Z)
-      AssertAssignableInstr(TokenPosition::kNoSource, value, type_args,
-                            NULL,  // TODO(regis): Pop function type arguments.
-                            dst_type, dst_name, H.thread()->GetNextDeoptId());
+  if (!dst_type.IsInstantiated(kCurrentFunction)) {
+    instructions += LoadFunctionTypeArguments();
+  } else {
+    instructions += NullConstant();
+  }
+  Value* function_type_args = Pop();
+
+  AssertAssignableInstr* instr = new (Z) AssertAssignableInstr(
+      TokenPosition::kNoSource, value, instantiator_type_args,
+      function_type_args, dst_type, dst_name, H.thread()->GetNextDeoptId());
   Push(instr);
 
   instructions += Fragment(instr);
 
   return instructions;
 }
 
 
 FlowGraph* FlowGraphBuilder::BuildGraphOfMethodExtractor(
     const Function& method) {
@@ skipping 814 matching lines @@
 
 
 void FlowGraphBuilder::VisitTypeLiteral(TypeLiteral* node) {
   const AbstractType& type = T.TranslateType(node->type());
   if (type.IsMalformed()) H.ReportError("Malformed type literal");
 
   Fragment instructions;
   if (type.IsInstantiated()) {
     instructions += Constant(type);
   } else {
-    instructions += LoadInstantiatorTypeArguments();
+    if (!type.IsInstantiated(kCurrentClass)) {
+      instructions += LoadInstantiatorTypeArguments();
+    } else {
+      instructions += NullConstant();
+    }
+    if (!type.IsInstantiated(kCurrentFunction)) {
+      instructions += LoadFunctionTypeArguments();
+    } else {
+      instructions += NullConstant();
+    }
     instructions += InstantiateType(type);
   }
   fragment_ = instructions;
 }
 
 
 void FlowGraphBuilder::VisitVariableGet(VariableGet* node) {
   fragment_ = LoadLocal(LookupVariable(node->variable()));
 }
 
@@ skipping 405 matching lines @@
       instructions += Constant(type);
       instructions += PushArgument();  // Type.
       instructions += InstanceCall(
           node->position(),
           dart::Library::PrivateCoreLibName(Symbols::_simpleInstanceOf()),
           Token::kIS, 2, 2);  // 2 checked arguments.
       fragment_ = instructions;
       return;
     }
 
-    if (!type.IsInstantiated()) {
+    if (!type.IsInstantiated(kCurrentClass)) {
       instructions += LoadInstantiatorTypeArguments();
     } else {
       instructions += NullConstant();
     }
-    instructions += PushArgument();  // Type arguments.
+    instructions += PushArgument();  // Instantiator type arguments.
+
+    if (!type.IsInstantiated(kCurrentFunction)) {
+      instructions += LoadFunctionTypeArguments();
+    } else {
+      instructions += NullConstant();
+    }
+    instructions += PushArgument();  // Function type arguments.
 
     instructions += Constant(type);
     instructions += PushArgument();  // Type.
 
     instructions +=
         InstanceCall(node->position(),
                      dart::Library::PrivateCoreLibName(Symbols::_instanceOf()),
-                     Token::kIS, 3);
+                     Token::kIS, 4);
   }
 
   fragment_ = instructions;
 }
 
 
 void FlowGraphBuilder::VisitAsExpression(AsExpression* node) {
   Fragment instructions = TranslateExpression(node->operand());
 
   // The VM does not like an Object_as call with a dynamic type. We need to
   // special case this situation.
   const Type& object_type = Type::Handle(Z, Type::ObjectType());
   const AbstractType& type = T.TranslateType(node->type());
   if (type.IsMalformed()) {
     instructions += Drop();
     instructions += ThrowTypeError();
     fragment_ = instructions;
     return;
   }
 
   if (type.IsInstantiated() &&
       object_type.IsSubtypeOf(type, NULL, NULL, Heap::kOld)) {
     // We already evaluated the operand on the left and just leave it there as
     // the result of the `obj as dynamic` expression.
   } else {
     instructions += PushArgument();
 
-    if (!type.IsInstantiated()) {
+    if (!type.IsInstantiated(kCurrentClass)) {
       instructions += LoadInstantiatorTypeArguments();
     } else {
       instructions += NullConstant();
     }
-    instructions += PushArgument();  // Type arguments.
+    instructions += PushArgument();  // Instantiator type arguments.
+
+    if (!type.IsInstantiated(kCurrentFunction)) {
+      instructions += LoadFunctionTypeArguments();
+    } else {
+      instructions += NullConstant();
+    }
+    instructions += PushArgument();  // Function type arguments.
 
     instructions += Constant(type);
     instructions += PushArgument();  // Type.
 
     instructions += InstanceCall(
         node->position(), dart::Library::PrivateCoreLibName(Symbols::_as()),
-        Token::kAS, 3);
+        Token::kAS, 4);
   }
 
   fragment_ = instructions;
 }
 
 
 void FlowGraphBuilder::VisitConditionalExpression(ConditionalExpression* node) {
   bool negate;
   Fragment instructions = TranslateCondition(node->condition(), &negate);
 
@@ skipping 1020 matching lines @@
     }
 
     if (type_guard != NULL) {
       if (type_guard->IsMalformed()) {
         catch_body += ThrowTypeError();
         catch_body += Drop();
       } else {
         catch_body += LoadLocal(CurrentException());
         catch_body += PushArgument();  // exception
         catch_body += NullConstant();
-        catch_body += PushArgument();  // type arguments
+        catch_body += PushArgument();  // instantiator type arguments
+        catch_body += NullConstant();
+        catch_body += PushArgument();  // function type arguments
         catch_body += Constant(*type_guard);
         catch_body += PushArgument();  // guard type
         catch_body += InstanceCall(
             TokenPosition::kNoSource,
             dart::Library::PrivateCoreLibName(Symbols::_instanceOf()),
-            Token::kIS, 3);
+            Token::kIS, 4);
 
         TargetEntryInstr* catch_entry;
         TargetEntryInstr* next_catch_entry;
         catch_body += BranchIfTrue(&catch_entry, &next_catch_entry);
 
         Fragment(catch_entry) + catch_handler_body;
         catch_body = Fragment(next_catch_entry);
       }
     } else {
       catch_body += catch_handler_body;
@@ skipping 308 matching lines @@
     thread->clear_sticky_error();
     return error.raw();
   }
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)