Merge pull request #70283 from DougGregor/typed-try-force-and-opt

Author: DougGregor

include/swift/AST/ASTScope.h

@@ -945,8 +945,6 @@ class CustomAttributeScope final : public ASTScopeImpl {
 
   bool ignoreInDebugInfo() const override { return true; }
 
-  DeclAttribute *getDeclAttr() const { return attr; }
-
 private:
   void expandAScopeThatDoesNotCreateANewInsertionPoint(ScopeCreator &);
 
@@ -1222,10 +1220,6 @@ class SpecializeAttributeScope final : public ASTScopeImpl {
     return specializeAttr;
   }
 
-  DeclAttribute *getDeclAttr() const {
-    return specializeAttr;
-  }
-
 protected:
   ASTScopeImpl *expandSpecifically(ScopeCreator &) override;
   bool lookupLocalsOrMembers(DeclConsumer) const override;
@@ -1256,10 +1250,6 @@ class DifferentiableAttributeScope final : public ASTScopeImpl {
     return differentiableAttr;
   }
 
-  DeclAttribute *getDeclAttr() const {
-    return differentiableAttr;
-  }
-
 protected:
   ASTScopeImpl *expandSpecifically(ScopeCreator &) override;
   bool lookupLocalsOrMembers(DeclConsumer) const override;
@@ -1839,6 +1829,32 @@ class BraceStmtScope final : public AbstractStmtScope {
     return scope->getKind() == ScopeKind::BraceStmt;
   }
 };
+
+/// Describes a scope introduced by a try/try!/try? expression.
+class TryScope final : public ASTScopeImpl {
+public:
+  AnyTryExpr *const expr;
+  TryScope(AnyTryExpr *e)
+      : ASTScopeImpl(ScopeKind::Try), expr(e) {}
+  virtual ~TryScope() {}
+
+protected:
+  ASTScopeImpl *expandSpecifically(ScopeCreator &scopeCreator) override;
+
+private:
+  void expandAScopeThatDoesNotCreateANewInsertionPoint(ScopeCreator &);
+
+public:
+  SourceRange
+  getSourceRangeOfThisASTNode(bool omitAssertions = false) const override;
+
+  Expr *getExpr() const { return expr; }
+
+  static bool classof(const ASTScopeImpl *scope) {
+    return scope->getKind() == ScopeKind::Try;
+  }
+};
+
 } // namespace ast_scope
 } // namespace swift
 

include/swift/AST/ASTScopeNodes.def

@@ -88,6 +88,7 @@ STMT_SCOPE_NODE(CaseStmt)
 SCOPE_NODE(CaseLabelItem)
 SCOPE_NODE(CaseStmtBody)
 STMT_SCOPE_NODE(BraceStmt)
+EXPR_SCOPE_NODE(Try)
 
 #undef DECL_ATTRIBUTE_SCOPE_NODE
 #undef EXPR_SCOPE_NODE

include/swift/AST/CatchNode.h

@@ -24,7 +24,7 @@ namespace swift {
 /// An AST node that represents a point where a thrown error can be caught and
 /// or rethrown, which includes functions do...catch statements.
 class CatchNode: public llvm::PointerUnion<
-    AbstractFunctionDecl *, AbstractClosureExpr *, DoCatchStmt *
+    AbstractFunctionDecl *, AbstractClosureExpr *, DoCatchStmt *, AnyTryExpr *
   > {
 public:
   using PointerUnion::PointerUnion;

lib/AST/ASTScopeCreation.cpp

@@ -100,8 +100,8 @@ class ScopeCreator final : public ASTAllocated<ScopeCreator> {
     ASTScopeAssert(expr,
                  "If looking for closures, must have an expression to search.");
 
-    /// AST walker that finds nested scopes in expressions. This handles both
-    /// closures and if/switch expressions.
+    /// AST walker that finds nested scopes in expressions. This handles
+    /// closures, if/switch expressions, and try/try!/try? expressions.
     class NestedExprScopeFinder : public ASTWalker {
       ScopeCreator &scopeCreator;
       ASTScopeImpl *parent;
@@ -130,6 +130,13 @@ class ScopeCreator final : public ASTAllocated<ScopeCreator> {
           scopeCreator.addToScopeTree(SVE->getStmt(), parent);
           return Action::SkipChildren(E);
         }
+
+        // If we have a try/try!/try?, we need to add a scope for it
+        if (auto anyTry = dyn_cast<AnyTryExpr>(E)) {
+          scopeCreator.constructExpandAndInsert<TryScope>(parent, anyTry);
+          return Action::SkipChildren(E);
+        }
+
         return Action::Continue(E);
       }
       PreWalkResult<Stmt *> walkToStmtPre(Stmt *S) override {
@@ -762,6 +769,7 @@ NO_NEW_INSERTION_POINT(MacroDefinitionScope)
 NO_NEW_INSERTION_POINT(MacroExpansionDeclScope)
 NO_NEW_INSERTION_POINT(SwitchStmtScope)
 NO_NEW_INSERTION_POINT(WhileStmtScope)
+NO_NEW_INSERTION_POINT(TryScope)
 
 NO_EXPANSION(GenericParamScope)
 NO_EXPANSION(SpecializeAttributeScope)
@@ -1372,6 +1380,11 @@ IterableTypeBodyPortion::insertionPointForDeferredExpansion(
   return s->getParent().get();
 }
 
+void TryScope::expandAScopeThatDoesNotCreateANewInsertionPoint(
+    ScopeCreator &scopeCreator) {
+  scopeCreator.addToScopeTree(expr->getSubExpr(), this);
+}
+
 #pragma mark verification
 
 void ast_scope::simple_display(llvm::raw_ostream &out,

lib/AST/ASTScopeLookup.cpp

@@ -724,6 +724,13 @@ CatchNode ASTScopeImpl::lookupCatchNode(ModuleDecl *module, SourceLoc loc) {
       return caught.first;
     }
 
+    // If this is a try scope for a try! or try?, it catches the error.
+    if (auto tryScope = dyn_cast<TryScope>(scope)) {
+      if (isa<ForceTryExpr>(tryScope->expr) ||
+          isa<OptionalTryExpr>(tryScope->expr))
+        return tryScope->expr;
+    }
+
     innerBodyScope = dyn_cast<BraceStmtScope>(scope);
   }
 

lib/AST/ASTScopeSourceRange.cpp

@@ -408,3 +408,8 @@ SourceLoc ast_scope::extractNearestSourceLoc(
   const ASTScopeImpl *scope = std::get<0>(scopeAndCreator);
   return scope->getSourceRangeOfThisASTNode().Start;
 }
+
+SourceRange TryScope::getSourceRangeOfThisASTNode(
+    const bool omitAssertions) const {
+  return expr->getSourceRange();
+}

lib/AST/Decl.cpp

@@ -11701,14 +11701,34 @@ CatchNode::getThrownErrorTypeInContext(DeclContext *dc) const {
     return llvm::None;
   }
 
-  auto doCatch = get<DoCatchStmt *>();
-  if (auto thrownError = doCatch->getCaughtErrorType(dc)) {
-    if (thrownError->isNever())
-      return llvm::None;
+  if (auto doCatch = dyn_cast<DoCatchStmt *>()) {
+    if (auto thrownError = doCatch->getCaughtErrorType(dc)) {
+      if (thrownError->isNever())
+        return llvm::None;
+
+      return thrownError;
+    }
+
+    // If we haven't computed the error type yet, return 'any Error'.
+    return dc->getASTContext().getErrorExistentialType();
+  }
+
+  auto tryExpr = get<AnyTryExpr *>();
+  if (auto forceTry = llvm::dyn_cast<ForceTryExpr>(tryExpr)) {
+    if (auto thrownError = forceTry->getThrownError())
+      return thrownError;
+
+    // If we haven't computed the error type yet, return 'any Error'.
+    return dc->getASTContext().getErrorExistentialType();
+  }
+
+  if (auto optTry = llvm::dyn_cast<OptionalTryExpr>(tryExpr)) {
+    if (auto thrownError = optTry->getThrownError())
+      return thrownError;
 
-    return thrownError;
+    // If we haven't computed the error type yet, return 'any Error'.
+    return dc->getASTContext().getErrorExistentialType();
   }
 
-  // If we haven't computed the error type yet, do so now.
-  return dc->getASTContext().getErrorExistentialType();
+  llvm_unreachable("Unhandled catch node kind");
 }

lib/SILGen/SILGenStmt.cpp

@@ -1569,7 +1569,7 @@ void SILGenFunction::emitThrow(SILLocation loc, ManagedValue exnMV,
   // If the thrown error type differs from what the throw destination expects,
   // perform the conversion.
   // FIXME: Can the AST tell us what to do here?
-  if (exnType != destErrorType && !shouldDiscard) {
+  if (exnType != destErrorType) {
     assert(destErrorType == SILType::getExceptionType(getASTContext()));
 
     ProtocolConformanceRef conformances[1] = {

test/NameLookup/scope_map-astscopelookup.swift

@@ -209,7 +209,7 @@ func HasLabeledDo() {
 // RUN: %FileCheck -check-prefix CHECK-EXPANDED %s < %t.expanded
 
 // CHECK-EXPANDED: ***Complete scope map***
-// CHECK-EXPANDED-NEXT: ASTSourceFileScope {{.*}}, [1:1 - 480:1] '{{.*}}scope_map-astscopelookup.swift'
+// CHECK-EXPANDED-NEXT: ASTSourceFileScope {{.*}}, [1:1 - 481:1] '{{.*}}scope_map-astscopelookup.swift'
 // CHECK-EXPANDED-NEXT: |-NominalTypeDeclScope {{.*}}, [5:1 - 7:1] 'S0'
 // CHECK-EXPANDED-NEXT:   `-NominalTypeBodyScope {{.*}}, [5:11 - 7:1] 'S0'
 // CHECK-EXPANDED-NEXT:     `-NominalTypeDeclScope {{.*}}, [6:3 - 6:19] 'InnerC0'
@@ -317,7 +317,8 @@ func HasLabeledDo() {
 // CHECK-EXPANDED-NEXT:                     |-ForEachStmtScope {{.*}}, [80:3 - 82:3] 
 // CHECK-EXPANDED-NEXT:                       `-ForEachPatternScope, [80:52 - 82:3] 
 // CHECK-EXPANDED-NEXT:                     |-DoCatchStmtScope {{.*}}, [84:3 - 88:3] 
-// CHECK-EXPANDED-NEXT:                       |-BraceStmtScope {{.*}}, [84:6 - 86:3] 
+// CHECK-EXPANDED-NEXT:                       |-BraceStmtScope {{.*}}, [84:6 - 86:3]
+// CHECK-EXPANDED-NEXT:                       `-TryScope {{.*}}, [85:5 - 85:18]
 // CHECK-EXPANDED-NEXT:                       |-CaseStmtScope {{.*}}, [86:5 - 87:3] 
 // CHECK-EXPANDED-NEXT:                         `-CaseLabelItemScope, [86:37 - 86:51] 
 // CHECK-EXPANDED-NEXT:                       `-CaseStmtScope {{.*}}, [87:5 - 88:3] 
@@ -396,8 +397,8 @@ func HasLabeledDo() {
 // CHECK-EXPANDED-NEXT:             `-BraceStmtScope {{.*}}, [160:12 - 160:22] 
 // CHECK-EXPANDED-NEXT:       `-ClosureParametersScope {{.*}}, [162:10 - 162:19] 
 // CHECK-EXPANDED-NEXT:         `-BraceStmtScope {{.*}}, [162:10 - 162:19] 
-// CHECK-EXPANDED-NEXT: `-TopLevelCodeScope {{.*}}, [165:1 - 480:1] 
-// CHECK-EXPANDED-NEXT:   `-BraceStmtScope {{.*}}, [165:1 - 480:1] 
+// CHECK-EXPANDED-NEXT: `-TopLevelCodeScope {{.*}}, [165:1 - 481:1] 
+// CHECK-EXPANDED-NEXT:   `-BraceStmtScope {{.*}}, [165:1 - 481:1] 
 // CHECK-EXPANDED-NEXT:     |-ClosureParametersScope {{.*}}, [165:1 - 165:14] 
 // CHECK-EXPANDED-NEXT:       `-BraceStmtScope {{.*}}, [165:1 - 165:14] 
 // CHECK-EXPANDED-NEXT:     |-AbstractFunctionDeclScope {{.*}}, [167:1 - 176:1] 'defaultArguments(i:j:)'

test/SILGen/typed_throws.swift

@@ -146,6 +146,36 @@ func throwsDifferentFromEnclosing() throws(Foo) {
   throw Foo()
 }
 
+// CHECK-LABEL: sil hidden [ossa] @$s12typed_throws17forceTryDifferentyyAA7MyErrorOYKF
+func forceTryDifferent() throws(MyError) {
+  // CHECK: try_apply{{.*}}, normal [[NORMAL_BB:bb[0-9]+]], error [[ERROR_BB:bb[0-9]+]]
+  // CHECK: [[NORMAL_BB]]([[RESULT:%.*]] : $()):
+  // CHECK: return
+  // CHECK: [[ERROR_BB]]([[ERROR:%.*]] : $MyBigError):
+  // CHECK-NEXT: unreachable
+  try! throwsMyBigError()
+}
+
+// CHECK-LABEL: sil hidden [ossa] @$s12typed_throws20optionalTryDifferentyyAA7MyErrorOYKF
+func optionalTryDifferent() throws(MyError) {
+  // CHECK: try_apply{{.*}}, normal [[NORMAL_BB:bb[0-9]+]], error [[ERROR_BB:bb[0-9]+]]
+  // CHECK: [[NORMAL_BB]]([[RESULT:%.*]] : $()):
+  // CHECK: br
+  // CHECK: [[ERROR_BB]]([[ERROR:%.*]] : $MyBigError):
+  // CHECK-NEXT: enum $Optional<()>, #Optional.none!enumelt
+  try? throwsMyBigError()
+}
+
+func throwsMyBigErrorOrReturnsInt() throws(MyBigError) -> Int { 5 }
+
+func mightThrowAny(arg: Int) throws { }
+
+// CHECK-LABEL: sil hidden [ossa] @$s12typed_throws14forceTryErasedyyF : $@convention(thin) () -> () {
+func forceTryErased() {
+  // CHECK: try_apply {{.*}} @error MyBigError
+  // CHECK: try_apply {{.*}} @error any Error
+  try! mightThrowAny(arg: throwsMyBigErrorOrReturnsInt())
+}
 
 // CHECK-LABEL:      sil_vtable MySubclass {
 // CHECK-NEXT:   #MyClass.init!allocator: <E where E : Error> (MyClass.Type) -> (() throws(E) -> ()) throws(E) -> MyClass : @$s12typed_throws10MySubclassC4bodyACyyxYKXE_txYKcs5ErrorRzlufC [override]

test/stmt/typed_throws.swift

@@ -170,3 +170,9 @@ func testDoCatchExplicitTyped() {
   do throws(HomeworkError) { // expected-error{{a 'do' statement with a 'throws' clause must have at least one 'catch'}}
   }
 }
+
+func tryBangQuestionMismatchingContext() throws(MyError) {
+  try! doHomework()
+  try? doHomework()
+  try doHomework() // expected-error{{thrown expression type 'HomeworkError' cannot be converted to error type 'MyError'}}
+}