[kernel] Change how TypeParameterType is calculated.

runtime/vm/kernel_reader.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_reader.h"
 
 #include <string.h>
 
 #include "vm/dart_api_impl.h"
 #include "vm/kernel_binary.h"
@@ skipping 239 matching lines @@
   library_helper.ReadUntilExcluding(LibraryHelper::kClasses);
 
   // Load all classes.
   int class_count = builder_.ReadListLength();  // read list length.
   for (intptr_t i = 0; i < class_count; ++i) {
     classes.Add(ReadClass(library, toplevel_class), Heap::kOld);
   }
 
   fields_.Clear();
   functions_.Clear();
-  ActiveClassScope active_class_scope(&active_class_, 0, -1, &toplevel_class);
+  ActiveClassScope active_class_scope(&active_class_, &toplevel_class);
   // Load toplevel fields.
   intptr_t field_count = builder_.ReadListLength();  // read list length.
   for (intptr_t i = 0; i < field_count; ++i) {
     intptr_t field_offset = builder_.ReaderOffset();
-    ActiveMemberScope active_member_scope(&active_class_, false, false, 0, -1);
+    ActiveMemberScope active_member_scope(&active_class_, NULL);
     FieldHelper field_helper(&builder_);
     field_helper.ReadUntilExcluding(FieldHelper::kName);
 
     const dart::String& name = builder_.ReadNameAsFieldName();
     field_helper.SetJustRead(FieldHelper::kName);
     field_helper.ReadUntilExcluding(FieldHelper::kType);
     const Object& script_class =
         ClassForScriptAt(toplevel_class, field_helper.source_uri_index_);
     dart::Field& field = dart::Field::Handle(
         Z, dart::Field::NewTopLevel(name, field_helper.IsFinal(),
@@ skipping 27 matching lines @@
 }
 
 void KernelReader::ReadPreliminaryClass(dart::Class* klass,
                                         ClassHelper* class_helper,
                                         intptr_t type_parameter_count) {
   // Note: This assumes that ClassHelper is exactly at the position where
   // the length of the type parameters have been read, and that the order in
   // the binary is as follows: [...], kTypeParameters, kSuperClass, kMixinType,
   // kImplementedClasses, [...].
 
-  // First setup the type parameters, so if any of the following code uses it
-  // (in a recursive way) we're fine.
-  TypeArguments& type_parameters =
-      TypeArguments::Handle(Z, TypeArguments::null());
-  if (type_parameter_count > 0) {
-    dart::TypeParameter& parameter = dart::TypeParameter::Handle(Z);
-    Type& null_bound = Type::Handle(Z, Type::null());
-
-    // Step a) Create array of [TypeParameter] objects (without bound).
-    type_parameters = TypeArguments::New(type_parameter_count);
-    {
-      AlternativeReadingScope alt(builder_.reader_);
-      for (intptr_t i = 0; i < type_parameter_count; i++) {
-        parameter = dart::TypeParameter::New(
-            *klass, Function::Handle(Z), i,
-            H.DartSymbol(
-                builder_.ReadStringReference()),  // read ith name index.
-            null_bound, TokenPosition::kNoSource);
-        type_parameters.SetTypeAt(i, parameter);
-        builder_.SkipDartType();  // read guard.
-      }
-    }
-    klass->set_type_parameters(type_parameters);
-
-    // Step b) Fill in the bounds of all [TypeParameter]s.
-    for (intptr_t i = 0; i < type_parameter_count; i++) {
-      builder_.SkipStringReference();  // read ith name index.
-
-      // TODO(github.com/dart-lang/kernel/issues/42): This should be handled
-      // by the frontend.
-      parameter ^= type_parameters.TypeAt(i);
-      Tag tag = builder_.PeekTag();  // peek ith bound type.
-      if (tag == kDynamicType) {
-        builder_.SkipDartType();  // read ith bound.
-        parameter.set_bound(Type::Handle(Z, I->object_store()->object_type()));
-      } else {
-        AbstractType& bound =
-            T.BuildTypeWithoutFinalization();  // read ith bound.
-        if (bound.IsMalformedOrMalbounded()) {
-          bound = I->object_store()->object_type();
-        }
-        parameter.set_bound(bound);
-      }
-    }
-  }
+  // Set type parameters.
+  ReadAndSetupTypeParameters(klass, type_parameter_count, *klass,
+                             Function::Handle(Z));
 
   // Set super type.  Some classes (e.g., Object) do not have one.
   Tag type_tag = builder_.ReadTag();  // read super class type (part 1).
   if (type_tag == kSomething) {
     AbstractType& super_type =
         T.BuildTypeWithoutFinalization();  // read super class type (part 2).
     if (super_type.IsMalformed()) H.ReportError("Malformed super type");
     klass->set_super_type(super_type);
   }
 
@@ skipping 29 matching lines @@
   if (klass.script() == Script::null()) {
     class_helper.ReadUntilIncluding(ClassHelper::kSourceUriIndex);
     klass.set_script(ScriptAt(class_helper.source_uri_index_));
   }
   if (klass.token_pos() == TokenPosition::kNoSource) {
     class_helper.ReadUntilIncluding(ClassHelper::kPosition);
     klass.set_token_pos(class_helper.position_);
   }
 
   class_helper.ReadUntilExcluding(ClassHelper::kTypeParameters);
-  intptr_t type_paremeter_counts =
+  intptr_t type_parameter_counts =
       builder_.ReadListLength();  // read type_parameters list length.
-  intptr_t type_paremeter_offset = builder_.ReaderOffset();
 
-  ActiveClassScope active_class_scope(&active_class_, type_paremeter_counts,
-                                      type_paremeter_offset, &klass);
+  ActiveClassScope active_class_scope(&active_class_, &klass);
   if (!klass.is_cycle_free()) {
-    ReadPreliminaryClass(&klass, &class_helper, type_paremeter_counts);
+    ReadPreliminaryClass(&klass, &class_helper, type_parameter_counts);
   } else {
-    for (intptr_t i = 0; i < type_paremeter_counts; ++i) {
+    for (intptr_t i = 0; i < type_parameter_counts; ++i) {
       builder_.SkipStringReference();  // read ith name index.
       builder_.SkipDartType();         // read ith bound.
     }
     class_helper.SetJustRead(ClassHelper::kTypeParameters);
   }
 
   fields_.Clear();
   functions_.Clear();
 
   if (library.raw() == dart::Library::InternalLibrary() &&
       klass.Name() == Symbols::ClassID().raw()) {
     // If this is a dart:internal.ClassID class ignore field declarations
     // contained in the Kernel file and instead inject our own const
     // fields.
     klass.InjectCIDFields();
   } else {
     class_helper.ReadUntilExcluding(ClassHelper::kFields);
     int field_count = builder_.ReadListLength();  // read list length.
     for (intptr_t i = 0; i < field_count; ++i) {
       intptr_t field_offset = builder_.ReaderOffset();
-      ActiveMemberScope active_member(&active_class_, false, false, 0, -1);
+      ActiveMemberScope active_member(&active_class_, NULL);
       FieldHelper field_helper(&builder_);
       field_helper.ReadUntilExcluding(FieldHelper::kName);
 
       const dart::String& name = builder_.ReadNameAsFieldName();
       field_helper.SetJustRead(FieldHelper::kName);
       field_helper.ReadUntilExcluding(FieldHelper::kType);
       const AbstractType& type =
           T.BuildTypeWithoutFinalization();  // read type.
       field_helper.SetJustRead(FieldHelper::kType);
       const Object& script_class =
@@ skipping 22 matching lines @@
       fields_.Add(&field);
     }
     klass.AddFields(fields_);
     class_helper.SetJustRead(ClassHelper::kFields);
   }
 
   class_helper.ReadUntilExcluding(ClassHelper::kConstructors);
   int constructor_count = builder_.ReadListLength();  // read list length.
   for (intptr_t i = 0; i < constructor_count; ++i) {
     intptr_t constructor_offset = builder_.ReaderOffset();
-    ActiveMemberScope active_member_scope(&active_class_, false, false, 0, -1);
+    ActiveMemberScope active_member_scope(&active_class_, NULL);
     ConstructorHelper constructor_helper(&builder_);
     constructor_helper.ReadUntilExcluding(ConstructorHelper::kFunction);
 
     const dart::String& name =
         H.DartConstructorName(constructor_helper.canonical_name_);
     Function& function = dart::Function::ZoneHandle(
         Z, dart::Function::New(name, RawFunction::kConstructor,
                                false,  // is_static
                                constructor_helper.IsConst(),
                                false,  // is_abstract
@@ skipping 45 matching lines @@
 
   return klass;
 }
 
 void KernelReader::ReadProcedure(const dart::Library& library,
                                  const dart::Class& owner,
                                  bool in_class) {
   intptr_t procedure_offset = builder_.ReaderOffset();
   ProcedureHelper procedure_helper(&builder_);
 
-  bool member_is_procedure = false;
-  bool is_factory_procedure = false;
-  intptr_t member_type_parameters = 0;
-  intptr_t member_type_parameters_offset_start = -1;
-  builder_.GetTypeParameterInfoForPossibleProcedure(
-      builder_.ReaderOffset(), &member_is_procedure, &is_factory_procedure,
-      &member_type_parameters, &member_type_parameters_offset_start);
-
-  ActiveMemberScope active_member(&active_class_, member_is_procedure,
-                                  is_factory_procedure, member_type_parameters,
-                                  member_type_parameters_offset_start);
-
   procedure_helper.ReadUntilExcluding(ProcedureHelper::kAnnotations);
   const dart::String& name =
       H.DartProcedureName(procedure_helper.canonical_name_);
   bool is_method = in_class && !procedure_helper.IsStatic();
   bool is_abstract = procedure_helper.IsAbstract();
   bool is_external = procedure_helper.IsExternal();
   dart::String* native_name = NULL;
   intptr_t annotation_count;
   if (is_external) {
     // Maybe it has a native implementation, which is not external as far as
@@ skipping 59 matching lines @@
       Z, Function::New(name, GetFunctionType(procedure_helper.kind_),
                        !is_method,  // is_static
                        false,       // is_const
                        is_abstract, is_external,
                        native_name != NULL,  // is_native
                        script_class, procedure_helper.position_));
   function.set_end_token_pos(procedure_helper.end_position_);
   functions_.Add(&function);
   function.set_kernel_offset(procedure_offset);
 
+  ActiveMemberScope active_member(&active_class_, &function);
+
   procedure_helper.ReadUntilExcluding(ProcedureHelper::kFunction);
   Tag function_node_tag = builder_.ReadTag();
   ASSERT(function_node_tag == kSomething);
   FunctionNodeHelper function_node_helper(&builder_);
   function_node_helper.ReadUntilIncluding(FunctionNodeHelper::kDartAsyncMarker);
   function.set_is_debuggable(function_node_helper.dart_async_marker_ ==
                              FunctionNode::kSync);
   switch (function_node_helper.dart_async_marker_) {
     case FunctionNode::kSyncStar:
       function.set_modifier(RawFunction::kSyncGen);
       break;
     case FunctionNode::kAsync:
       function.set_modifier(RawFunction::kAsync);
       function.set_is_inlinable(!FLAG_causal_async_stacks);
       break;
     case FunctionNode::kAsyncStar:
       function.set_modifier(RawFunction::kAsyncGen);
       function.set_is_inlinable(!FLAG_causal_async_stacks);
       break;
     default:
       // no special modifier
       break;
   }
   ASSERT(function_node_helper.async_marker_ == FunctionNode::kSync);
 
   if (native_name != NULL) {
     function.set_native_name(*native_name);
   }
 
+  function_node_helper.ReadUntilExcluding(FunctionNodeHelper::kTypeParameters);
+  if (!function.IsFactory()) {
+    // Read type_parameters list length.
+    intptr_t type_parameter_count = builder_.ReadListLength();
+    // Set type parameters.
+    ReadAndSetupTypeParameters(&function, type_parameter_count,
+                               Class::Handle(Z), function);
+    function_node_helper.SetJustRead(FunctionNodeHelper::kTypeParameters);
+  }
+
   function_node_helper.ReadUntilExcluding(
       FunctionNodeHelper::kRequiredParameterCount);
   builder_.SetupFunctionParameters(owner, function, is_method,
                                    false,  // is_closure
                                    &function_node_helper);
   function_node_helper.ReadUntilExcluding(FunctionNodeHelper::kEnd);
   procedure_helper.SetJustRead(ProcedureHelper::kFunction);
 
   if (!in_class) {
     library.AddObject(function, name);
     ASSERT(!Object::Handle(
                 Z, library.LookupObjectAllowPrivate(
                        H.DartProcedureName(procedure_helper.canonical_name_)))
                 .IsNull());
   }
   if (FLAG_enable_mirrors && annotation_count > 0) {
     library.AddFunctionMetadata(function, TokenPosition::kNoSource,
                                 procedure_offset);
   }
 
   procedure_helper.ReadUntilExcluding(ProcedureHelper::kEnd);
 }
 
+template <typename U>
+void KernelReader::ReadAndSetupTypeParameters(
+    U* set_on,
+    intptr_t type_parameter_count,
+    const Class& parameterized_class,
+    const Function& parameterized_function) {
+  if (type_parameter_count > 0) {
+    // First setup the type parameters, so if any of the following code uses it
+    // (in a recursive way) we're fine.
+    TypeArguments& type_parameters =
+        TypeArguments::Handle(Z, TypeArguments::null());
+    dart::TypeParameter& parameter = dart::TypeParameter::Handle(Z);
+    Type& null_bound = Type::Handle(Z, Type::null());
+
+    // Step a) Create array of [TypeParameter] objects (without bound).
+    type_parameters = TypeArguments::New(type_parameter_count);
+    {
+      AlternativeReadingScope alt(builder_.reader_);
+      for (intptr_t i = 0; i < type_parameter_count; i++) {
+        parameter = dart::TypeParameter::New(
+            parameterized_class, parameterized_function, i,
+            H.DartSymbol(
+                builder_.ReadStringReference()),  // read ith name index.
+            null_bound, TokenPosition::kNoSource);
+        type_parameters.SetTypeAt(i, parameter);
+        builder_.SkipDartType();  // read guard.
+      }
+    }
+    set_on->set_type_parameters(type_parameters);

[Kevin Millikin (Google), 2017/08/08 14:08:51]

Having two different template instantiations of this function seems unnecessary.
 I suggest passing a const Object& and using something like:

ASSERT(set_on.IsClass() || set_on.IsFunction());
if (set_on.IsClass()) {
  Class::Cast(set_on).set_type_parameters...
} else {
  Function::Cast(set_on).set...
}

[jensj, 2017/08/09 08:39:47]

Done.

+
+    // Step b) Fill in the bounds of all [TypeParameter]s.
+    for (intptr_t i = 0; i < type_parameter_count; i++) {
+      builder_.SkipStringReference();  // read ith name index.
+
+      // TODO(github.com/dart-lang/kernel/issues/42): This should be handled
+      // by the frontend.
+      parameter ^= type_parameters.TypeAt(i);
+      Tag tag = builder_.PeekTag();  // peek ith bound type.
+      if (tag == kDynamicType) {
+        builder_.SkipDartType();  // read ith bound.
+        parameter.set_bound(Type::Handle(Z, I->object_store()->object_type()));
+      } else {
+        AbstractType& bound =
+            T.BuildTypeWithoutFinalization();  // read ith bound.
+        if (bound.IsMalformedOrMalbounded()) {
+          bound = I->object_store()->object_type();
+        }
+        parameter.set_bound(bound);
+      }
+    }
+  }
+}
+
 const Object& KernelReader::ClassForScriptAt(const dart::Class& klass,
                                              intptr_t source_uri_index) {
   Script& correct_script = ScriptAt(source_uri_index);
   if (klass.script() != correct_script.raw()) {
     // TODO(jensj): We could probably cache this so we don't create
     // new PatchClasses all the time
     return PatchClass::ZoneHandle(Z, PatchClass::New(klass, correct_script));
   }
   return klass;
 }
@@ skipping 234 matching lines @@
   initializer_fun.set_result_type(AbstractType::Handle(zone, field.type()));
   initializer_fun.set_is_debuggable(false);
   initializer_fun.set_is_reflectable(false);
   initializer_fun.set_is_inlinable(false);
   return new (zone) ParsedFunction(thread, initializer_fun);
 }
 
 }  // namespace kernel
 }  // namespace dart
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)