Add "marker" protocols, indicated by @_marker.

A marker protocol is a protocol with no requirements and with no ABI
footprint. They can be used to indicate semantics, only, and one can
never have values of a marker protocol type.

We still mangle marker protocols when they are used as generic
requirements, because they are a distinguishing characteristic for
overloading, but "no ABI footprint" means no protocol descriptors,
conformance descriptors, or dynamic discovery of any kind.

Author: DougGregor

include/swift/AST/Attr.def

@@ -606,6 +606,12 @@ SIMPLE_DECL_ATTR(concurrent, Concurrent,
   APIBreakingToAdd | APIBreakingToRemove,
   107)
 
+SIMPLE_DECL_ATTR(_marker, Marker,
+  OnProtocol | UserInaccessible |
+  ABIBreakingToAdd | ABIBreakingToRemove |
+  APIBreakingToAdd | APIBreakingToRemove,
+  108)
+
 #undef TYPE_ATTR
 #undef DECL_ATTR_ALIAS
 #undef CONTEXTUAL_DECL_ATTR_ALIAS

include/swift/AST/Decl.h

@@ -4162,6 +4162,10 @@ class ProtocolDecl final : public NominalTypeDecl {
   ProtocolRethrowsRequirementList getRethrowingRequirements() const;
   bool isRethrowingProtocol() const;
 
+  /// Determine whether this is a "marker" protocol, meaning that is indicates
+  /// semantics but has no corresponding witness table.
+  bool isMarkerProtocol() const;
+
 private:
   void computeKnownProtocolKind() const;
 

include/swift/AST/DiagnosticsSema.def

@@ -5581,6 +5581,17 @@ NOTE(result_builder_missing_build_limited_availability, none,
         "expression shuffles the elements of this tuple; "
         "this behavior is deprecated", ())
 
+//------------------------------------------------------------------------------
+// MARK: marker protocol diagnostics
+//------------------------------------------------------------------------------
+ERROR(marker_protocol_requirement, none,
+      "marker protocol %0 cannot have any requirements", (DeclName))
+ERROR(marker_protocol_inherit_nonmarker, none,
+      "marker protocol %0 cannot inherit non-marker protocol %1",
+      (DeclName, DeclName))
+ERROR(marker_protocol_value,none,
+      "marker protocol %0 can only be used in generic constraints", (DeclName))
+
 //------------------------------------------------------------------------------
 // MARK: differentiable programming diagnostics
 //------------------------------------------------------------------------------

include/swift/SIL/TypeLowering.h

@@ -813,6 +813,9 @@ class TypeConverter {
 
   /// True if a protocol uses witness tables for dynamic dispatch.
   static bool protocolRequiresWitnessTable(ProtocolDecl *P) {
+    if (P->isMarkerProtocol())
+      return false;
+
     return swift::protocolRequiresWitnessTable(getProtocolDispatchStrategy(P));
   }
 

lib/AST/Decl.cpp

@@ -4601,6 +4601,10 @@ ProtocolDecl::ProtocolDecl(DeclContext *DC, SourceLoc ProtocolLoc,
     setTrailingWhereClause(TrailingWhere);
 }
 
+bool ProtocolDecl::isMarkerProtocol() const {
+  return getAttrs().hasAttribute<MarkerAttr>();
+}
+
 ArrayRef<ProtocolDecl *> ProtocolDecl::getInheritedProtocols() const {
   auto *mutThis = const_cast<ProtocolDecl *>(this);
   return evaluateOrDefault(getASTContext().evaluator,

lib/IRGen/GenMeta.cpp

@@ -5150,6 +5150,10 @@ SpecialProtocol irgen::getSpecialProtocolID(ProtocolDecl *P) {
 void IRGenModule::emitProtocolDecl(ProtocolDecl *protocol) {
   PrettyStackTraceDecl stackTraceRAII("emitting metadata for", protocol);
 
+  // Marker protocols are never emitted.
+  if (protocol->isMarkerProtocol())
+    return;
+
   // Emit remote reflection metadata for the protocol.
   emitFieldDescriptor(protocol);
 

lib/Sema/TypeCheckAttr.cpp

@@ -391,6 +391,35 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
       }
     }
   }
+
+  void visitMarkerAttr(MarkerAttr *attr) {
+    auto proto = dyn_cast<ProtocolDecl>(D);
+    if (!proto)
+      return;
+
+    // A marker protocol cannot inherit a non-marker protocol.
+    for (auto inheritedProto : proto->getInheritedProtocols()) {
+      if (!inheritedProto->isMarkerProtocol()) {
+        proto->diagnose(
+            diag::marker_protocol_inherit_nonmarker,
+            proto->getName(), inheritedProto->getName());
+        inheritedProto->diagnose(
+            diag::decl_declared_here, inheritedProto->getName());
+      }
+    }
+
+    // A marker protocol cannot have any requirements.
+    for (auto member : proto->getAllMembers()) {
+      auto value = dyn_cast<ValueDecl>(member);
+      if (!value)
+        continue;
+
+      if (value->isProtocolRequirement()) {
+        value->diagnose(diag::marker_protocol_requirement, proto->getName());
+        break;
+      }
+    }
+  }
 };
 } // end anonymous namespace
 

lib/Sema/TypeCheckDeclOverride.cpp

@@ -1534,6 +1534,7 @@ namespace  {
     UNINTERESTING_ATTR(Concurrent)
 
     UNINTERESTING_ATTR(AtRethrows)
+    UNINTERESTING_ATTR(Marker)
 #undef UNINTERESTING_ATTR
 
     void visitAvailableAttr(AvailableAttr *attr) {

lib/Sema/TypeCheckType.cpp

@@ -3918,6 +3918,12 @@ class UnsupportedProtocolVisitor
                            proto->getName());
         T->setInvalid();
       }
+      if (proto->isMarkerProtocol()) {
+        Ctx.Diags.diagnose(comp->getNameLoc(),
+                           diag::marker_protocol_value,
+                           proto->getName());
+        T->setInvalid();
+      }
     } else if (auto *alias = dyn_cast_or_null<TypeAliasDecl>(comp->getBoundDecl())) {
       auto type = Type(alias->getDeclaredInterfaceType()->getDesugaredType());
       type.findIf([&](Type type) -> bool {
@@ -3928,6 +3934,14 @@ class UnsupportedProtocolVisitor
           for (auto *proto : layout.getProtocols()) {
             auto *protoDecl = proto->getDecl();
 
+            if (protoDecl->isMarkerProtocol()) {
+              Ctx.Diags.diagnose(comp->getNameLoc(),
+                                 diag::marker_protocol_value,
+                                 protoDecl->getName());
+              T->setInvalid();
+              continue;
+            }
+
             if (protoDecl->existentialTypeSupported())
               continue;
 

test/IRGen/marker_protocol.swift

@@ -0,0 +1,22 @@
+// RUN: %target-swift-frontend -primary-file %s -emit-ir -o - | %FileCheck %s
+
+// Marker protocols should have no ABI impact at all, so this source file checks
+// for the absence of symbols related to marker protocols.
+
+// CHECK-NOT: $s15marker_protocol1PP
+// CHECK-NOT: $s15marker_protocol1PMp
+// CHECK-NOT: "\01l_protocols"
+
+@_marker public protocol P { }
+
+extension Int: P { }
+extension Array: P where Element: P { }
+
+// Note: no witness tables
+// CHECK: define swiftcc void @"$s15marker_protocol7genericyyxAA1PRzlF"(%swift.opaque* noalias nocapture %0, %swift.type* %T)
+public func generic<T: P>(_: T) { }
+
+public func testGeneric(i: Int, array: [Int]) {
+  generic(i)
+  generic(array)
+}