Merge pull request #76660 from kavon/small-fixes

Sema: generalize `findSyntacticErrorForConsume`

Author: kavon

include/swift/Sema/ConstraintSystem.h

@@ -6534,7 +6534,8 @@ ForcedCheckedCastExpr *findForcedDowncast(ASTContext &ctx, Expr *expr);
 /// can I add `consume` around this expression?
 ///
 /// \param module represents the module in which the expr appears
-bool canAddExplicitConsume(ModuleDecl *module, Expr *expr);
+bool canAddExplicitConsume(constraints::Solution &sol,
+                           ModuleDecl *module, Expr *expr);
 
 // Count the number of overload sets present
 // in the expression and all of the children.

lib/Sema/CSApply.cpp

@@ -5620,18 +5620,18 @@ namespace {
 
       /// Check if it needs an explicit consume, due to this being a cast.
       auto *module = dc->getParentModule();
-      auto origType = cs.getType(injection->getSubExpr());
+      auto origType = solution.getResolvedType(injection->getSubExpr());
       if (willHaveConfusingConsumption(origType, locator, cs) &&
-          canAddExplicitConsume(module, injection->getSubExpr()))
+          canAddExplicitConsume(solution, module, injection->getSubExpr()))
         ConsumingCoercions.push_back(injection);
     }
 
     void diagnoseExistentialErasureOf(Expr *fromExpr, Expr *toExpr,
                                       ConstraintLocatorBuilder locator) {
       auto *module = dc->getParentModule();
-      auto fromType = cs.getType(fromExpr);
+      auto fromType = solution.getResolvedType(fromExpr);
       if (willHaveConfusingConsumption(fromType, locator, cs) &&
-          canAddExplicitConsume(module, fromExpr)) {
+          canAddExplicitConsume(solution, module, fromExpr)) {
         ConsumingCoercions.push_back(toExpr);
       }
     }

lib/Sema/MiscDiagnostics.cpp

@@ -1478,12 +1478,13 @@ static void diagSyntacticUseRestrictions(const Expr *E, const DeclContext *DC,
 }
 
 DeferredDiags swift::findSyntacticErrorForConsume(
-    ModuleDecl *module, SourceLoc loc, Expr *subExpr) {
+    ModuleDecl *module, SourceLoc loc, Expr *subExpr,
+    llvm::function_ref<Type(Expr *)> getType) {
   assert(!isa<ConsumeExpr>(subExpr) && "operates on the sub-expr of a consume");
 
   DeferredDiags result;
   const bool noncopyable =
-      subExpr->getType()->getCanonicalType()->isNoncopyable();
+      getType(subExpr)->isNoncopyable();
 
   bool partial = false;
   Expr *current = subExpr;

lib/Sema/MiscDiagnostics.h

@@ -21,6 +21,7 @@
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/SourceLoc.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/STLFunctionalExtras.h"
 #include <optional>
 
 namespace swift {
@@ -162,10 +163,18 @@ namespace swift {
   /// \param loc corresponds to the location of the 'consume' for which
   ///            diagnostics should be collected, if any.
   ///
+  /// \param getType is a function that can correctly determine the type of
+  ///                an expression. This is to support calls from the
+  ///                constraint solver.
+  ///
   /// \returns an empty collection if there are no errors.
-  DeferredDiags findSyntacticErrorForConsume(ModuleDecl *module,
-                                             SourceLoc loc,
-                                             Expr *subExpr);
+  DeferredDiags findSyntacticErrorForConsume(
+                     ModuleDecl *module,
+                     SourceLoc loc,
+                     Expr *subExpr,
+                     llvm::function_ref<Type(Expr *)> getType = [](Expr *E) {
+                       return E->getType();
+                     });
 } // namespace swift
 
 #endif // SWIFT_SEMA_MISC_DIAGNOSTICS_H

lib/Sema/TypeCheckConstraints.cpp

@@ -2338,15 +2338,18 @@ ForcedCheckedCastExpr *swift::findForcedDowncast(ASTContext &ctx, Expr *expr) {
   return nullptr;
 }
 
-bool swift::canAddExplicitConsume(ModuleDecl *module, Expr *expr) {
+bool swift::canAddExplicitConsume(constraints::Solution &sol,
+                                  ModuleDecl *module,
+                                  Expr *expr) {
   expr = expr->getSemanticsProvidingExpr();
 
   // Is it already wrapped in a `consume`?
   if (isa<ConsumeExpr>(expr))
     return false;
 
   // Is this expression valid to wrap inside a `consume`?
-  auto diags = findSyntacticErrorForConsume(module, SourceLoc(), expr);
+  auto diags = findSyntacticErrorForConsume(module, SourceLoc(), expr,
+                            [&](Expr *e) { return sol.getResolvedType(e); });
   return diags.empty();
 }
 

test/Sema/moveonly_casts.swift

@@ -131,3 +131,12 @@ struct ImplicitInit: ~Copyable {
 func test(_ nc: consuming NC) -> ImplicitInit {
   return .init(x: nc)
 }
+
+
+// rdar://134371893 (optional chaining on ~Copyable type)
+struct NonCopyable: ~Copyable {
+    var shared: Self { .init() }
+}
+func f() {
+    _ = (Optional<NonCopyable>.none)?.shared
+}