Record throwing property accesses as potential throw sites

Author: DougGregor

include/swift/Sema/ConstraintSystem.h

@@ -1455,6 +1455,9 @@ struct PotentialThrowSite {
     /// A non-exhaustive do...catch, which rethrows whatever is thrown from
     /// inside it's `do` block.
     NonExhaustiveDoCatch,
+
+    /// A property access that can throw an error.
+    PropertyAccess,
   } kind;
 
   /// The type that describes the potential throw site, such as the type of the
@@ -2070,6 +2073,9 @@ struct DeclReferenceType {
   /// (e.g.) applying the base of a member access. This is the type of the
   /// expression used to form the declaration reference.
   Type adjustedReferenceType;
+
+  /// The type that could be thrown by accessing this declaration.
+  Type thrownErrorTypeOnAccess;
 };
 
 /// Describes a system of constraints on type variables, the

lib/Sema/ConstraintSystem.cpp

@@ -456,6 +456,7 @@ Type ConstraintSystem::getCaughtErrorType(CatchNode catchNode) {
 
     case PotentialThrowSite::ExplicitThrow:
     case PotentialThrowSite::NonExhaustiveDoCatch:
+    case PotentialThrowSite::PropertyAccess:
       thrownErrorType = type;
       break;
     }
@@ -1809,7 +1810,7 @@ ConstraintSystem::getTypeOfReference(ValueDecl *value,
 
     // The reference implicitly binds 'self'.
     return {origOpenedType, openedType,
-            origOpenedType->getResult(), openedType->getResult()};
+            origOpenedType->getResult(), openedType->getResult(), Type()};
   }
 
   // Unqualified reference to a local or global function.
@@ -1854,7 +1855,7 @@ ConstraintSystem::getTypeOfReference(ValueDecl *value,
     // If we opened up any type variables, record the replacements.
     recordOpenedTypes(locator, replacements);
 
-    return { origOpenedType, openedType, origOpenedType, openedType };
+    return { origOpenedType, openedType, origOpenedType, openedType, Type() };
   }
 
   // Unqualified reference to a type.
@@ -1876,11 +1877,11 @@ ConstraintSystem::getTypeOfReference(ValueDecl *value,
 
     // Module types are not wrapped in metatypes.
     if (type->is<ModuleType>())
-      return { type, type, type, type };
+      return { type, type, type, type, Type() };
 
     // If it's a value reference, refer to the metatype.
     type = MetatypeType::get(type);
-    return { type, type, type, type };
+    return { type, type, type, type, Type() };
   }
 
   // Unqualified reference to a macro.
@@ -1898,7 +1899,7 @@ ConstraintSystem::getTypeOfReference(ValueDecl *value,
 
     // FIXME: Should we use replaceParamErrorTypeByPlaceholder() here?
 
-    return { openedType, openedType, openedType, openedType };
+    return { openedType, openedType, openedType, openedType, Type() };
   }
 
   // Only remaining case: unqualified reference to a property.
@@ -1911,9 +1912,15 @@ ConstraintSystem::getTypeOfReference(ValueDecl *value,
       getUnopenedTypeOfReference(varDecl, Type(), useDC, /*base=*/nullptr,
                                  wantInterfaceType);
 
+  Type thrownErrorType;
+  if (auto accessor = varDecl->getEffectfulGetAccessor()) {
+    thrownErrorType =
+        accessor->getEffectiveThrownErrorType().value_or(Type());
+  }
+
   assert(!valueType->hasUnboundGenericType() &&
          !valueType->hasTypeParameter());
-  return { valueType, valueType, valueType, valueType };
+  return { valueType, valueType, valueType, valueType, thrownErrorType };
 }
 
 /// Bind type variables for archetypes that are determined from
@@ -2640,13 +2647,13 @@ ConstraintSystem::getTypeOfMemberReference(
     memberTy = MetatypeType::get(memberTy);
 
     auto openedType = FunctionType::get({baseObjParam}, memberTy);
-    return { openedType, openedType, memberTy, memberTy };
+    return { openedType, openedType, memberTy, memberTy, Type() };
   }
 
   if (isa<AbstractFunctionDecl>(value) || isa<EnumElementDecl>(value)) {
     if (value->getInterfaceType()->is<ErrorType>()) {
       auto genericErrorTy = ErrorType::get(getASTContext());
-      return { genericErrorTy, genericErrorTy, genericErrorTy, genericErrorTy };
+      return { genericErrorTy, genericErrorTy, genericErrorTy, genericErrorTy, Type() };
     }
   }
 
@@ -2665,6 +2672,7 @@ ConstraintSystem::getTypeOfMemberReference(
   if (genericSig)
     openGenericParameters(outerDC, genericSig, replacements, locator);
 
+  Type thrownErrorType;
   if (isa<AbstractFunctionDecl>(value) || isa<EnumElementDecl>(value)) {
     // This is the easy case.
     openedType = value->getInterfaceType()->castTo<AnyFunctionType>();
@@ -2674,20 +2682,14 @@ ConstraintSystem::getTypeOfMemberReference(
           [&](Type type) { return openType(type, replacements, locator); });
     }
   } else {
-    // Figure out the effect information for the reference.
-    FunctionType::ExtInfo info;
+    // If the storage has a throwing getter, save the thrown error type..
     auto storage = cast<AbstractStorageDecl>(value);
-
-    // If the storage has a throwing getter, record that in the type.
-    if (auto effectfulGetter = storage->getEffectfulGetAccessor()) {
-      if (effectfulGetter->hasThrows()) {
-        Type thrownErrorType = effectfulGetter->getThrownInterfaceType();
-        info = info.withThrows(true, thrownErrorType);
-      }
+    if (auto accessor = storage->getEffectfulGetAccessor()) {
+      thrownErrorType = accessor->getEffectiveThrownErrorType().value_or(Type());
     }
 
     // For a property, build a type (Self) -> PropType.
-    // For a subscript, build a type (Self) -> (Indices...) -> ElementType.
+    // For a subscript, build a type (Self) -> (Indices...) throws(?) -> ElementType.
     //
     // If the access is mutating, wrap the storage type in an lvalue type.
     Type refType;
@@ -2700,6 +2702,14 @@ ConstraintSystem::getTypeOfMemberReference(
       auto indices = subscript->getInterfaceType()
                               ->castTo<AnyFunctionType>()->getParams();
 
+      // Transfer the thrown error type into the subscript reference type,
+      // which will be used in the application.
+      FunctionType::ExtInfo info;
+      if (thrownErrorType) {
+        info = info.withThrows(true, thrownErrorType);
+        thrownErrorType = Type();
+      }
+
       refType = FunctionType::get(indices, elementTy, info);
     } else {
       // Delay the adjustment for preconcurrency until after we've formed
@@ -2728,9 +2738,13 @@ ConstraintSystem::getTypeOfMemberReference(
     if (genericSig) {
       selfTy = openType(selfTy, replacements, locator);
       refType = openType(refType, replacements, locator);
+
+      if (thrownErrorType)
+        thrownErrorType = openType(thrownErrorType, replacements, locator);
     }
     FunctionType::Param selfParam(selfTy, Identifier(), selfFlags);
 
+    FunctionType::ExtInfo info;
     openedType = FunctionType::get({selfParam}, refType, info);
   }
   assert(!openedType->hasTypeParameter());
@@ -2863,7 +2877,7 @@ ConstraintSystem::getTypeOfMemberReference(
   // If we opened up any type variables, record the replacements.
   recordOpenedTypes(locator, replacements);
 
-  return { origOpenedType, openedType, origType, type };
+  return { origOpenedType, openedType, origType, type, thrownErrorType };
 }
 
 Type ConstraintSystem::getEffectiveOverloadType(ConstraintLocator *locator,
@@ -3090,7 +3104,7 @@ static DeclReferenceType getTypeOfReferenceWithSpecialTypeCheckingSemantics(
     // FIXME: Verify ExtInfo state is correct, not working by accident.
     FunctionType::ExtInfo info;
     auto refType = FunctionType::get({inputArg}, output, info);
-    return {refType, refType, refType, refType};
+    return {refType, refType, refType, refType, Type()};
   }
   case DeclTypeCheckingSemantics::WithoutActuallyEscaping: {
     // Proceed with a "WithoutActuallyEscaping" operation. The body closure
@@ -3125,7 +3139,7 @@ static DeclReferenceType getTypeOfReferenceWithSpecialTypeCheckingSemantics(
                                          .withAsync(true)
                                          .withThrows(true, /*FIXME:*/Type())
                                          .build());
-    return {refType, refType, refType, refType};
+    return {refType, refType, refType, refType, Type()};
   }
   case DeclTypeCheckingSemantics::OpenExistential: {
     // The body closure receives a freshly-opened archetype constrained by the
@@ -3158,7 +3172,7 @@ static DeclReferenceType getTypeOfReferenceWithSpecialTypeCheckingSemantics(
                                          .withThrows(true, /*FIXME:*/Type())
                                          .withAsync(true)
                                          .build());
-    return {refType, refType, refType, refType};
+    return {refType, refType, refType, refType, Type()};
   }
   }
 
@@ -3751,6 +3765,7 @@ void ConstraintSystem::resolveOverload(ConstraintLocator *locator,
   Type adjustedOpenedType;
   Type refType;
   Type adjustedRefType;
+  Type thrownErrorTypeOnAccess;
 
   switch (auto kind = choice.getKind()) {
   case OverloadChoiceKind::Decl:
@@ -3784,7 +3799,7 @@ void ConstraintSystem::resolveOverload(ConstraintLocator *locator,
     adjustedOpenedType = declRefType.adjustedOpenedType;
     refType = declRefType.referenceType;
     adjustedRefType = declRefType.adjustedReferenceType;
-
+    thrownErrorTypeOnAccess = declRefType.thrownErrorTypeOnAccess;
     break;
   }
 
@@ -3951,6 +3966,13 @@ void ConstraintSystem::resolveOverload(ConstraintLocator *locator,
     }
   }
 
+  // If accessing this declaration could throw an error, record this as a
+  // potential throw site.
+  if (thrownErrorTypeOnAccess) {
+    recordPotentialThrowSite(
+        PotentialThrowSite::PropertyAccess, thrownErrorTypeOnAccess, locator);
+  }
+
   // Note that we have resolved this overload.
   auto overload = SelectedOverload{
       choice, openedType, adjustedOpenedType, refType, adjustedRefType,

lib/Sema/TypeCheckConstraints.cpp

@@ -1670,6 +1670,9 @@ void ConstraintSystem::print(raw_ostream &out) const {
       case PotentialThrowSite::NonExhaustiveDoCatch:
         out << " - non-exhaustive do..catch @ ";
         break;
+      case PotentialThrowSite::PropertyAccess:
+        out << " - property access @ ";
+        break;
       }
 
       throwSite.second.locator->dump(&getASTContext().SourceMgr, out);

test/stmt/typed_throws.swift

@@ -196,12 +196,24 @@ struct ThrowingMembers {
   subscript(i: Int) -> Int {
     get throws(MyError) { i }
   }
+
+  var intOrThrows: Int {
+    get throws(MyError) { 5 }
+  }
 }
 
 struct ThrowingStaticSubscript {
   static subscript(i: Int) -> Int {
     get throws(MyError) { i }
   }
+
+  static var intOrThrows: Int {
+    get throws(MyError) { 5 }
+  }
+}
+
+var globalIntOrThrows: Int {
+  get throws(MyError) { 5 }
 }
 
 func testDoCatchInClosure(cond: Bool, x: ThrowingMembers) {
@@ -262,4 +274,29 @@ func testDoCatchInClosure(cond: Bool, x: ThrowingMembers) {
       let _: MyError = error
     }
   }
+
+  // Property accesses as potential throw sites
+  apply {
+    do {
+      _ = try x.intOrThrows
+    } catch {
+      let _: MyError = error
+    }
+  }
+
+  apply {
+    do {
+      _ = try ThrowingStaticSubscript.intOrThrows
+    } catch {
+      let _: MyError = error
+    }
+  }
+
+  apply {
+    do {
+      _ = try globalIntOrThrows
+    } catch {
+      let _: MyError = error
+    }
+  }
 }