AST: Don't allow @_transparent on extensions

Quiz: What does @_transparent on an extension actually *do*?

1) Make all members @_transparent?
2) Allow your members to be @_transparent?
3) Some other magical effect that has nothing to do with members?

The correct answer is 1), however a few places in the stdlib defined
a @_transparent extension and then proceeded to make some or all members
also @_transparent, and in a couple of places we defined a @_transparent
extension with no members at all.

To avoid cargo culting and confusion, remove the ability to make
@_transparent extensions altogether, and force usages to be explicit.

Author: slavapestov

include/swift/AST/Attr.def

@@ -152,7 +152,7 @@ SIMPLE_DECL_ATTR(prefix , Prefix , OnFunc | OnOperator | DeclModifier, 24)
 SIMPLE_DECL_ATTR(postfix, Postfix, OnFunc | OnOperator | DeclModifier, 25)
 
 SIMPLE_DECL_ATTR(_transparent, Transparent,
-                 OnFunc|OnConstructor|OnVar|OnExtension|UserInaccessible, 26)
+                 OnFunc|OnConstructor|OnVar|UserInaccessible, 26)
 SIMPLE_DECL_ATTR(requires_stored_property_inits, RequiresStoredPropertyInits,
                  OnClass, 27)
 DECL_ATTR(autoclosure, AutoClosure, OnParam, 28)

include/swift/AST/Decl.h

@@ -733,10 +733,6 @@ class alignas(1 << DeclAlignInBits) Decl {
 
   bool walk(ASTWalker &walker);
 
-  /// \brief Should this declaration be treated as if annotated with transparent
-  /// attribute.
-  bool isTransparent() const;
-
   /// \brief Return whether this declaration has been determined invalid.
   bool isInvalid() const { return DeclBits.Invalid; }
 
@@ -3784,6 +3780,10 @@ class AbstractStorageDecl : public ValueDecl {
   }
 public:
 
+  /// \brief Should this declaration be treated as if annotated with transparent
+  /// attribute.
+  bool isTransparent() const;
+
   /// \brief Determine whether this storage is a static member, if it
   /// is a member.  Currently only variables can be static.
   inline bool isStatic() const; // defined in this header
@@ -4595,8 +4595,13 @@ class AbstractFunctionDecl : public ValueDecl, public DeclContext {
   }
 
   void setGenericParams(GenericParamList *GenericParams);
-  
+
 public:
+
+  /// \brief Should this declaration be treated as if annotated with transparent
+  /// attribute.
+  bool isTransparent() const;
+
   void setGenericSignature(GenericSignature *GenericSig) {
     assert(!this->GenericSig && "already have signature?");
     this->GenericSig = GenericSig;

include/swift/AST/DiagnosticsSema.def

@@ -930,8 +930,6 @@ ERROR(static_functions_not_mutating,none,
 
 ERROR(transparent_stored_property,none,
       "@_transparent cannot be applied to stored properties", ())
-ERROR(transparent_on_invalid_extension,none,
-      "@_transparent is only supported on struct and enum extensions", ())
 ERROR(transparent_in_protocols_not_supported,none,
       "@_transparent is not supported on declarations within protocols", ())
 ERROR(transparent_in_classes_not_supported,none,

lib/AST/Decl.cpp

@@ -348,19 +348,15 @@ case DeclKind::ID: return cast<ID##Decl>(this)->getLoc();
   llvm_unreachable("Unknown decl kind");
 }
 
-bool Decl::isTransparent() const {
+bool AbstractStorageDecl::isTransparent() const {
+  return getAttrs().hasAttribute<TransparentAttr>();
+}
+
+bool AbstractFunctionDecl::isTransparent() const {
   // Check if the declaration had the attribute.
   if (getAttrs().hasAttribute<TransparentAttr>())
     return true;
 
-  // Check if this is a function declaration which is within a transparent
-  // extension.
-  if (const AbstractFunctionDecl *FD = dyn_cast<AbstractFunctionDecl>(this)) {
-    if (const ExtensionDecl *ED = dyn_cast<ExtensionDecl>(FD->getParent()))
-      if (ED->isTransparent())
-        return true;
-  }
-
   // If this is an accessor, check if the transparent attribute was set
   // on the value decl.
   if (const FuncDecl *FD = dyn_cast<FuncDecl>(this)) {

lib/SIL/SILDeclRef.cpp

@@ -482,7 +482,15 @@ bool SILDeclRef::isTransparent() const {
   if (hasAutoClosureExpr())
     return true;
 
-  return hasDecl() ? getDecl()->isTransparent() : false;
+  if (hasDecl()) {
+    if (auto *AFD = dyn_cast<AbstractFunctionDecl>(getDecl()))
+      return AFD->isTransparent();
+
+    if (auto *ASD = dyn_cast<AbstractStorageDecl>(getDecl()))
+      return ASD->isTransparent();
+  }
+
+  return false;
 }
 
 /// \brief True if the function should have its body serialized.

lib/Sema/TypeCheckAttr.cpp

@@ -219,15 +219,6 @@ class AttributeEarlyChecker : public AttributeVisitor<AttributeEarlyChecker> {
 } // end anonymous namespace
 
 void AttributeEarlyChecker::visitTransparentAttr(TransparentAttr *attr) {
-  if (auto *ED = dyn_cast<ExtensionDecl>(D)) {
-    CanType ExtendedTy = ED->getExtendedType()->getCanonicalType();
-    const NominalTypeDecl *ExtendedNominal = ExtendedTy->getAnyNominal();
-    // Only Struct and Enum extensions can be transparent.
-    if (!isa<StructDecl>(ExtendedNominal) && !isa<EnumDecl>(ExtendedNominal))
-      return diagnoseAndRemoveAttr(attr,diag::transparent_on_invalid_extension);
-    return;
-  }
-  
   DeclContext *Ctx = D->getDeclContext();
   // Protocol declarations cannot be transparent.
   if (isa<ProtocolDecl>(Ctx))