[Concurrency] Compute the source of actor isolation in ActorIsolationRequest.

include/swift/AST/ActorIsolation.h

@@ -275,9 +275,13 @@ class ActorIsolation {
  void print(llvm::raw_ostream &os) const;
 
  void printForSIL(llvm::raw_ostream &os) const;
-
+
+ /// Print the given isolation for diagnostics. If \c asNoun is \c false,
+ /// the participle adjective form is printed, e.g. "main actor-isolated".
+ /// Otherwise, the noun form is printed, e.g. "main actor isolation".
  void printForDiagnostics(llvm::raw_ostream &os,
- StringRef openingQuotationMark = "'") const;
+ StringRef openingQuotationMark = "'",
+ bool asNoun = false) const;
 
  SWIFT_DEBUG_DUMPER(dump());
 
@@ -287,9 +291,68 @@ class ActorIsolation {
  SWIFT_DEBUG_DUMPER(dumpForDiagnostics());
 };
 
+struct IsolationSource {
+ enum Kind : uint8_t {
+ /// Isolation is written in an explicit attribute.
+ Explicit,
+ /// Isolation is inferred from the enclosing lexical context.
+ LexicalContext,
+ /// Isolation is inferred from conformance to a protocol.
+ Conformance,
+ /// Isolation is inherited from a superclass.
+ Superclass,
+ /// Isolation is inferred from an overridden superclass method.
+ Override,
+ /// Isolation is inferred from \c @main.
+ MainFunction,
+ /// Isolation is inferred in top-level code.
+ TopLevelCode,
+ /// Unspecified isolation, which defaults to \c nonisolated.
+ None,
+ };
+
+ using InferenceSource =
+ llvm::PointerUnion<Decl *, AbstractClosureExpr *>;
+
+ /// The declaration with the original isolation attribute.
+ InferenceSource inferenceSource;
+ Kind kind;
+
+ IsolationSource(InferenceSource inferenceSource = nullptr,
+ Kind kind = Kind::None)
+ : inferenceSource(inferenceSource), kind(kind) {}
+
+ bool isInferred() const {
+ return (kind != None) && (kind != Explicit);
+ }
+
+ void printForDiagnostics(llvm::raw_ostream &os,
+ StringRef openingQuotationMark = "'") const;
+};
+
+struct InferredActorIsolation {
+ ActorIsolation isolation;
+ IsolationSource source;
+
+ static InferredActorIsolation forUnspecified() {
+ return {
+ ActorIsolation::forUnspecified(),
+ IsolationSource()
+ };
+ }
+
+ bool preconcurrency() const {
+ return isolation.preconcurrency();
+ }
+};
+
 /// Determine how the given value declaration is isolated.
 ActorIsolation getActorIsolation(ValueDecl *value);
 
+/// Infer the actor isolation of the given declaration, including
+/// the source of isolation inference.
+InferredActorIsolation getInferredActorIsolation(ValueDecl *value);
+
 /// Trampoline for AbstractClosureExpr::getActorIsolation.
 ActorIsolation
 __AbstractClosureExpr_getActorIsolation(AbstractClosureExpr *CE);

include/swift/AST/DiagnosticEngine.h

@@ -140,6 +140,7 @@ namespace swift {
  VersionTuple,
  LayoutConstraint,
  ActorIsolation,
+ IsolationSource,
  Diagnostic,
  ClangDecl
  };
@@ -175,6 +176,7 @@ namespace swift {
  llvm::VersionTuple VersionVal;
  LayoutConstraint LayoutConstraintVal;
  ActorIsolation ActorIsolationVal;
+ IsolationSource IsolationSourceVal;
  DiagnosticInfo *DiagnosticVal;
  const clang::NamedDecl *ClangDecl;
  };
@@ -283,6 +285,11 @@ namespace swift {
  ActorIsolationVal(AI) {
  }
 
+ DiagnosticArgument(IsolationSource IS)
+ : Kind(DiagnosticArgumentKind::IsolationSource),
+ IsolationSourceVal(IS){
+ }
+
  DiagnosticArgument(DiagnosticInfo *D)
  : Kind(DiagnosticArgumentKind::Diagnostic),
  DiagnosticVal(D) {
@@ -402,6 +409,11 @@ namespace swift {
  return ActorIsolationVal;
  }
 
+ IsolationSource getAsIsolationSource() const {
+ assert(Kind == DiagnosticArgumentKind::IsolationSource);
+ return IsolationSourceVal;
+ }
+
  DiagnosticInfo *getAsDiagnostic() const {
  assert(Kind == DiagnosticArgumentKind::Diagnostic);
  return DiagnosticVal;

include/swift/AST/DiagnosticsSema.def

@@ -5535,6 +5535,10 @@ NOTE(actor_isolated_sync_func_value,none,
  "calls function of type %0 from outside of its actor context are "
  "implicitly asynchronous",
  (Type))
+NOTE(actor_isolation_source,none,
+ "%noun0 inferred from %1",
+ (ActorIsolation, IsolationSource))
+
 NOTE(note_distributed_actor_isolated_method,none,
  "distributed actor-isolated %kind0 declared here",
  (const ValueDecl *))

include/swift/AST/TypeCheckRequests.h

@@ -1536,15 +1536,16 @@ class GlobalActorAttributeRequest
 /// Determine the actor isolation for the given declaration.
 class ActorIsolationRequest :
  public SimpleRequest<ActorIsolationRequest,
- ActorIsolation(ValueDecl *),
+ InferredActorIsolation(ValueDecl *),
  RequestFlags::Cached> {
 public:
  using SimpleRequest::SimpleRequest;
 
 private:
  friend SimpleRequest;
 
- ActorIsolation evaluate(Evaluator &evaluator, ValueDecl *value) const;
+ InferredActorIsolation evaluate(Evaluator &evaluator,
+ ValueDecl *value) const;
 
 public:
  // Caching

lib/AST/Decl.cpp

@@ -11295,10 +11295,15 @@ bool VarDecl::isSelfParamCaptureIsolated() const {
 }
 
 ActorIsolation swift::getActorIsolation(ValueDecl *value) {
+ return getInferredActorIsolation(value).isolation;
+}
+
+InferredActorIsolation
+swift::getInferredActorIsolation(ValueDecl *value) {
  auto &ctx = value->getASTContext();
  return evaluateOrDefault(
  ctx.evaluator, ActorIsolationRequest{value},
- ActorIsolation::forUnspecified());
+ InferredActorIsolation::forUnspecified());
 }
 
 ActorIsolation swift::getActorIsolationOfContext(

lib/AST/DiagnosticEngine.cpp

@@ -1012,8 +1012,16 @@ static void formatDiagnosticArgument(StringRef Modifier,
  << FormatOpts.ClosingQuotationMark;
  break;
  case DiagnosticArgumentKind::ActorIsolation: {
- assert(Modifier.empty() && "Improper modifier for ActorIsolation argument");
+ assert((Modifier.empty() || Modifier == "noun") &&
+ "Improper modifier for ActorIsolation argument");
  auto isolation = Arg.getAsActorIsolation();
+ isolation.printForDiagnostics(Out, FormatOpts.OpeningQuotationMark,
+ /*asNoun*/ Modifier == "noun");
+ break;
+ }
+ case DiagnosticArgumentKind::IsolationSource: {
+ assert(Modifier.empty() && "Improper modifier for IsolationSource argument");
+ auto isolation = Arg.getAsIsolationSource();
  isolation.printForDiagnostics(Out, FormatOpts.OpeningQuotationMark);
  break;
  }

lib/AST/TypeCheckRequests.cpp

@@ -1804,19 +1804,20 @@ ActorIsolation ActorIsolation::subst(SubstitutionMap subs) const {
 }
 
 void ActorIsolation::printForDiagnostics(llvm::raw_ostream &os,
- StringRef openingQuotationMark) const {
+ StringRef openingQuotationMark,
+ bool asNoun) const {
  switch (*this) {
  case ActorIsolation::ActorInstance:
- os << "actor-isolated";
+ os << "actor" << (asNoun ? " isolation" : "-isolated");
  break;
 
  case ActorIsolation::GlobalActor: {
  if (isMainActor()) {
- os << "main actor-isolated";
+ os << "main actor" << (asNoun ? " isolation" : "-isolated");
  } else {
  Type globalActor = getGlobalActor();
  os << "global actor " << openingQuotationMark << globalActor.getString()
- << openingQuotationMark << "-isolated";
+ << openingQuotationMark << (asNoun ? " isolation" : "-isolated");
  }
  break;
  }
@@ -1942,6 +1943,52 @@ void swift::simple_display(
  }
 }
 
+void IsolationSource::printForDiagnostics(
+ llvm::raw_ostream &os,
+ StringRef openingQuotationMark) const {
+ switch (this->kind) {
+ case IsolationSource::Explicit:
+ os << "explicit isolation";
+ return;
+
+ case IsolationSource::None:
+ os << "unspecified isolation";
+ return;
+
+ case IsolationSource::MainFunction:
+ os << "@main";
+ return;
+
+ case IsolationSource::TopLevelCode:
+ os << "top-level code";
+ return;
+
+ case IsolationSource::LexicalContext:
+ os << "enclosing context";
+ return;
+
+ case IsolationSource::Override:
+ os << "overridden superclass method";
+ return;
+
+ case IsolationSource::Conformance:
+ os << "conformance to ";
+ break;
+
+ case IsolationSource::Superclass:
+ os << "inheritance from ";
+ break;
+ }
+
+ auto *decl = inferenceSource.dyn_cast<Decl *>();
+ os << Decl::getDescriptiveKindName(decl->getDescriptiveKind());
+ if (auto *vd = dyn_cast<ValueDecl>(decl)) {
+ os << " " << openingQuotationMark;
+ vd->getName().printPretty(os);
+ os << openingQuotationMark;
+ }
+}
+
 bool swift::areTypesEqual(Type type1, Type type2) {
  if (!type1 || !type2)
  return !type1 && !type2;