[Typed throws] Record thrown error types and conversions in the AST

For any operation that can throw an error, such as calls, property
accesses, and non-exhaustive do..catch statements, record the thrown
error type along with the conversion from that thrown error to the
error type expected in context, as appropriate. This will prevent
later stages from having to re-compute the conversion sequences.

Author: DougGregor

include/swift/AST/Expr.h

@@ -28,6 +28,7 @@
 #include "swift/AST/FreestandingMacroExpansion.h"
 #include "swift/AST/FunctionRefKind.h"
 #include "swift/AST/ProtocolConformanceRef.h"
+#include "swift/AST/ThrownErrorDestination.h"
 #include "swift/AST/TypeAlignments.h"
 #include "swift/Basic/Debug.h"
 #include "swift/Basic/InlineBitfield.h"
@@ -324,9 +325,8 @@ class alignas(8) Expr : public ASTAllocated<Expr> {
     NumCaptures : 32
   );
 
-  SWIFT_INLINE_BITFIELD(ApplyExpr, Expr, 1+1+1+1+1+1+1,
+  SWIFT_INLINE_BITFIELD(ApplyExpr, Expr, 1+1+1+1+1,
     ThrowsIsSet : 1,
-    Throws : 1,
     ImplicitlyAsync : 1,
     ImplicitlyThrows : 1,
     NoAsync : 1,
@@ -1180,6 +1180,11 @@ class DeclRefExpr : public Expr {
   DeclNameLoc Loc;
   ActorIsolation implicitActorHopTarget;
 
+  /// Destination information for a thrown error, which includes any
+  /// necessary conversions from the actual type thrown to the type that
+  /// is expected by the enclosing context.
+  ThrownErrorDestination ThrowDest;
+
 public:
   DeclRefExpr(ConcreteDeclRef D, DeclNameLoc Loc, bool Implicit,
               AccessSemantics semantics = AccessSemantics::Ordinary,
@@ -1230,6 +1235,14 @@ class DeclRefExpr : public Expr {
     return Bits.DeclRefExpr.IsImplicitlyThrows;
   }
 
+  /// The error thrown from this access.
+  ThrownErrorDestination throws() const { return ThrowDest; }
+
+  void setThrows(ThrownErrorDestination throws) {
+    assert(!ThrowDest);
+    ThrowDest = throws;
+  }
+
   /// Set whether this reference must account for a `throw` occurring for reasons
   /// other than the function implementation itself throwing, e.g. an
   /// `DistributedActorSystem` implementing a `distributed func` call throwing a
@@ -1562,6 +1575,11 @@ class LookupExpr : public Expr {
     assert(Base);
   }
 
+  /// Destination information for a thrown error, which includes any
+  /// necessary conversions from the actual type thrown to the type that
+  /// is expected by the enclosing context.
+  ThrownErrorDestination ThrowDest;
+
 public:
   /// Retrieve the base of the expression.
   Expr *getBase() const { return Base; }
@@ -1603,6 +1621,14 @@ class LookupExpr : public Expr {
     implicitActorHopTarget = target;
   }
 
+  /// The error thrown from this access.
+  ThrownErrorDestination throws() const { return ThrowDest; }
+
+  void setThrows(ThrownErrorDestination throws) {
+    assert(!ThrowDest);
+    ThrowDest = throws;
+  }
+
   /// Determine whether this reference needs may implicitly throw.
   ///
   /// This is the case for non-throwing `distributed func` declarations,
@@ -4627,6 +4653,11 @@ class ApplyExpr : public Expr {
   // isolations in this struct.
   llvm::Optional<ApplyIsolationCrossing> IsolationCrossing;
 
+  /// Destination information for a thrown error, which includes any
+  /// necessary conversions from the actual type thrown to the type that
+  /// is expected by the enclosing context.
+  ThrownErrorDestination ThrowDest;
+
 protected:
   ApplyExpr(ExprKind kind, Expr *fn, ArgumentList *argList, bool implicit,
             Type ty = Type())
@@ -4656,16 +4687,18 @@ class ApplyExpr : public Expr {
   /// Does this application throw?  This is only meaningful after
   /// complete type-checking.
   ///
-  /// If true, the function expression must have a throwing function
-  /// type.  The converse is not true because of 'rethrows' functions.
-  bool throws() const {
+  /// Returns the thrown error destination, which includes both the type
+  /// thrown from this application as well as the the context's error type,
+  /// which may be different.
+  ThrownErrorDestination throws() const {
     assert(Bits.ApplyExpr.ThrowsIsSet);
-    return Bits.ApplyExpr.Throws;
+    return ThrowDest;
   }
-  void setThrows(bool throws) {
+
+  void setThrows(ThrownErrorDestination throws) {
     assert(!Bits.ApplyExpr.ThrowsIsSet);
     Bits.ApplyExpr.ThrowsIsSet = true;
-    Bits.ApplyExpr.Throws = throws;
+    ThrowDest = throws;
   }
 
   /// Is this a 'rethrows' function that is known not to throw?

include/swift/AST/Stmt.h

@@ -24,6 +24,7 @@
 #include "swift/AST/ConcreteDeclRef.h"
 #include "swift/AST/IfConfigClause.h"
 #include "swift/AST/TypeAlignments.h"
+#include "swift/AST/ThrownErrorDestination.h"
 #include "swift/Basic/Debug.h"
 #include "swift/Basic/NullablePtr.h"
 #include "llvm/ADT/None.h"
@@ -1383,6 +1384,7 @@ class DoCatchStmt final
 
   SourceLoc DoLoc;
   Stmt *Body;
+  ThrownErrorDestination RethrowDest;
 
   DoCatchStmt(LabeledStmtInfo labelInfo, SourceLoc doLoc, Stmt *body,
               ArrayRef<CaseStmt *> catches, llvm::Optional<bool> implicit)
@@ -1433,6 +1435,15 @@ class DoCatchStmt final
   // rethrown.
   Type getCaughtErrorType() const;
 
+  /// Retrieves the rethrown error and its conversion to the error type
+  /// expected by the enclosing context.
+  ThrownErrorDestination rethrows() const { return RethrowDest; }
+
+  void setRethrows(ThrownErrorDestination rethrows) {
+    assert(!RethrowDest);
+    RethrowDest = rethrows;
+  }
+
   static bool classof(const Stmt *S) {
     return S->getKind() == StmtKind::DoCatch;
   }

include/swift/AST/ThrownErrorDestination.h

@@ -0,0 +1,87 @@
+//===--- ThrownErrorDestination.h - Thrown error dest -----------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the ThrownErrorDestination class.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_AST_THROWNERRORDESTINATION
+#define SWIFT_AST_THROWNERRORDESTINATION
+
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/PointerUnion.h"
+#include "swift/AST/Type.h"
+#include "swift/AST/TypeAlignments.h"
+
+namespace swift {
+class Expr;
+class OpaqueValueExpr;
+
+/// Describes an error thrown from a particular operation and its conversion
+/// to the error type expected by its context.
+class ThrownErrorDestination {
+  struct Conversion {
+    /// The opaque value, which is of the thrown error type.
+    OpaqueValueExpr *thrownError;
+
+    /// The conversion from the opaque value type to the type needed by the
+    /// context.
+    Expr *conversion;
+  };
+
+  llvm::PointerUnion<TypeBase *, Conversion *> storage;
+
+  ThrownErrorDestination(Type type) : storage(type.getPointer()) { }
+  ThrownErrorDestination(Conversion *conversion) : storage(conversion) { }
+
+public:
+  /// Construct a non-throwing destination.
+  ThrownErrorDestination() : storage(nullptr) { }
+
+  /// Construct a non-throwing destination.
+  ThrownErrorDestination(std::nullptr_t) : storage(nullptr) { }
+
+  /// Whether there is a thrown error destination at all.
+  explicit operator bool() const { return !storage.isNull(); }
+
+  /// A thrown error destination where the thrown type corresponds to the
+  /// type caught (or rethrows) by the enclosing context.
+  static ThrownErrorDestination forMatchingContextType(Type thrownError) {
+    return ThrownErrorDestination(thrownError);
+  }
+
+  /// A thrown error destination where the thrown error requires a conversion
+  /// to the error type expected by its context.
+  static ThrownErrorDestination forConversion(OpaqueValueExpr *thrownError,
+                                              Expr *conversion);
+
+  /// Retrieve the type of error thrown from this function call.
+  Type getThrownErrorType() const;
+
+  /// Retrieve the type of the error expected in this context.
+  Type getContextErrorType() const;
+
+  /// Retrieve the conversion as a pair of (opaque thrown error value,
+  /// conversion expression), when a conversion from the thrown error type
+  /// to the context error type is required.
+  llvm::Optional<std::pair<OpaqueValueExpr *, Expr *>> getConversion() const {
+    if (auto conversion = storage.dyn_cast<Conversion *>()) {
+      return std::make_pair(conversion->thrownError, conversion->conversion);
+    }
+
+    return llvm::None;
+  }
+};
+
+} // end namespace swift
+
+#endif // SWIFT_AST_THROWNERRORDESTINATION

lib/AST/ASTDumper.cpp

@@ -893,6 +893,33 @@ namespace {
       printFieldQuotedRaw([&](raw_ostream &OS) { declRef.dump(OS); }, label,
                           Color);
     }
+
+    void printThrowDest(ThrownErrorDestination throws, bool wantNothrow) {
+      if (!throws) {
+        if (wantNothrow)
+          printFlag("nothrow", ExprModifierColor);
+
+        return;
+      }
+
+      auto thrownError = throws.getThrownErrorType();
+      auto contextError = throws.getContextErrorType();
+      if (thrownError->isEqual(contextError)) {
+        // No translation of the thrown error type is required, so ony print
+        // the thrown error type.
+        Type errorExistentialType =
+            contextError->getASTContext().getErrorExistentialType();
+        if (errorExistentialType && thrownError->isEqual(errorExistentialType))
+          printFlag("throws", ExprModifierColor);
+        else {
+          printFlag("throws(" + thrownError.getString() + ")", ExprModifierColor);
+        }
+        return;
+      }
+
+      printFlag("throws(" + thrownError.getString() + " to " +
+                contextError.getString() + ")", ExprModifierColor);
+    }
   };
 
   class PrintPattern : public PatternVisitor<PrintPattern, void, StringRef>,
@@ -2021,6 +2048,7 @@ class PrintStmt : public StmtVisitor<PrintStmt, void, StringRef>,
 
   void visitDoCatchStmt(DoCatchStmt *S, StringRef label) {
     printCommon(S, "do_catch_stmt", label);
+    printThrowDest(S->rethrows(), /*wantNothrow=*/true);
     printRec(S->getBody(), "body");
     printRecRange(S->getCatches(), Ctx, "catch_stmts");
     printFoot();
@@ -2208,6 +2236,7 @@ class PrintExpr : public ExprVisitor<PrintExpr, void, StringRef>,
 
   void visitDeclRefExpr(DeclRefExpr *E, StringRef label) {
     printCommon(E, "declref_expr", label);
+    printThrowDest(E->throws(), /*wantNothrow=*/false);
 
     printDeclRefField(E->getDeclRef(), "decl");
     if (E->getAccessSemantics() != AccessSemantics::Ordinary)
@@ -2279,6 +2308,7 @@ class PrintExpr : public ExprVisitor<PrintExpr, void, StringRef>,
 
   void visitMemberRefExpr(MemberRefExpr *E, StringRef label) {
     printCommon(E, "member_ref_expr", label);
+    printThrowDest(E->throws(), /*wantNothrow=*/false);
 
     printDeclRefField(E->getMember(), "decl");
     if (E->getAccessSemantics() != AccessSemantics::Ordinary)
@@ -2290,6 +2320,7 @@ class PrintExpr : public ExprVisitor<PrintExpr, void, StringRef>,
   }
   void visitDynamicMemberRefExpr(DynamicMemberRefExpr *E, StringRef label) {
     printCommon(E, "dynamic_member_ref_expr", label);
+    printThrowDest(E->throws(), /*wantNothrow=*/false);
 
     printDeclRefField(E->getMember(), "decl");
 
@@ -2389,6 +2420,7 @@ class PrintExpr : public ExprVisitor<PrintExpr, void, StringRef>,
   }
   void visitSubscriptExpr(SubscriptExpr *E, StringRef label) {
     printCommon(E, "subscript_expr", label);
+    printThrowDest(E->throws(), /*wantNothrow=*/false);
 
     if (E->getAccessSemantics() != AccessSemantics::Ordinary)
       printFlag(getDumpString(E->getAccessSemantics()), AccessLevelColor);
@@ -2410,6 +2442,7 @@ class PrintExpr : public ExprVisitor<PrintExpr, void, StringRef>,
   }
   void visitDynamicSubscriptExpr(DynamicSubscriptExpr *E, StringRef label) {
     printCommon(E, "dynamic_subscript_expr", label);
+    printThrowDest(E->throws(), /*wantNothrow=*/false);
 
     printDeclRefField(E->getMember(), "decl");
 
@@ -2798,7 +2831,7 @@ class PrintExpr : public ExprVisitor<PrintExpr, void, StringRef>,
   void printApplyExpr(ApplyExpr *E, const char *NodeName, StringRef label) {
     printCommon(E, NodeName, label);
     if (E->isThrowsSet()) {
-      printFlag(E->throws() ? "throws" : "nothrow", ExprModifierColor);
+      printThrowDest(E->throws(), /*wantNothrow=*/true);
     }
     printFieldQuotedRaw([&](raw_ostream &OS) {
       auto isolationCrossing = E->getIsolationCrossing();

lib/AST/Expr.cpp

@@ -2860,3 +2860,36 @@ Type Expr::findOriginalType() const {
 
   return expr->getType()->getRValueType();
 }
+
+ThrownErrorDestination
+ThrownErrorDestination::forConversion(OpaqueValueExpr *thrownError,
+                                      Expr *conversion) {
+  ASTContext &ctx = thrownError->getType()->getASTContext();
+  auto conversionStorage = ctx.Allocate<Conversion>();
+  conversionStorage->thrownError = thrownError;
+  conversionStorage->conversion = conversion;
+
+  return ThrownErrorDestination(conversionStorage);
+}
+
+Type ThrownErrorDestination::getThrownErrorType() const {
+  if (!*this)
+    return Type();
+
+  if (auto type = storage.dyn_cast<TypeBase *>())
+    return Type(type);
+
+  auto conversion = storage.get<Conversion *>();
+  return conversion->thrownError->getType();
+}
+
+Type ThrownErrorDestination::getContextErrorType() const {
+  if (!*this)
+    return Type();
+
+  if (auto type = storage.dyn_cast<TypeBase *>())
+    return Type(type);
+
+  auto conversion = storage.get<Conversion *>();
+  return conversion->conversion->getType();
+}