[kernel] vm: Fix a few issues in the kernel flow graph builder, update status file for checked-mode

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>
 #include <set>
 #include <string>
 
 #include "vm/kernel_to_il.h"
 
@@ skipping 4945 matching lines @@
   }
 
   dart::Class& klass = dart::Class::ZoneHandle(
       Z, H.LookupClassByKernelClass(node->target()->EnclosingName()));
 
   Fragment instructions;
 
   // Check for malbounded-ness of type.
   if (I->type_checks()) {
     List<DartType>& kernel_type_arguments = node->arguments()->types();
-    const TypeArguments& type_arguments = T.TranslateInstantiatedTypeArguments(
-        klass, kernel_type_arguments.raw_array(),
-        kernel_type_arguments.length());
+    const TypeArguments& type_arguments = T.TranslateTypeArguments(
+        kernel_type_arguments.raw_array(), kernel_type_arguments.length());
 
     AbstractType& type = AbstractType::Handle(
         Z, Type::New(klass, type_arguments, TokenPosition::kNoSource));
     type = ClassFinalizer::FinalizeType(klass, type);
 
     if (type.IsMalbounded()) {
       // Evaluate expressions for correctness.
       List<Expression>& positional = node->arguments()->positional();
       List<NamedExpression>& named = node->arguments()->named();
       for (intptr_t i = 0; i < positional.length(); ++i) {
@@ skipping 1465 matching lines @@
       return NULL;
     }
 
     Thread* thread = Thread::Current();
     Zone* zone_ = thread->zone();
     TranslationHelper translation_helper(thread);
     DartTypeTranslator type_translator(&translation_helper, NULL, true);
     ConstantEvaluator constant_evaluator(/* flow_graph_builder = */ NULL, Z,
                                          &translation_helper, &type_translator);
 
-
-    intptr_t param_count = function_node->positional_parameters().length() +
-                           function_node->named_parameters().length();
+    const intptr_t positional_count =
+        function_node->positional_parameters().length();
+    const intptr_t param_count =
+        positional_count + function_node->named_parameters().length();
     const Array& param_descriptor = Array::Handle(
         Array::New(param_count * Parser::kParameterEntrySize, Heap::kOld));
     for (intptr_t i = 0; i < param_count; ++i) {
+      const intptr_t entry_start = i * Parser::kParameterEntrySize;
+
       VariableDeclaration* variable;
-      if (i < function_node->positional_parameters().length()) {
+      if (i < positional_count) {
         variable = function_node->positional_parameters()[i];
       } else {
-        variable = function_node->named_parameters()[i];
+        variable = function_node->named_parameters()[i - positional_count];
       }
 
       param_descriptor.SetAt(
-          i + Parser::kParameterIsFinalOffset,
+          entry_start + Parser::kParameterIsFinalOffset,
           variable->IsFinal() ? Bool::True() : Bool::False());
 
       if (variable->initializer() != NULL) {
         param_descriptor.SetAt(
-            i + Parser::kParameterDefaultValueOffset,
+            entry_start + Parser::kParameterDefaultValueOffset,
             constant_evaluator.EvaluateExpression(variable->initializer()));
       } else {
-        param_descriptor.SetAt(i + Parser::kParameterDefaultValueOffset,
-                               Object::null_instance());
+        param_descriptor.SetAt(
+            entry_start + Parser::kParameterDefaultValueOffset,
+            Object::null_instance());
       }
 
-      param_descriptor.SetAt(i + Parser::kParameterMetadataOffset,
+      param_descriptor.SetAt(entry_start + Parser::kParameterMetadataOffset,
                              /* Issue(28434): Missing parameter metadata. */
                              Object::null_instance());
     }
     return param_descriptor.raw();
   } else {
     Thread* thread = Thread::Current();
     Error& error = Error::Handle();
     error = thread->sticky_error();
     thread->clear_sticky_error();
     return error.raw();
   }
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)