[kernel] const constructor type arguments

runtime/vm/kernel_binary_flowgraph.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 "vm/kernel_binary_flowgraph.h"
 #include "vm/compiler.h"
 #include "vm/longjump.h"
 #include "vm/object_store.h"
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
@@ skipping 2516 matching lines @@
       Function::Handle(Z, H.LookupConstructorByKernelConstructor(target));
   Class& klass = Class::Handle(Z, constructor.Owner());
 
   intptr_t argument_count =
       builder_->ReadUInt();  // read arguments part #1: arguments count.
 
   // Build the type arguments vector (if necessary).
   const TypeArguments* type_arguments =
       TranslateTypeArguments(constructor, &klass);  // read argument types.
 
+  if (klass.NumTypeArguments() > 0 && !klass.IsGeneric()) {

[jensj, 2017/09/04 07:56:42]

This code is basically just a copy-pasta from the non-const case in
StreamingFlowGraphBuilder::BuildConstructorInvocation.

[kustermann, 2017/09/04 10:21:34]

It seems correct, since NumTypeArguments (as opposed to NumTypeParameters)
returns the length of the type argument vector for an instance of [klass].

+    Type& type = Type::ZoneHandle(Z, T.ReceiverType(klass).raw());
+    // TODO(27590): Can we move this code into [ReceiverType]?
+    type ^= ClassFinalizer::FinalizeType(*builder_->active_class()->klass, type,
+                                         ClassFinalizer::kFinalize);
+    ASSERT(!type.IsMalformedOrMalbounded());
+
+    TypeArguments& canonicalized_type_arguments =
+        TypeArguments::ZoneHandle(Z, type.arguments());
+    canonicalized_type_arguments = canonicalized_type_arguments.Canonicalize();
+    type_arguments = &canonicalized_type_arguments;
+  }
+
   // Prepare either the instance or the type argument vector for the constructor
   // call.
   Instance* receiver = NULL;
   const TypeArguments* type_arguments_argument = NULL;
   if (!constructor.IsFactory()) {
     receiver = &Instance::ZoneHandle(Z, Instance::New(klass, Heap::kOld));
     if (type_arguments != NULL) {
       receiver->SetTypeArguments(*type_arguments);
     }
   } else {
@@ skipping 5209 matching lines @@
     }
   }
 
   return Array::Handle(Array::null());
 }
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)