[send-not-sendable] Eliminate relative includes and add a file header.

Specifically, the two routines we were importing relatively were:

1. TypeChecker::conformsToProtocol. I moved this onto a helper routine on
SILType.

2. swift::findOriginalValueType(Expr *). This routine just looks through various
implicit conversions to find the original underlying type. I moved it to a
helper method on Expr.

Author: gottesmm

include/swift/AST/Expr.h

@@ -447,6 +447,10 @@ class alignas(8) Expr : public ASTAllocated<Expr> {
     return const_cast<Expr *>(this)->getValueProvidingExpr();
   }
 
+  /// Find the original type of a value, looking through various implicit
+  /// conversions.
+  Type findOriginalType() const;
+
   /// If this is a reference to an operator written as a member of a type (or
   /// extension thereof), return the underlying operator reference.
   DeclRefExpr *getMemberOperatorRef();

include/swift/SIL/SILType.h

@@ -873,6 +873,9 @@ class SILType {
 
   bool isMarkedAsImmortal() const;
 
+  ProtocolConformanceRef conformsToProtocol(SILFunction *fn,
+                                            ProtocolDecl *protocol) const;
+
   //
   // Accessors for types used in SIL instructions:
   //

lib/AST/Expr.cpp

@@ -2789,3 +2789,28 @@ FrontendStatsTracer::getTraceFormatter<const Expr *>() {
   return &TF;
 }
 
+Type Expr::findOriginalType() const {
+  auto *expr = this;
+  do {
+    expr = expr->getSemanticsProvidingExpr();
+
+    if (auto inout = dyn_cast<InOutExpr>(expr)) {
+      expr = inout->getSubExpr();
+      continue;
+    }
+
+    if (auto ice = dyn_cast<ImplicitConversionExpr>(expr)) {
+      expr = ice->getSubExpr();
+      continue;
+    }
+
+    if (auto open = dyn_cast<OpenExistentialExpr>(expr)) {
+      expr = open->getSubExpr();
+      continue;
+    }
+
+    break;
+  } while (true);
+
+  return expr->getType()->getRValueType();
+}

lib/SIL/IR/SILType.cpp

@@ -1211,3 +1211,8 @@ SILType SILType::removingMoveOnlyWrapperToBoxedType(const SILFunction *fn) {
                                     boxTy->getSubstitutions());
   return SILType::getPrimitiveObjectType(newBoxType);
 }
+
+ProtocolConformanceRef
+SILType::conformsToProtocol(SILFunction *fn, ProtocolDecl *protocol) const {
+  return fn->getParentModule()->conformsToProtocol(getASTType(), protocol);
+}

lib/SILOptimizer/Mandatory/SendNonSendable.cpp

@@ -1,5 +1,15 @@
-#include "../../Sema/TypeCheckConcurrency.h"
-#include "../../Sema/TypeChecker.h"
+//===--- SendNonSendable.cpp ----------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
 #include "swift/AST/DiagnosticsSIL.h"
 #include "swift/AST/Expr.h"
 #include "swift/AST/Type.h"
@@ -256,18 +266,17 @@ class PartitionOpTranslator {
     switch (type.getASTType()->getKind()) {
     case TypeKind::BuiltinNativeObject:
     case TypeKind::BuiltinRawPointer:
-      // these are very unsafe... definitely not Sendable
+      // These are very unsafe... definitely not Sendable.
       return true;
     default:
-      // consider caching this if it's a performance bottleneck
-      return TypeChecker::conformsToProtocol(
-                 type.getASTType(), sendableProtocol, function->getParentModule())
+      // Consider caching this if it's a performance bottleneck.
+      return type.conformsToProtocol(function, sendableProtocol)
           .hasMissingConformance(function->getParentModule());
     }
   }
 
-  // used to statefully track the instruction currently being translated,
-  // for insertion into generated PartitionOps
+  // Used to statefully track the instruction currently being translated, for
+  // insertion into generated PartitionOps.
   SILInstruction *currentInstruction;
 
   // ===========================================================================
@@ -1586,12 +1595,13 @@ class PartitionAnalysis {
     if (!argExpr)
       assert(false && "sourceExpr should be populated for ApplyExpr consumptions");
 
-    function->getASTContext().Diags.diagnose(
-        argExpr->getLoc(), diag::call_site_consumption_yields_race,
-        findOriginalValueType(argExpr),
-        isolationCrossing.value().getCallerIsolation(),
-        isolationCrossing.value().getCalleeIsolation(),
-        numDisplayed, numDisplayed != 1, numHidden > 0, numHidden)
+    function->getASTContext()
+        .Diags
+        .diagnose(argExpr->getLoc(), diag::call_site_consumption_yields_race,
+                  argExpr->findOriginalType(),
+                  isolationCrossing.value().getCallerIsolation(),
+                  isolationCrossing.value().getCalleeIsolation(), numDisplayed,
+                  numDisplayed != 1, numHidden > 0, numHidden)
         .highlight(argExpr->getSourceRange());
     return true;
   }

lib/Sema/TypeCheckConcurrency.cpp

@@ -1837,33 +1837,6 @@ static void noteGlobalActorOnContext(DeclContext *dc, Type globalActor) {
   }
 }
 
-/// Find the original type of a value, looking through various implicit
-/// conversions.
-Type swift::findOriginalValueType(Expr *expr) {
-  do {
-    expr = expr->getSemanticsProvidingExpr();
-
-    if (auto inout = dyn_cast<InOutExpr>(expr)) {
-      expr = inout->getSubExpr();
-      continue;
-    }
-
-    if (auto ice = dyn_cast<ImplicitConversionExpr>(expr)) {
-      expr = ice->getSubExpr();
-      continue;
-    }
-
-    if (auto open = dyn_cast<OpenExistentialExpr>(expr)) {
-      expr = open->getSubExpr();
-      continue;
-    }
-
-    break;
-  } while (true);
-
-  return expr->getType()->getRValueType();
-}
-
 bool swift::diagnoseApplyArgSendability(ApplyExpr *apply, const DeclContext *declContext) {
   auto isolationCrossing = apply->getIsolationCrossing();
   if (!isolationCrossing.has_value())
@@ -1904,7 +1877,7 @@ bool swift::diagnoseApplyArgSendability(ApplyExpr *apply, const DeclContext *dec
       // Determine the type of the argument, ignoring any implicit
       // conversions that could have stripped sendability.
       if (Expr *argExpr = arg.getExpr()) {
-          argType = findOriginalValueType(argExpr);
+          argType = argExpr->findOriginalType();
       }
     }
 

lib/Sema/TypeCheckConcurrency.h

@@ -362,10 +362,6 @@ struct SendableCheckContext {
   bool isExplicitSendableConformance() const;
 };
 
-/// Find the original type of a value, looking through various implicit
-/// conversions.
-Type findOriginalValueType(Expr *expr);
-
 /// Diagnose any non-Sendable types that occur within the given type, using
 /// the given diagnostic.
 ///