[ast] Hide CapturedValue(OpaqueValueExpr *) so that it only can be used by TypeLowering.

The reason why I am doing this is before this commit despite the fact that
CapturedValue was only used by TypeLowering, this constructor was exposed to the
entire rest of the compiler. This made it so that other code (like the
AbstractClosureExpr::getIsolationCrossing() that I added in the previous series
of commits) would have to handle that API even though there was nothing to
handle just in case someone added something in the future.

Rather than create such a burden on the rest of the compiler, in this commit, we
instead hide said constructor and make it only accessible from
TypeLowering. This creates a barrier from new uses appearing in AST and make it
reasonable for code in the AST that will never see things from TypeLowering
(like the ACE API I mentioned above) just assert on that case without needing to
worry about additional uses cropping in easily by mistake.

Author: gottesmm

include/swift/AST/CaptureInfo.h

@@ -25,12 +25,18 @@
 
 namespace swift {
 class CapturedValue;
-}
+} // namespace swift
+
+namespace swift {
+namespace Lowering {
+class TypeConverter;
+} // namespace Lowering
+} // namespace swift
 
 namespace llvm {
 class raw_ostream;
 template <> struct DenseMapInfo<swift::CapturedValue>;
-}
+} // namespace llvm
 
 namespace swift {
 class ValueDecl;
@@ -41,6 +47,8 @@ class VarDecl;
 /// CapturedValue includes both the declaration being captured, along with flags
 /// that indicate how it is captured.
 class CapturedValue {
+  friend class Lowering::TypeConverter;
+
 public:
   using Storage =
       llvm::PointerIntPair<llvm::PointerUnion<ValueDecl*, OpaqueValueExpr*>, 2,
@@ -69,9 +77,17 @@ class CapturedValue {
   CapturedValue(ValueDecl *Val, unsigned Flags, SourceLoc Loc)
       : Value(Val, Flags), Loc(Loc) {}
 
-  CapturedValue(OpaqueValueExpr *Val, unsigned Flags)
+private:
+  // This is only used in TypeLowering when forming Lowered Capture
+  // Info. OpaqueValueExpr captured value should never show up in the AST
+  // itself.
+  //
+  // NOTE: AbstractClosureExpr::getIsolationCrossing relies upon this and
+  // asserts that it never sees one of these.
+  explicit CapturedValue(OpaqueValueExpr *Val, unsigned Flags)
       : Value(Val, Flags), Loc(SourceLoc()) {}
 
+public:
   static CapturedValue getDynamicSelfMetadata() {
     return CapturedValue((ValueDecl *)nullptr, 0, SourceLoc());
   }

lib/AST/Expr.cpp

@@ -2942,10 +2942,10 @@ void AbstractClosureExpr::getIsolationCrossing(
 
     auto declIsolation = swift::getActorIsolation(capture.getDecl());
 
-    // Then see if we have an opaque value.
-    if (auto *opaqueValue = capture.getOpaqueValue()) {
-      continue;
-    }
+    // Assert that we do not have an opaque value capture. These only appear in
+    // TypeLowering and should never appear in the AST itself.
+    assert(!capture.getOpaqueValue() &&
+           "This should only be created in TypeLowering");
 
     // If our decl is actor isolated...
     if (declIsolation.isActorIsolated()) {