Parse: New syntax for primary associated types

Author: slavapestov

include/swift/AST/DiagnosticsParse.def

@@ -1797,8 +1797,14 @@ ERROR(redundant_class_requirement,none,
 ERROR(late_class_requirement,none,
       "'class' must come first in the requirement list", ())
 ERROR(where_inside_brackets,none,
-        "'where' clause next to generic parameters is obsolete, "
-        "must be written following the declaration's type", ())
+      "'where' clause next to generic parameters is obsolete, "
+      "must be written following the declaration's type", ())
+
+
+ERROR(expected_rangle_primary_associated_type_list,PointsToFirstBadToken,
+      "expected '>' to complete primary associated type list", ())
+ERROR(expected_primary_associated_type_name,PointsToFirstBadToken,
+      "expected an identifier to name primary associated type", ())
 
 //------------------------------------------------------------------------------
 // MARK: Conditional compilation parsing diagnostics

include/swift/Parse/Parser.h

@@ -1199,6 +1199,9 @@ class Parser {
   void parseAbstractFunctionBody(AbstractFunctionDecl *AFD);
   BodyAndFingerprint
   parseAbstractFunctionBodyDelayed(AbstractFunctionDecl *AFD);
+
+  ParserStatus parsePrimaryAssociatedTypes(
+      SmallVectorImpl<AssociatedTypeDecl *> &AssocTypes);
   ParserResult<ProtocolDecl> parseDeclProtocol(ParseDeclOptions Flags,
                                                DeclAttributes &Attributes);
 

lib/Parse/ParseDecl.cpp

@@ -7963,14 +7963,125 @@ ParserResult<ClassDecl> Parser::parseDeclClass(ParseDeclOptions Flags,
   return DCC.fixupParserResult(Status, CD);
 }
 
+ParserStatus Parser::parsePrimaryAssociatedTypes(
+    SmallVectorImpl<AssociatedTypeDecl *> &AssocTypes) {
+  SourceLoc LAngleLoc = consumeStartingLess();
+
+  ParserStatus Result;
+  SyntaxParsingContext PATContext(SyntaxContext,
+                                  SyntaxKind::PrimaryAssociatedTypeList);
+
+  bool HasNextParam = false;
+  do {
+    SyntaxParsingContext ATContext(SyntaxContext,
+                                   SyntaxKind::PrimaryAssociatedType);
+
+    // Note that we're parsing a declaration.
+    StructureMarkerRAII ParsingDecl(*this, Tok.getLoc(),
+                                    StructureMarkerKind::Declaration);
+
+    // Parse attributes.
+    DeclAttributes Attrs;
+    if (Tok.hasComment())
+      Attrs.add(new (Context) RawDocCommentAttr(Tok.getCommentRange()));
+    parseDeclAttributeList(Attrs);
+
+    // Parse the name of the parameter.
+    Identifier Name;
+    SourceLoc NameLoc;
+    if (parseIdentifier(Name, NameLoc, /*diagnoseDollarPrefix=*/true,
+                        diag::expected_primary_associated_type_name)) {
+      Result.setIsParseError();
+      break;
+    }
+
+    // Parse the ':' followed by a type.
+    SmallVector<InheritedEntry, 1> Inherited;
+    if (Tok.is(tok::colon)) {
+      (void)consumeToken();
+      ParserResult<TypeRepr> Ty;
+
+      if (Tok.isAny(tok::identifier, tok::code_complete, tok::kw_protocol,
+                    tok::kw_Any)) {
+        Ty = parseType();
+      } else if (Tok.is(tok::kw_class)) {
+        diagnose(Tok, diag::unexpected_class_constraint);
+        diagnose(Tok, diag::suggest_anyobject)
+        .fixItReplace(Tok.getLoc(), "AnyObject");
+        consumeToken();
+        Result.setIsParseError();
+      } else {
+        diagnose(Tok, diag::expected_generics_type_restriction, Name);
+        Result.setIsParseError();
+      }
+
+      if (Ty.hasCodeCompletion())
+        return makeParserCodeCompletionStatus();
+
+      if (Ty.isNonNull())
+        Inherited.push_back({Ty.get()});
+    }
+
+    ParserResult<TypeRepr> UnderlyingTy;
+    if (Tok.is(tok::equal)) {
+      SyntaxParsingContext InitContext(SyntaxContext,
+                                       SyntaxKind::TypeInitializerClause);
+      consumeToken(tok::equal);
+      UnderlyingTy = parseType(diag::expected_type_in_associatedtype);
+      Result |= UnderlyingTy;
+      if (UnderlyingTy.isNull())
+        return Result;
+    }
+
+    auto *AssocType = new (Context)
+        AssociatedTypeDecl(CurDeclContext, NameLoc, Name, NameLoc,
+                           UnderlyingTy.getPtrOrNull(),
+                           /*trailingWhere=*/nullptr);
+    AssocType->getAttrs() = Attrs;
+    if (!Inherited.empty())
+      AssocType->setInherited(Context.AllocateCopy(Inherited));
+    AssocType->getAttrs().add(new (Context) PrimaryAssociatedTypeAttr(
+        /*Implicit=*/true));
+
+    AssocTypes.push_back(AssocType);
+
+    // Parse the comma, if the list continues.
+    HasNextParam = consumeIf(tok::comma);
+  } while (HasNextParam);
+
+  // Parse the closing '>'.
+  SourceLoc RAngleLoc;
+  if (startsWithGreater(Tok)) {
+    RAngleLoc = consumeStartingGreater();
+  } else {
+    diagnose(Tok, diag::expected_rangle_primary_associated_type_list);
+    diagnose(LAngleLoc, diag::opening_angle);
+
+    // Skip until we hit the '>'.
+    RAngleLoc = skipUntilGreaterInTypeList();
+  }
+
+  return Result;
+}
+
 /// Parse a 'protocol' declaration, doing no token skipping on error.
 ///
 /// \verbatim
 ///   decl-protocol:
 ///      protocol-head '{' protocol-member* '}'
 ///
 ///   protocol-head:
-///     'protocol' attribute-list identifier inheritance? 
+///     attribute-list 'protocol' identifier primary-associated-type-list?
+///     inheritance? 
+///
+///   primary-associated-type-list:
+///     '<' primary-associated-type+ '>'
+///
+///   primary-associated-type:
+///     identifier inheritance? default-associated-type
+///
+///   default-associated-type:
+///     '=' type
 ///
 ///   protocol-member:
 ///      decl-func
@@ -7991,12 +8102,20 @@ parseDeclProtocol(ParseDeclOptions Flags, DeclAttributes &Attributes) {
   if (Status.isErrorOrHasCompletion())
     return Status;
 
-  // Protocols don't support generic parameters, but people often want them and
-  // we want to have good error recovery if they try them out.  Parse them and
-  // produce a specific diagnostic if present.
-  if (startsWithLess(Tok)) {
-    diagnose(Tok, diag::generic_arguments_protocol);
-    maybeParseGenericParams();
+  SmallVector<AssociatedTypeDecl *, 2> PrimaryAssociatedTypes;
+
+  if (Context.LangOpts.EnableParameterizedProtocolTypes) {
+    if (startsWithLess(Tok)) {
+      Status |= parsePrimaryAssociatedTypes(PrimaryAssociatedTypes);
+    }
+  } else {
+    // Protocols don't support generic parameters, but people often want them and
+    // we want to have good error recovery if they try them out.  Parse them and
+    // produce a specific diagnostic if present.
+    if (startsWithLess(Tok)) {
+      diagnose(Tok, diag::generic_arguments_protocol);
+      maybeParseGenericParams();
+    }
   }
 
   DebuggerContextChange DCC (*this);
@@ -8035,6 +8154,12 @@ parseDeclProtocol(ParseDeclOptions Flags, DeclAttributes &Attributes) {
 
   ContextChange CC(*this, Proto);
 
+  // Re-parent the primary associated type declarations into the protocol.
+  for (auto *AssocType : PrimaryAssociatedTypes) {
+    AssocType->setDeclContext(Proto);
+    Proto->addMember(AssocType);
+  }
+
   // Parse the body.
   {
     SyntaxParsingContext BlockContext(SyntaxContext, SyntaxKind::MemberDeclBlock);

test/Constraints/opened_existentials.swift

@@ -72,9 +72,7 @@ func testMagic(pt: any P.Type) {
 }
 
 // --- With primary associated types and opaque parameter types
-protocol CollectionOf: Collection {
-  @_primaryAssociatedType associatedtype Element
-}
+protocol CollectionOf<Element>: Collection { }
 
 extension Array: CollectionOf { }
 extension Set: CollectionOf { }

test/type/opaque_parameters.swift

@@ -68,9 +68,7 @@ func testAnyDictionary(numberNames: [Int: String]) {
 }
 
 // Combine with parameterized protocol types
-protocol PrimaryCollection: Collection {
-  @_primaryAssociatedType associatedtype Element
-}
+protocol PrimaryCollection<Element>: Collection {}
 
 extension Array: PrimaryCollection { }
 extension Set: PrimaryCollection { }

test/type/parameterized_protocol.swift

@@ -3,16 +3,30 @@
 // RUN: not %target-swift-frontend -typecheck %s -debug-generic-signatures -requirement-machine-protocol-signatures=verify -enable-parameterized-protocol-types -requirement-machine-inferred-signatures=verify -disable-availability-checking 2>&1 | %FileCheck %s
 
 
-protocol Sequence {
-  @_primaryAssociatedType associatedtype Element
+/// Test some invalid syntax first
+
+protocol Invalid1<> {}
+// expected-error@-1 {{expected an identifier to name primary associated type}}
+
+protocol Invalid2<A B> {}
+// expected-error@-1 {{expected '>' to complete primary associated type list}}
+// expected-note@-2 {{to match this opening '<'}}
+
+protocol Invalid3<Element, +> {}
+// expected-error@-1 {{expected an identifier to name primary associated type}}
+// expected-error@-2 {{expected '>' to complete primary associated type list}}
+// expected-note@-3 {{to match this opening '<'}}
+
+
+/// Test semantics
+
+protocol Sequence<Element> {
   // expected-note@-1 {{protocol requires nested type 'Element'; do you want to add it?}}
 }
 
 struct ConcreteSequence<Element> : Sequence {}
 
-protocol EquatableSequence {
-  @_primaryAssociatedType associatedtype Element : Equatable
-}
+protocol EquatableSequence<Element : Equatable> {}
 
 struct ConcreteEquatableSequence<Element : Equatable> : EquatableSequence {}
 
@@ -86,10 +100,7 @@ protocol SequenceWrapperProtocol2 {
 
 
 /// Multiple primary associated types
-protocol Collection {
-  @_primaryAssociatedType associatedtype Element
-  @_primaryAssociatedType associatedtype Index
-}
+protocol Collection<Element, Index> {}
 
 // CHECK-LABEL: .testCollection1@
 // CHECK-NEXT: Generic signature: <T where T : Collection, T.[Collection]Element == String>

utils/gyb_syntax_support/GenericNodes.py

@@ -64,6 +64,27 @@
                    is_optional=True),
          ]),
 
+    Node('PrimaryAssociatedTypeList', kind='SyntaxCollection',
+         element='PrimaryAssociatedType'),
+
+    # primary-associated-type -> type-name
+    #                          | type-name (: type-identifier)? (= type)?
+    Node('PrimaryAssociatedType', kind='Syntax',
+         traits=['WithTrailingComma'],
+         children=[
+             Child('Attributes', kind='AttributeList',
+                   collection_element_name='Attribute', is_optional=True),
+             Child('Name', kind='IdentifierToken'),
+             Child('Colon', kind='ColonToken',
+                   is_optional=True),
+             Child('InheritedType', kind='Type',
+                   is_optional=True),
+             Child('Initializer', kind='TypeInitializerClause',
+                   is_optional=True),
+             Child('TrailingComma', kind='CommaToken',
+                   is_optional=True),
+         ]),
+
     # generic-parameter-clause -> '<' generic-parameter-list '>'
     Node('GenericParameterClause', kind='Syntax',
          children=[

utils/gyb_syntax_support/NodeSerializationCodes.py

@@ -255,6 +255,8 @@
     'UnavailabilityCondition': 251,
     'AvailabilityEntry' : 252,
     'RegexLiteralExpr': 253,
+    'PrimaryAssociatedTypeList' : 254,
+    'PrimaryAssociatedType' : 255,
 }