Merge pull request swiftlang#38298 from DougGregor/actor-no-class

Author: swift-ci

lib/AST/Decl.cpp

@@ -1595,10 +1595,12 @@ SourceRange PatternBindingDecl::getSourceRange() const {
 }
 
 static StaticSpellingKind getCorrectStaticSpellingForDecl(const Decl *D) {
-  if (!D->getDeclContext()->getSelfClassDecl())
-    return StaticSpellingKind::KeywordStatic;
+  if (auto classDecl = D->getDeclContext()->getSelfClassDecl()) {
+    if (!classDecl->isActor())
+      return StaticSpellingKind::KeywordClass;
+  }
 
-  return StaticSpellingKind::KeywordClass;
+  return StaticSpellingKind::KeywordStatic;
 }
 
 StaticSpellingKind PatternBindingDecl::getCorrectStaticSpelling() const {

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -2107,6 +2107,14 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
       }
     }
 
+    // Reject "class" methods on actors.
+    if (SD->getStaticSpelling() == StaticSpellingKind::KeywordClass &&
+        SD->getDeclContext()->getSelfClassDecl() &&
+        SD->getDeclContext()->getSelfClassDecl()->isActor()) {
+      SD->diagnose(diag::class_subscript_not_in_class, false)
+          .fixItReplace(SD->getStaticLoc(), "static");
+    }
+
     // Now check all the accessors.
     SD->visitEmittedAccessors([&](AccessorDecl *accessor) {
       visit(accessor);
@@ -2753,6 +2761,14 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
       }
     }
 
+    // Reject "class" methods on actors.
+    if (StaticSpelling == StaticSpellingKind::KeywordClass &&
+        FD->getDeclContext()->getSelfClassDecl() &&
+        FD->getDeclContext()->getSelfClassDecl()->isActor()) {
+      FD->diagnose(diag::class_func_not_in_class, false)
+          .fixItReplace(FD->getStaticLoc(), "static");
+    }
+
     // Member functions need some special validation logic.
     if (FD->getDeclContext()->isTypeContext()) {
       if (FD->isOperator() && !isMemberOperator(FD, nullptr)) {

lib/Sema/TypeCheckStorage.cpp

@@ -233,6 +233,14 @@ PatternBindingEntryRequest::evaluate(Evaluator &eval,
     }
   }
 
+  // Reject "class" methods on actors.
+  if (StaticSpelling == StaticSpellingKind::KeywordClass &&
+      binding->getDeclContext()->getSelfClassDecl() &&
+      binding->getDeclContext()->getSelfClassDecl()->isActor()) {
+    binding->diagnose(diag::class_var_not_in_class, false)
+        .fixItReplace(binding->getStaticLoc(), "static");
+  }
+
   // Check the pattern.
   auto contextualPattern =
       ContextualPattern::forPatternBindingDecl(binding, entryNumber);

test/Concurrency/actor_isolation.swift

@@ -71,7 +71,7 @@ actor MyActor: MySuperActor { // expected-error{{actor types do not support inhe
     return self.name // expected-error{{property 'name' isolated to global actor 'MainActor' can not be referenced from actor 'MyActor' in a synchronous context}}
   }
 
-  class func synchronousClass() { }
+  static func synchronousClass() { }
   static func synchronousStatic() { }
 
   func synchronous() -> String { text.first ?? "nothing" } // expected-note 9{{calls to instance method 'synchronous()' from outside of its actor context are implicitly asynchronous}}

test/decl/class/actor/basic.swift

@@ -27,3 +27,24 @@ actor public class BarbraStreisand {}
 public actor struct JulieAndrews {}
 // expected-error@+1{{keyword 'public' cannot be used as an identifier here}}
 actor public enum TomHanks {}
+
+open actor A1 { } // expected-error{{only classes and overridable class members can be declared 'open'; use 'public'}}
+
+actor A2 {
+  required init() { } // expected-error{{'required' initializer in non-class type 'A2'}}
+  open func f() { } // expected-error{{only classes and overridable class members can be declared 'open'; use 'public'}}
+
+  final func g() { } // okay for now
+  class func h() { } // expected-error{{class methods are only allowed within classes; use 'static' to declare a static method}}
+  static func i() { } // okay
+
+  class var someProp: Int { 0 } // expected-error{{class properties are only allowed within classes; use 'static' to declare a static property}}
+}
+
+extension A2 {
+  class func h2() { } // expected-error{{class methods are only allowed within classes; use 'static' to declare a static method}}
+  static func i2() { } // okay
+
+  class subscript(i: Int) -> Int { i } // expected-error{{class subscripts are only allowed within classes; use 'static' to declare a static subscript}}
+  static subscript(s: String) -> String { s }
+}