sema: diagnose passing a non-constant value into a constant parameter

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/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
 //------------------------------------------------------------------------------

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/Types.h

@@ -1981,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

include/swift/Sema/CSFix.h

@@ -379,6 +379,9 @@ enum class FixKind : uint8_t {
 
   /// Produce a warning for a tuple label mismatch.
   AllowTupleLabelMismatch,
+
+  /// Produce an error for not getting a compile-time constant
+  NotCompileTimeConst,
 };
 
 class ConstraintFix {
@@ -1861,6 +1864,23 @@ class RemoveReturn final : public ContextualMismatch {
   }
 };
 
+class NotCompileTimeConst final : public ContextualMismatch {
+  NotCompileTimeConst(ConstraintSystem &cs, Type paramTy, ConstraintLocator *locator);
+
+public:
+  std::string getName() const override { return "replace with an literal"; }
+
+  bool diagnose(const Solution &solution, bool asNote = false) const override;
+
+  static NotCompileTimeConst *create(ConstraintSystem &cs,
+                                     Type paramTy,
+                                     ConstraintLocator *locator);
+
+  static bool classof(ConstraintFix *fix) {
+    return fix->getKind() == FixKind::NotCompileTimeConst;
+  }
+};
+
 class CollectionElementContextualMismatch final
     : public ContextualMismatch,
       private llvm::TrailingObjects<CollectionElementContextualMismatch,

lib/AST/ASTDumper.cpp

@@ -3464,6 +3464,7 @@ namespace {
       printFlag(paramFlags.isVariadic(), "vararg");
       printFlag(paramFlags.isAutoClosure(), "autoclosure");
       printFlag(paramFlags.isNonEphemeral(), "nonEphemeral");
+      printFlag(paramFlags.isCompileTimeConst(), "compileTimeConst");
       switch (paramFlags.getValueOwnership()) {
       case ValueOwnership::Default: break;
       case ValueOwnership::Owned: printFlag("owned"); break;

lib/AST/ArgumentList.cpp

@@ -39,6 +39,10 @@ bool Argument::isInOut() const {
   return ArgExpr->isSemanticallyInOutExpr();
 }
 
+bool Argument::isConst() const {
+  return ArgExpr->isSemanticallyConstExpr();
+}
+
 ArgumentList *ArgumentList::create(ASTContext &ctx, SourceLoc lParenLoc,
                                    ArrayRef<Argument> args, SourceLoc rParenLoc,
                                    Optional<unsigned> firstTrailingClosureIndex,

lib/AST/Expr.cpp

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

lib/Sema/CSDiagnostics.cpp

@@ -5436,6 +5436,11 @@ bool ExtraneousReturnFailure::diagnoseAsError() {
   return true;
 }
 
+bool NotCompileTimeConstFailure::diagnoseAsError() {
+  emitDiagnostic(diag::expect_compile_time_const);
+  return true;
+}
+
 bool CollectionElementContextualFailure::diagnoseAsError() {
   auto anchor = getRawAnchor();
   auto *locator = getLocator();

lib/Sema/CSDiagnostics.h

@@ -1753,6 +1753,14 @@ class ExtraneousReturnFailure final : public FailureDiagnostic {
   bool diagnoseAsError() override;
 };
 
+class NotCompileTimeConstFailure final : public FailureDiagnostic {
+public:
+  NotCompileTimeConstFailure(const Solution &solution, ConstraintLocator *locator)
+      : FailureDiagnostic(solution, locator) {}
+
+  bool diagnoseAsError() override;
+};
+
 /// Diagnose a contextual mismatch between expected collection element type
 /// and the one provided (e.g. source of the assignment or argument to a call)
 /// e.g.: