Apply @_predatesConcurrency adjustments to variables, subscripts.

DougGregor · DougGregor · commit f32572b4cd03 · 2021-11-18T21:12:28.000-08:00
diff --git a/lib/Sema/ConstraintSystem.cpp b/lib/Sema/ConstraintSystem.cpp
@@ -1107,6 +1107,9 @@ Type ConstraintSystem::getUnopenedTypeOfReference(
   Type requestedType =
       getType(value)->getWithoutSpecifierType()->getReferenceStorageReferent();
 
+  // Adjust the type for concurrency.
+  requestedType = adjustVarTypeForConcurrency(requestedType, value, UseDC);
+
   // If we're dealing with contextual types, and we referenced this type from
   // a different context, map the type.
   if (!wantInterfaceType && requestedType->hasArchetype()) {
@@ -1757,7 +1760,11 @@ ConstraintSystem::getTypeOfMemberReference(
                               ->castTo<AnyFunctionType>()->getParams();
       // FIXME: Verify ExtInfo state is correct, not working by accident.
       FunctionType::ExtInfo info;
-      refType = FunctionType::get(indices, elementTy, info);
+      auto *refFnType = FunctionType::get(indices, elementTy, info);
+
+      refType = adjustFunctionTypeForConcurrency(
+          refFnType, subscript, useDC, /*numApplies=*/1,
+          /*isMainDispatchQueue=*/false);
     } else {
       refType = getUnopenedTypeOfReference(cast<VarDecl>(value), baseTy, useDC,
                                            locator,
@@ -2051,14 +2058,17 @@ Type ConstraintSystem::getEffectiveOverloadType(ConstraintLocator *locator,
                        ->castTo<AnyFunctionType>()->getParams();
       // FIXME: Verify ExtInfo state is correct, not working by accident.
       FunctionType::ExtInfo info;
-      type = FunctionType::get(indices, elementTy, info);
+      type = adjustFunctionTypeForConcurrency(
+          FunctionType::get(indices, elementTy, info),
+          subscript, useDC, /*numApplies=*/1, /*isMainDispatchQueue=*/false);
     } else if (auto var = dyn_cast<VarDecl>(decl)) {
       type = var->getValueInterfaceType();
       if (doesStorageProduceLValue(var, overload.getBaseType(), useDC)) {
         type = LValueType::get(type);
       } else if (type->hasDynamicSelfType()) {
         type = withDynamicSelfResultReplaced(type, /*uncurryLevel=*/0);
       }
+      type = adjustVarTypeForConcurrency(type, var, useDC);
     } else if (isa<AbstractFunctionDecl>(decl) || isa<EnumElementDecl>(decl)) {
       if (decl->isInstanceMember() &&
           (!overload.getBaseType() ||
@@ -2087,7 +2097,10 @@ Type ConstraintSystem::getEffectiveOverloadType(ConstraintLocator *locator,
         }
       }
 
-      type = type->castTo<FunctionType>()->getResult();
+      type = adjustFunctionTypeForConcurrency(
+          type->castTo<FunctionType>(),
+          subscript, useDC, /*numApplies=*/2, /*isMainDispatchQueue=*/false)
+        ->getResult();
     }
   }
 
diff --git a/lib/Sema/TypeCheckConcurrency.cpp b/lib/Sema/TypeCheckConcurrency.cpp
@@ -4032,33 +4032,32 @@ static Type applyUnsafeConcurrencyToParameterType(
                                .withGlobalActor(globalActor));
 }
 
-/// Strip concurrency from the type of the given parameter.
-static Type stripConcurrencyFromParameterType(
-    Type paramType, bool dropGlobalActor) {
+/// Strip concurrency from the given type.
+static Type stripConcurrencyFromType(Type type, bool dropGlobalActor) {
   // Look through optionals.
-  if (Type optionalObject = paramType->getOptionalObjectType()) {
+  if (Type optionalObject = type->getOptionalObjectType()) {
     Type newOptionalObject =
-        stripConcurrencyFromParameterType(optionalObject, dropGlobalActor);
+        stripConcurrencyFromType(optionalObject, dropGlobalActor);
     if (optionalObject->isEqual(newOptionalObject))
-      return paramType;
+      return type;
 
     return OptionalType::get(newOptionalObject);
   }
 
   // For function types, strip off Sendable and possibly the global actor.
-  if (auto fnType = paramType->getAs<FunctionType>()) {
+  if (auto fnType = type->getAs<FunctionType>()) {
     auto extInfo = fnType->getExtInfo().withConcurrent(false);
     if (dropGlobalActor)
       extInfo = extInfo.withGlobalActor(Type());
     auto newFnType = FunctionType::get(
         fnType->getParams(), fnType->getResult(), extInfo);
-    if (newFnType->isEqual(paramType))
-      return paramType;
+    if (newFnType->isEqual(type))
+      return type;
 
     return newFnType;
   }
 
-  return paramType;
+  return type;
 }
 
 /// Determine whether the given name is that of a DispatchQueue operation that
@@ -4094,18 +4093,42 @@ static bool hasKnownUnsafeSendableFunctionParams(AbstractFunctionDecl *func) {
   return false;
 }
 
+Type swift::adjustVarTypeForConcurrency(
+    Type type, VarDecl *var, DeclContext *dc) {
+  if (!var->predatesConcurrency())
+    return type;
+
+  if (contextUsesConcurrencyFeatures(dc))
+    return type;
+
+  bool isLValue = false;
+  if (auto *lvalueType = type->getAs<LValueType>()) {
+    type = lvalueType->getObjectType();
+    isLValue = true;
+  }
+
+  type = stripConcurrencyFromType(type, /*dropGlobalActor=*/true);
+
+  if (isLValue)
+    type = LValueType::get(type);
+
+  return type;
+}
+
 /// Adjust a function type for @_unsafeSendable, @_unsafeMainActor, and
 /// @_predatesConcurrency.
 static AnyFunctionType *applyUnsafeConcurrencyToFunctionType(
-    AnyFunctionType *fnType, ValueDecl *funcOrEnum,
+    AnyFunctionType *fnType, ValueDecl *decl,
     bool inConcurrencyContext, unsigned numApplies, bool isMainDispatchQueue) {
-  // Only functions can have @_unsafeSendable/@_unsafeMainActor parameters.
-  auto func = dyn_cast<AbstractFunctionDecl>(funcOrEnum);
-  if (!func)
+  // Functions/subscripts/enum elements have function types to adjust.
+  auto func = dyn_cast_or_null<AbstractFunctionDecl>(decl);
+  auto subscript = dyn_cast_or_null<SubscriptDecl>(decl);
+
+  if (!func && !subscript)
     return fnType;
 
   AnyFunctionType *outerFnType = nullptr;
-  if (func->hasImplicitSelfDecl()) {
+  if (func && func->hasImplicitSelfDecl()) {
     outerFnType = fnType;
     fnType = outerFnType->getResult()->castTo<AnyFunctionType>();
 
@@ -4115,15 +4138,13 @@ static AnyFunctionType *applyUnsafeConcurrencyToFunctionType(
 
   SmallVector<AnyFunctionType::Param, 4> newTypeParams;
   auto typeParams = fnType->getParams();
-  auto paramDecls = func->getParameters();
+  auto paramDecls = func ? func->getParameters() : subscript->getIndices();
   assert(typeParams.size() == paramDecls->size());
-  bool knownUnsafeParams = hasKnownUnsafeSendableFunctionParams(func);
+  bool knownUnsafeParams = func && hasKnownUnsafeSendableFunctionParams(func);
   bool stripConcurrency =
-      funcOrEnum->predatesConcurrency() &&
-      !inConcurrencyContext;
+      decl->predatesConcurrency() && !inConcurrencyContext;
   for (unsigned index : indices(typeParams)) {
     auto param = typeParams[index];
-    auto paramDecl = (*paramDecls)[index];
 
     // Determine whether the resulting parameter should be @Sendable or
     // @MainActor. @Sendable occurs only in concurrency contents, while
@@ -4138,7 +4159,7 @@ static AnyFunctionType *applyUnsafeConcurrencyToFunctionType(
       newParamType = applyUnsafeConcurrencyToParameterType(
         param.getPlainType(), addSendable, addMainActor);
     } else if (stripConcurrency) {
-      newParamType = stripConcurrencyFromParameterType(
+      newParamType = stripConcurrencyFromType(
           param.getPlainType(), numApplies == 0);
     }
 
@@ -4160,14 +4181,25 @@ static AnyFunctionType *applyUnsafeConcurrencyToFunctionType(
     newTypeParams.push_back(param.withType(newParamType));
   }
 
+  // Compute the new result type.
+  Type newResultType = fnType->getResult();
+  if (stripConcurrency) {
+    newResultType = stripConcurrencyFromType(
+        newResultType, /*dropGlobalActor=*/true);
+
+    if (!newResultType->isEqual(fnType->getResult()) && newTypeParams.empty()) {
+      newTypeParams.append(typeParams.begin(), typeParams.end());
+    }
+  }
+
   // If we didn't change any parameters, we're done.
-  if (newTypeParams.empty()) {
+  if (newTypeParams.empty() && newResultType->isEqual(fnType->getResult())) {
     return outerFnType ? outerFnType : fnType;
   }
 
   // Rebuild the (inner) function type.
   fnType = FunctionType::get(
-      newTypeParams, fnType->getResult(), fnType->getExtInfo());
+      newTypeParams, newResultType, fnType->getExtInfo());
 
   if (!outerFnType)
     return fnType;
@@ -4184,39 +4216,41 @@ static AnyFunctionType *applyUnsafeConcurrencyToFunctionType(
 }
 
 AnyFunctionType *swift::adjustFunctionTypeForConcurrency(
-    AnyFunctionType *fnType, ValueDecl *funcOrEnum, DeclContext *dc,
+    AnyFunctionType *fnType, ValueDecl *decl, DeclContext *dc,
     unsigned numApplies, bool isMainDispatchQueue) {
   // Apply unsafe concurrency features to the given function type.
   fnType = applyUnsafeConcurrencyToFunctionType(
-      fnType, funcOrEnum, contextUsesConcurrencyFeatures(dc), numApplies,
+      fnType, decl, contextUsesConcurrencyFeatures(dc), numApplies,
       isMainDispatchQueue);
 
   Type globalActorType;
-  switch (auto isolation = getActorIsolation(funcOrEnum)) {
-  case ActorIsolation::ActorInstance:
-  case ActorIsolation::DistributedActorInstance:
-  case ActorIsolation::Independent:
-  case ActorIsolation::Unspecified:
-    return fnType;
-
-  case ActorIsolation::GlobalActorUnsafe:
-    // Only treat as global-actor-qualified within code that has adopted
-    // Swift Concurrency features.
-    if (!contextUsesConcurrencyFeatures(dc))
+  if (decl) {
+    switch (auto isolation = getActorIsolation(decl)) {
+    case ActorIsolation::ActorInstance:
+    case ActorIsolation::DistributedActorInstance:
+    case ActorIsolation::Independent:
+    case ActorIsolation::Unspecified:
       return fnType;
 
-    LLVM_FALLTHROUGH;
+    case ActorIsolation::GlobalActorUnsafe:
+      // Only treat as global-actor-qualified within code that has adopted
+      // Swift Concurrency features.
+      if (!contextUsesConcurrencyFeatures(dc))
+        return fnType;
 
-  case ActorIsolation::GlobalActor:
-    globalActorType = isolation.getGlobalActor();
-    break;
+      LLVM_FALLTHROUGH;
+
+    case ActorIsolation::GlobalActor:
+      globalActorType = isolation.getGlobalActor();
+      break;
+    }
   }
 
   // If there's no implicit "self" declaration, apply the global actor to
   // the outermost function type.
-  bool hasImplicitSelfDecl = isa<EnumElementDecl>(funcOrEnum) ||
-      (isa<AbstractFunctionDecl>(funcOrEnum) &&
-       cast<AbstractFunctionDecl>(funcOrEnum)->hasImplicitSelfDecl());
+  bool hasImplicitSelfDecl = decl && (isa<EnumElementDecl>(decl) ||
+      (isa<AbstractFunctionDecl>(decl) &&
+       cast<AbstractFunctionDecl>(decl)->hasImplicitSelfDecl()));
   if (!hasImplicitSelfDecl) {
     return fnType->withExtInfo(
         fnType->getExtInfo().withGlobalActor(globalActorType));
diff --git a/lib/Sema/TypeCheckConcurrency.h b/lib/Sema/TypeCheckConcurrency.h
@@ -310,6 +310,15 @@ checkGlobalActorAttributes(
 /// Get the explicit global actor specified for a closure.
 Type getExplicitGlobalActor(ClosureExpr *closure);
 
+/// Adjust the type of the variable for concurrency.
+Type adjustVarTypeForConcurrency(Type type, VarDecl *var, DeclContext *dc);
+
+/// Adjust the function type of a function / subscript / enum case for
+/// concurrency.
+AnyFunctionType *adjustFunctionTypeForConcurrency(
+    AnyFunctionType *fnType, ValueDecl *decl, DeclContext *dc,
+    unsigned numApplies, bool isMainDispatchQueue);
+
 /// Adjust the given function type to account for concurrency-specific
 /// attributes whose affect on the type might differ based on context.
 /// This includes adjustments for unsafe parameter attributes like
diff --git a/test/Concurrency/predates_concurrency.swift b/test/Concurrency/predates_concurrency.swift
@@ -9,8 +9,18 @@
 
 struct X {
   @_predatesConcurrency func unsafelyDoEverythingClosure(_ closure: @MainActor @Sendable () -> Void) { }
+
+  @_predatesConcurrency var sendableVar: @Sendable () -> Void
+  @_predatesConcurrency var mainActorVar: @MainActor () -> Void
+
+  @_predatesConcurrency
+  subscript(_: @MainActor () -> Void) -> (@Sendable () -> Void) { {} }
+
+  @_predatesConcurrency
+  static subscript(statically _: @MainActor () -> Void) -> (@Sendable () -> Void) { { } }
 }
 
+@MainActor func onMainActor() { }
 
 func testInAsync(x: X) async {
   let _: Int = unsafelySendableClosure // expected-error{{type '(@Sendable () -> Void) -> ()'}}
@@ -19,6 +29,12 @@ func testInAsync(x: X) async {
   let _: Int = x.unsafelyDoEverythingClosure // expected-error{{type '(@MainActor @Sendable () -> Void) -> ()'}}
   let _: Int = X.unsafelyDoEverythingClosure // expected-error{{type '(X) -> (@MainActor @Sendable () -> Void) -> ()'}}
   let _: Int = (X.unsafelyDoEverythingClosure)(x) // expected-error{{type '(@MainActor @Sendable () -> Void) -> ()'}}
+
+  let _: Int = x.sendableVar // expected-error{{type '@Sendable () -> Void'}}
+  let _: Int = x.mainActorVar // expected-error{{type '@MainActor () -> Void'}}
+
+  let _: Int = x[{ onMainActor() }] // expected-error{{type '@Sendable () -> Void'}}
+  let _: Int = X[statically: { onMainActor() }] // expected-error{{type '@Sendable () -> Void'}}
 }
 
 func testElsewhere(x: X) {
@@ -28,10 +44,12 @@ func testElsewhere(x: X) {
   let _: Int = x.unsafelyDoEverythingClosure // expected-error{{type '(() -> Void) -> ()'}}
   let _: Int = X.unsafelyDoEverythingClosure // expected-error{{type '(X) -> (() -> Void) -> ()'}}
   let _: Int = (X.unsafelyDoEverythingClosure)(x) // expected-error{{type '(() -> Void) -> ()'}}
+  let _: Int = x.sendableVar // expected-error{{type '() -> Void'}}
+  let _: Int = x.mainActorVar // expected-error{{type '() -> Void'}}
+  let _: Int = x[{ onMainActor() }] // expected-error{{type '() -> Void'}}
+  let _: Int = X[statically: { onMainActor() }] // expected-error{{type '() -> Void'}}
 }
 
-@MainActor func onMainActor() { }
-
 @MainActor @_predatesConcurrency func onMainActorAlways() { }
 
 @_predatesConcurrency @MainActor class MyModelClass {
