[kernel] Change how TypeParameterType is calculated.

runtime/vm/kernel_to_il.h

Index: runtime/vm/kernel_to_il.h
diff --git a/runtime/vm/kernel_to_il.h b/runtime/vm/kernel_to_il.h
index 2c719c2264ea66d86a4442cf872893d0c5b37889..43a589d36c4a5a481ed11fa948dc8eea9c0c6702 100644
--- a/runtime/vm/kernel_to_il.h
+++ b/runtime/vm/kernel_to_il.h
@@ -190,42 +190,60 @@ typedef ZoneGrowableArray<PushArgumentInstr*>* ArgumentArray;
 
 class ActiveClass {
  public:
-  ActiveClass()
-      : kernel_class(NULL),
-        class_type_parameters(0),
-        class_type_parameters_offset_start(-1),
-        klass(NULL),
-        member_is_procedure(false),
-        member_is_factory_procedure(false),
-        member_type_parameters(0),
-        member_type_parameters_offset_start(-1) {}
-
-  // The current enclosing kernel class (if available, otherwise NULL).
-  Class* kernel_class;
-  intptr_t class_type_parameters;
-  intptr_t class_type_parameters_offset_start;
-
-  // The current enclosing class (or the library top-level class).  When this is
-  // a library's top-level class, the kernel_class will be NULL.
+  ActiveClass() : klass(NULL), member(NULL) {}
+
+  bool MemberIsProcedure() {
+    if (member == NULL) return false;

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

This doesn't seem safe.  I think if there is no member it's a mistake to ask if
the member is a procedure.  You might interpret "false" as something like "it's
a Field" and that is a latent bug.

Can we assert member != NULL?

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

I've added as "HasMember" function, and guarded calls with that.

+    RawFunction::Kind function_kind = member->kind();
+    return function_kind == RawFunction::kRegularFunction ||
+           function_kind == RawFunction::kGetterFunction ||
+           function_kind == RawFunction::kSetterFunction ||
+           function_kind == RawFunction::kMethodExtractor ||
+           member->IsFactory();
+  }
+
+  bool MemberIsFactoryProcedure() {
+    if (member == NULL) return false;

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

Likewise, I'm not sure this is safe.

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

As above.

+    return member->IsFactory();
+  }
+
+  intptr_t MemberTypeParameterCount(Zone* zone) {

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

We don't need all this code in the header file, do we?

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

I don't really care - but no, it doesn't have to be in the header file. I've
moved it to the .cc file.

+    if (member == NULL) return 0;
+    RawFunction::Kind function_kind = member->kind();
+    if (member->IsFactory()) {
+      TypeArguments& class_types =
+          dart::TypeArguments::Handle(zone, klass->type_parameters());
+      return class_types.Length();
+    } else if (function_kind == RawFunction::kMethodExtractor) {

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

member->IsMethodExtractor()

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

Done.

+      Function& extracted =
+          Function::Handle(zone, member->extracted_method_closure());
+      TypeArguments& function_types =
+          dart::TypeArguments::Handle(zone, extracted.type_parameters());
+      return function_types.Length();
+    } else {
+      TypeArguments& function_types =
+          dart::TypeArguments::Handle(zone, member->type_parameters());
+      return function_types.Length();
+    }
+  }
+
+  intptr_t ClassTypeParameterCount(Zone* zone) {
+    if (klass == NULL) return 0;
+    TypeArguments& class_types =
+        dart::TypeArguments::Handle(zone, klass->type_parameters());
+    return class_types.Length();
+  }
+
+  // The current enclosing class (or the library top-level class).
   const dart::Class* klass;
 
-  bool member_is_procedure;
-  bool member_is_factory_procedure;
-  intptr_t member_type_parameters;
-  intptr_t member_type_parameters_offset_start;
+  const dart::Function* member;
 };
 
 class ActiveClassScope {
  public:
-  ActiveClassScope(ActiveClass* active_class,
-                   intptr_t class_type_parameters,
-                   intptr_t class_type_parameters_offset_start,
-                   const dart::Class* klass)
+  ActiveClassScope(ActiveClass* active_class, const dart::Class* klass)
       : active_class_(active_class), saved_(*active_class) {
-    active_class_->kernel_class = NULL;
-    active_class_->class_type_parameters = class_type_parameters;
-    active_class_->class_type_parameters_offset_start =
-        class_type_parameters_offset_start;
     active_class_->klass = klass;
   }
 
@@ -238,18 +256,10 @@ class ActiveClassScope {
 
 class ActiveMemberScope {
  public:
-  ActiveMemberScope(ActiveClass* active_class,
-                    bool member_is_procedure,
-                    bool member_is_factory_procedure,
-                    intptr_t member_type_parameters,
-                    intptr_t member_type_parameters_offset_start)
+  ActiveMemberScope(ActiveClass* active_class, const Function* member)
       : active_class_(active_class), saved_(*active_class) {
-    // The class and kernel_class is inherited.
-    active_class_->member_is_procedure = member_is_procedure;
-    active_class_->member_is_factory_procedure = member_is_factory_procedure;
-    active_class_->member_type_parameters = member_type_parameters;
-    active_class_->member_type_parameters_offset_start =
-        member_type_parameters_offset_start;
+    // The class is inherited.
+    active_class_->member = member;
   }
 
   ~ActiveMemberScope() { *active_class_ = saved_; }