AST: Move some code from ProtocolConformance.cpp to Effects.cpp / TypeCheckEffects.cpp

Author: slavapestov

lib/AST/Effects.cpp

@@ -18,6 +18,7 @@
 #include "swift/AST/Effects.h"
 #include "swift/AST/Evaluator.h"
 #include "swift/AST/Decl.h"
+#include "swift/AST/ProtocolConformanceRef.h"
 #include "swift/AST/Type.h"
 #include "swift/AST/TypeCheckRequests.h"
 #include "llvm/ADT/ArrayRef.h"
@@ -70,4 +71,11 @@ void swift::simple_display(llvm::raw_ostream &out,
     out << "invalid";
     break;
   }
+}
+
+bool ProtocolConformanceRef::classifyAsThrows() const {
+  if (!isConcrete()) { return true; }
+  return evaluateOrDefault(getRequirement()->getASTContext().evaluator,
+     ProtocolConformanceRefClassifyAsThrowsRequest{ *this }, 
+     true);
 }

lib/AST/ProtocolConformance.cpp

@@ -186,79 +186,6 @@ ProtocolConformanceRef::getWitnessByName(Type type, DeclName name) const {
   return getConcrete()->getWitnessDeclRef(requirement);
 }
 
-
-static bool classifyRequirement(ModuleDecl *module, 
-                                ProtocolConformance *reqConformance, 
-                                ValueDecl *requiredFn) {
-  auto declRef = reqConformance->getWitnessDeclRef(requiredFn);
-  auto witnessDecl = cast<AbstractFunctionDecl>(declRef.getDecl());
-  switch (witnessDecl->getRethrowingKind()) {
-    case FunctionRethrowingKind::ByConformance: {
-      auto substitutions = reqConformance->getSubstitutions(module);
-      for (auto conformanceRef : substitutions.getConformances()) {
-        if (conformanceRef.classifyAsThrows()) {
-          return true;
-        }
-      }
-      break;
-    }
-    case FunctionRethrowingKind::None:
-      break;
-    case FunctionRethrowingKind::Throws:
-      return true;
-    default:
-      return true;
-  }
-  return false;
-}
-
-// classify the type requirements of a given prottocol type with a function
-// requirement as throws or not. This will detect if the signature of the 
-// function is throwing or not depending on associated types.
-static bool classifyTypeRequirement(ModuleDecl *module, Type protoType, 
-                                    ValueDecl *requiredFn, 
-                                    ProtocolConformance *conformance,
-                                    ProtocolDecl *requiredProtocol) {
-  auto reqProtocol = cast<ProtocolDecl>(requiredFn->getDeclContext());
-  ProtocolConformance *reqConformance;
-
-  if(protoType->isEqual(reqProtocol->getSelfInterfaceType()) && 
-     requiredProtocol == reqProtocol) {
-    reqConformance = conformance;
-  } else {
-    auto reqConformanceRef = 
-      conformance->getAssociatedConformance(protoType, reqProtocol);
-    if (!reqConformanceRef.isConcrete()) {
-      return true;
-    }
-    reqConformance = reqConformanceRef.getConcrete();
-  }
-
-  return classifyRequirement(module, reqConformance, requiredFn);
-}
-
-bool
-ProtocolConformanceRefClassifyAsThrowsRequest::evaluate(
-  Evaluator &evaluator, ProtocolConformanceRef conformanceRef) const {
-  auto conformance = conformanceRef.getConcrete();
-  auto requiredProtocol = conformanceRef.getRequirement();
-  auto module = requiredProtocol->getModuleContext();
-  for (auto req : requiredProtocol->getRethrowingRequirements()) {
-    if (classifyTypeRequirement(module, req.first, req.second, 
-                                conformance, requiredProtocol)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-bool ProtocolConformanceRef::classifyAsThrows() const {
-  if (!isConcrete()) { return true; }
-  return evaluateOrDefault(getRequirement()->getASTContext().evaluator,
-     ProtocolConformanceRefClassifyAsThrowsRequest{ *this }, 
-     true);
-}
-
 void *ProtocolConformance::operator new(size_t bytes, ASTContext &context,
                                         AllocationArena arena,
                                         unsigned alignment) {

lib/Sema/TypeCheckEffects.cpp

@@ -188,6 +188,71 @@ FunctionRethrowingKindRequest::evaluate(Evaluator &evaluator,
   return FunctionRethrowingKind::None;
 }
 
+static bool classifyRequirement(ModuleDecl *module, 
+                                ProtocolConformance *reqConformance, 
+                                ValueDecl *requiredFn) {
+  auto declRef = reqConformance->getWitnessDeclRef(requiredFn);
+  auto witnessDecl = cast<AbstractFunctionDecl>(declRef.getDecl());
+  switch (witnessDecl->getRethrowingKind()) {
+    case FunctionRethrowingKind::ByConformance: {
+      auto substitutions = reqConformance->getSubstitutions(module);
+      for (auto conformanceRef : substitutions.getConformances()) {
+        if (conformanceRef.classifyAsThrows()) {
+          return true;
+        }
+      }
+      break;
+    }
+    case FunctionRethrowingKind::None:
+      break;
+    case FunctionRethrowingKind::Throws:
+      return true;
+    default:
+      return true;
+  }
+  return false;
+}
+
+// classify the type requirements of a given protocol type with a function
+// requirement as throws or not. This will detect if the signature of the 
+// function is throwing or not depending on associated types.
+static bool classifyTypeRequirement(ModuleDecl *module, Type protoType, 
+                                    ValueDecl *requiredFn, 
+                                    ProtocolConformance *conformance,
+                                    ProtocolDecl *requiredProtocol) {
+  auto reqProtocol = cast<ProtocolDecl>(requiredFn->getDeclContext());
+  ProtocolConformance *reqConformance;
+
+  if(protoType->isEqual(reqProtocol->getSelfInterfaceType()) && 
+     requiredProtocol == reqProtocol) {
+    reqConformance = conformance;
+  } else {
+    auto reqConformanceRef = 
+      conformance->getAssociatedConformance(protoType, reqProtocol);
+    if (!reqConformanceRef.isConcrete()) {
+      return true;
+    }
+    reqConformance = reqConformanceRef.getConcrete();
+  }
+
+  return classifyRequirement(module, reqConformance, requiredFn);
+}
+
+bool
+ProtocolConformanceRefClassifyAsThrowsRequest::evaluate(
+  Evaluator &evaluator, ProtocolConformanceRef conformanceRef) const {
+  auto conformance = conformanceRef.getConcrete();
+  auto requiredProtocol = conformanceRef.getRequirement();
+  auto module = requiredProtocol->getModuleContext();
+  for (auto req : requiredProtocol->getRethrowingRequirements()) {
+    if (classifyTypeRequirement(module, req.first, req.second, 
+                                conformance, requiredProtocol)) {
+      return true;
+    }
+  }
+  return false;
+}
+
 namespace {
 
 /// A function reference.