[AST] Add OperatorFixity

Use this instead of DeclKind in a few places.

Author: hamishknight

include/swift/AST/Decl.h

@@ -7063,6 +7063,28 @@ class PrecedenceGroupDecl : public Decl {
   }
 };
 
+/// The fixity of an OperatorDecl.
+enum class OperatorFixity : uint8_t {
+  Infix,
+  Prefix,
+  Postfix
+};
+
+inline void simple_display(llvm::raw_ostream &out, OperatorFixity fixity) {
+  switch (fixity) {
+  case OperatorFixity::Infix:
+    out << "infix";
+    return;
+  case OperatorFixity::Prefix:
+    out << "prefix";
+    return;
+  case OperatorFixity::Postfix:
+    out << "postfix";
+    return;
+  }
+  llvm_unreachable("Unhandled case in switch");
+}
+
 /// Abstract base class of operator declarations.
 class OperatorDecl : public Decl {
   SourceLoc OperatorLoc, NameLoc;
@@ -7088,6 +7110,21 @@ class OperatorDecl : public Decl {
       : Decl(kind, DC), OperatorLoc(OperatorLoc), NameLoc(NameLoc), name(Name),
         DesignatedNominalTypes(DesignatedNominalTypes) {}
 
+  /// Retrieve the operator's fixity, corresponding to the concrete subclass
+  /// of the OperatorDecl.
+  OperatorFixity getFixity() const {
+    switch (getKind()) {
+#define DECL(Id, Name) case DeclKind::Id: llvm_unreachable("Not an operator!");
+#define OPERATOR_DECL(Id, Name)
+#include "swift/AST/DeclNodes.def"
+    case DeclKind::InfixOperator:
+      return OperatorFixity::Infix;
+    case DeclKind::PrefixOperator:
+      return OperatorFixity::Prefix;
+    case DeclKind::PostfixOperator:
+      return OperatorFixity::Postfix;
+    }
+  }
 
   SourceLoc getOperatorLoc() const { return OperatorLoc; }
   SourceLoc getNameLoc() const { return NameLoc; }

include/swift/AST/FileUnit.h

@@ -346,8 +346,9 @@ class LoadedFile : public FileUnit {
   ///
   /// \param name The operator name ("+", ">>", etc.)
   ///
-  /// \param fixity One of PrefixOperator, InfixOperator, or PostfixOperator.
-  virtual OperatorDecl *lookupOperator(Identifier name, DeclKind fixity) const {
+  /// \param fixity One of Prefix, Infix, or Postfix.
+  virtual OperatorDecl *lookupOperator(Identifier name,
+                                       OperatorFixity fixity) const {
     return nullptr;
   }
 

include/swift/Serialization/SerializedModuleLoader.h

@@ -329,7 +329,7 @@ class SerializedASTFile final : public LoadedFile {
                    const NominalTypeDecl *parent) const override;
 
   virtual OperatorDecl *lookupOperator(Identifier name,
-                                       DeclKind fixity) const override;
+                                       OperatorFixity fixity) const override;
 
   virtual PrecedenceGroupDecl *
   lookupPrecedenceGroup(Identifier name) const override;

lib/AST/Module.cpp

@@ -948,7 +948,7 @@ namespace {
     template <typename T>
     static PrefixOperatorDecl *lookup(T &container, Identifier name) {
       return cast_or_null<PrefixOperatorDecl>(
-               container.lookupOperator(name, DeclKind::PrefixOperator));
+               container.lookupOperator(name, OperatorFixity::Prefix));
     }
   };
 
@@ -958,7 +958,7 @@ namespace {
     template <typename T>
     static InfixOperatorDecl *lookup(T &container, Identifier name) {
       return cast_or_null<InfixOperatorDecl>(
-               container.lookupOperator(name, DeclKind::InfixOperator));
+               container.lookupOperator(name, OperatorFixity::Infix));
     }
   };
 
@@ -968,7 +968,7 @@ namespace {
     template <typename T>
     static PostfixOperatorDecl *lookup(T &container, Identifier name) {
       return cast_or_null<PostfixOperatorDecl>(
-               container.lookupOperator(name, DeclKind::PostfixOperator));
+               container.lookupOperator(name, OperatorFixity::Postfix));
     }
   };
 

lib/Serialization/Deserialization.cpp

@@ -1654,7 +1654,7 @@ ModuleFile::resolveCrossReference(ModuleID MID, uint32_t pathLen) {
           return true;
         if (!fn->getOperatorDecl())
           return true;
-        if (getStableFixity(fn->getOperatorDecl()->getKind()) != rawKind)
+        if (getStableFixity(fn->getOperatorDecl()->getFixity()) != rawKind)
           return true;
         return false;
       });

lib/Serialization/ModuleFile.cpp

@@ -2156,7 +2156,8 @@ TypeDecl *ModuleFile::lookupNestedType(Identifier name,
   return nullptr;
 }
 
-OperatorDecl *ModuleFile::lookupOperator(Identifier name, DeclKind fixity) {
+OperatorDecl *ModuleFile::lookupOperator(Identifier name,
+                                         OperatorFixity fixity) {
   PrettyStackTraceModuleFile stackEntry(*this);
 
   if (!OperatorDecls)

lib/Serialization/ModuleFile.h

@@ -731,7 +731,7 @@ class ModuleFile
   /// Searches the module's operators for one with the given name and fixity.
   ///
   /// If none is found, returns null.
-  OperatorDecl *lookupOperator(Identifier name, DeclKind fixity);
+  OperatorDecl *lookupOperator(Identifier name, OperatorFixity fixity);
 
   /// Searches the module's precedence groups for one with the given
   /// name and fixity.

lib/Serialization/ModuleFormat.h

@@ -385,19 +385,18 @@ enum class SelfAccessKind : uint8_t {
 };
 using SelfAccessKindField = BCFixed<2>;
 
-/// Translates an operator DeclKind to a Serialization fixity, whose values are
-/// guaranteed to be stable.
-static inline OperatorKind getStableFixity(DeclKind kind) {
-  switch (kind) {
-  case DeclKind::PrefixOperator:
+/// Translates an operator decl fixity to a Serialization fixity, whose values
+/// are guaranteed to be stable.
+static inline OperatorKind getStableFixity(OperatorFixity fixity) {
+  switch (fixity) {
+  case OperatorFixity::Prefix:
     return Prefix;
-  case DeclKind::PostfixOperator:
+  case OperatorFixity::Postfix:
     return Postfix;
-  case DeclKind::InfixOperator:
+  case OperatorFixity::Infix:
     return Infix;
-  default:
-    llvm_unreachable("unknown operator fixity");
   }
+  llvm_unreachable("Unhandled case in switch");
 }
 
 // These IDs must \em not be renumbered or reordered without incrementing

lib/Serialization/Serialization.cpp

@@ -1730,7 +1730,7 @@ void Serializer::writeCrossReference(const DeclContext *DC, uint32_t pathLen) {
       assert(op);
       abbrCode = DeclTypeAbbrCodes[XRefOperatorOrAccessorPathPieceLayout::Code];
       auto emptyID = addDeclBaseNameRef(Identifier());
-      auto fixity = getStableFixity(op->getKind());
+      auto fixity = getStableFixity(op->getFixity());
       XRefOperatorOrAccessorPathPieceLayout::emitRecord(Out, ScratchRecord,
                                                         abbrCode, emptyID,
                                                         fixity);
@@ -1750,7 +1750,7 @@ void Serializer::writeCrossReference(const Decl *D) {
 
     abbrCode = DeclTypeAbbrCodes[XRefOperatorOrAccessorPathPieceLayout::Code];
     auto nameID = addDeclBaseNameRef(op->getName());
-    auto fixity = getStableFixity(op->getKind());
+    auto fixity = getStableFixity(op->getFixity());
     XRefOperatorOrAccessorPathPieceLayout::emitRecord(Out, ScratchRecord,
                                                       abbrCode, nameID,
                                                       fixity);
@@ -4924,7 +4924,7 @@ void Serializer::writeAST(ModuleOrSourceFile DC) {
           .push_back({ extendedNominal, addDeclRef(D) });
       } else if (auto OD = dyn_cast<OperatorDecl>(D)) {
         operatorDecls[OD->getName()]
-          .push_back({ getStableFixity(OD->getKind()), addDeclRef(D) });
+          .push_back({ getStableFixity(OD->getFixity()), addDeclRef(D) });
       } else if (auto PGD = dyn_cast<PrecedenceGroupDecl>(D)) {
         precedenceGroupDecls[PGD->getName()]
           .push_back({ decls_block::PRECEDENCE_GROUP_DECL, addDeclRef(D) });

lib/Serialization/SerializedModuleLoader.cpp

@@ -1085,7 +1085,7 @@ SerializedASTFile::lookupNestedType(Identifier name,
 }
 
 OperatorDecl *SerializedASTFile::lookupOperator(Identifier name,
-                                                DeclKind fixity) const {
+                                                OperatorFixity fixity) const {
   return File.lookupOperator(name, fixity);
 }