libSyntax: support generic parameter clause. (#13286)

This patch also performs minor refactoring to align syntax parsing
context with the right scope. We start to support the generic clauses
because they are necessary pieces to construct struct or
function syntax node.

Author: nkcsgexi

include/swift/Parse/Parser.h

@@ -1329,6 +1329,8 @@ class Parser {
 
   ParserResult<GenericParamList> parseGenericParameters();
   ParserResult<GenericParamList> parseGenericParameters(SourceLoc LAngleLoc);
+  ParserStatus parseGenericParametersBeforeWhere(SourceLoc LAngleLoc,
+                        SmallVectorImpl<GenericTypeParamDecl *> &GenericParams);
   ParserResult<GenericParamList> maybeParseGenericParams();
   void
   diagnoseWhereClauseInGenericParamList(const GenericParamList *GenericParams);

lib/Parse/ParseGeneric.cpp

@@ -38,17 +38,20 @@ using namespace swift::syntax;
 /// When parsing the generic parameters, this routine establishes a new scope
 /// and adds those parameters to the scope.
 ParserResult<GenericParamList> Parser::parseGenericParameters() {
+  SyntaxParsingContext GPSContext(SyntaxContext, SyntaxKind::GenericParameterClause);
   // Parse the opening '<'.
   assert(startsWithLess(Tok) && "Generic parameter list must start with '<'");
   return parseGenericParameters(consumeStartingLess());
 }
 
-ParserResult<GenericParamList>
-Parser::parseGenericParameters(SourceLoc LAngleLoc) {
-  // Parse the generic parameter list.
-  SmallVector<GenericTypeParamDecl *, 4> GenericParams;
-  bool Invalid = false;
+ParserStatus
+Parser::parseGenericParametersBeforeWhere(SourceLoc LAngleLoc,
+                        SmallVectorImpl<GenericTypeParamDecl *> &GenericParams) {
+  ParserStatus Result;
+  SyntaxParsingContext GPSContext(SyntaxContext, SyntaxKind::GenericParameterList);
+  bool HasNextParam;
   do {
+    SyntaxParsingContext GParamContext(SyntaxContext, SyntaxKind::GenericParameter);
     // Note that we're parsing a declaration.
     StructureMarkerRAII ParsingDecl(*this, Tok.getLoc(),
                                     StructureMarkerKind::Declaration);
@@ -65,7 +68,7 @@ Parser::parseGenericParameters(SourceLoc LAngleLoc) {
     SourceLoc NameLoc;
     if (parseIdentifier(Name, NameLoc,
                         diag::expected_generics_parameter_name)) {
-      Invalid = true;
+      Result.setIsParseError();
       break;
     }
 
@@ -74,18 +77,19 @@ Parser::parseGenericParameters(SourceLoc LAngleLoc) {
     if (Tok.is(tok::colon)) {
       (void)consumeToken();
       ParserResult<TypeRepr> Ty;
-      
-      if (Tok.isAny(tok::identifier, tok::code_complete, tok::kw_protocol, tok::kw_Any)) {
+
+      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");
+        .fixItReplace(Tok.getLoc(), "AnyObject");
         consumeToken();
-        Invalid = true;
+        Result.setIsParseError();
       } else {
         diagnose(Tok, diag::expected_generics_type_restriction, Name);
-        Invalid = true;
+        Result.setIsParseError();
       }
 
       if (Ty.hasCodeCompletion())
@@ -98,10 +102,9 @@ Parser::parseGenericParameters(SourceLoc LAngleLoc) {
     // We always create generic type parameters with an invalid depth.
     // Semantic analysis fills in the depth when it processes the generic
     // parameter list.
-    auto Param = new (Context) GenericTypeParamDecl(
-        CurDeclContext, Name, NameLoc,
-        GenericTypeParamDecl::InvalidDepth,
-        GenericParams.size());
+    auto Param = new (Context) GenericTypeParamDecl(CurDeclContext, Name, NameLoc,
+                                            GenericTypeParamDecl::InvalidDepth,
+                                                    GenericParams.size());
     if (!Inherited.empty())
       Param->setInherited(Context.AllocateCopy(Inherited));
     GenericParams.push_back(Param);
@@ -113,7 +116,22 @@ Parser::parseGenericParameters(SourceLoc LAngleLoc) {
     addToScope(Param);
 
     // Parse the comma, if the list continues.
-  } while (consumeIf(tok::comma));
+    HasNextParam = consumeIf(tok::comma);
+  } while (HasNextParam);
+
+  return Result;
+}
+
+ParserResult<GenericParamList>
+Parser::parseGenericParameters(SourceLoc LAngleLoc) {
+  // Parse the generic parameter list.
+  SmallVector<GenericTypeParamDecl *, 4> GenericParams;
+  auto Result = parseGenericParametersBeforeWhere(LAngleLoc, GenericParams);
+
+  // Return early if there was code completion token.
+  if (Result.hasCodeCompletion())
+    return Result;
+  auto Invalid = Result.isError();
 
   // Parse the optional where-clause.
   SourceLoc WhereLoc;

lib/Syntax/SyntaxFactory.cpp.gyb

@@ -308,7 +308,7 @@ TupleTypeElementSyntax SyntaxFactory::makeTupleTypeElement(TypeSyntax Type,
 GenericParameterSyntax
 SyntaxFactory::makeGenericParameter(TokenSyntax Name,
   llvm::Optional<TokenSyntax> TrailingComma) {
-  return makeGenericParameter(Name, None, None, TrailingComma);
+  return makeGenericParameter(None, Name, None, None, TrailingComma);
 }
 
 TypeSyntax SyntaxFactory::makeTypeIdentifier(OwnedString TypeName,

test/Syntax/Outputs/round_trip_parse_gen.swift.withkinds

@@ -85,4 +85,4 @@ struct foo <MemberDeclBlock>{<Attribute>
   }
 }</MemberDeclBlock>
 
-struct S<A, B, C, D> <GenericWhereClause>where <ConformanceRequirement><SimpleTypeIdentifier>A</SimpleTypeIdentifier>:<SimpleTypeIdentifier>B</SimpleTypeIdentifier>, </ConformanceRequirement><SameTypeRequirement><SimpleTypeIdentifier>B</SimpleTypeIdentifier>==<SimpleTypeIdentifier>C</SimpleTypeIdentifier>, </SameTypeRequirement><ConformanceRequirement><SimpleTypeIdentifier>A </SimpleTypeIdentifier>: <SimpleTypeIdentifier>C</SimpleTypeIdentifier>, </ConformanceRequirement><SameTypeRequirement><MemberTypeIdentifier><SimpleTypeIdentifier>B</SimpleTypeIdentifier>.C </MemberTypeIdentifier>== <MemberTypeIdentifier><SimpleTypeIdentifier>D</SimpleTypeIdentifier>.A</MemberTypeIdentifier>, </SameTypeRequirement><ConformanceRequirement><MemberTypeIdentifier><SimpleTypeIdentifier>A</SimpleTypeIdentifier>.B</MemberTypeIdentifier>: <MemberTypeIdentifier><SimpleTypeIdentifier>C</SimpleTypeIdentifier>.D </MemberTypeIdentifier></ConformanceRequirement></GenericWhereClause><MemberDeclBlock>{}</MemberDeclBlock>
+struct S<GenericParameterClause><<GenericParameter>A, </GenericParameter><GenericParameter>B, </GenericParameter><GenericParameter>C, </GenericParameter><GenericParameter><Attribute>@objc </Attribute>D</GenericParameter>> </GenericParameterClause><GenericWhereClause>where <ConformanceRequirement><SimpleTypeIdentifier>A</SimpleTypeIdentifier>:<SimpleTypeIdentifier>B</SimpleTypeIdentifier>, </ConformanceRequirement><SameTypeRequirement><SimpleTypeIdentifier>B</SimpleTypeIdentifier>==<SimpleTypeIdentifier>C</SimpleTypeIdentifier>, </SameTypeRequirement><ConformanceRequirement><SimpleTypeIdentifier>A </SimpleTypeIdentifier>: <SimpleTypeIdentifier>C</SimpleTypeIdentifier>, </ConformanceRequirement><SameTypeRequirement><MemberTypeIdentifier><SimpleTypeIdentifier>B</SimpleTypeIdentifier>.C </MemberTypeIdentifier>== <MemberTypeIdentifier><SimpleTypeIdentifier>D</SimpleTypeIdentifier>.A</MemberTypeIdentifier>, </SameTypeRequirement><ConformanceRequirement><MemberTypeIdentifier><SimpleTypeIdentifier>A</SimpleTypeIdentifier>.B</MemberTypeIdentifier>: <MemberTypeIdentifier><SimpleTypeIdentifier>C</SimpleTypeIdentifier>.D </MemberTypeIdentifier></ConformanceRequirement></GenericWhereClause><MemberDeclBlock>{}</MemberDeclBlock>

test/Syntax/round_trip_parse_gen.swift

@@ -85,4 +85,4 @@ struct foo {
   }
 }
 
-struct S<A, B, C, D> where A:B, B==C, A : C, B.C == D.A, A.B: C.D {}
+struct S<A, B, C, @objc D> where A:B, B==C, A : C, B.C == D.A, A.B: C.D {}

tools/SwiftSyntax/SyntaxFactory.swift.gyb

@@ -139,7 +139,7 @@ public enum SyntaxFactory {
 
   public static func makeGenericParameter(name: TokenSyntax,
       trailingComma: TokenSyntax) -> GenericParameterSyntax {
-    return makeGenericParameter(name: name, colon: nil,
+    return makeGenericParameter(attributes: nil, name: name, colon: nil,
                                 inheritedType: nil,
                                 trailingComma: trailingComma)
   }

unittests/Syntax/DeclSyntaxTests.cpp

@@ -82,7 +82,7 @@ TEST(DeclSyntaxTests, TypealiasMakeAPIs) {
     auto Subsequence = SyntaxFactory::makeIdentifier("MyCollection", {}, {});
     auto ElementName = SyntaxFactory::makeIdentifier("Element", {}, {});
     auto ElementParam =
-      SyntaxFactory::makeGenericParameter(ElementName, None, None, None);
+      SyntaxFactory::makeGenericParameter(None, ElementName, None, None, None);
     auto LeftAngle = SyntaxFactory::makeLeftAngleToken({}, {});
     auto RightAngle = SyntaxFactory::makeRightAngleToken({}, Trivia::spaces(1));
     auto GenericParams = GenericParameterClauseSyntaxBuilder()
@@ -119,7 +119,7 @@ TEST(DeclSyntaxTests, TypealiasWithAPIs) {
   auto MyCollection = SyntaxFactory::makeIdentifier("MyCollection", {}, {});
   auto ElementName = SyntaxFactory::makeIdentifier("Element", {}, {});
   auto ElementParam =
-      SyntaxFactory::makeGenericParameter(ElementName, None, None, None);
+      SyntaxFactory::makeGenericParameter(None, ElementName, None, None, None);
   auto LeftAngle = SyntaxFactory::makeLeftAngleToken({}, {});
   auto RightAngle =
     SyntaxFactory::makeRightAngleToken({}, { Trivia::spaces(1) });

utils/gyb_syntax_support/GenericNodes.py

@@ -35,6 +35,8 @@
     #                    | type-name : protocol-composition-type
     Node('GenericParameter', kind='Syntax',
          children=[
+             Child('Attributes', kind='AttributeList',
+                   is_optional=True),
              Child('Name', kind='IdentifierToken'),
              Child('Colon', kind='ColonToken',
                    is_optional=True),