[kernel] Fix loss of supertype 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"
 
@@ skipping 1666 matching lines @@
   }
 
   UNREACHABLE();
 }
 
 const TypeArguments& StreamingDartTypeTranslator::BuildTypeArguments(
     intptr_t length) {
   bool only_dynamic = true;
   intptr_t offset = builder_->ReaderOffset();
   for (intptr_t i = 0; i < length; ++i) {
     if (builder_->ReadTag() != kDynamicType) {  // read ith type's tag.

[Kevin Millikin (Google), 2017/06/21 06:43:42]

Format comments as if they were sentences.  Capitalize the first word.

       only_dynamic = false;
       builder_->SetOffset(offset);
       break;
     }
   }
   TypeArguments& type_arguments = TypeArguments::ZoneHandle(Z);
   if (!only_dynamic) {
     type_arguments = TypeArguments::New(length);
     for (intptr_t i = 0; i < length; ++i) {
       BuildTypeInternal();  // read ith type.
-      if (!result_.IsDynamicType()) {
-        only_dynamic = false;
-      }
       if (result_.IsMalformed()) {
         type_arguments = TypeArguments::null();
         // skip rest of arguments.

[Kevin Millikin (Google), 2017/06/21 06:43:42]

'skip rest of' ==> 'Skip the rest of the'.

         for (++i; i < length; ++i) {
           builder_->SkipDartType();
         }
         return type_arguments;
       }
       type_arguments.SetTypeAt(i, result_);
     }
 
     if (finalize_) {
       type_arguments = type_arguments.Canonicalize();
     }
   }
   return type_arguments;
 }
 
 const TypeArguments&
 StreamingDartTypeTranslator::BuildInstantiatedTypeArguments(
     const dart::Class& receiver_class,
     intptr_t length) {
   const TypeArguments& type_arguments = BuildTypeArguments(length);
-  if (type_arguments.IsNull()) return type_arguments;
+
+  // If type_arguments is null all arguments are dynamic.
+  // If, however, this class doesn't specify all the type arguments directly we
+  // still need to finalize the type below in order to get any non-dynamic types
+  // from any super. See http://www.dartbug.com/29537.
+  if (type_arguments.IsNull() && receiver_class.NumTypeArguments() == length) {
+    return type_arguments;
+  }
 
   // We make a temporary [Type] object and use `ClassFinalizer::FinalizeType` to
   // finalize the argument types.
   // (This can for example make the [type_arguments] vector larger)
   Type& type = Type::Handle(
       Z, Type::New(receiver_class, type_arguments, TokenPosition::kNoSource));
   if (finalize_) {
     type ^= ClassFinalizer::FinalizeType(*active_class_->klass, type);
   }
 
@@ skipping 3578 matching lines @@
       instructions += ThrowTypeError();
 
       // Bail out early.
       return instructions;
     }
 
     SetOffset(offset);
   }
 
   if (klass.NumTypeArguments() > 0) {
-    const TypeArguments& type_arguments = PeekArgumentsInstantiatedType(klass);
     if (!klass.IsGeneric()) {
       Type& type = Type::ZoneHandle(Z, T.ReceiverType(klass).raw());
 
       // TODO(27590): Can we move this code into [ReceiverType]?
       type ^= ClassFinalizer::FinalizeType(*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();
       instructions += Constant(canonicalized_type_arguments);
     } else {
+      const TypeArguments& type_arguments =
+          PeekArgumentsInstantiatedType(klass);
       instructions += TranslateInstantiatedTypeArguments(type_arguments);
     }
 
     instructions += PushArgument();
     instructions += AllocateObject(klass, 1);
   } else {
     instructions += AllocateObject(klass, 0);
   }
   LocalVariable* variable = MakeTemporary();
 
@@ skipping 1802 matching lines @@
     metadata_values.SetAt(i, value);
   }
 
   return metadata_values.raw();
 }
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)