[AST] NFC: Rename FunctionRefKind -> FunctionRefInfo

Author: hamishknight

include/swift/AST/Expr.h

@@ -26,7 +26,7 @@
 #include "swift/AST/DeclContext.h"
 #include "swift/AST/DeclNameLoc.h"
 #include "swift/AST/FreestandingMacroExpansion.h"
-#include "swift/AST/FunctionRefKind.h"
+#include "swift/AST/FunctionRefInfo.h"
 #include "swift/AST/ProtocolConformanceRef.h"
 #include "swift/AST/ThrownErrorDestination.h"
 #include "swift/AST/TypeAlignments.h"
@@ -195,14 +195,14 @@ class alignas(8) Expr : public ASTAllocated<Expr> {
 
   SWIFT_INLINE_BITFIELD(DeclRefExpr, Expr, 2+2+1+1,
     Semantics : 2, // an AccessSemantics
-    FunctionRefKind : 2,
+    FunctionRefInfo : 2,
     IsImplicitlyAsync : 1,
     IsImplicitlyThrows : 1
   );
 
   SWIFT_INLINE_BITFIELD(UnresolvedDeclRefExpr, Expr, 2+2,
     DeclRefKind : 2,
-    FunctionRefKind : 2
+    FunctionRefInfo : 2
   );
 
   SWIFT_INLINE_BITFIELD(MemberRefExpr, LookupExpr, 2,
@@ -226,7 +226,7 @@ class alignas(8) Expr : public ASTAllocated<Expr> {
   );
 
   SWIFT_INLINE_BITFIELD(UnresolvedDotExpr, Expr, 2,
-    FunctionRefKind : 2
+    FunctionRefInfo : 2
   );
 
   SWIFT_INLINE_BITFIELD_FULL(SubscriptExpr, LookupExpr, 2,
@@ -236,11 +236,11 @@ class alignas(8) Expr : public ASTAllocated<Expr> {
   SWIFT_INLINE_BITFIELD_EMPTY(DynamicSubscriptExpr, DynamicLookupExpr);
 
   SWIFT_INLINE_BITFIELD_FULL(UnresolvedMemberExpr, Expr, 2,
-    FunctionRefKind : 2
+    FunctionRefInfo : 2
   );
 
   SWIFT_INLINE_BITFIELD(OverloadSetRefExpr, Expr, 2,
-    FunctionRefKind : 2
+    FunctionRefInfo : 2
   );
 
   SWIFT_INLINE_BITFIELD(BooleanLiteralExpr, LiteralExpr, 1,
@@ -1231,9 +1231,9 @@ class DeclRefExpr : public Expr {
     : Expr(ExprKind::DeclRef, Implicit, Ty), D(D), Loc(Loc),
       implicitActorHopTarget(ActorIsolation::forUnspecified()) {
     Bits.DeclRefExpr.Semantics = (unsigned) semantics;
-    Bits.DeclRefExpr.FunctionRefKind =
-      static_cast<unsigned>(Loc.isCompound() ? FunctionRefKind::Compound
-                                             : FunctionRefKind::Unapplied);
+    Bits.DeclRefExpr.FunctionRefInfo =
+      static_cast<unsigned>(Loc.isCompound() ? FunctionRefInfo::Compound
+                                             : FunctionRefInfo::Unapplied);
     Bits.DeclRefExpr.IsImplicitlyAsync = false;
     Bits.DeclRefExpr.IsImplicitlyThrows = false;
   }
@@ -1300,13 +1300,13 @@ class DeclRefExpr : public Expr {
   DeclNameLoc getNameLoc() const { return Loc; }
 
   /// Retrieve the kind of function reference.
-  FunctionRefKind getFunctionRefKind() const {
-    return static_cast<FunctionRefKind>(Bits.DeclRefExpr.FunctionRefKind);
+  FunctionRefInfo getFunctionRefInfo() const {
+    return static_cast<FunctionRefInfo>(Bits.DeclRefExpr.FunctionRefInfo);
   }
 
   /// Set the kind of function reference.
-  void setFunctionRefKind(FunctionRefKind refKind) {
-    Bits.DeclRefExpr.FunctionRefKind = static_cast<unsigned>(refKind);
+  void setFunctionRefInfo(FunctionRefInfo refKind) {
+    Bits.DeclRefExpr.FunctionRefInfo = static_cast<unsigned>(refKind);
   }
 
   static bool classof(const Expr *E) {
@@ -1506,10 +1506,10 @@ class OverloadSetRefExpr : public Expr {
 
 protected:
   OverloadSetRefExpr(ExprKind Kind, ArrayRef<ValueDecl*> decls,
-                     FunctionRefKind functionRefKind, bool Implicit, Type Ty)
+                     FunctionRefInfo functionRefInfo, bool Implicit, Type Ty)
       : Expr(Kind, Implicit, Ty), Decls(decls) {
-    Bits.OverloadSetRefExpr.FunctionRefKind =
-      static_cast<unsigned>(functionRefKind);
+    Bits.OverloadSetRefExpr.FunctionRefInfo =
+      static_cast<unsigned>(functionRefInfo);
   }
 
 public:
@@ -1529,14 +1529,14 @@ class OverloadSetRefExpr : public Expr {
   bool hasBaseObject() const;
 
   /// Retrieve the kind of function reference.
-  FunctionRefKind getFunctionRefKind() const {
-    return static_cast<FunctionRefKind>(
-             Bits.OverloadSetRefExpr.FunctionRefKind);
+  FunctionRefInfo getFunctionRefInfo() const {
+    return static_cast<FunctionRefInfo>(
+             Bits.OverloadSetRefExpr.FunctionRefInfo);
   }
 
   /// Set the kind of function reference.
-  void setFunctionRefKind(FunctionRefKind refKind) {
-    Bits.OverloadSetRefExpr.FunctionRefKind = static_cast<unsigned>(refKind);
+  void setFunctionRefInfo(FunctionRefInfo refKind) {
+    Bits.OverloadSetRefExpr.FunctionRefInfo = static_cast<unsigned>(refKind);
   }
 
   static bool classof(const Expr *E) {
@@ -1552,9 +1552,9 @@ class OverloadedDeclRefExpr final : public OverloadSetRefExpr {
 
 public:
   OverloadedDeclRefExpr(ArrayRef<ValueDecl*> Decls, DeclNameLoc Loc,
-                        FunctionRefKind functionRefKind,
+                        FunctionRefInfo functionRefInfo,
                         bool Implicit, Type Ty = Type())
-      : OverloadSetRefExpr(ExprKind::OverloadedDeclRef, Decls, functionRefKind,
+      : OverloadSetRefExpr(ExprKind::OverloadedDeclRef, Decls, functionRefInfo,
                            Implicit, Ty),
         Loc(Loc) {
   }
@@ -1584,9 +1584,9 @@ class UnresolvedDeclRefExpr : public Expr {
       : Expr(ExprKind::UnresolvedDeclRef, /*Implicit=*/loc.isInvalid()),
         Name(name), Loc(loc) {
     Bits.UnresolvedDeclRefExpr.DeclRefKind = static_cast<unsigned>(refKind);
-    Bits.UnresolvedDeclRefExpr.FunctionRefKind =
-      static_cast<unsigned>(Loc.isCompound() ? FunctionRefKind::Compound
-                                             : FunctionRefKind::Unapplied);
+    Bits.UnresolvedDeclRefExpr.FunctionRefInfo =
+      static_cast<unsigned>(Loc.isCompound() ? FunctionRefInfo::Compound
+                                             : FunctionRefInfo::Unapplied);
   }
 
   static UnresolvedDeclRefExpr *createImplicit(
@@ -1616,14 +1616,14 @@ class UnresolvedDeclRefExpr : public Expr {
   }
 
   /// Retrieve the kind of function reference.
-  FunctionRefKind getFunctionRefKind() const {
-    return static_cast<FunctionRefKind>(
-             Bits.UnresolvedDeclRefExpr.FunctionRefKind);
+  FunctionRefInfo getFunctionRefInfo() const {
+    return static_cast<FunctionRefInfo>(
+             Bits.UnresolvedDeclRefExpr.FunctionRefInfo);
   }
 
   /// Set the kind of function reference.
-  void setFunctionRefKind(FunctionRefKind refKind) {
-    Bits.UnresolvedDeclRefExpr.FunctionRefKind = static_cast<unsigned>(refKind);
+  void setFunctionRefInfo(FunctionRefInfo refKind) {
+    Bits.UnresolvedDeclRefExpr.FunctionRefInfo = static_cast<unsigned>(refKind);
   }
 
   DeclNameLoc getNameLoc() const { return Loc; }
@@ -1901,7 +1901,7 @@ class UnresolvedMemberExpr final
                        bool implicit)
     : Expr(ExprKind::UnresolvedMember, implicit), DotLoc(dotLoc),
       NameLoc(nameLoc), Name(name) {
-    // FIXME: Really, we should be setting this to `FunctionRefKind::Compound`
+    // FIXME: Really, we should be setting this to `FunctionRefInfo::Compound`
     // if `NameLoc` is compound, but this would be a source break for cases like
     // ```
     // struct S {
@@ -1912,8 +1912,8 @@ class UnresolvedMemberExpr final
     // ```
     // Instead, we should store compound-ness as a separate bit from applied/
     // unapplied.
-    Bits.UnresolvedMemberExpr.FunctionRefKind =
-        static_cast<unsigned>(FunctionRefKind::Unapplied);
+    Bits.UnresolvedMemberExpr.FunctionRefInfo =
+        static_cast<unsigned>(FunctionRefInfo::Unapplied);
   }
 
   DeclNameRef getName() const { return Name; }
@@ -1926,14 +1926,14 @@ class UnresolvedMemberExpr final
   SourceLoc getEndLoc() const { return NameLoc.getSourceRange().End; }
 
   /// Retrieve the kind of function reference.
-  FunctionRefKind getFunctionRefKind() const {
-    return static_cast<FunctionRefKind>(
-        Bits.UnresolvedMemberExpr.FunctionRefKind);
+  FunctionRefInfo getFunctionRefInfo() const {
+    return static_cast<FunctionRefInfo>(
+        Bits.UnresolvedMemberExpr.FunctionRefInfo);
   }
 
   /// Set the kind of function reference.
-  void setFunctionRefKind(FunctionRefKind refKind) {
-    Bits.UnresolvedMemberExpr.FunctionRefKind = static_cast<unsigned>(refKind);
+  void setFunctionRefInfo(FunctionRefInfo refKind) {
+    Bits.UnresolvedMemberExpr.FunctionRefInfo = static_cast<unsigned>(refKind);
   }
 
   static bool classof(const Expr *E) {
@@ -2627,9 +2627,9 @@ class UnresolvedDotExpr : public Expr {
       : Expr(ExprKind::UnresolvedDot, Implicit), SubExpr(subexpr),
         DotLoc(dotloc), NameLoc(nameloc), Name(name),
         OuterAlternatives(outerAlternatives) {
-    Bits.UnresolvedDotExpr.FunctionRefKind =
-      static_cast<unsigned>(NameLoc.isCompound() ? FunctionRefKind::Compound
-                                                 : FunctionRefKind::Unapplied);
+    Bits.UnresolvedDotExpr.FunctionRefInfo =
+      static_cast<unsigned>(NameLoc.isCompound() ? FunctionRefInfo::Compound
+                                                 : FunctionRefInfo::Unapplied);
   }
 
   static UnresolvedDotExpr *createImplicit(
@@ -2692,13 +2692,13 @@ class UnresolvedDotExpr : public Expr {
   }
 
   /// Retrieve the kind of function reference.
-  FunctionRefKind getFunctionRefKind() const {
-    return static_cast<FunctionRefKind>(Bits.UnresolvedDotExpr.FunctionRefKind);
+  FunctionRefInfo getFunctionRefInfo() const {
+    return static_cast<FunctionRefInfo>(Bits.UnresolvedDotExpr.FunctionRefInfo);
   }
 
   /// Set the kind of function reference.
-  void setFunctionRefKind(FunctionRefKind refKind) {
-    Bits.UnresolvedDotExpr.FunctionRefKind = static_cast<unsigned>(refKind);
+  void setFunctionRefInfo(FunctionRefInfo refKind) {
+    Bits.UnresolvedDotExpr.FunctionRefInfo = static_cast<unsigned>(refKind);
   }
 
   static bool classof(const Expr *E) {

include/swift/AST/FunctionRefKind.h renamed to include/swift/AST/FunctionRefInfo.h

@@ -1,4 +1,4 @@
-//===--- FunctionRefKind.h - Function reference kind ------------*- C++ -*-===//
+//===--- FunctionRefInfo.h - Function reference info ------------*- C++ -*-===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -10,12 +10,12 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// This file defines the FunctionRefKind enum, which is used to describe how
+// This file defines the FunctionRefInfo enum, which is used to describe how
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef SWIFT_AST_FUNCTION_REF_KIND_H
-#define SWIFT_AST_FUNCTION_REF_KIND_H
+#ifndef SWIFT_AST_FUNCTION_REF_INFO_H
+#define SWIFT_AST_FUNCTION_REF_INFO_H
 
 #include "llvm/ADT/StringRef.h"
 
@@ -28,7 +28,7 @@ namespace swift {
 /// How a function is referenced comes down to how it was spelled in
 /// the source code, e.g., was it called in the source code and was it
 /// spelled as a compound name.
-enum class FunctionRefKind : unsigned {
+enum class FunctionRefInfo : unsigned {
   /// The function was referenced using a bare function name (e.g.,
   /// 'f') and not directly called.
   Unapplied,
@@ -45,8 +45,8 @@ enum class FunctionRefKind : unsigned {
 
 /// Produce a string describing a function reference kind, for
 /// debugging purposes.
-llvm::StringRef getFunctionRefKindStr(FunctionRefKind refKind);
+llvm::StringRef getFunctionRefInfoStr(FunctionRefInfo refKind);
 
 }
 
-#endif // SWIFT_AST_FUNCTION_REF_KIND_H
+#endif // SWIFT_AST_FUNCTION_REF_INFO_H

include/swift/Sema/CSFix.h

@@ -3244,7 +3244,7 @@ class SpecifyBaseTypeForOptionalUnresolvedMember final : public ConstraintFix {
 
   static SpecifyBaseTypeForOptionalUnresolvedMember *
   attempt(ConstraintSystem &cs, ConstraintKind kind, Type baseTy,
-          DeclNameRef memberName, FunctionRefKind functionRefKind,
+          DeclNameRef memberName, FunctionRefInfo functionRefInfo,
           MemberLookupResult result, ConstraintLocator *locator);
 
   static bool classof(const ConstraintFix *fix) {

include/swift/Sema/Constraint.h

@@ -19,7 +19,7 @@
 #define SWIFT_SEMA_CONSTRAINT_H
 
 #include "swift/AST/ASTNode.h"
-#include "swift/AST/FunctionRefKind.h"
+#include "swift/AST/FunctionRefInfo.h"
 #include "swift/AST/Identifier.h"
 #include "swift/AST/Type.h"
 #include "swift/AST/TypeLoc.h"
@@ -384,7 +384,7 @@ class Constraint final : public llvm::ilist_node<Constraint>,
   unsigned NumTypeVariables : 11;
 
   /// The kind of function reference, for member references.
-  unsigned TheFunctionRefKind : 2;
+  unsigned TheFunctionRefInfo : 2;
 
   /// The trailing closure matching for an applicable function constraint,
   /// if any. 0 = None, 1 = Forward, 2 = Backward.
@@ -471,14 +471,14 @@ class Constraint final : public llvm::ilist_node<Constraint>,
 
   /// Construct a new member constraint.
   Constraint(ConstraintKind kind, Type first, Type second, DeclNameRef member,
-             DeclContext *useDC, FunctionRefKind functionRefKind,
+             DeclContext *useDC, FunctionRefInfo functionRefInfo,
              ConstraintLocator *locator,
              SmallPtrSetImpl<TypeVariableType *> &typeVars);
 
   /// Construct a new value witness constraint.
   Constraint(ConstraintKind kind, Type first, Type second,
              ValueDecl *requirement, DeclContext *useDC,
-             FunctionRefKind functionRefKind, ConstraintLocator *locator,
+             FunctionRefInfo functionRefInfo, ConstraintLocator *locator,
              SmallPtrSetImpl<TypeVariableType *> &typeVars);
 
   /// Construct a new overload-binding constraint, which might have a fix.
@@ -534,21 +534,21 @@ class Constraint final : public llvm::ilist_node<Constraint>,
   /// alternatives.
   static Constraint *createMemberOrOuterDisjunction(
       ConstraintSystem &cs, ConstraintKind kind, Type first, Type second,
-      DeclNameRef member, DeclContext *useDC, FunctionRefKind functionRefKind,
+      DeclNameRef member, DeclContext *useDC, FunctionRefInfo functionRefInfo,
       ArrayRef<OverloadChoice> outerAlternatives, ConstraintLocator *locator);
 
   /// Create a new member constraint.
   static Constraint *createMember(ConstraintSystem &cs, ConstraintKind kind,
                                   Type first, Type second, DeclNameRef member,
                                   DeclContext *useDC,
-                                  FunctionRefKind functionRefKind,
+                                  FunctionRefInfo functionRefInfo,
                                   ConstraintLocator *locator);
 
   /// Create a new value witness constraint.
   static Constraint *createValueWitness(
       ConstraintSystem &cs, ConstraintKind kind, Type first, Type second,
       ValueDecl *requirement, DeclContext *useDC,
-      FunctionRefKind functionRefKind, ConstraintLocator *locator);
+      FunctionRefInfo functionRefInfo, ConstraintLocator *locator);
 
   /// Create an overload-binding constraint, possibly with a fix.
   static Constraint *createBindOverload(ConstraintSystem &cs, Type type, 
@@ -798,14 +798,14 @@ class Constraint final : public llvm::ilist_node<Constraint>,
   }
 
   /// Determine the kind of function reference we have for a member reference.
-  FunctionRefKind getFunctionRefKind() const {
+  FunctionRefInfo getFunctionRefInfo() const {
     if (Kind == ConstraintKind::ValueMember ||
         Kind == ConstraintKind::UnresolvedValueMember ||
         Kind == ConstraintKind::ValueWitness)
-      return static_cast<FunctionRefKind>(TheFunctionRefKind);
+      return static_cast<FunctionRefInfo>(TheFunctionRefInfo);
 
     // Conservative answer: drop all of the labels.
-    return FunctionRefKind::Compound;
+    return FunctionRefInfo::Compound;
   }
 
   /// Retrieve the set of constraints in a disjunction.