[AST] Split out "is compound" bit on FunctionRefInfo

FunctionRefKind was originally designed to represent
the handling needed for argument labels on function
references, in which the unapplied and compound cases
are effectively the same. However it has since been
adopted in a bunch of other places where the
spelling of the function reference is entirely
orthogonal to the application level.

Split out the application level from the
"is compound" bit. Should be NFC. I've left some
FIXMEs for non-NFC changes that I'll address in a
follow-up.

Author: hamishknight

include/swift/AST/Expr.h

@@ -193,16 +193,16 @@ class alignas(8) Expr : public ASTAllocated<Expr> {
     LiteralCapacity : 32
   );
 
-  SWIFT_INLINE_BITFIELD(DeclRefExpr, Expr, 2+2+1+1,
+  SWIFT_INLINE_BITFIELD(DeclRefExpr, Expr, 2+3+1+1,
     Semantics : 2, // an AccessSemantics
-    FunctionRefInfo : 2,
+    FunctionRefInfo : 3,
     IsImplicitlyAsync : 1,
     IsImplicitlyThrows : 1
   );
 
-  SWIFT_INLINE_BITFIELD(UnresolvedDeclRefExpr, Expr, 2+2,
+  SWIFT_INLINE_BITFIELD(UnresolvedDeclRefExpr, Expr, 2+3,
     DeclRefKind : 2,
-    FunctionRefInfo : 2
+    FunctionRefInfo : 3
   );
 
   SWIFT_INLINE_BITFIELD(MemberRefExpr, LookupExpr, 2,
@@ -225,8 +225,8 @@ class alignas(8) Expr : public ASTAllocated<Expr> {
     NumElements : 32
   );
 
-  SWIFT_INLINE_BITFIELD(UnresolvedDotExpr, Expr, 2,
-    FunctionRefInfo : 2
+  SWIFT_INLINE_BITFIELD(UnresolvedDotExpr, Expr, 3,
+    FunctionRefInfo : 3
   );
 
   SWIFT_INLINE_BITFIELD_FULL(SubscriptExpr, LookupExpr, 2,
@@ -235,12 +235,12 @@ class alignas(8) Expr : public ASTAllocated<Expr> {
 
   SWIFT_INLINE_BITFIELD_EMPTY(DynamicSubscriptExpr, DynamicLookupExpr);
 
-  SWIFT_INLINE_BITFIELD_FULL(UnresolvedMemberExpr, Expr, 2,
-    FunctionRefInfo : 2
+  SWIFT_INLINE_BITFIELD_FULL(UnresolvedMemberExpr, Expr, 3,
+    FunctionRefInfo : 3
   );
 
-  SWIFT_INLINE_BITFIELD(OverloadSetRefExpr, Expr, 2,
-    FunctionRefInfo : 2
+  SWIFT_INLINE_BITFIELD(OverloadSetRefExpr, Expr, 3,
+    FunctionRefInfo : 3
   );
 
   SWIFT_INLINE_BITFIELD(BooleanLiteralExpr, LiteralExpr, 1,
@@ -1230,12 +1230,10 @@ class DeclRefExpr : public Expr {
               Type Ty = Type())
     : Expr(ExprKind::DeclRef, Implicit, Ty), D(D), Loc(Loc),
       implicitActorHopTarget(ActorIsolation::forUnspecified()) {
-    Bits.DeclRefExpr.Semantics = (unsigned) semantics;
-    Bits.DeclRefExpr.FunctionRefInfo =
-      static_cast<unsigned>(Loc.isCompound() ? FunctionRefInfo::Compound
-                                             : FunctionRefInfo::Unapplied);
+    Bits.DeclRefExpr.Semantics = (unsigned)semantics;
     Bits.DeclRefExpr.IsImplicitlyAsync = false;
     Bits.DeclRefExpr.IsImplicitlyThrows = false;
+    setFunctionRefInfo(FunctionRefInfo::unapplied(Loc));
   }
 
   /// Retrieve the declaration to which this expression refers.
@@ -1301,12 +1299,13 @@ class DeclRefExpr : public Expr {
 
   /// Retrieve the kind of function reference.
   FunctionRefInfo getFunctionRefInfo() const {
-    return static_cast<FunctionRefInfo>(Bits.DeclRefExpr.FunctionRefInfo);
+    return FunctionRefInfo::fromOpaque(Bits.DeclRefExpr.FunctionRefInfo);
   }
 
   /// Set the kind of function reference.
   void setFunctionRefInfo(FunctionRefInfo refKind) {
-    Bits.DeclRefExpr.FunctionRefInfo = static_cast<unsigned>(refKind);
+    Bits.DeclRefExpr.FunctionRefInfo = refKind.getOpaqueValue();
+    ASSERT(refKind == getFunctionRefInfo() && "FunctionRefInfo truncated");
   }
 
   static bool classof(const Expr *E) {
@@ -1508,8 +1507,7 @@ class OverloadSetRefExpr : public Expr {
   OverloadSetRefExpr(ExprKind Kind, ArrayRef<ValueDecl*> decls,
                      FunctionRefInfo functionRefInfo, bool Implicit, Type Ty)
       : Expr(Kind, Implicit, Ty), Decls(decls) {
-    Bits.OverloadSetRefExpr.FunctionRefInfo =
-      static_cast<unsigned>(functionRefInfo);
+    setFunctionRefInfo(functionRefInfo);
   }
 
 public:
@@ -1530,13 +1528,13 @@ class OverloadSetRefExpr : public Expr {
 
   /// Retrieve the kind of function reference.
   FunctionRefInfo getFunctionRefInfo() const {
-    return static_cast<FunctionRefInfo>(
-             Bits.OverloadSetRefExpr.FunctionRefInfo);
+    return FunctionRefInfo::fromOpaque(Bits.OverloadSetRefExpr.FunctionRefInfo);
   }
 
   /// Set the kind of function reference.
   void setFunctionRefInfo(FunctionRefInfo refKind) {
-    Bits.OverloadSetRefExpr.FunctionRefInfo = static_cast<unsigned>(refKind);
+    Bits.OverloadSetRefExpr.FunctionRefInfo = refKind.getOpaqueValue();
+    ASSERT(refKind == getFunctionRefInfo() && "FunctionRefInfo truncated");
   }
 
   static bool classof(const Expr *E) {
@@ -1584,9 +1582,7 @@ class UnresolvedDeclRefExpr : public Expr {
       : Expr(ExprKind::UnresolvedDeclRef, /*Implicit=*/loc.isInvalid()),
         Name(name), Loc(loc) {
     Bits.UnresolvedDeclRefExpr.DeclRefKind = static_cast<unsigned>(refKind);
-    Bits.UnresolvedDeclRefExpr.FunctionRefInfo =
-      static_cast<unsigned>(Loc.isCompound() ? FunctionRefInfo::Compound
-                                             : FunctionRefInfo::Unapplied);
+    setFunctionRefInfo(FunctionRefInfo::unapplied(loc));
   }
 
   static UnresolvedDeclRefExpr *createImplicit(
@@ -1617,13 +1613,14 @@ class UnresolvedDeclRefExpr : public Expr {
 
   /// Retrieve the kind of function reference.
   FunctionRefInfo getFunctionRefInfo() const {
-    return static_cast<FunctionRefInfo>(
-             Bits.UnresolvedDeclRefExpr.FunctionRefInfo);
+    return FunctionRefInfo::fromOpaque(
+        Bits.UnresolvedDeclRefExpr.FunctionRefInfo);
   }
 
   /// Set the kind of function reference.
   void setFunctionRefInfo(FunctionRefInfo refKind) {
-    Bits.UnresolvedDeclRefExpr.FunctionRefInfo = static_cast<unsigned>(refKind);
+    Bits.UnresolvedDeclRefExpr.FunctionRefInfo = refKind.getOpaqueValue();
+    ASSERT(refKind == getFunctionRefInfo() && "FunctionRefInfo truncated");
   }
 
   DeclNameLoc getNameLoc() const { return Loc; }
@@ -1901,19 +1898,18 @@ class UnresolvedMemberExpr final
                        bool implicit)
     : Expr(ExprKind::UnresolvedMember, implicit), DotLoc(dotLoc),
       NameLoc(nameLoc), Name(name) {
-    // FIXME: Really, we should be setting this to `FunctionRefInfo::Compound`
-    // if `NameLoc` is compound, but this would be a source break for cases like
+    // FIXME(FunctionRefInfo): Really, we should be passing `nameLoc` directly,
+    // allowing the FunctionRefInfo to be treated as compound. This would
+    // require us to enable IUOs for compound names, e.g:
     // ```
     // struct S {
     //   static func makeS(_: Int) -> S! { S() }
     // }
     //
     // let s: S = .makeS(_:)(0)
     // ```
-    // Instead, we should store compound-ness as a separate bit from applied/
-    // unapplied.
-    Bits.UnresolvedMemberExpr.FunctionRefInfo =
-        static_cast<unsigned>(FunctionRefInfo::Unapplied);
+    setFunctionRefInfo(
+        FunctionRefInfo::unapplied(DeclNameLoc(nameLoc.getBaseNameLoc())));
   }
 
   DeclNameRef getName() const { return Name; }
@@ -1927,15 +1923,16 @@ class UnresolvedMemberExpr final
 
   /// Retrieve the kind of function reference.
   FunctionRefInfo getFunctionRefInfo() const {
-    return static_cast<FunctionRefInfo>(
+    return FunctionRefInfo::fromOpaque(
         Bits.UnresolvedMemberExpr.FunctionRefInfo);
   }
 
   /// Set the kind of function reference.
   void setFunctionRefInfo(FunctionRefInfo refKind) {
-    Bits.UnresolvedMemberExpr.FunctionRefInfo = static_cast<unsigned>(refKind);
+    Bits.UnresolvedMemberExpr.FunctionRefInfo = refKind.getOpaqueValue();
+    ASSERT(refKind == getFunctionRefInfo() && "FunctionRefInfo truncated");
   }
-  
+
   static bool classof(const Expr *E) {
     return E->getKind() == ExprKind::UnresolvedMember;
   }
@@ -2627,9 +2624,7 @@ class UnresolvedDotExpr : public Expr {
       : Expr(ExprKind::UnresolvedDot, Implicit), SubExpr(subexpr),
         DotLoc(dotloc), NameLoc(nameloc), Name(name),
         OuterAlternatives(outerAlternatives) {
-    Bits.UnresolvedDotExpr.FunctionRefInfo =
-      static_cast<unsigned>(NameLoc.isCompound() ? FunctionRefInfo::Compound
-                                                 : FunctionRefInfo::Unapplied);
+    setFunctionRefInfo(FunctionRefInfo::unapplied(nameloc));
   }
 
   static UnresolvedDotExpr *createImplicit(
@@ -2693,12 +2688,13 @@ class UnresolvedDotExpr : public Expr {
 
   /// Retrieve the kind of function reference.
   FunctionRefInfo getFunctionRefInfo() const {
-    return static_cast<FunctionRefInfo>(Bits.UnresolvedDotExpr.FunctionRefInfo);
+    return FunctionRefInfo::fromOpaque(Bits.UnresolvedDotExpr.FunctionRefInfo);
   }
 
   /// Set the kind of function reference.
   void setFunctionRefInfo(FunctionRefInfo refKind) {
-    Bits.UnresolvedDotExpr.FunctionRefInfo = static_cast<unsigned>(refKind);
+    Bits.UnresolvedDotExpr.FunctionRefInfo = refKind.getOpaqueValue();
+    ASSERT(refKind == getFunctionRefInfo() && "FunctionRefInfo truncated");
   }
 
   static bool classof(const Expr *E) {

include/swift/AST/FunctionRefInfo.h

@@ -2,51 +2,158 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 2024 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 //===----------------------------------------------------------------------===//
 //
-// This file defines the FunctionRefInfo enum, which is used to describe how
+// This file defines the FunctionRefInfo class, which describes how a function
+// is referenced in an expression.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SWIFT_AST_FUNCTION_REF_INFO_H
 #define SWIFT_AST_FUNCTION_REF_INFO_H
 
-#include "llvm/ADT/StringRef.h"
+#include "swift/Basic/Debug.h"
+#include "swift/Basic/LLVM.h"
 
 namespace swift {
 
-/// Describes how a function is referenced within an expression node,
-/// which dictates whether argument labels are part of the resulting
-/// function type or not.
+class DeclNameLoc;
+class DeclNameRef;
+
+/// Describes how a function is referenced within an expression node.
+///
+/// This dictates things like:
+/// - Whether argument labels are part of the resulting function type or not.
+/// - Whether the result can produce an implicitly unwrapped optional.
+/// - Whether the function type needs adjustment for concurrency.
 ///
 /// 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 FunctionRefInfo : unsigned {
-  /// The function was referenced using a bare function name (e.g.,
-  /// 'f') and not directly called.
-  Unapplied,
-  /// The function was referenced using a bare function name and was
-  /// directly applied once, e.g., "f(a: 1, b: 2)".
-  SingleApply,
-  /// The function was referenced using a bare function name and was
-  /// directly applied two or more times, e.g., "g(x)(y)".
-  DoubleApply,
-  /// The function was referenced using a compound function name,
+class FunctionRefInfo final {
+public:
+  /// Whether the function reference is part of a call, and if so how many
+  /// applications were used.
+  enum class ApplyLevel : uint8_t {
+    /// The function is not directly called.
+    Unapplied,
+    /// The function is directly applied once, e.g., "f(a: 1, b: 2)".
+    SingleApply,
+    /// The function is directly applied two or more times, e.g., "g(x)(y)".
+    DoubleApply,
+  };
+
+private:
+  /// The application level of the function reference.
+  ApplyLevel ApplyLevelKind;
+
+  /// Whether the function was referenced using a compound function name,
   /// e.g., "f(a:b:)".
-  Compound,
-};
+  bool IsCompoundName;
+
+  FunctionRefInfo(ApplyLevel applyLevel, bool isCompoundName)
+      : ApplyLevelKind(applyLevel), IsCompoundName(isCompoundName) {}
+
+public:
+  /// An unapplied function reference for a given DeclNameLoc.
+  static FunctionRefInfo unapplied(DeclNameLoc nameLoc);
+
+  /// An unapplied function reference for a given DeclNameRef.
+  static FunctionRefInfo unapplied(DeclNameRef nameRef);
+
+  /// An unapplied function reference using a base name, e.g `let x = fn`.
+  static FunctionRefInfo unappliedBaseName() {
+    return FunctionRefInfo(ApplyLevel::Unapplied, /*isCompoundName*/ false);
+  }
+
+  /// An unapplied function reference using a compound name,
+  /// e.g `let x = fn(x:)`.
+  static FunctionRefInfo unappliedCompoundName() {
+    return FunctionRefInfo(ApplyLevel::Unapplied, /*isCompoundName*/ true);
+  }
+
+  /// A single application using a base name, e.g `fn(x: 0)`.
+  static FunctionRefInfo singleBaseNameApply() {
+    return FunctionRefInfo(ApplyLevel::SingleApply, /*isCompoundName*/ false);
+  }
+
+  /// A single application using a compound name, e.g `fn(x:)(0)`.
+  static FunctionRefInfo singleCompoundNameApply() {
+    return FunctionRefInfo(ApplyLevel::SingleApply, /*isCompoundName*/ true);
+  }
 
-/// Produce a string describing a function reference kind, for
-/// debugging purposes.
-llvm::StringRef getFunctionRefInfoStr(FunctionRefInfo refKind);
+  /// A double application using a base name, e.g `S.fn(S())(x: 0)`.
+  static FunctionRefInfo doubleBaseNameApply() {
+    return FunctionRefInfo(ApplyLevel::DoubleApply, /*isCompoundName*/ false);
+  }
 
+  /// A double application using a compound name, e.g `S.fn(x:)(S())(0)`.
+  static FunctionRefInfo doubleCompoundNameApply() {
+    return FunctionRefInfo(ApplyLevel::DoubleApply, /*isCompoundName*/ true);
+  }
+
+  /// Reconstructs a FunctionRefInfo from its \c getOpaqueValue().
+  static FunctionRefInfo fromOpaque(uint8_t bits) {
+    return FunctionRefInfo(static_cast<ApplyLevel>(bits >> 1), bits & 0x1);
+  }
+
+  /// Retrieves an opaque value that can be stored in e.g a bitfield.
+  uint8_t getOpaqueValue() const {
+    return (static_cast<uint8_t>(ApplyLevelKind) << 1) | !!IsCompoundName;
+  }
+
+  /// Whether the function reference is part of a call, and if so how many
+  /// applications were used.
+  ApplyLevel getApplyLevel() const { return ApplyLevelKind; }
+
+  /// Whether the function was referenced using a compound name,
+  /// e.g `fn(x:)(0)`.
+  bool isCompoundName() const { return IsCompoundName; }
+
+  /// Whether the function reference is not part of a call.
+  bool isUnapplied() const {
+    return getApplyLevel() == ApplyLevel::Unapplied;
+  }
+
+  /// Whether the function reference is both not part of a call, and is
+  /// not using a compound name.
+  bool isUnappliedBaseName() const {
+    return getApplyLevel() == ApplyLevel::Unapplied && !isCompoundName();
+  }
+
+  /// Whether the function reference has been applied a single time.
+  bool isSingleApply() const {
+    return getApplyLevel() == ApplyLevel::SingleApply;
+  }
+
+  /// Whether the function reference has been applied twice.
+  bool isDoubleApply() const {
+    return getApplyLevel() == ApplyLevel::DoubleApply;
+  }
+
+  /// Returns the FunctionRefInfo with an additional level of function
+  /// application added.
+  FunctionRefInfo addingApplicationLevel() const;
+
+  friend bool operator==(const FunctionRefInfo &lhs,
+                         const FunctionRefInfo &rhs) {
+    return lhs.getApplyLevel() == rhs.getApplyLevel() &&
+           lhs.isCompoundName() == rhs.isCompoundName();
+  }
+  friend bool operator!=(const FunctionRefInfo &lhs,
+                         const FunctionRefInfo &rhs) {
+    return !(lhs == rhs);
+  }
+
+  void dump(raw_ostream &os) const;
+  SWIFT_DEBUG_DUMP;
+};
 }
 
 #endif // SWIFT_AST_FUNCTION_REF_INFO_H