Change operator decl representation for designated type.

Update the representation to allow for multiple types to be specified
for a single operator.

No parsing, serialization, or deserialization support yet, so NFC.

Author: rudkx

include/swift/AST/Decl.h

@@ -6380,18 +6380,17 @@ class OperatorDecl : public Decl {
 
   Identifier name;
 
-  Identifier DesignatedNominalTypeName;
-  SourceLoc DesignatedNominalTypeNameLoc;
+  ArrayRef<Identifier> Identifiers;
+  ArrayRef<SourceLoc> IdentifierLocs;
   NominalTypeDecl *DesignatedNominalType = nullptr;
 
 public:
   OperatorDecl(DeclKind kind, DeclContext *DC, SourceLoc OperatorLoc,
                Identifier Name, SourceLoc NameLoc,
-               Identifier DesignatedNominalTypeName = Identifier(),
-               SourceLoc DesignatedNominalTypeNameLoc = SourceLoc())
+               ArrayRef<Identifier> Identifiers,
+               ArrayRef<SourceLoc> IdentifierLocs)
       : Decl(kind, DC), OperatorLoc(OperatorLoc), NameLoc(NameLoc), name(Name),
-        DesignatedNominalTypeName(DesignatedNominalTypeName),
-        DesignatedNominalTypeNameLoc(DesignatedNominalTypeNameLoc) {}
+        Identifiers(Identifiers), IdentifierLocs(IdentifierLocs) {}
 
   OperatorDecl(DeclKind kind, DeclContext *DC, SourceLoc OperatorLoc,
                Identifier Name, SourceLoc NameLoc,
@@ -6405,12 +6404,20 @@ class OperatorDecl : public Decl {
   SourceLoc getNameLoc() const { return NameLoc; }
   Identifier getName() const { return name; }
 
+  ArrayRef<Identifier> getIdentifiers() const {
+    return Identifiers;
+  }
+
+  ArrayRef<SourceLoc> getIdentifierLocs() const {
+    return IdentifierLocs;
+  }
+
   Identifier getDesignatedNominalTypeName() const {
-    return DesignatedNominalTypeName;
+    return !Identifiers.empty() ? Identifiers[0] : Identifier();
   }
 
   SourceLoc getDesignatedNominalTypeNameLoc() const {
-    return DesignatedNominalTypeNameLoc;
+    return !IdentifierLocs.empty() ? IdentifierLocs[0] : SourceLoc();
   }
 
   NominalTypeDecl *getDesignatedNominalType() const {
@@ -6436,20 +6443,17 @@ class OperatorDecl : public Decl {
 /// infix operator /+/ : AdditionPrecedence, Numeric
 /// \endcode
 class InfixOperatorDecl : public OperatorDecl {
-  SourceLoc ColonLoc, FirstIdentifierLoc, SecondIdentifierLoc;
-  Identifier FirstIdentifier, SecondIdentifier;
+  SourceLoc ColonLoc;
   PrecedenceGroupDecl *PrecedenceGroup = nullptr;
 
 public:
   InfixOperatorDecl(DeclContext *DC, SourceLoc operatorLoc, Identifier name,
                     SourceLoc nameLoc, SourceLoc colonLoc,
-                    Identifier firstIdentifier, SourceLoc firstIdentifierLoc,
-                    Identifier secondIdentifier = Identifier(),
-                    SourceLoc secondIdentifierLoc = SourceLoc())
-      : OperatorDecl(DeclKind::InfixOperator, DC, operatorLoc, name, nameLoc),
-        ColonLoc(colonLoc), FirstIdentifierLoc(firstIdentifierLoc),
-        SecondIdentifierLoc(secondIdentifierLoc),
-        FirstIdentifier(firstIdentifier), SecondIdentifier(secondIdentifier) {}
+                    ArrayRef<Identifier> identifiers,
+                    ArrayRef<SourceLoc> identifierLocs)
+      : OperatorDecl(DeclKind::InfixOperator, DC, operatorLoc, name, nameLoc,
+                     identifiers, identifierLocs),
+        ColonLoc(colonLoc) {}
 
   InfixOperatorDecl(DeclContext *DC, SourceLoc operatorLoc, Identifier name,
                     SourceLoc nameLoc, SourceLoc colonLoc,
@@ -6460,22 +6464,34 @@ class InfixOperatorDecl : public OperatorDecl {
         ColonLoc(colonLoc), PrecedenceGroup(precedenceGroup) {}
 
   SourceLoc getEndLoc() const {
-    if (!SecondIdentifier.empty())
-      return SecondIdentifierLoc;
-    if (!FirstIdentifier.empty())
-      return FirstIdentifierLoc;
+    if (!getSecondIdentifier().empty())
+      return getSecondIdentifierLoc();
+    if (!getFirstIdentifier().empty())
+      return getFirstIdentifierLoc();
     return getNameLoc();
   }
   SourceRange getSourceRange() const {
     return { getOperatorLoc(), getEndLoc() };
   }
 
   SourceLoc getColonLoc() const { return ColonLoc; }
-  SourceLoc getFirstIdentifierLoc() const { return FirstIdentifierLoc; }
-  SourceLoc getSecondIdentifierLoc() const { return SecondIdentifierLoc; }
+  SourceLoc getFirstIdentifierLoc() const {
+    auto identifierLocs = getIdentifierLocs();
+    return !identifierLocs.empty() ? identifierLocs[0] : SourceLoc();
+  }
+  SourceLoc getSecondIdentifierLoc() const {
+    auto identifierLocs = getIdentifierLocs();
+    return identifierLocs.size() > 1 ? identifierLocs[1] : SourceLoc();
+  }
 
-  Identifier getFirstIdentifier() const { return FirstIdentifier; }
-  Identifier getSecondIdentifier() const { return SecondIdentifier; }
+  Identifier getFirstIdentifier() const {
+    auto identifiers = getIdentifiers();
+    return !identifiers.empty()  ? identifiers[0] : Identifier();
+  }
+  Identifier getSecondIdentifier() const {
+    auto identifiers = getIdentifiers();
+    return identifiers.size() > 1  ? identifiers[1] : Identifier();
+  }
 
   PrecedenceGroupDecl *getPrecedenceGroup() const { return PrecedenceGroup; }
   void setPrecedenceGroup(PrecedenceGroupDecl *PGD) {
@@ -6502,10 +6518,10 @@ class PrefixOperatorDecl : public OperatorDecl {
 public:
   PrefixOperatorDecl(DeclContext *DC, SourceLoc OperatorLoc, Identifier Name,
                      SourceLoc NameLoc,
-                     Identifier DesignatedNominalTypeName = Identifier(),
-                     SourceLoc DesignatedNominalTypeNameLoc = SourceLoc())
+                     ArrayRef<Identifier> Identifiers,
+                     ArrayRef<SourceLoc> IdentifierLocs)
       : OperatorDecl(DeclKind::PrefixOperator, DC, OperatorLoc, Name, NameLoc,
-                     DesignatedNominalTypeName, DesignatedNominalTypeNameLoc) {}
+                     Identifiers, IdentifierLocs) {}
 
   PrefixOperatorDecl(DeclContext *DC, SourceLoc OperatorLoc, Identifier Name,
                      SourceLoc NameLoc, NominalTypeDecl *DesignatedNominalType)
@@ -6536,10 +6552,10 @@ class PostfixOperatorDecl : public OperatorDecl {
 public:
   PostfixOperatorDecl(DeclContext *DC, SourceLoc OperatorLoc, Identifier Name,
                       SourceLoc NameLoc,
-                      Identifier DesignatedNominalTypeName = Identifier(),
-                      SourceLoc DesignatedNominalTypeNameLoc = SourceLoc())
+                      ArrayRef<Identifier> Identifiers,
+                      ArrayRef<SourceLoc> IdentifierLocs)
       : OperatorDecl(DeclKind::PostfixOperator, DC, OperatorLoc, Name, NameLoc,
-                     DesignatedNominalTypeName, DesignatedNominalTypeNameLoc) {}
+                     Identifiers, IdentifierLocs) {}
 
   PostfixOperatorDecl(DeclContext *DC, SourceLoc OperatorLoc, Identifier Name,
                       SourceLoc NameLoc, NominalTypeDecl *DesignatedNominalType)

lib/Parse/ParseDecl.cpp

@@ -6496,40 +6496,39 @@ Parser::parseDeclOperatorImpl(SourceLoc OperatorLoc, Identifier Name,
   // parse them both as identifiers here and sort it out in type
   // checking.
   SourceLoc colonLoc;
-  Identifier firstIdentifierName;
-  SourceLoc firstIdentifierNameLoc;
-  Identifier secondIdentifierName;
-  SourceLoc secondIdentifierNameLoc;
+  SmallVector<Identifier, 4> identifiers;
+  SmallVector<SourceLoc, 4> identifierLocs;
   if (Tok.is(tok::colon)) {
-    SyntaxParsingContext GroupCtxt(SyntaxContext, SyntaxKind::InfixOperatorGroup);
+    SyntaxParsingContext GroupCtxt(SyntaxContext,
+                                   SyntaxKind::InfixOperatorGroup);
     colonLoc = consumeToken();
 
     if (Context.LangOpts.EnableOperatorDesignatedTypes) {
       if (Tok.is(tok::identifier)) {
-        firstIdentifierName = Context.getIdentifier(Tok.getText());
-        firstIdentifierNameLoc = consumeToken(tok::identifier);
+        identifiers.push_back(Context.getIdentifier(Tok.getText()));
+        identifierLocs.push_back(consumeToken(tok::identifier));
 
         if (consumeIf(tok::comma)) {
           if (isPrefix || isPostfix)
             diagnose(colonLoc, diag::precedencegroup_not_infix)
-                .fixItRemove({colonLoc, firstIdentifierNameLoc});
+                .fixItRemove({colonLoc, identifierLocs.back()});
 
           if (Tok.is(tok::identifier)) {
-            secondIdentifierName = Context.getIdentifier(Tok.getText());
-            secondIdentifierNameLoc = consumeToken(tok::identifier);
+            identifiers.push_back(Context.getIdentifier(Tok.getText()));
+            identifierLocs.push_back(consumeToken(tok::identifier));
           } else {
             auto otherTokLoc = consumeToken();
             diagnose(otherTokLoc, diag::operator_decl_trailing_comma);
           }
         }
       }
     } else if (Tok.is(tok::identifier)) {
-      firstIdentifierName = Context.getIdentifier(Tok.getText());
-      firstIdentifierNameLoc = consumeToken(tok::identifier);
+      identifiers.push_back(Context.getIdentifier(Tok.getText()));
+      identifierLocs.push_back(consumeToken(tok::identifier));
 
       if (isPrefix || isPostfix) {
         diagnose(colonLoc, diag::precedencegroup_not_infix)
-            .fixItRemove({colonLoc, firstIdentifierNameLoc});
+            .fixItRemove({colonLoc, identifierLocs.back()});
       }
     }
   }
@@ -6542,7 +6541,8 @@ Parser::parseDeclOperatorImpl(SourceLoc OperatorLoc, Identifier Name,
     } else {
       auto Diag = diagnose(lBraceLoc, diag::deprecated_operator_body);
       if (Tok.is(tok::r_brace)) {
-        SourceLoc lastGoodLoc = firstIdentifierNameLoc;
+        SourceLoc lastGoodLoc =
+            !identifierLocs.empty() ? identifierLocs.back() : SourceLoc();
         if (lastGoodLoc.isInvalid())
           lastGoodLoc = NameLoc;
         SourceLoc lastGoodLocEnd = Lexer::getLocForEndOfToken(SourceMgr,
@@ -6560,16 +6560,18 @@ Parser::parseDeclOperatorImpl(SourceLoc OperatorLoc, Identifier Name,
   if (Attributes.hasAttribute<PrefixAttr>())
     res = new (Context)
         PrefixOperatorDecl(CurDeclContext, OperatorLoc, Name, NameLoc,
-                           firstIdentifierName, firstIdentifierNameLoc);
+                           Context.AllocateCopy(identifiers),
+                           Context.AllocateCopy(identifierLocs));
   else if (Attributes.hasAttribute<PostfixAttr>())
     res = new (Context)
         PostfixOperatorDecl(CurDeclContext, OperatorLoc, Name, NameLoc,
-                            firstIdentifierName, firstIdentifierNameLoc);
+                            Context.AllocateCopy(identifiers),
+                            Context.AllocateCopy(identifierLocs));
   else
     res = new (Context)
         InfixOperatorDecl(CurDeclContext, OperatorLoc, Name, NameLoc, colonLoc,
-                          firstIdentifierName, firstIdentifierNameLoc,
-                          secondIdentifierName, secondIdentifierNameLoc);
+                          Context.AllocateCopy(identifiers),
+                          Context.AllocateCopy(identifierLocs));
 
   diagnoseOperatorFixityAttributes(*this, Attributes, res);