[Compile Time Values] Add parsing of @constInitialized attribute under CompileTimeValues experimental feature

Author: kubamracek

include/swift/AST/Decl.h

@@ -5898,6 +5898,7 @@ class AbstractStorageDecl : public ValueDecl {
     Bits.AbstractStorageDecl.IsStatic = IsStatic;
   }
   bool isCompileTimeLiteral() const;
+  bool isConstVal() const;
 
   /// \returns the way 'static'/'class' should be spelled for this declaration.
   StaticSpellingKind getCorrectStaticSpelling() const;

include/swift/AST/DeclAttr.def

@@ -872,8 +872,13 @@ SIMPLE_DECL_ATTR(const, ConstVal,
   ABIStableToAdd | ABIBreakingToRemove | APIBreakingToAdd | APIBreakingToRemove,
   167)
 DECL_ATTR_FEATURE_REQUIREMENT(ConstVal, CompileTimeValues)
+SIMPLE_DECL_ATTR(constInitialized, ConstInitialized,
+  OnVar,
+  ABIStableToAdd | ABIBreakingToRemove | APIBreakingToAdd | APIBreakingToRemove,
+  168)
+DECL_ATTR_FEATURE_REQUIREMENT(ConstInitialized, CompileTimeValues)
 
-LAST_DECL_ATTR(ConstVal)
+LAST_DECL_ATTR(ConstInitialized)
 
 #undef DECL_ATTR_ALIAS
 #undef CONTEXTUAL_DECL_ATTR_ALIAS

include/swift/AST/DiagnosticsCommon.def

@@ -77,14 +77,20 @@ 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,
+ERROR(require_static_for_literal,none,
       "'static' is required for _const variable declaration", ())
 
-ERROR(require_let_for_const,none,
+ERROR(require_let_for_literal,none,
       "let is required for a _const variable declaration", ())
 
+ERROR(require_literal_initializer_for_literal,none,
+      "_const let should be initialized with a literal value", ())
+      
 ERROR(require_const_initializer_for_const,none,
-      "_const let should be initialized with a compile-time literal", ())
+      "@const value should be initialized with a compile-time value", ())
+
+ERROR(require_const_arg_for_parameter,none,
+      "expected a compile-time value for a '@const' parameter", ())
 
 // FIXME: Used by both the parser and the type-checker.
 ERROR(func_decl_without_brace,PointsToFirstBadToken,

include/swift/AST/DiagnosticsSema.def

@@ -2149,7 +2149,7 @@ ERROR(attr_only_at_non_local_scope, none,
 ERROR(attr_only_at_non_generic_scope, none,
       "attribute '%0' cannot be used in a generic context", (StringRef))
 ERROR(attr_only_on_static_properties, none,
-      "properties with attribute '_section' must be static", (StringRef))
+      "properties with attribute '%0' must be static", (StringRef))
 
 ERROR(weak_unowned_in_embedded_swift, none,
       "attribute %0 cannot be used in embedded Swift", (ReferenceOwnership))
@@ -4046,6 +4046,10 @@ ERROR(attr_incompatible_with_objc,none,
       "'%0' must not be used on an '@objc' %1",
       (DeclAttribute, DescriptiveDeclKind))
 
+ERROR(attr_unusable_in_protocol,none,
+      "'%0' cannot be used inside a protocol declaration",
+      (DeclAttribute))
+
 ERROR(final_not_on_accessors,none,
       "only the %select{property|subscript}0 itself can be marked as 'final'"
       ,(bool))

lib/AST/ASTDumper.cpp

@@ -4819,6 +4819,7 @@ class PrintAttribute : public AttributeVisitor<PrintAttribute, void, Label>,
   TRIVIAL_ATTR_PRINTER(Borrowing, borrowing)
   TRIVIAL_ATTR_PRINTER(CompileTimeLiteral, compile_time_literal)
   TRIVIAL_ATTR_PRINTER(ConstVal, compile_time_value)
+  TRIVIAL_ATTR_PRINTER(ConstInitialized, const_initialized)
   TRIVIAL_ATTR_PRINTER(CompilerInitialized, compiler_initialized)
   TRIVIAL_ATTR_PRINTER(Consuming, consuming)
   TRIVIAL_ATTR_PRINTER(Convenience, convenience)

lib/AST/Decl.cpp

@@ -1294,6 +1294,10 @@ bool AbstractStorageDecl::isCompileTimeLiteral() const {
   return getAttrs().hasAttribute<CompileTimeLiteralAttr>();
 }
 
+bool AbstractStorageDecl::isConstVal() const {
+  return getAttrs().hasAttribute<ConstValAttr>();
+}
+
 bool AbstractStorageDecl::isTransparent() const {
   return getAttrs().hasAttribute<TransparentAttr>();
 }

lib/AST/FeatureSet.cpp

@@ -363,7 +363,8 @@ static bool usesFeatureConcurrencySyntaxSugar(Decl *decl) {
 }
 
 static bool usesFeatureCompileTimeValues(Decl *decl) {
-  return decl->getAttrs().hasAttribute<ConstValAttr>();
+  return decl->getAttrs().hasAttribute<ConstValAttr>() ||
+         decl->getAttrs().hasAttribute<ConstInitializedAttr>();
 }
 
 static bool usesFeatureClosureBodyMacro(Decl *decl) {

lib/ASTGen/Sources/ASTGen/DeclAttrs.swift

@@ -224,6 +224,7 @@ extension ASTGenVisitor {
         .borrowed,
         .compilerInitialized,
         .constVal,
+        .constInitialized,
         .dynamicCallable,
         .eagerMove,
         .exported,

lib/SIL/IR/SILGlobalVariable.cpp

@@ -106,10 +106,16 @@ bool SILGlobalVariable::mustBeInitializedStatically() const {
   if (getSectionAttr())
     return true;
 
-  auto *decl = getDecl();
+  auto *decl = getDecl();  
   if (decl && isDefinition() && decl->getAttrs().hasAttribute<SILGenNameAttr>())
     return true;
 
+  if (decl && isDefinition() && decl->getAttrs().hasAttribute<ConstValAttr>())
+    return true;
+
+  if (decl && isDefinition() && decl->getAttrs().hasAttribute<ConstInitializedAttr>())
+    return true;
+
   return false;
 }
 

lib/Sema/TypeCheckAttr.cpp

@@ -435,7 +435,8 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
   void visitFinalAttr(FinalAttr *attr);
   void visitMoveOnlyAttr(MoveOnlyAttr *attr);
   void visitCompileTimeLiteralAttr(CompileTimeLiteralAttr *attr) {}
-  void visitConstValAttr(ConstValAttr *attr) {}
+  void visitConstValAttr(ConstValAttr *attr);
+  void visitConstInitializedAttr(ConstInitializedAttr *attr);
   void visitIBActionAttr(IBActionAttr *attr);
   void visitIBSegueActionAttr(IBSegueActionAttr *attr);
   void visitLazyAttr(LazyAttr *attr);
@@ -2843,6 +2844,39 @@ void AttributeChecker::visitMoveOnlyAttr(MoveOnlyAttr *attr) {
     .fixItRemove(attr->getRange());
 }
 
+void AttributeChecker::visitConstValAttr(ConstValAttr *attr) {
+  auto *VD = dyn_cast<VarDecl>(D);
+  if (VD) {
+    if (!VD->isLet() && !isa<ProtocolDecl>(D->getDeclContext())) {
+      diagnose(D->getStartLoc(), diag::attr_only_one_decl_kind,
+               attr, "let");
+      attr->setInvalid();
+      return;
+    }
+  }
+}
+
+void AttributeChecker::visitConstInitializedAttr(ConstInitializedAttr *attr) {
+  auto *VD = cast<VarDecl>(D);
+  
+  if (D->getDeclContext()->isLocalContext()) {
+    diagnose(attr->getLocation(), diag::attr_only_at_non_local_scope,
+             attr->getAttrName());
+  } else
+  if (isa<ProtocolDecl>(D->getDeclContext())) {
+    diagnose(attr->getLocation(), diag::attr_unusable_in_protocol,
+             attr);
+  } else
+  if (!VD->isStatic() && !D->getDeclContext()->isModuleScopeContext()) {
+    diagnose(attr->getLocation(), diag::attr_only_on_static_properties,
+             attr->getAttrName());
+  } else
+  if (!VD->hasStorageOrWrapsStorage()) {
+    diagnose(attr->getLocation(), diag::attr_not_on_computed_properties,
+             attr);
+  }
+}
+
 /// Return true if this is a builtin operator that cannot be defined in user
 /// code.
 static bool isBuiltinOperator(StringRef name, DeclAttribute *attr) {