Don't perform @preconcurrency typealias adjustments in @preconcurrency decls

When a `@preconcurrency` typealias is used within the type of a
`@preconcurrency` declaration, such as a function, do not strip
concurrency-related types, because the stripping will happen in the
outer declaration.

Fixes #60488.

(cherry picked from commit 2fbdad7)

Author: DougGregor

lib/Sema/TypeCheckDecl.cpp

@@ -1814,6 +1814,8 @@ UnderlyingTypeRequest::evaluate(Evaluator &evaluator,
   TypeResolutionOptions options((typeAlias->getGenericParams()
                                      ? TypeResolverContext::GenericTypeAliasDecl
                                      : TypeResolverContext::TypeAliasDecl));
+  if (typeAlias->preconcurrency())
+    options |= TypeResolutionFlags::Preconcurrency;
 
   // This can happen when code completion is attempted inside
   // of typealias underlying type e.g. `typealias F = () -> Int#^TOK^#`
@@ -2094,8 +2096,11 @@ ResultTypeRequest::evaluate(Evaluator &evaluator, ValueDecl *decl) const {
             : ErrorType::get(ctx));
   }
 
-  const auto options =
+  auto options =
       TypeResolutionOptions(TypeResolverContext::FunctionResult);
+  if (decl->preconcurrency())
+    options |= TypeResolutionFlags::Preconcurrency;
+
   auto *const dc = decl->getInnermostDeclContext();
   return TypeResolution::forInterface(dc, options,
                                       /*unboundTyOpener*/ nullptr,
@@ -2196,6 +2201,13 @@ static Type validateParameterType(ParamDecl *decl) {
     options = TypeResolutionOptions(TypeResolverContext::EnumElementDecl);
   }
 
+  // Set the "preconcurrency" flag if this is a parameter of a preconcurrency
+  // declaration.
+  if (auto decl = dc->getAsDecl()) {
+    if (decl->preconcurrency())
+      options |= TypeResolutionFlags::Preconcurrency;
+  }
+
   // If the element is a variadic parameter, resolve the parameter type as if
   // it were in non-parameter position, since we want functions to be
   // @escaping in this case.

lib/Sema/TypeCheckType.cpp

@@ -289,10 +289,20 @@ static Type getIdentityOpaqueTypeArchetypeType(
 /// Adjust the underlying type of a typealias within the given context to
 /// account for @preconcurrency.
 static Type adjustTypeAliasTypeInContext(
-    Type type, TypeAliasDecl *aliasDecl, DeclContext *fromDC) {
+    Type type, TypeAliasDecl *aliasDecl, DeclContext *fromDC,
+    TypeResolutionOptions options) {
+  // If we are in a @preconcurrency declaration, don't adjust the types of
+  // type aliases.
+  if (options.contains(TypeResolutionFlags::Preconcurrency))
+    return type;
+
+  // If the type alias itself isn't marked with @preconcurrency, don't
+  // adjust the type.
   if (!aliasDecl->preconcurrency())
     return type;
 
+  // Only adjust the type within a strict concurrency context, so we don't
+  // change the types as seen by code that hasn't adopted concurrency.
   if (contextRequiresStrictConcurrencyChecking(
           fromDC,
           [](const AbstractClosureExpr *closure) {
@@ -332,7 +342,7 @@ Type TypeResolution::resolveTypeInContext(TypeDecl *typeDecl,
   /// to adjust its type for concurrency.
   auto adjustAliasType = [&](Type type) -> Type {
     return adjustTypeAliasTypeInContext(
-        type, cast<TypeAliasDecl>(typeDecl), fromDC);
+        type, cast<TypeAliasDecl>(typeDecl), fromDC, options);
   };
 
   if (!isSpecialized) {
@@ -1602,7 +1612,8 @@ static Type resolveNestedIdentTypeComponent(TypeResolution resolution,
     // Type aliases might require adjustment due to @preconcurrency.
     if (auto aliasDecl = dyn_cast<TypeAliasDecl>(member)) {
       memberType = adjustTypeAliasTypeInContext(
-          memberType, aliasDecl, resolution.getDeclContext());
+          memberType, aliasDecl, resolution.getDeclContext(),
+          resolution.getOptions());
     }
 
     if (options.contains(TypeResolutionFlags::SilenceErrors)) {

lib/Sema/TypeCheckType.h

@@ -67,6 +67,9 @@ enum class TypeResolutionFlags : uint16_t {
   /// Needed to enforce that \c any P<some Q> does not resolve to a
   /// parameterized existential with an opaque type constraint.
   DisallowOpaqueTypes = 1 << 9,
+
+  /// We are in a `@preconcurrency` declaration.
+  Preconcurrency = 1 << 10,
 };
 
 /// Type resolution contexts that require special handling.

test/Concurrency/preconcurrency_typealias.swift

@@ -10,6 +10,15 @@ struct Outer {
   @preconcurrency typealias FN = @Sendable () -> Void
 }
 
+@preconcurrency func preconcurrencyFunc(callback: FN) {}
+
+func usage() {
+}
+
+func usageAsync() async {
+}
+
+
 func test() {
   var _: Outer.FN = {
     f()
@@ -19,6 +28,12 @@ func test() {
     f()
     print("Hello")
   }
+
+  var mutableVariable = 0
+  preconcurrencyFunc {
+    mutableVariable += 1 // no sendable warning
+  }
+  mutableVariable += 1
 }
 
 @available(SwiftStdlib 5.1, *)
@@ -31,4 +46,10 @@ func testAsync() async {
     f() // expected-error{{call to main actor-isolated global function 'f()' in a synchronous nonisolated context}}
     print("Hello")
   }
+
+  var mutableVariable = 0
+  preconcurrencyFunc {
+    mutableVariable += 1 // expected-warning{{mutation of captured var 'mutableVariable' in concurrently-executing code; this is an error in Swift 6}}
+  }
+  mutableVariable += 1
 }