[kernel] Change how TypeParameterType is calculated.

runtime/vm/kernel_to_il.h

 // 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.
 
 #ifndef RUNTIME_VM_KERNEL_TO_IL_H_
 #define RUNTIME_VM_KERNEL_TO_IL_H_
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 
 #include "vm/growable_array.h"
@@ skipping 172 matching lines @@
   Fragment closed();
 };
 
 Fragment operator+(const Fragment& first, const Fragment& second);
 Fragment operator<<(const Fragment& fragment, Instruction* next);
 
 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) {}
+  ActiveClass() : klass(NULL), member(NULL) {}
 
-  // The current enclosing kernel class (if available, otherwise NULL).
-  Class* kernel_class;
-  intptr_t class_type_parameters;
-  intptr_t class_type_parameters_offset_start;
+  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();
+  }
 
-  // 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.
+  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;
   }
 
   ~ActiveClassScope() { *active_class_ = saved_; }
 
  private:
   ActiveClass* active_class_;
   ActiveClass saved_;
 };
 
 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_; }
 
  private:
   ActiveClass* active_class_;
   ActiveClass saved_;
 };
 
 class TranslationHelper {
@@ skipping 690 matching lines @@
 namespace kernel {
 
 RawObject* EvaluateMetadata(const dart::Field& metadata_field);
 RawObject* BuildParameterDescriptor(const Function& function);
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 #endif  // RUNTIME_VM_KERNEL_TO_IL_H_