Extend effects checking to the various expressions that reference declarations

Only "unsafe" checking is affected here.

Author: DougGregor

lib/Sema/TypeCheckEffects.cpp

@@ -591,6 +591,22 @@ class EffectsHandlingWalker : public ASTWalker {
       recurse = asImpl().checkWithSubstitutionMap(E, UTO->substitutions);
     } else if (auto *EE = dyn_cast<ErasureExpr>(E)) {
       recurse = asImpl().checkWithConformances(E, EE->getConformances());
+    } else if (auto *OCD = dyn_cast<OtherConstructorDeclRefExpr>(E)) {
+      recurse = asImpl().checkDeclRef(OCD, OCD->getDeclRef(), OCD->getLoc(),
+                                      /*isImplicitlyAsync=*/false,
+                                      /*isImplicitlyThrows=*/false);
+    } else if (auto *ME = dyn_cast<MacroExpansionExpr>(E)) {
+      recurse = asImpl().checkDeclRef(ME, ME->getMacroRef(), ME->getLoc(),
+                                      /*isImplicitlyAsync=*/false,
+                                      /*isImplicitlyThrows=*/false);
+    } else if (auto *LE = dyn_cast<LiteralExpr>(E)) {
+      recurse = asImpl().checkDeclRef(LE, LE->getInitializer(), LE->getLoc(),
+                                      /*isImplicitlyAsync=*/false,
+                                      /*isImplicitlyThrows=*/false);
+    } else if (auto *CE = dyn_cast<CollectionExpr>(E)) {
+      recurse = asImpl().checkDeclRef(CE, CE->getInitializer(), CE->getLoc(),
+                                      /*isImplicitlyAsync=*/false,
+                                      /*isImplicitlyThrows=*/false);
     }
     // Error handling validation (via checkTopLevelEffects) happens after
     // type checking. If an unchecked expression is still around, the code was
@@ -1879,7 +1895,7 @@ class ApplyClassifier {
           Self.classifyDeclRef(
             declRef, loc, isImplicitlyAsync, isImplicitlyThrows
           ).onlyThrowing());
-      return ShouldNotRecurse;
+      return ShouldRecurse;
     }
     ShouldRecurse_t checkAsyncLet(PatternBindingDecl *patternBinding) {
       return ShouldRecurse;
@@ -2006,7 +2022,7 @@ class ApplyClassifier {
           AsyncKind = ConditionalEffectKind::Always;
       }
 
-      return ShouldNotRecurse;
+      return ShouldRecurse;
     }
     ShouldRecurse_t checkAsyncLet(PatternBindingDecl *patternBinding) {
       AsyncKind = ConditionalEffectKind::Always;
@@ -3634,7 +3650,7 @@ class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage>
         declRefExpr->setThrows(throwDest);
     }
 
-    return ShouldNotRecurse;
+    return ShouldRecurse;
   }
 
   ShouldRecurse_t checkAsyncLet(PatternBindingDecl *patternBinding) {

test/Unsafe/safe.swift

@@ -81,6 +81,16 @@ func returnsExistentialP() -> any P {
   // expected-note@-1{{@unsafe conformance of 'Int' to protocol 'P' involves unsafe code}}
 }
 
+class MyRange {
+  @unsafe init(unchecked bounds: Range<Int>) { }
+
+  convenience init(_ bounds: Range<Int>) {
+    // bounds check
+    self.init(unchecked: bounds) // expected-warning{{expression uses unsafe constructs but is not marked with 'unsafe'}}
+    // expected-note@-1{{reference to unsafe initializer 'init(unchecked:)'}}
+  }
+}
+
 // Parsing of `unsafe` expressions.
 func testUnsafePositionError() -> Int {
   return 3 + unsafe unsafeInt() // expected-error{{'unsafe' cannot appear to the right of a non-assignment operator}}