Sema: Consolidate diagnostics for invalid usage of DynamicSelfType

Author: slavapestov

include/swift/AST/DiagnosticsSema.def

@@ -2576,19 +2576,19 @@ NOTE(missing_member_type_conformance_prevents_synthesis, none,
 ERROR(dynamic_self_non_method,none,
       "%select{global|local}0 function cannot return 'Self'", (bool))
 
-ERROR(self_in_nominal,none,
-      "'Self' is only available in a protocol or as the result of a "
-      "method in a class; did you mean '%0'?", (StringRef))
-ERROR(self_in_alias,none,
-      "'Self' is not available in a typealias", ())
-ERROR(self_in_mutable_property,none,
-      "'Self' is not available as the type of a mutable property", ())
-ERROR(self_in_mutable_subscript,none,
-      "'Self' is not available as the type of a mutable subscript", ())
-ERROR(self_in_parameter,none,
-      "'Self' cannot be the type of a function argument in a class", ())
-ERROR(self_in_nested_return,none,
-      "'Self' can only appear at the top level of a method result type", ())
+ERROR(dynamic_self_invalid,none,
+      "covariant 'Self' can only appear as the type of a property, subscript or method result; "
+      "did you mean '%0'?", (StringRef))
+ERROR(dynamic_self_in_mutable_property,none,
+      "mutable property cannot have covariant 'Self' type", ())
+ERROR(dynamic_self_in_mutable_subscript,none,
+      "mutable subscript cannot have covariant 'Self' type", ())
+ERROR(dynamic_self_invalid_property,none,
+      "covariant 'Self' can only appear at the top level of property type", ())
+ERROR(dynamic_self_invalid_subscript,none,
+      "covariant 'Self' can only appear at the top level of subscript element type", ())
+ERROR(dynamic_self_invalid_method,none,
+      "covariant 'Self' can only appear at the top level of method result type", ())
 
 //------------------------------------------------------------------------------
 // MARK: Type Check Attributes

lib/Sema/TypeCheckDecl.cpp

@@ -2181,6 +2181,32 @@ static void checkProtocolSelfRequirements(ProtocolDecl *proto,
       });
 }
 
+/// For now, DynamicSelfType can only appear at the top level of a
+/// function result type, possibly wrapped in an optional type.
+///
+/// In the future, we could generalize it to allow it in any
+/// covariant position, so that for example a class method could
+/// return '() -> Self'.
+static void checkDynamicSelfType(ValueDecl *decl, Type type) {
+  if (!type->hasDynamicSelfType())
+    return;
+
+  if (auto objectTy = type->getOptionalObjectType())
+    type = objectTy;
+
+  if (type->is<DynamicSelfType>())
+    return;
+
+  if (isa<FuncDecl>(decl))
+    decl->diagnose(diag::dynamic_self_invalid_method);
+  else if (isa<VarDecl>(decl))
+    decl->diagnose(diag::dynamic_self_invalid_property);
+  else {
+    assert(isa<SubscriptDecl>(decl));
+    decl->diagnose(diag::dynamic_self_invalid_subscript);
+  }
+}
+
 namespace {
 class DeclChecker : public DeclVisitor<DeclChecker> {
 public:
@@ -2224,31 +2250,6 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     }
   }
 
-  bool isDynamicSelf(Type Ty) {
-    return Ty->lookThroughAllOptionalTypes()->hasDynamicSelfType();
-  }
-
-  bool isDeclaredInClass(Decl *decl) {
-    return decl->getDeclContext()->getSelfClassDecl() != nullptr;
-  }
-
-  /// diagnoseSelfTypedParameters()
-  /// Diagnose instances of (Dynamic)Self as the type of a function arugument.
-  void diagnoseSelfTypedParameters(Type Ty, SourceLoc Loc, int level = 0) {
-    if (auto func = dyn_cast<FunctionType>(Ty->getCanonicalType())) {
-      for (auto &param : func->getParams()) {
-        if (isDynamicSelf(param.getParameterType())) {
-          TC.diagnose(Loc, diag::self_in_parameter);
-          diagnoseSelfTypedParameters(param.getParameterType(), Loc, level + 1);
-        }
-      }
-      if (Type returnTy = func->getResult()) {
-        if (level > 0 && isDynamicSelf(returnTy))
-          TC.diagnose(Loc, diag::self_in_nested_return);
-        diagnoseSelfTypedParameters(returnTy, Loc, level + 1);
-      }
-    }
-  }
 
   //===--------------------------------------------------------------------===//
   // Visit Methods.
@@ -2372,6 +2373,15 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
 
     triggerAccessorSynthesis(TC, VD);
 
+    if (VD->getDeclContext()->getSelfClassDecl()) {
+      checkDynamicSelfType(VD, VD->getValueInterfaceType());
+
+      if (VD->getValueInterfaceType()->hasDynamicSelfType() &&
+          VD->isSettable(nullptr)) {
+        VD->diagnose(diag::dynamic_self_in_mutable_property);
+      }
+    }
+
     // FIXME: Temporary hack until capture computation has been request-ified.
     if (VD->getDeclContext()->isLocalContext()) {
       VD->visitExpectedOpaqueAccessors([&](AccessorKind kind) {
@@ -2625,11 +2635,14 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     TC.checkParameterAttributes(SD->getIndices());
     TC.checkDefaultArguments(SD->getIndices(), SD);
 
-    if (SD->isSettable() && isDynamicSelf(SD->getElementInterfaceType()))
-      TC.diagnose(SD->getLoc(), diag::self_in_mutable_subscript);
+    if (SD->getDeclContext()->getSelfClassDecl()) {
+      checkDynamicSelfType(SD, SD->getValueInterfaceType());
 
-    diagnoseSelfTypedParameters(SD->getElementInterfaceType(),
-                                SD->getElementTypeLoc().getLoc());
+      if (SD->getValueInterfaceType()->hasDynamicSelfType() &&
+          SD->isSettable()) {
+        SD->diagnose(diag::dynamic_self_in_mutable_subscript);
+      }
+    }
   }
 
   void visitTypeAliasDecl(TypeAliasDecl *TAD) {
@@ -2639,12 +2652,6 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     TC.checkDeclAttributes(TAD);
 
     checkAccessControl(TC, TAD);
-
-    TypeLoc &TyLoc = TAD->getUnderlyingTypeLoc();
-    if (isDynamicSelf(TyLoc.getType()))
-      TC.diagnose(TyLoc.getLoc(), diag::self_in_alias);
-
-    diagnoseSelfTypedParameters(TyLoc.getType(), TyLoc.getLoc());
   }
 
   void visitOpaqueTypeDecl(OpaqueTypeDecl *OTD) {
@@ -3106,14 +3113,6 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
   void visitVarDecl(VarDecl *VD) {
     // Delay type-checking on VarDecls until we see the corresponding
     // PatternBindingDecl.
-
-    if (isDeclaredInClass(VD)) {
-      if (VD->isSettable(nullptr) && isDynamicSelf(VD->getValueInterfaceType()))
-        TC.diagnose(VD->getLoc(), diag::self_in_mutable_property);
-      else
-        diagnoseSelfTypedParameters(VD->getValueInterfaceType(),
-                                    VD->getTypeLoc().getLoc());
-    }
   }
 
   /// Determine whether the given declaration requires a definition.
@@ -3195,31 +3194,8 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
 
     checkExplicitAvailability(FD);
 
-    if (isDeclaredInClass(FD)) {
-      for (auto *Param : *FD->getParameters()) {
-        TypeLoc TyLoc = Param->getTypeLoc();
-        SourceLoc Loc = TyLoc.hasLocation() ? TyLoc.getLoc() : Param->getLoc();
-        if (isDynamicSelf(Param->getInterfaceType()))
-          TC.diagnose(Loc, diag::self_in_parameter);
-        else
-          diagnoseSelfTypedParameters(Param->getInterfaceType(), Loc, 1);
-      }
-
-      auto ResultTy = FD->getResultInterfaceType();
-
-      // For now, DynamicSelfType can only appear at the top level of a
-      // function result type, possibly wrapped in an optional type.
-      if (ResultTy->hasDynamicSelfType()) {
-        if (auto ObjectTy = ResultTy->getOptionalObjectType())
-          ResultTy = ObjectTy;
-        if (!ResultTy->is<DynamicSelfType>()) {
-          auto loc = FD->getBodyResultTypeLoc().getLoc();
-          if (loc.isInvalid())
-            loc = FD->getLoc();
-          TC.diagnose(loc, diag::self_in_nested_return);
-        }
-      }
-    }
+    if (FD->getDeclContext()->getSelfClassDecl())
+      checkDynamicSelfType(FD, FD->getResultInterfaceType());
   }
 
   void visitModuleDecl(ModuleDecl *) { }

lib/Sema/TypeCheckType.cpp

@@ -1079,7 +1079,7 @@ static Type diagnoseUnknownType(TypeResolution resolution,
 
         // Produce a Fix-It replacing 'Self' with the nominal type name.
         auto name = getDeclNameFromContext(dc, nominal);
-        diags.diagnose(comp->getIdLoc(), diag::self_in_nominal, name)
+        diags.diagnose(comp->getIdLoc(), diag::dynamic_self_invalid, name)
           .fixItReplace(comp->getIdLoc(), name);
 
         auto type = resolution.mapTypeIntoContext(
@@ -1240,18 +1240,28 @@ static SelfTypeKind getSelfTypeKind(DeclContext *dc,
   if (!typeDC->getSelfClassDecl())
     return SelfTypeKind::StaticSelf;
 
-  // In local functions inside classes, 'Self' is the DynamicSelfType and can
-  // be used anywhere.
-  if (dc->isLocalContext())
-    return SelfTypeKind::DynamicSelf;
-
   // In class methods, 'Self' is the DynamicSelfType and can only appear in
   // the return type.
   switch (options.getBaseContext()) {
   case TypeResolverContext::FunctionResult:
   case TypeResolverContext::PatternBindingDecl:
     return SelfTypeKind::DynamicSelf;
+  case TypeResolverContext::AbstractFunctionDecl:
+  case TypeResolverContext::SubscriptDecl:
+  case TypeResolverContext::TypeAliasDecl:
+  case TypeResolverContext::GenericTypeAliasDecl:
+    // When checking a function or subscript parameter list, we have to go up
+    // one level to determine if we're in a local context or not.
+    if (dc->getParent()->isLocalContext())
+      return SelfTypeKind::DynamicSelf;
+
+    return SelfTypeKind::InvalidSelf;
   default:
+    // In local functions inside classes, 'Self' is the DynamicSelfType and can
+    // be used anywhere.
+    if (dc->isLocalContext())
+      return SelfTypeKind::DynamicSelf;
+
     return SelfTypeKind::InvalidSelf;
   }
 }

test/decl/ext/generic.swift

@@ -149,7 +149,7 @@ extension Array where Element == String { }
 extension GenericClass : P3 where T : P3 { }
 
 extension GenericClass where Self : P3 { }
-// expected-error@-1{{'Self' is only available in a protocol or as the result of a method in a class; did you mean 'GenericClass'?}} {{30-34=GenericClass}}
+// expected-error@-1{{covariant 'Self' can only appear as the type of a property, subscript or method result; did you mean 'GenericClass'?}} {{30-34=GenericClass}}
 // expected-error@-2{{'GenericClass<T>' in conformance requirement does not refer to a generic parameter or associated type}}
 
 protocol P4 {

test/decl/func/dynamic_self.swift

@@ -24,9 +24,9 @@ enum E0 {
 class C0 {
   func f() -> Self { } // okay
 
-  func g(_ ds: Self) { } // expected-error{{'Self' cannot be the type of a function argument in a class}}
+  func g(_ ds: Self) { } // expected-error{{covariant 'Self' can only appear as the type of a property, subscript or method result; did you mean 'C0'?}}
 
-  func h(_ ds: Self) -> Self { } // expected-error{{'Self' cannot be the type of a function argument in a class}}
+  func h(_ ds: Self) -> Self { } // expected-error{{covariant 'Self' can only appear as the type of a property, subscript or method result; did you mean 'C0'?}}
 }
 
 protocol P0 {

test/type/self.swift

@@ -5,7 +5,7 @@ struct S0<T> {
 }
 
 class C0<T> {
-  func foo(_ other: Self) { } // expected-error{{'Self' cannot be the type of a function argument in a class}}
+  func foo(_ other: Self) { } // expected-error{{covariant 'Self' can only appear as the type of a property, subscript or method result; did you mean 'C0'?}}
 }
 
 enum E0<T> {
@@ -47,15 +47,15 @@ final class FinalMario : Mario {
 
 class A<T> {
   typealias _Self = Self
-  // expected-error@-1 {{'Self' is only available in a protocol or as the result of a method in a class; did you mean 'A'?}}
+  // expected-error@-1 {{covariant 'Self' can only appear as the type of a property, subscript or method result; did you mean 'A'?}}
   let b: Int
   required init(a: Int) {
     print("\(Self.self).\(#function)")
     Self.y()
     b = a
   }
   static func z(n: Self? = nil) {
-    // expected-error@-1 {{'Self' cannot be the type of a function argument in a class}}
+    // expected-error@-1 {{covariant 'Self' can only appear as the type of a property, subscript or method result; did you mean 'A'?}}
     print("\(Self.self).\(#function)")
   }
   class func y() {
@@ -80,12 +80,11 @@ class A<T> {
     let copy = Self.init(a: 11)
     return copy
   }
-  subscript (i: Int) -> Self { // expected-error {{'Self' is not available as the type of a mutable subscript}}
+  subscript (i: Int) -> Self { // expected-error {{mutable subscript cannot have covariant 'Self' type}}
     get {
       return Self.init(a: i)
     }
     set(newValue) {
-      // expected-error@-1 {{'Self' cannot be the type of a function argument in a class}}
     }
   }
 }
@@ -122,38 +121,39 @@ class C {
 
   func f() {
     func g(_: Self) {}
+    let x: Self = self as! Self
+    g(x)
+    typealias _Self = Self
   }
   func g() {
     _ = Self.init() as? Self
     // expected-warning@-1 {{conditional cast from 'Self' to 'Self' always succeeds}}
   }
   func h(j: () -> Self) -> () -> Self {
-    // expected-error@-1 {{'Self' cannot be the type of a function argument in a class}}
-    // expected-error@-2 {{'Self' can only appear at the top level of a method result type}}
+    // expected-error@-1 {{covariant 'Self' can only appear at the top level of method result type}}
     return { return self }
   }
   func i() -> (Self, Self) {}
-  // expected-error@-1 {{'Self' can only appear at the top level of a method result type}}
+  // expected-error@-1 {{covariant 'Self' can only appear at the top level of method result type}}
 
   func j() -> Self.Type {}
-  // expected-error@-1 {{'Self' can only appear at the top level of a method result type}}
+  // expected-error@-1 {{covariant 'Self' can only appear at the top level of method result type}}
 
   let p0: Self?
-  var p1: Self? // expected-error {{'Self' is not available as the type of a mutable property}}
-  // expected-error@-1 {{'Self' cannot be the type of a function argument in a class}}
+  var p1: Self? // expected-error {{mutable property cannot have covariant 'Self' type}}
 
-  var prop: Self { // expected-error {{'Self' is not available as the type of a mutable property}}
+  var prop: Self { // expected-error {{mutable property cannot have covariant 'Self' type}}
     get {
       return self
     }
-    set (newValue) { // expected-error {{'Self' cannot be the type of a function argument in a class}}
+    set (newValue) {
     }
   }
-  subscript (i: Int) -> Self { // expected-error {{'Self' is not available as the type of a mutable subscript}}
+  subscript (i: Int) -> Self { // expected-error {{mutable subscript cannot have covariant 'Self' type}}
     get {
       return self
     }
-    set (newValue) { // expected-error {{'Self' cannot be the type of a function argument in a class}}
+    set (newValue) {
     }
   }
 }