[SIL Parser] Handle parsing of ‘Self’ in default witness tables.

There is no good way to do this, so take a shortcut for now of 
pre-resolving ‘Self’.

Author: DougGregor

lib/ParseSIL/ParseSIL.cpp

@@ -5812,6 +5812,41 @@ ProtocolConformance *SILParser::parseProtocolConformanceHelper(
   return retVal;
 }
 
+/// Bind any unqualified 'Self' references to the given protocol's 'Self'
+/// generic parameter.
+///
+/// FIXME: This is a hack to work around the lack of a DeclContext for
+/// witness tables.
+static void bindProtocolSelfInTypeRepr(TypeLoc &TL, ProtocolDecl *proto) {
+  if (auto typeRepr = TL.getTypeRepr()) {
+    // AST walker to update 'Self' references.
+    class BindProtocolSelf : public ASTWalker {
+      ProtocolDecl *proto;
+      GenericTypeParamDecl *selfParam;
+      Identifier selfId;
+
+    public:
+      BindProtocolSelf(ProtocolDecl *proto)
+        : proto(proto),
+          selfParam(proto->getProtocolSelfType()->getDecl()),
+          selfId(proto->getASTContext().Id_Self) {
+      }
+
+      virtual bool walkToTypeReprPre(TypeRepr *T) override {
+        if (auto ident = dyn_cast<IdentTypeRepr>(T)) {
+          auto firstComponent = ident->getComponentRange().front();
+          if (firstComponent->getIdentifier() == selfId)
+            firstComponent->setValue(selfParam, proto);
+        }
+
+        return true;
+      }
+    };
+
+    typeRepr->walk(BindProtocolSelf(proto));
+  }
+}
+
 /// Parser a single SIL vtable entry and add it to either \p witnessEntries
 /// or \c conditionalConformances.
 static bool parseSILVTableEntry(
@@ -5820,6 +5855,7 @@ static bool parseSILVTableEntry(
          ProtocolDecl *proto,
          GenericEnvironment *witnessEnv,
          SILParser &witnessState,
+         bool isDefaultWitnessTable,
          std::vector<SILWitnessTable::Entry> &witnessEntries,
          std::vector<SILWitnessTable::ConditionalConformance>
            &conditionalConformances) {
@@ -5865,6 +5901,8 @@ static bool parseSILVTableEntry(
       if (TyR.isNull())
         return true;
       TypeLoc Ty = TyR.get();
+      if (isDefaultWitnessTable)
+        bindProtocolSelfInTypeRepr(Ty, proto);
       if (swift::performTypeLocChecking(P.Context, Ty,
                                         /*isSILMode=*/false,
                                         /*isSILType=*/false,
@@ -5921,6 +5959,8 @@ static bool parseSILVTableEntry(
     if (TyR.isNull())
       return true;
     TypeLoc Ty = TyR.get();
+    if (isDefaultWitnessTable)
+      bindProtocolSelfInTypeRepr(Ty, proto);
     if (swift::performTypeLocChecking(P.Context, Ty,
                                       /*isSILMode=*/false,
                                       /*isSILType=*/false,
@@ -6046,7 +6086,7 @@ bool SILParserTUState::parseSILWitnessTable(Parser &P) {
 
   if (P.Tok.isNot(tok::r_brace)) {
     do {
-      if (parseSILVTableEntry(P, M, proto, witnessEnv, WitnessState,
+      if (parseSILVTableEntry(P, M, proto, witnessEnv, WitnessState, false,
                               witnessEntries, conditionalConformances))
         return true;
     } while (P.Tok.isNot(tok::r_brace) && P.Tok.isNot(tok::eof));
@@ -6092,6 +6132,8 @@ bool SILParserTUState::parseSILDefaultWitnessTable(Parser &P) {
 
   // Parse the protocol.
   ProtocolDecl *protocol = parseProtocolDecl(P, WitnessState);
+  if (!protocol)
+    return true;
 
   // Parse the body.
   SourceLoc LBraceLoc = P.Tok.getLoc();
@@ -6106,8 +6148,9 @@ bool SILParserTUState::parseSILDefaultWitnessTable(Parser &P) {
 
   if (P.Tok.isNot(tok::r_brace)) {
     do {
-      if (parseSILVTableEntry(P, M, protocol, nullptr, WitnessState,
-                              witnessEntries, conditionalConformances))
+      if (parseSILVTableEntry(P, M, protocol, protocol->getGenericEnvironment(),
+                              WitnessState, true, witnessEntries,
+                              conditionalConformances))
         return true;
     } while (P.Tok.isNot(tok::r_brace) && P.Tok.isNot(tok::eof));
   }

test/SIL/Parser/default_witness_tables.sil

@@ -4,9 +4,10 @@
 sil_stage raw
 
 public protocol Proto {}
+public struct Wrapper<T>: Proto { }
 
 public protocol ResilientProtocol {
-  associatedtype T : Proto
+  associatedtype T : Proto = Wrapper<Self>
   func noDefaultA()
   func noDefaultB()
   func defaultC()
@@ -48,7 +49,7 @@ bb0(%0 : $*Self):
 
 // CHECK-LABEL: sil_default_witness_table ResilientProtocol {
 // CHECK: no_default
-// CHECK: no_default
+// CHECK: associated_type T: Wrapper<Self>
 // CHECK: no_default
 // CHECK: no_default
 // CHECK: method #ResilientProtocol.defaultC!1: {{.*}} : @defaultC
@@ -58,7 +59,7 @@ bb0(%0 : $*Self):
 
 sil_default_witness_table ResilientProtocol {
   no_default
-  no_default
+  associated_type T: Wrapper<Self>
   no_default
   no_default
   method #ResilientProtocol.defaultC!1: @defaultC