Tweak diagnostic text on @section/@const errors

Author: kubamracek

include/swift/AST/DiagnosticsSema.def

@@ -826,29 +826,29 @@ ERROR(expect_compile_time_literal,none,
       "expect a compile-time constant literal", ())
 
 ERROR(const_unsupported_enum_associated_value,none,
-      "enums with associated values not supported in a '@const' expression", ())
+      "enums with associated values not supported in a constant expression", ())
 ERROR(const_unsupported_operator,none,
-      "unsupported operator in a '@const' expression", ())
+      "unsupported operator in a constant expression", ())
 ERROR(const_unsupported_type,none,
-      "unsupported type in a '@const' expression", ())
+      "unsupported type in a constant expression", ())
 ERROR(const_unsupported_type_expr,none,
-      "type expressions not supported in a '@const' expression", ())
+      "type expressions not supported in a constant expression", ())
 ERROR(const_unsupported_closure,none,
-      "closures not supported in a '@const' expression", ())
+      "closures not supported in a constant expression", ())
 ERROR(const_unsupported_keypath,none,
-      "keypaths not supported in a '@const' expression", ())
+      "keypaths not supported in a constant expression", ())
 ERROR(const_opaque_decl_ref,none,
-      "unable to resolve variable reference in a '@const' expression", ())
+      "unable to resolve variable reference in a constant expression", ())
 ERROR(const_opaque_func_decl_ref,none,
-      "unable to resolve function reference in a '@const' expression", ())
+      "unable to resolve function reference in a constant expression", ())
 ERROR(const_non_convention_c_conversion,none,
-      "only 'convention(c)' function values are supported in a '@const' expression", ())
+      "only 'convention(c)' function values are supported in a constant expression", ())
 ERROR(const_opaque_callee,none,
-      "unable to resolve callee in a '@const' expression", ())
+      "unable to resolve callee in a constant expression", ())
 ERROR(const_non_const_param,none,
-      "reference to a non-'@const' parameter in a '@const' expression", ())
+      "reference to a non-'@const' parameter in a constant expression", ())
 ERROR(const_unknown_default,none,
-      "not supported in a '@const' expression", ())
+      "not supported in a constant expression", ())
 
 //------------------------------------------------------------------------------
 // MARK: Import Resolution

test/ConstValues/DiagModulesSyntactic.swift

@@ -17,4 +17,4 @@ public func foo() -> Int {
 import MyModule
 
 @const let constGlobal1: Int = foo()
-// expected-error@-1 {{not supported in a '@const' expression}}
+// expected-error@-1 {{not supported in a constant expression}}

test/ConstValues/DiagNotConstSyntactic.swift

@@ -3,11 +3,11 @@
 // RUN: %target-swift-frontend -emit-ir -primary-file %s -parse-as-library -verify -enable-experimental-feature CompileTimeValues
 
 @const let a: Bool = Bool.random()
-// expected-error@-1 {{not supported in a '@const' expression}}
+// expected-error@-1 {{not supported in a constant expression}}
 
 func foo() -> Int {
 	return 42 * Int.random(in: 0 ..< 10)
 }
 
 @const let b: Int = foo()
-// expected-error@-1 {{not supported in a '@const' expression}}
+// expected-error@-1 {{not supported in a constant expression}}

test/ConstValues/FunctionTypesSyntactic.swift

@@ -6,25 +6,25 @@ func foo_void_to_void() {}
 func foo_int_to_int(x: Int) -> Int { return 42 }
 
 @const let constGlobalA1: ()->() = { }
-// expected-error@-1{{closures not supported in a '@const' expression}}
+// expected-error@-1{{closures not supported in a constant expression}}
 @const let constGlobalA2: @convention(c) ()->() = { }
-// expected-error@-1{{closures not supported in a '@const' expression}}
+// expected-error@-1{{closures not supported in a constant expression}}
 @const let constGlobalA3: @convention(thin) ()->() = { }
-// expected-error@-1{{only 'convention(c)' function values are supported in a '@const' expression}}
+// expected-error@-1{{only 'convention(c)' function values are supported in a constant expression}}
 
 @const let constGlobalB1: ()->() = foo_void_to_void // TODO: Diagnose the type of the variable as not eligigle for '@const' (not the init expression)
 @const let constGlobalB2: @convention(c) ()->() = foo_void_to_void
 @const let constGlobalB3: @convention(thin) ()->() = foo_void_to_void
-// expected-error@-1{{only 'convention(c)' function values are supported in a '@const' expression}}
+// expected-error@-1{{only 'convention(c)' function values are supported in a constant expression}}
 
 @const let constGlobalC1: (Int)->(Int) = { _ in return 42 }
-// expected-error@-1{{closures not supported in a '@const' expression}}
+// expected-error@-1{{closures not supported in a constant expression}}
 @const let constGlobalC2: @convention(c) (Int)->(Int) = { _ in return 42 }
-// expected-error@-1{{closures not supported in a '@const' expression}}
+// expected-error@-1{{closures not supported in a constant expression}}
 @const let constGlobalC3: @convention(thin) (Int)->(Int) = { _ in return 42 }
-// expected-error@-1{{only 'convention(c)' function values are supported in a '@const' expression}}
+// expected-error@-1{{only 'convention(c)' function values are supported in a constant expression}}
 
 @const let constGlobalD1: (Int)->(Int) = foo_int_to_int
 @const let constGlobalD2: @convention(c) (Int)->(Int) = foo_int_to_int
 @const let constGlobalD3: @convention(thin) (Int)->(Int) = foo_int_to_int
-// expected-error@-1{{only 'convention(c)' function values are supported in a '@const' expression}}
+// expected-error@-1{{only 'convention(c)' function values are supported in a constant expression}}

test/ConstValues/IntegerExpressionsSyntactic.swift

@@ -5,7 +5,7 @@
 
 @const let constGlobal1: Int = (42 + 42 + 42) / 3
 @const let constGlobal2: Int = MemoryLayout<UInt32>.size + 4
-// expected-error@-1{{in a '@const' expression}}
+// expected-error@-1{{in a constant expression}}
 @const let constGlobal3: Int = Int(17.0 / 3.5)
 @const let constGlobal4: Int = constGlobal1 + 1
 @const let constGlobal5: Int = -constGlobal1 + 1

test/ConstValues/ParametersSyntactic.swift

@@ -14,5 +14,5 @@ func foo() {
     #endif
     let _ = bar(UInt.random(in: 0..<10))
     // expected-error@-1 {{expected a compile-time value argument for a '@const' parameter}}
-    // expected-error@-2 {{not supported in a '@const' expression}}
+    // expected-error@-2 {{not supported in a constant expression}}
 }

test/ConstValues/SectionSyntactic.swift

@@ -26,19 +26,19 @@
 
 // operators (should be rejected)
 @section("mysection") let invalidOperator1 = 1 + 1
-// expected-error@-1{{unsupported operator in a '@const' expression}}
+// expected-error@-1{{unsupported operator in a constant expression}}
 @section("mysection") let invalidOperator2 = 3.14 * 2.0
-// expected-error@-1{{unsupported operator in a '@const' expression}}
+// expected-error@-1{{unsupported operator in a constant expression}}
 @section("mysection") let invalidOperator3: Int = -(1)
-// expected-error@-1{{unsupported operator in a '@const' expression}}
+// expected-error@-1{{unsupported operator in a constant expression}}
 
 // non-literal expressions (should be rejected)
 @section("mysection") let invalidNonLiteral1 = Int.max
-// expected-error@-1{{not supported in a '@const' expression}}
+// expected-error@-1{{not supported in a constant expression}}
 @section("mysection") let invalidNonLiteral2 = UInt8(42)
-// expected-error@-1{{not supported in a '@const' expression}}
+// expected-error@-1{{not supported in a constant expression}}
 @section("mysection") let invalidNonLiteral3 = true.hashValue
-// expected-error@-1{{not supported in a '@const' expression}}
+// expected-error@-1{{not supported in a constant expression}}
 
 func foo() -> Int { return 42 }
 func bar(x: Int) -> String { return "test" }
@@ -49,21 +49,21 @@ func bar(x: Int) -> String { return "test" }
 
 // invalid function references (should be rejected)
 @section("mysection") let invalidFuncRef1 = foo()
-// expected-error@-1{{not supported in a '@const' expression}}
+// expected-error@-1{{not supported in a constant expression}}
 @section("mysection") let invalidFuncRef2 = Bool.self.random
-// expected-error@-1{{closures not supported in a '@const' expression}}
+// expected-error@-1{{closures not supported in a constant expression}}
 @section("mysection") let invalidFuncRef3 = (Bool.self as Bool.Type).random
-// expected-error@-1{{not supported in a '@const' expression}}
+// expected-error@-1{{not supported in a constant expression}}
 
 // generic function references (should be rejected)
 @section("mysection") let invalidGenericFunc = [Int].randomElement
-// expected-error@-1{{not supported in a '@const' expression}}
+// expected-error@-1{{not supported in a constant expression}}
 
 // closures (should be rejected)
 @section("mysection") let invalidClosure1 = { }
-// expected-error@-1{{closures not supported in a '@const' expression}}
+// expected-error@-1{{closures not supported in a constant expression}}
 @section("mysection") let invalidClosure2 = { return 42 }
-// expected-error@-1{{closures not supported in a '@const' expression}}
+// expected-error@-1{{closures not supported in a constant expression}}
 
 struct S { }
 enum E { case a }
@@ -73,13 +73,13 @@ enum E { case a }
 
 // invalid metatype references
 @section("mysection") let invalidMetatype1 = Int.self.self
-// expected-error@-1{{type expressions not supported in a '@const' expression}}
+// expected-error@-1{{type expressions not supported in a constant expression}}
 @section("mysection") let invalidMetatype2 = (1 == 1 ? Int.self : Int.self).self
-// expected-error@-1{{type expressions not supported in a '@const' expression}}
+// expected-error@-1{{type expressions not supported in a constant expression}}
 @section("mysection") let invalidMetatype3 = Array<Int>.self // generic
-// expected-error@-1{{type expressions not supported in a '@const' expression}}
+// expected-error@-1{{type expressions not supported in a constant expression}}
 @section("mysection") let invalidMetatype4 = Mirror.self // resilient
-// expected-error@-1{{type expressions not supported in a '@const' expression}}
+// expected-error@-1{{type expressions not supported in a constant expression}}
 
 // tuples
 @section("mysection") let tuple1 = (1, 2, 3, 2.718, true) // ok
@@ -88,35 +88,35 @@ enum E { case a }
 
 // invalid tuples (should be rejected)
 @section("mysection") let invalidTuple1 = (1, 2, Int.max)
-// expected-error@-1{{not supported in a '@const' expression}}
+// expected-error@-1{{not supported in a constant expression}}
 @section("mysection") let invalidTuple2 = (1 + 1, 2)
-// expected-error@-1{{unsupported operator in a '@const' expression}}
+// expected-error@-1{{unsupported operator in a constant expression}}
 
 let someVar = 42
 
 // variables (should be rejected)
 @section("mysection") let invalidVarRef = someVar
-// expected-error@-1{{unable to resolve variable reference in a '@const' expression}}
+// expected-error@-1{{unable to resolve variable reference in a constant expression}}
 
 struct MyCustomExpressibleByIntegerLiteral: ExpressibleByIntegerLiteral {
     init(integerLiteral value: Int) {}
 }
 
 // custom types (should be rejected)
 @section("mysection") let invalidCustomType1: MyCustomExpressibleByIntegerLiteral = 42
-// expected-error@-1{{unsupported type in a '@const' expression}}
+// expected-error@-1{{unsupported type in a constant expression}}
 @section("mysection") let invalidCustomType2: E = E.a
-// expected-error@-1{{not supported in a '@const' expression}}
+// expected-error@-1{{not supported in a constant expression}}
 @section("mysection") let invalidCustomType3: S = S()
-// expected-error@-1{{not supported in a '@const' expression}}
+// expected-error@-1{{not supported in a constant expression}}
 
 // other standard types (should be rejected)
 @section("mysection") let invalidString = "hello"
-// expected-error@-1{{unsupported type in a '@const' expression}}
+// expected-error@-1{{unsupported type in a constant expression}}
 @section("mysection") let invalidArray = [1, 2, 3]
-// expected-error@-1{{unsupported type in a '@const' expression}}
+// expected-error@-1{{unsupported type in a constant expression}}
 @section("mysection") let invalidDict = ["key": "value"]
-// expected-error@-1{{not supported in a '@const' expression}}
+// expected-error@-1{{not supported in a constant expression}}
 
 // inline array
 @available(SwiftStdlib 6.2, *)
@@ -125,20 +125,20 @@ struct MyCustomExpressibleByIntegerLiteral: ExpressibleByIntegerLiteral {
 // invalid inline array (should be rejected)
 @available(SwiftStdlib 6.2, *)
 @section("mysection") let invalidInlineArray: InlineArray = [1, 2, 3, Int.max]
-// expected-error@-1{{not supported in a '@const' expression}}
+// expected-error@-1{{not supported in a constant expression}}
 
 // optionals (should be rejected)
 @section("mysection") let optional1: Int? = 42
-// expected-error@-1{{unsupported type in a '@const' expression}}
+// expected-error@-1{{unsupported type in a constant expression}}
 @section("mysection") let optional2: Int? = nil
-// expected-error@-1{{unsupported type in a '@const' expression}}
+// expected-error@-1{{unsupported type in a constant expression}}
 @section("mysection") let optional3: Double? = 3.14
-// expected-error@-1{{unsupported type in a '@const' expression}}
+// expected-error@-1{{unsupported type in a constant expression}}
 @section("mysection") let optional4: Bool? = true
-// expected-error@-1{{unsupported type in a '@const' expression}}
+// expected-error@-1{{unsupported type in a constant expression}}
 @section("mysection") let optional5: Bool? = false
-// expected-error@-1{{unsupported type in a '@const' expression}}
+// expected-error@-1{{unsupported type in a constant expression}}
 @section("mysection") let optional6: Int? = 1 + 1
-// expected-error@-1{{unsupported type in a '@const' expression}}
+// expected-error@-1{{unsupported type in a constant expression}}
 @section("mysection") let optional7: Int? = Int.max
-// expected-error@-1{{unsupported type in a '@const' expression}}
+// expected-error@-1{{unsupported type in a constant expression}}

test/ConstValues/Tuples.swift

@@ -11,4 +11,4 @@
 @const let constGlobal5: (Int, Float) = (42, 42.0)
 
 // Closure call not supported in syntactically-validated mode
-@const let constGlobal7: (UInt64, StaticString, @convention(c) ()->Int) = (42, "hi", { return 42 }) // expected-error {{not supported in a '@const' expression}}
+@const let constGlobal7: (UInt64, StaticString, @convention(c) ()->Int) = (42, "hi", { return 42 }) // expected-error {{not supported in a constant expression}}

test/Parse/const.swift

@@ -21,11 +21,11 @@ func takeIntConst(@const _ a: Int) {}
 struct Article {
   let id: String
 }
-@const let keypath = \Article.id // expected-error{{keypaths not supported in a '@const' expression}}
+@const let keypath = \Article.id // expected-error{{keypaths not supported in a constant expression}}
 
 func LocalConstVarUser() -> Int {
   @const let localConst = 3
   return localConst + 1
 }
 
-@const let a: Bool = Bool.random() // expected-error{{not supported in a '@const' expression}}
+@const let a: Bool = Bool.random() // expected-error{{not supported in a constant expression}}