Teach the SIL cast optimizer to handle conditional conformance.

Previously the cast optimizer bailed out on any conformance with
requirements.

We can now constant-propagate this:

```
protocol P {}
struct S<E> {
  var e: E
}

extension S : P where E == Int {}

func specializeMe<T>(_ t: T) {
  if let p = t as? P {
    // do fast things.
  }
}

specializeMe(S(e: 0))
```

This turns out to be as simple as calling the TypeChecker.

<rdar://problem/46375150> Inlining does not seem to handle
specialization properly for Data.

This enabled two SIL transformations required to optimize
the code above:

(1) The witness method call can be devirtualized.

(2) The allows expensive dynamic runtime checks such as:

  unconditional_checked_cast_addr Array<UInt8> in %array : $*Array<UInt8> to ContiguousBytes in %protocol : $*ContiguousBytes

Will be converted into:

  %value = init_existential_addr %existential : $*ContiguousBytes, $Array<UInt8>
  store %array to %value : $*Array<UInt8>

Author: atrick

include/swift/AST/Module.h

@@ -392,6 +392,12 @@ class ModuleDecl : public DeclContext, public TypeDecl {
   Optional<ProtocolConformanceRef>
   lookupExistentialConformance(Type type, ProtocolDecl *protocol);
 
+  /// Exposes TypeChecker functionality for querying protocol conformance.
+  /// Returns a valid ProtocolConformanceRef only if all conditional
+  /// requirements are successfully resolved.
+  Optional<ProtocolConformanceRef>
+  conformsToProtocol(Type sourceTy, ProtocolDecl *targetProtocol);
+
   /// Find a member named \p name in \p container that was declared in this
   /// module.
   ///

include/swift/SIL/DynamicCasts.h

@@ -19,6 +19,7 @@
 #define SWIFT_SIL_DYNAMICCASTS_H
 
 #include "swift/Basic/ProfileCounter.h"
+#include "swift/SIL/SILValue.h"
 
 namespace swift {
 

lib/SIL/DynamicCasts.cpp

@@ -10,11 +10,12 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "swift/SIL/DynamicCasts.h"
 #include "swift/AST/Module.h"
+#include "swift/AST/ProtocolConformance.h"
 #include "swift/AST/Types.h"
 #include "swift/SIL/SILArgument.h"
 #include "swift/SIL/SILBuilder.h"
-#include "swift/SIL/DynamicCasts.h"
 #include "swift/SIL/TypeLowering.h"
 
 using namespace swift;
@@ -93,15 +94,10 @@ classifyDynamicCastToProtocol(ModuleDecl *M, CanType source, CanType target,
   if (!TargetProtocol)
     return DynamicCastFeasibility::MaySucceed;
 
-  auto conformance = M->lookupConformance(source, TargetProtocol);
-  if (conformance) {
-    // A conditional conformance can have things that need to be evaluated
-    // dynamically.
-    if (conformance->getConditionalRequirements().empty())
-      return DynamicCastFeasibility::WillSucceed;
-
-    return DynamicCastFeasibility::MaySucceed;
-  }
+  // If conformsToProtocol returns a valid conformance, then all requirements
+  // were proven by the type checker.
+  if (M->conformsToProtocol(source, TargetProtocol))
+    return DynamicCastFeasibility::WillSucceed;
 
   auto *SourceNominalTy = source.getAnyNominal();
   if (!SourceNominalTy)
@@ -129,6 +125,22 @@ classifyDynamicCastToProtocol(ModuleDecl *M, CanType source, CanType target,
     }
   }
 
+  // The WillFail conditions below assume any possible conformance on the
+  // nominal source type has been ruled out. The prior conformsToProtocol query
+  // identified any definite conformance. Now check if there is already a known
+  // conditional conformance on the nominal type with requirements that were
+  // not proven.
+  //
+  // TODO: The TypeChecker can easily prove that some requirements cannot be
+  // met. Returning WillFail in those cases would be more optimal. To do that,
+  // the conformsToProtocol interface needs to be reformulated as a query, and
+  // the implementation, including checkGenericArguments, needs to be taught to
+  // recognize that types with archetypes may potentially succeed.
+  if (auto conformance = M->lookupConformance(source, TargetProtocol)) {
+    assert(!conformance->getConditionalRequirements().empty());
+    return DynamicCastFeasibility::MaySucceed;
+  }
+
   // If the source type is file-private or target protocol is file-private,
   // then conformances cannot be changed at run-time, because only this
   // file could have implemented them, but no conformances were found.

lib/SILOptimizer/Utils/CastOptimizer.cpp

@@ -1391,68 +1391,68 @@ static bool optimizeStaticallyKnownProtocolConformance(
     auto *SM = Mod.getSwiftModule();
 
     auto Proto = dyn_cast<ProtocolDecl>(TargetType->getAnyNominal());
-    if (Proto) {
-      auto Conformance = SM->lookupConformance(SourceType, Proto);
-      if (Conformance.hasValue() &&
-          Conformance->getConditionalRequirements().empty()) {
-        // SourceType is a non-existential type with a non-conditional
-        // conformance to a protocol represented by the TargetType.
-        //
-        // Conditional conformances are complicated: they may depend on
-        // information not known until runtime. For instance, if `X: P` where `T
-        // == Int` in `func foo<T>(_: T) { ... X<T>() as? P ... }`, the cast
-        // will succeed for `foo(0)` but not for `foo("string")`. There are many
-        // cases where everything is completely static (`X<Int>() as? P`), but
-        // we don't try to handle that at the moment.
-        SILBuilder B(Inst);
-        SmallVector<ProtocolConformanceRef, 1> NewConformances;
-        NewConformances.push_back(Conformance.getValue());
-        ArrayRef<ProtocolConformanceRef> Conformances =
-            Ctx.AllocateCopy(NewConformances);
-
-        auto ExistentialRepr =
-            Dest->getType().getPreferredExistentialRepresentation(Mod,
-                                                                  SourceType);
-
-        switch (ExistentialRepr) {
-        default:
-          return false;
-        case ExistentialRepresentation::Opaque: {
-          auto ExistentialAddr = B.createInitExistentialAddr(
-              Loc, Dest, SourceType, Src->getType().getObjectType(),
-              Conformances);
-          B.createCopyAddr(Loc, Src, ExistentialAddr, IsTake_t::IsTake,
-                           IsInitialization_t::IsInitialization);
-          break;
-        }
-        case ExistentialRepresentation::Class: {
-          auto Value = B.createLoad(Loc, Src,
-                                    swift::LoadOwnershipQualifier::Unqualified);
-          auto Existential =
-              B.createInitExistentialRef(Loc, Dest->getType().getObjectType(),
-                                         SourceType, Value, Conformances);
-          B.createStore(Loc, Existential, Dest,
-                        swift::StoreOwnershipQualifier::Unqualified);
-          break;
-        }
-        case ExistentialRepresentation::Boxed: {
-          auto AllocBox = B.createAllocExistentialBox(Loc, Dest->getType(),
-                                                      SourceType, Conformances);
-          auto Projection =
-              B.createProjectExistentialBox(Loc, Src->getType(), AllocBox);
-          // This needs to be a copy_addr (for now) because we must handle
-          // address-only types.
-          B.createCopyAddr(Loc, Src, Projection, IsTake, IsInitialization);
-          B.createStore(Loc, AllocBox, Dest,
-                        swift::StoreOwnershipQualifier::Unqualified);
-          break;
-        }
-        };
+    if (!Proto)
+      return false;
 
-        return true;
-      }
+    // SourceType is a non-existential type with a non-conditional
+    // conformance to a protocol represented by the TargetType.
+    //
+    // TypeChecker::conformsToProtocol checks any conditional conformances. If
+    // they depend on information not known until runtime, the conformance
+    // will not be returned. For instance, if `X: P` where `T == Int` in `func
+    // foo<T>(_: T) { ... X<T>() as? P ... }`, the cast will succeed for
+    // `foo(0)` but not for `foo("string")`. There are many cases where
+    // everything is completely static (`X<Int>() as? P`), in which case a
+    // valid conformance will be returned.
+    auto Conformance = SM->conformsToProtocol(SourceType, Proto);
+    if (!Conformance)
+      return false;
+
+    SILBuilder B(Inst);
+    SmallVector<ProtocolConformanceRef, 1> NewConformances;
+    NewConformances.push_back(Conformance.getValue());
+    ArrayRef<ProtocolConformanceRef> Conformances =
+        Ctx.AllocateCopy(NewConformances);
+
+    auto ExistentialRepr =
+        Dest->getType().getPreferredExistentialRepresentation(Mod, SourceType);
+
+    switch (ExistentialRepr) {
+    default:
+      return false;
+    case ExistentialRepresentation::Opaque: {
+      auto ExistentialAddr = B.createInitExistentialAddr(
+          Loc, Dest, SourceType, Src->getType().getObjectType(), Conformances);
+      B.createCopyAddr(Loc, Src, ExistentialAddr, IsTake_t::IsTake,
+                       IsInitialization_t::IsInitialization);
+      break;
     }
+    case ExistentialRepresentation::Class: {
+      auto Value =
+          B.createLoad(Loc, Src, swift::LoadOwnershipQualifier::Unqualified);
+      auto Existential =
+          B.createInitExistentialRef(Loc, Dest->getType().getObjectType(),
+                                     SourceType, Value, Conformances);
+      B.createStore(Loc, Existential, Dest,
+                    swift::StoreOwnershipQualifier::Unqualified);
+      break;
+    }
+    case ExistentialRepresentation::Boxed: {
+      auto AllocBox = B.createAllocExistentialBox(Loc, Dest->getType(),
+                                                  SourceType, Conformances);
+      auto Projection =
+          B.createProjectExistentialBox(Loc, Src->getType(), AllocBox);
+      // This needs to be a copy_addr (for now) because we must handle
+      // address-only types.
+      B.createCopyAddr(Loc, Src, Projection, IsTake, IsInitialization);
+      B.createStore(Loc, AllocBox, Dest,
+                    swift::StoreOwnershipQualifier::Unqualified);
+      break;
+    }
+    };
+    return true;
   }
+  // Not a concrete -> existential cast.
   return false;
 }
 

lib/Sema/TypeCheckProtocol.cpp

@@ -4163,6 +4163,28 @@ Optional<ProtocolConformanceRef> TypeChecker::conformsToProtocol(
   return lookupResult;
 }
 
+// Exposes TypeChecker functionality for querying protocol conformance.
+//
+// Invoking TypeChecker::conformsToProtocol from the ModuleDecl bypasses
+// certain functionality that only applies to the diagnostic type checker:
+//
+// - ConformanceCheckFlags skips dependence checking.
+//
+// - Passing an invalid SourceLoc skips diagnostics.
+//
+// - Type::subst will be a nop, because 'source' type is already fully
+// substituted in SIL. Consequently, TypeChecker::LookUpConformance, which
+// is only valid during type checking, will never be invoked.
+//
+// - mapTypeIntoContext will be a nop.
+Optional<ProtocolConformanceRef>
+ModuleDecl::conformsToProtocol(Type sourceTy, ProtocolDecl *targetProtocol) {
+
+  auto flags = ConformanceCheckFlags::SuppressDependencyTracking;
+
+  return TypeChecker::conformsToProtocol(sourceTy, targetProtocol, this, flags);
+}
+
 void TypeChecker::markConformanceUsed(ProtocolConformanceRef conformance,
                                       DeclContext *dc) {
   if (conformance.isAbstract()) return;