sema: diagnose compile-time const variables are properly initialized

Author: nkcsgexi

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", ())

lib/AST/Expr.cpp

@@ -198,7 +198,7 @@ Expr *Expr::getSemanticsProvidingExpr() {
   return this;
 }
 
-bool Expr:: isSemanticallyConstExpr() const {
+bool Expr::isSemanticallyConstExpr() const {
   if (auto *LE = dyn_cast<LiteralExpr>(getSemanticsProvidingExpr())) {
     return LE->getKind() != ExprKind::InterpolatedStringLiteral;
   }

lib/Sema/TypeCheckStorage.cpp

@@ -250,6 +250,45 @@ PatternBindingEntryRequest::evaluate(Evaluator &eval,
     return &pbe;
   }
 
+  llvm::SmallVector<VarDecl *, 2> vars;
+  binding->getPattern(entryNumber)->collectVariables(vars);
+  bool isReq = false;
+  if (auto *d = binding->getDeclContext()->getAsDecl()) {
+    isReq = isa<ProtocolDecl>(d);
+  }
+  for (auto *sv: vars) {
+    bool hasConst = sv->getAttrs().getAttribute<CompileTimeConstAttr>();
+    bool hasStatic = StaticSpelling != StaticSpellingKind::None;
+    if (!hasConst)
+      break;
+    while(1) {
+      // only static _const let/var is supported
+      if (!hasStatic) {
+        binding->diagnose(diag::require_static_for_const);
+        break;
+      }
+      if (isReq) {
+        break;
+      }
+      // var is only allowed in a protocol.
+      if (!sv->isLet()) {
+        binding->diagnose(diag::require_let_for_const);
+        break;
+      }
+      // Diagnose when an init isn't given and it's not a compile-time constant
+      auto *init = binding->getInit(entryNumber);
+      if (!init) {
+        binding->diagnose(diag::require_const_initializer_for_const);
+        break;
+      }
+      if (!init->isSemanticallyConstExpr()) {
+        binding->diagnose(diag::require_const_initializer_for_const);
+        break;
+      }
+      break;
+    }
+  }
+
   // If we have a type but no initializer, check whether the type is
   // default-initializable. If so, do it.
   if (!pbe.isInitialized() &&
@@ -297,8 +336,6 @@ PatternBindingEntryRequest::evaluate(Evaluator &eval,
   // If the pattern binding appears in a type or library file context, then
   // it must bind at least one variable.
   if (!contextAllowsPatternBindingWithoutVariables(binding->getDeclContext())) {
-    llvm::SmallVector<VarDecl *, 2> vars;
-    binding->getPattern(entryNumber)->collectVariables(vars);
     if (vars.empty()) {
       // Selector for error message.
       enum : unsigned {

test/Sema/const_pass_as_arguments.swift

@@ -37,9 +37,28 @@ protocol ConstFan {
 }
 
 class ConstFanClass1: ConstFan { // expected-error {{type 'ConstFanClass1' does not conform to protocol 'ConstFan'}}
-	static var v: String = "" // expected-note {{candidate operates as non-const, not const as required}}
+	static let v: String = "" // expected-note {{candidate operates as non-const, not const as required}}
 }
 
 class ConstFanClassCorrect: ConstFan {
-	static _const var v: String = ""
+	static _const let v: String = ""
+}
+
+class ConstFanClassWrong1: ConstFan {
+	static _const let v: String // expected-error {{_const let should be initialized with a compile-time literal}}
+	// expected-error@-1 {{'static let' declaration requires an initializer expression or an explicitly stated getter}}
+	// expected-note@-2 {{add an initializer to silence this error}}
+}
+
+class ConstFanClassWrong2: ConstFan {
+	static _const let v: String = "\(v)" // expected-error {{_const let should be initialized with a compile-time literal}}
+}
+
+class ConstFanClassWrong3: ConstFan {
+	static _const var v: String = "" // expected-error {{let is required for a _const variable declaration}}
+}
+
+class ConstFanClassWrong4: ConstFan {
+	static func giveMeString() -> String { return "" }
+	static _const let v: String = giveMeString() // expected-error {{_const let should be initialized with a compile-time literal}}
 }