Moving toward a better model of inferred thrown error types

Author: DougGregor

lib/Sema/CSGen.cpp

@@ -916,6 +916,9 @@ TypeVarRefCollector::walkToStmtPre(Stmt *stmt) {
         !Locator->directlyAt<ClosureExpr>()) {
       SmallPtrSet<TypeVariableType *, 4> typeVars;
       CS.getClosureType(CE)->getResult()->getTypeVariables(typeVars);
+
+      FIXME if we're doing full typed throws, also look at the thrown
+        error type here?
       TypeVars.insert(typeVars.begin(), typeVars.end());
     }
   }
@@ -2470,12 +2473,9 @@ namespace {
         // If we are inferring thrown error types, create a type variable
         // to capture the thrown error type. This will be resolved based on the
         // throw sites that occur within the body of the closure.
-        // FIXME: Single-expression closures don't yet work.
-        if (CS.getASTContext().LangOpts.hasFeature(Feature::FullTypedThrows) &&
-            !CS.getAppliedResultBuilderTransform(closure) &&
-            !closure->hasSingleExpressionBody()) {
-          return Type(
-              CS.createTypeVariable(thrownErrorLocator, TVO_CanBindToHole));
+        if (CS.getASTContext().LangOpts.hasFeature(
+                Feature::FullTypedThrows)) {
+          return Type(CS.createTypeVariable(thrownErrorLocator, 0));
         }
 
         // Thrown type inferred from context.

lib/Sema/CSSyntacticElement.cpp

@@ -287,6 +287,23 @@ static bool isViableElement(ASTNode element,
 using ElementInfo = std::tuple<ASTNode, ContextualTypeInfo,
                                /*isDiscarded=*/bool, ConstraintLocator *>;
 
+static TypeVariableType *assignClosureThrownErrorType(
+    ConstraintSystem &cs, ClosureExpr *closure) {
+  // FIXME: Remove this once the inference is working in general.
+  if (!cs.getASTContext().LangOpts.hasFeature(Feature::FullTypedThrows))
+    return nullptr;
+
+  auto closureType = cs.getClosureType(closure);
+  auto thrownType = closureType->getEffectiveThrownErrorTypeOrNever();
+  auto computedThrownType = cs.inferCaughtErrorType(closure);
+  cs.addConstraint(
+      ConstraintKind::Conversion, computedThrownType, thrownType, 
+      cs.getConstraintLocator(closure,
+                              ConstraintLocator::ClosureThrownError));
+
+  return computedThrownType->getAs<TypeVariableType>();
+}
+
 static void createConjunction(ConstraintSystem &cs, DeclContext *dc,
                               ArrayRef<ElementInfo> elements,
                               ConstraintLocator *locator, bool isIsolated,
@@ -370,14 +387,16 @@ static void createConjunction(ConstraintSystem &cs, DeclContext *dc,
   for (auto *externalVar : paramCollector.getTypeVars())
     referencedVars.push_back(externalVar);
 
+#if false
   // If the body of the closure is being used to infer the thrown error type
   // of that closure, introduce a constraint to do so.
   if (locator->directlyAt<ClosureExpr>()) {
     auto *closure = castToExpr<ClosureExpr>(locator->getAnchor());
-    if (auto thrownErrorTypeVar = cs.getInferredThrownError(closure))
+    if (auto thrownErrorTypeVar = assignClosureThrownErrorType(cs, closure))
       referencedVars.push_back(thrownErrorTypeVar);
   }
-
+#endif
+  
   // It's possible that there are no viable elements in the body,
   // because e.g. whole body is an `#if` statement or it only has
   // declarations that are checked during solution application.
@@ -1137,9 +1156,9 @@ class SyntacticElementConstraintGenerator
       }
 
       if (closure) {
-        auto closureType = cs.getClosureType(closure);
+        assignClosureThrownErrorType(cs, closure);
       }
-      
+
       return;
     }