Swift SIL: deal with a generic self type in SubstitutionMap.getMethodSubstitutions

If the method is a default witness methods (`selfType` != nil) it has generic self type.
In this case the generic self parameter is at depth 0 and the actual generic parameters of the substitution map are at depth + 1, e.g:
```
    @convention(witness_method: P) <τ_0_0><τ_1_0 where τ_0_0 : GenClass<τ_1_0>.T>
                                      ^      ^
                                   self      params of substitution map at depth + 1
```

Author: eeckstein

SwiftCompilerSources/Sources/SIL/ASTExtensions.swift

@@ -50,8 +50,19 @@ extension ClassDecl {
 }
 
 extension SubstitutionMap {
-  public func getMethodSubstitutions(for method: Function) -> SubstitutionMap {
-    return SubstitutionMap(bridged: method.bridged.getMethodSubstitutions(bridged))
+  /// Returns the substitutions to specialize a method.
+  ///
+  /// If this is a default witness methods (`selfType` != nil) it has generic self type. In this case
+  /// the generic self parameter is at depth 0 and the actual generic parameters of the substitution map
+  /// are at depth + 1, e.g:
+  /// ```
+  ///     @convention(witness_method: P) <τ_0_0><τ_1_0 where τ_0_0 : GenClass<τ_1_0>.T>
+  ///                                       ^      ^
+  ///                                    self      params of substitution map at depth + 1
+  /// ```
+  public func getMethodSubstitutions(for method: Function, selfType: CanonicalType? = nil) -> SubstitutionMap {
+    return SubstitutionMap(bridged: method.bridged.getMethodSubstitutions(bridged,
+                                                                          selfType?.bridged ?? BridgedCanType()))
   }
 }
 

include/swift/AST/ASTBridging.h

@@ -3123,6 +3123,7 @@ class BridgedCanType {
   swift::TypeBase * _Nullable type;
 
 public:
+  BRIDGED_INLINE BridgedCanType();
   BRIDGED_INLINE BridgedCanType(swift::CanType ty);
   BRIDGED_INLINE swift::CanType unbridged() const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedASTType getRawType() const;

include/swift/AST/ASTBridgingImpl.h

@@ -623,6 +623,9 @@ static_assert((int)BridgedASTType::MetatypeRepresentation::ObjC == (int)swift::M
 // MARK: BridgedCanType
 //===----------------------------------------------------------------------===//
 
+BridgedCanType::BridgedCanType() : type(nullptr) {
+}
+
 BridgedCanType::BridgedCanType(swift::CanType ty) : type(ty.getPointer()) {
 }
 

include/swift/SIL/SILBridging.h

@@ -516,7 +516,8 @@ struct BridgedFunction {
   bool isConvertPointerToPointerArgument() const;
   bool isAutodiffVJP() const;
   SwiftInt specializationLevel() const;
-  SWIFT_IMPORT_UNSAFE BridgedSubstitutionMap getMethodSubstitutions(BridgedSubstitutionMap contextSubs) const;
+  SWIFT_IMPORT_UNSAFE BridgedSubstitutionMap getMethodSubstitutions(BridgedSubstitutionMap contextSubs,
+                                                                    BridgedCanType selfType) const;
   BRIDGED_INLINE OptionalSourceFileKind getSourceFileKind() const;
 
   enum class ParseEffectsMode {

lib/SIL/Utils/SILBridging.cpp

@@ -197,15 +197,44 @@ BridgedOwnedString BridgedFunction::getDebugDescription() const {
   return BridgedOwnedString(str);
 }
 
-BridgedSubstitutionMap BridgedFunction::getMethodSubstitutions(BridgedSubstitutionMap contextSubs) const {
+BridgedSubstitutionMap BridgedFunction::getMethodSubstitutions(BridgedSubstitutionMap contextSubstitutions,
+                                                               BridgedCanType selfType) const {
   swift::SILFunction *f = getFunction();
   swift::GenericSignature genericSig = f->getLoweredFunctionType()->getInvocationGenericSignature();
 
   if (!genericSig || genericSig->areAllParamsConcrete())
     return swift::SubstitutionMap();
 
+  SubstitutionMap contextSubs = contextSubstitutions.unbridged();
+  if (selfType.unbridged() &&
+      contextSubs.getGenericSignature().getGenericParams().size() + 1 == genericSig.getGenericParams().size()) {
+
+    // If this is a default witness methods (`selfType` != nil) it has generic self type. In this case
+    // the generic self parameter is at depth 0 and the actual generic parameters of the substitution map
+    // are at depth + 1, e.g:
+    // ```
+    //     @convention(witness_method: P) <τ_0_0><τ_1_0 where τ_0_0 : GenClass<τ_1_0>.T>
+    //                                       ^      ^
+    //                                    self      params of substitution map at depth + 1
+    // ```
+    return swift::SubstitutionMap::get(genericSig,
+      [&](SubstitutableType *type) -> Type {
+        GenericTypeParamType *genericParam = cast<GenericTypeParamType>(type);
+        // The self type is τ_0_0
+        if (genericParam->getDepth() == 0 && genericParam->getIndex() == 0)
+          return selfType.unbridged();
+
+        // Lookup the substitution map types at depth - 1.
+        auto *depthMinus1Param = GenericTypeParamType::getType(genericParam->getDepth() - 1,
+                                                               genericParam->getIndex(),
+                                                               genericParam->getASTContext());
+        return swift::QuerySubstitutionMap{contextSubs}(depthMinus1Param);
+      },
+      swift::LookUpConformanceInModule());
+
+  }
   return swift::SubstitutionMap::get(genericSig,
-                                     swift::QuerySubstitutionMap{contextSubs.unbridged()},
+                                     swift::QuerySubstitutionMap{contextSubs},
                                      swift::LookUpConformanceInModule());
 }