Merge pull request #40272 from nkcsgexi/85268028

ModuleInterface: consume _const keyword at var and parameter decls and keep them in textual/binary modules

Author: nkcsgexi

include/swift/AST/ArgumentList.h

@@ -83,6 +83,9 @@ class Argument final {
   /// Whether the argument is \c inout, denoted with the '&' prefix.
   bool isInOut() const;
 
+  /// Whether the argument is a compile-time constant value.
+  bool isConst() const;
+
   bool operator==(const Argument &other) {
     return LabelLoc == other.LabelLoc && Label == other.Label &&
            ArgExpr == other.ArgExpr;

include/swift/AST/Attr.def

@@ -694,6 +694,11 @@ SIMPLE_DECL_ATTR(_predatesConcurrency, PredatesConcurrency,
   ABIBreakingToAdd | ABIBreakingToRemove | APIBreakingToAdd | APIBreakingToRemove,
   125)
 
+CONTEXTUAL_SIMPLE_DECL_ATTR(_const, CompileTimeConst,
+  DeclModifier | OnParam | OnVar |
+  ABIStableToAdd | ABIStableToRemove | APIBreakingToAdd | APIStableToRemove,
+  126)
+
 // If you're adding a new underscored attribute here, please document it in
 // docs/ReferenceGuides/UnderscoredAttributes.md.
 

include/swift/AST/Decl.h

@@ -4583,6 +4583,7 @@ class AbstractStorageDecl : public ValueDecl {
   void setStatic(bool IsStatic) {
     Bits.AbstractStorageDecl.IsStatic = IsStatic;
   }
+  bool isCompileTimeConst() const;
 
   /// \returns the way 'static'/'class' should be spelled for this declaration.
   StaticSpellingKind getCorrectStaticSpelling() const;
@@ -5356,7 +5357,7 @@ class ParamDecl : public VarDecl {
 
   TypeRepr *TyRepr = nullptr;
 
-  struct alignas(1 << DeclAlignInBits) StoredDefaultArgument {
+  struct alignas(1 << StoredDefaultArgumentAlignInBits) StoredDefaultArgument {
     PointerUnion<Expr *, VarDecl *> DefaultArg;
 
     /// Stores the context for the default argument as well as a bit to
@@ -5380,10 +5381,13 @@ class ParamDecl : public VarDecl {
 
     /// Whether or not this parameter is 'isolated'.
     IsIsolated = 1 << 2,
+
+    /// Whether or not this parameter is '_const'.
+    IsCompileTimeConst = 1 << 3,
   };
 
   /// The default value, if any, along with flags.
-  llvm::PointerIntPair<StoredDefaultArgument *, 3, OptionSet<Flags>>
+  llvm::PointerIntPair<StoredDefaultArgument *, 4, OptionSet<Flags>>
       DefaultValueAndFlags;
 
   friend class ParamSpecifierRequest;
@@ -5552,6 +5556,17 @@ class ParamDecl : public VarDecl {
                                       : flags - Flags::IsIsolated);
   }
 
+  /// Whether or not this parameter is marked with '_const'.
+  bool isCompileTimeConst() const {
+    return DefaultValueAndFlags.getInt().contains(Flags::IsCompileTimeConst);
+  }
+
+  void setCompileTimeConst(bool value = true) {
+    auto flags = DefaultValueAndFlags.getInt();
+    DefaultValueAndFlags.setInt(value ? flags | Flags::IsCompileTimeConst
+                                      : flags - Flags::IsCompileTimeConst);
+  }
+
   /// Does this parameter reject temporary pointer conversions?
   bool isNonEphemeral() const;
 

include/swift/AST/DiagnosticsCommon.def

@@ -71,6 +71,15 @@ ERROR(class_subscript_not_in_class,none,
       "class subscripts are only allowed within classes; "
       "use 'static' to declare a %select{static|requirement fulfilled by either a static or class}0 subscript", (bool))
 
+ERROR(require_static_for_const,none,
+      "'static' is required for _const variable declaration", ())
+
+ERROR(require_let_for_const,none,
+      "let is required for a _const variable declaration", ())
+
+ERROR(require_const_initializer_for_const,none,
+      "_const let should be initialized with a compile-time literal", ())
+
 // FIXME: Used by both the parser and the type-checker.
 ERROR(func_decl_without_brace,PointsToFirstBadToken,
       "expected '{' in body of function declaration", ())

include/swift/AST/DiagnosticsSema.def

@@ -722,6 +722,9 @@ ERROR(cannot_return_value_from_void_func,none,
 NOTE(add_return_type_note,none,
      "did you mean to add a return type?", ())
 
+ERROR(expect_compile_time_const,none,
+      "expect a compile-time constant literal", ())
+
 //------------------------------------------------------------------------------
 // MARK: Import Resolution
 //------------------------------------------------------------------------------
@@ -2320,6 +2323,9 @@ WARNING(warn_protocol_witness_optionality,none,
 NOTE(protocol_witness_static_conflict,none,
      "candidate operates on %select{a type|an instance}0, not "
      "%select{an instance|a type}0 as required", (bool))
+NOTE(protocol_witness_const_conflict,none,
+     "candidate operates as %select{const|non-const}0, not "
+     "%select{non-const|const}0 as required", (bool))
 NOTE(protocol_witness_prefix_postfix_conflict,none,
      "candidate is %select{|prefix, |postfix, }1not "
      "%select{prefix|postfix}0 as required", (bool, unsigned))

include/swift/AST/Expr.h

@@ -486,7 +486,9 @@ class alignas(8) Expr : public ASTAllocated<Expr> {
   bool isSemanticallyInOutExpr() const {
     return getSemanticsProvidingExpr()->getKind() == ExprKind::InOut;
   }
-  
+
+  bool isSemanticallyConstExpr() const;
+
   /// Returns false if this expression needs to be wrapped in parens when
   /// used inside of a any postfix expression, true otherwise.
   ///

include/swift/AST/TypeAlignments.h

@@ -75,6 +75,7 @@ namespace swift {
   constexpr size_t SILFunctionAlignInBits = 2;
   constexpr size_t ASTContextAlignInBits = 2;
   constexpr size_t TypeVariableAlignInBits = 4;
+  constexpr size_t StoredDefaultArgumentAlignInBits = 4;
 
   // Well, this is the *minimum* pointer alignment; it's going to be 3 on
   // 64-bit targets, but that doesn't matter.

include/swift/AST/TypeRepr.h

@@ -1018,6 +1018,21 @@ class IsolatedTypeRepr : public SpecifierTypeRepr {
   static bool classof(const IsolatedTypeRepr *T) { return true; }
 };
 
+/// An '_const' type.
+/// \code
+///   x : _const Int
+/// \endcode
+class CompileTimeConstTypeRepr : public SpecifierTypeRepr {
+public:
+  CompileTimeConstTypeRepr(TypeRepr *Base, SourceLoc InOutLoc)
+    : SpecifierTypeRepr(TypeReprKind::CompileTimeConst, Base, InOutLoc) {}
+
+  static bool classof(const TypeRepr *T) {
+    return T->getKind() == TypeReprKind::CompileTimeConst;
+  }
+  static bool classof(const CompileTimeConstTypeRepr *T) { return true; }
+};
+
 /// A TypeRepr for a known, fixed type.
 ///
 /// Fixed type representations should be used sparingly, in places
@@ -1287,6 +1302,7 @@ inline bool TypeRepr::isSimple() const {
   case TypeReprKind::Owned:
   case TypeReprKind::Isolated:
   case TypeReprKind::Placeholder:
+  case TypeReprKind::CompileTimeConst:
     return true;
   }
   llvm_unreachable("bad TypeRepr kind");

include/swift/AST/TypeReprNodes.def

@@ -61,6 +61,7 @@ ABSTRACT_TYPEREPR(Specifier, TypeRepr)
   TYPEREPR(Shared, SpecifierTypeRepr)
   TYPEREPR(Owned, SpecifierTypeRepr)
   TYPEREPR(Isolated, SpecifierTypeRepr)
+  TYPEREPR(CompileTimeConst, SpecifierTypeRepr)
 TYPEREPR(Fixed, TypeRepr)
 TYPEREPR(SILBox, TypeRepr)
 LAST_TYPEREPR(SILBox)

include/swift/AST/Types.h

@@ -1917,7 +1917,7 @@ class TypeAliasType final
 /// Provide parameter type relevant flags, i.e. variadic, autoclosure, and
 /// escaping.
 class ParameterTypeFlags {
-  enum ParameterFlags : uint8_t {
+  enum ParameterFlags : uint16_t {
     None         = 0,
     Variadic     = 1 << 0,
     AutoClosure  = 1 << 1,
@@ -1926,32 +1926,36 @@ class ParameterTypeFlags {
     Ownership    = 7 << OwnershipShift,
     NoDerivative = 1 << 6,
     Isolated     = 1 << 7,
-    NumBits = 8
+    CompileTimeConst = 1 << 8,
+    NumBits = 9
   };
   OptionSet<ParameterFlags> value;
   static_assert(NumBits <= 8*sizeof(OptionSet<ParameterFlags>), "overflowed");
 
-  ParameterTypeFlags(OptionSet<ParameterFlags, uint8_t> val) : value(val) {}
+  ParameterTypeFlags(OptionSet<ParameterFlags, uint16_t> val) : value(val) {}
 
 public:
   ParameterTypeFlags() = default;
-  static ParameterTypeFlags fromRaw(uint8_t raw) {
+  static ParameterTypeFlags fromRaw(uint16_t raw) {
     return ParameterTypeFlags(OptionSet<ParameterFlags>(raw));
   }
 
   ParameterTypeFlags(bool variadic, bool autoclosure, bool nonEphemeral,
-                     ValueOwnership ownership, bool isolated, bool noDerivative)
+                     ValueOwnership ownership, bool isolated, bool noDerivative,
+                     bool compileTimeConst)
       : value((variadic ? Variadic : 0) | (autoclosure ? AutoClosure : 0) |
               (nonEphemeral ? NonEphemeral : 0) |
               uint8_t(ownership) << OwnershipShift |
               (isolated ? Isolated : 0) |
-              (noDerivative ? NoDerivative : 0)) {}
+              (noDerivative ? NoDerivative : 0) |
+              (compileTimeConst ? CompileTimeConst : 0)){}
 
   /// Create one from what's present in the parameter type
   inline static ParameterTypeFlags
   fromParameterType(Type paramTy, bool isVariadic, bool isAutoClosure,
                     bool isNonEphemeral, ValueOwnership ownership,
-                    bool isolated, bool isNoDerivative);
+                    bool isolated, bool isNoDerivative,
+                    bool compileTimeConst);
 
   bool isNone() const { return !value; }
   bool isVariadic() const { return value.contains(Variadic); }
@@ -1961,6 +1965,7 @@ class ParameterTypeFlags {
   bool isShared() const { return getValueOwnership() == ValueOwnership::Shared;}
   bool isOwned() const { return getValueOwnership() == ValueOwnership::Owned; }
   bool isIsolated() const { return value.contains(Isolated); }
+  bool isCompileTimeConst() const { return value.contains(CompileTimeConst); }
   bool isNoDerivative() const { return value.contains(NoDerivative); }
 
   ValueOwnership getValueOwnership() const {
@@ -1976,6 +1981,11 @@ class ParameterTypeFlags {
     return withValueOwnership(isInout ? ValueOwnership::InOut
                                       : ValueOwnership::Default);
   }
+
+  ParameterTypeFlags withCompileTimeConst(bool isConst) const {
+    return ParameterTypeFlags(isConst ? value | ParameterTypeFlags::CompileTimeConst
+                                      : value | ParameterTypeFlags::CompileTimeConst);
+  }
 
   ParameterTypeFlags withShared(bool isShared) const {
     return withValueOwnership(isShared ? ValueOwnership::Shared
@@ -2083,7 +2093,8 @@ class YieldTypeFlags {
     return ParameterTypeFlags(/*variadic*/ false,
                               /*autoclosure*/ false,
                               /*nonEphemeral*/ false, getValueOwnership(),
-                              /*isolated*/ false, /*noDerivative*/ false);
+                              /*isolated*/ false, /*noDerivative*/ false,
+                              /*compileTimeConst*/false);
   }
 
   bool operator ==(const YieldTypeFlags &other) const {
@@ -2882,6 +2893,9 @@ class AnyFunctionType : public TypeBase {
     /// Whether the parameter is 'isolated'.
     bool isIsolated() const { return Flags.isIsolated(); }
 
+    /// Whether the parameter is 'isCompileTimeConst'.
+    bool isCompileTimeConst() const { return Flags.isCompileTimeConst(); }
+
     /// Whether the parameter is marked '@noDerivative'.
     bool isNoDerivative() const { return Flags.isNoDerivative(); }
 
@@ -6325,7 +6339,8 @@ inline TupleTypeElt TupleTypeElt::getWithType(Type T) const {
 /// Create one from what's present in the parameter decl and type
 inline ParameterTypeFlags ParameterTypeFlags::fromParameterType(
     Type paramTy, bool isVariadic, bool isAutoClosure, bool isNonEphemeral,
-    ValueOwnership ownership, bool isolated, bool isNoDerivative) {
+    ValueOwnership ownership, bool isolated, bool isNoDerivative,
+    bool compileTimeConst) {
   // FIXME(Remove InOut): The last caller that needs this is argument
   // decomposition.  Start by enabling the assertion there and fixing up those
   // callers, then remove this, then remove
@@ -6336,7 +6351,7 @@ inline ParameterTypeFlags ParameterTypeFlags::fromParameterType(
     ownership = ValueOwnership::InOut;
   }
   return {isVariadic, isAutoClosure, isNonEphemeral, ownership, isolated,
-          isNoDerivative};
+          isNoDerivative, compileTimeConst};
 }
 
 inline const Type *BoundGenericType::getTrailingObjectsPointer() const {