[NFC] Infrastructure to avoid storing simple generic params in metadata

The vast majority of generic parameters follow a simple pattern
(type parameter that defines a key argument), which we can take
advantage of to avoid actually representing them in type metadata:
if all the type arguments is the simple pattern, and there's not
more than some preset number, simply use a pre-allocated array in
the runtime.

Actually doing this for generic types will require some care around
back-deployment, as well as finding a bit to store that we've done
it.  But we can at least start doing this for new ABI, such as the
extended existential shape descriptors.

Author: rjmccall

include/swift/ABI/MetadataValues.h

@@ -24,6 +24,7 @@
 #include "swift/AST/Ownership.h"
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/FlagSet.h"
+#include "llvm/ADT/ArrayRef.h"
 
 #include <stdlib.h>
 #include <stdint.h>
@@ -55,6 +56,10 @@ enum {
 
   /// The number of words in an AsyncLet (flags + child task context & allocation)
   NumWords_AsyncLet = 80, // 640 bytes ought to be enough for anyone
+
+  /// The maximum number of generic parameters that can be
+  /// implicitly declared, for generic signatures that support that.
+  MaxNumImplicitGenericParamDescriptors = 64,
 };
 
 struct InProcess;
@@ -1652,8 +1657,40 @@ class GenericParamDescriptor {
   constexpr uint8_t getIntValue() const {
     return Value;
   }
+
+  friend bool operator==(GenericParamDescriptor lhs,
+                         GenericParamDescriptor rhs) {
+    return lhs.getIntValue() == rhs.getIntValue();
+  }
+  friend bool operator!=(GenericParamDescriptor lhs,
+                         GenericParamDescriptor rhs) {
+    return !(lhs == rhs);
+  }
+
+  /// The default parameter descriptor for an implicit parameter.
+  static constexpr GenericParamDescriptor implicit() {
+    return GenericParamDescriptor(GenericParamKind::Type,
+                                  /*key argument*/ true,
+                                  /*extra argument*/ false);
+  }
 };
 
+/// Can the given generic parameter array be implicit, for places in
+/// the ABI which support that?
+inline bool canGenericParamsBeImplicit(
+                            llvm::ArrayRef<GenericParamDescriptor> params) {
+  // If there are more parameters than the maximum, they cannot be implicit.
+  if (params.size() > MaxNumImplicitGenericParamDescriptors)
+    return false;
+
+  // If any parameter is not the implicit pattern, they cannot be implicit.
+  for (auto param : params)
+    if (param != GenericParamDescriptor::implicit())
+      return false;
+
+  return true;
+}
+
 enum class GenericRequirementKind : uint8_t {
   /// A protocol requirement.
   Protocol = 0,