Merge pull request #3474 from CodaFi/postminimalist-abstract-expressionism

[SE-0115] Rename *LiteralConvertible protocols to ExpressibleBy*…

Author: CodaFi

docs/GenericsManifesto.md

@@ -110,7 +110,7 @@ extension Collection {
 
 `let` constants could be allowed to have generic parameters, such that they produce differently-typed values depending on how they are used. For example, this is particularly useful for named literal values, e.g.,
 
-```let π<T : FloatLiteralConvertible>: T = 3.141592653589793238462643383279502884197169399```
+```let π<T : ExpressibleByFloatLiteral>: T = 3.141592653589793238462643383279502884197169399```
 
 The Clang importer could make particularly good use of this when importing macros.
 

docs/Literals.rst

@@ -23,7 +23,7 @@ is an NSWindow, there will only be one possible method named ``setTitle``,
 which takes an NSString. Therefore, we want the string literal expression to
 end up being an NSString.
 
-Fortunately, NSString implements StringLiteralConvertible, so the type checker
+Fortunately, NSString implements ExpressibleByStringLiteral, so the type checker
 will indeed be able to choose NSString as the type of the string literal. All
 is well.
 
@@ -32,41 +32,41 @@ infinite precision. Once the type has been chosen, the value is checked to see
 if it is in range for that type.
 
 
-The StringLiteralConvertible Protocol
+The ExpressibleByStringLiteral Protocol
 -------------------------------------
 
-Here is the StringLiteralConvertible protocol as defined in the standard
+Here is the ExpressibleByStringLiteral protocol as defined in the standard
 library's CompilerProtocols.swift::
 
   // NOTE: the compiler has builtin knowledge of this protocol
   // Conforming types can be initialized with arbitrary string literals.
-  public protocol StringLiteralConvertible
-    : ExtendedGraphemeClusterLiteralConvertible {
+  public protocol ExpressibleByStringLiteral
+    : ExpressibleByExtendedGraphemeClusterLiteral {
     
-    typealias StringLiteralType : _BuiltinStringLiteralConvertible
+    typealias StringLiteralType : _ExpressibleByBuiltinStringLiteral
     // Create an instance initialized to `value`.
     init(stringLiteral value: StringLiteralType)
   }
 
 Curiously, the protocol is not defined in terms of primitive types, but in
 terms of any StringLiteralType that the implementer chooses. In most cases,
 this will be Swift's own native String type, which means users can implement
-their own StringLiteralConvertible types while still dealing with a high-level
+their own ExpressibleByStringLiteral types while still dealing with a high-level
 interface.
 
 (Why is this not hardcoded? A String *must* be a valid Unicode string, but
 if the string literal contains escape sequences, an invalid series of code
 points could be constructed...which may be what's desired in some cases.)
 
 
-The _BuiltinStringLiteralConvertible Protocol
+The _ExpressibleByBuiltinStringLiteral Protocol
 ---------------------------------------------
 
 CompilerProtocols.swift contains a second protocol::
 
   // NOTE: the compiler has builtin knowledge of this protocol
-  public protocol _BuiltinStringLiteralConvertible
-    : _BuiltinExtendedGraphemeClusterLiteralConvertible {
+  public protocol _ExpressibleByBuiltinStringLiteral
+    : _ExpressibleByBuiltinExtendedGraphemeClusterLiteral {
 
     init(
         _builtinStringLiteral start: Builtin.RawPointer,
@@ -82,9 +82,9 @@ data from the literal, and the arguments describe that raw data.
 So, the general runtime behavior is now clear:
 
 1. The compiler generates raw string data.
-2. Some type conforming to _BuiltinStringLiteralConvertible is constructed from 
+2. Some type conforming to _ExpressibleByBuiltinStringLiteral is constructed from 
    the raw string data. This will be a standard library type.
-3. Some type conforming to StringLiteralConvertible is constructed from the
+3. Some type conforming to ExpressibleByStringLiteral is constructed from the
    object constructed in step 2. This may be a user-defined type. This is the
    result.
 
@@ -101,7 +101,7 @@ This algorithm can go forwards or backwards, since it's actually defined in
 terms of constraints, but it's easiest to understand as a linear process.
 
 1. Filter the types provided by the context to only include those that are 
-   StringLiteralConvertible.
+   ExpressibleByStringLiteral.
 2. Using the associated StringLiteralType, find the appropriate
    ``_convertFromBuiltinStringLiteral``.
 3. Using the type from step 1, find the appropriate 
@@ -114,7 +114,7 @@ How about cases where there is no context? ::
 
 Here we have nothing to go on, so instead the type checker looks for a global
 type named ``StringLiteralType`` in the current module-scope context, and uses
-that type if it is actually a StringLiteralConvertible type. This both allows
+that type if it is actually a ExpressibleByStringLiteral type. This both allows
 different standard libraries to set different default literal types, and allows
 a user to *override* the default type in their own source file.
 
@@ -138,6 +138,6 @@ literal type is always Dictionary.
 
 String interpolations are a bit different: they try to individually convert
 each element of the interpolation to the type that adopts
-StringInterpolationConvertible, then calls the variadic
+ExpressibleByStringInterpolation, then calls the variadic
 ``convertFromStringInterpolation`` to put them all together. The default type
 for an interpolated literal without context is also ``StringLiteralType``.

docs/TextFormatting.rst

@@ -259,7 +259,7 @@ used for ``Int``. It represents an example of how a relatively
 complicated ``format(…)`` might be written::
 
   protocol CustomStringConvertibleInteger 
-    : IntegerLiteralConvertible, Comparable, SignedNumber, CustomStringConvertible {
+    : ExpressibleByIntegerLiteral, Comparable, SignedNumber, CustomStringConvertible {
     func %(lhs: Self, rhs: Self) -> Self
     func /(lhs: Self, rhs: Self) -> Self
     constructor(x: Int)

docs/TypeChecker.rst

@@ -638,7 +638,7 @@ can be converted [#]_.
 Default Literal Types
 ..........................................
 If a type variable is bound by a conformance constraint to one of the
-literal protocols, "``T0`` conforms to ``IntegerLiteralConvertible``",
+literal protocols, "``T0`` conforms to ``ExpressibleByIntegerLiteral``",
 then the constraint solver will guess that the type variable can be
 bound to the default literal type for that protocol. For example,
 ``T0`` would get the default integer literal type ``Int``, allowing
@@ -738,18 +738,18 @@ checking problem::
 This constraint system generates the constraints "``T(f)`` ==Fn ``T0
 -> T1``" (for fresh variables ``T0`` and ``T1``), "``(T2, X) <c
 T0``" (for fresh variable ``T2``) and "``T2`` conforms to
-``FloatLiteralConvertible``". As part of the solution, after ``T0`` is
+``ExpressibleByFloatLiteral``". As part of the solution, after ``T0`` is
 replaced with ``(i : Int, s : String)``, the second of
 these constraints is broken down into "``T2 <c Int``" and "``X <c
 String``". These two constraints are interesting for different
 reasons: the first will fail, because ``Int`` does not conform to
-``FloatLiteralConvertible``. The second will succeed by selecting one
+``ExpressibleByFloatLiteral``. The second will succeed by selecting one
 of the (overloaded) conversion functions.
 
 In both of these cases, we need to map the actual constraint of
 interest back to the expressions they refer to. In the first case, we
 want to report not only that the failure occurred because ``Int`` is
-not ``FloatLiteralConvertible``, but we also want to point out where
+not ``ExpressibleByFloatLiteral``, but we also want to point out where
 the ``Int`` type actually came from, i.e., in the parameter. In the
 second case, we want to determine which of the overloaded conversion
 functions was selected to perform the conversion, so that conversion
@@ -816,7 +816,7 @@ important decisions made by the solver. However, the locators
 determined by the solver may not directly refer to the most specific
 expression for the purposes of identifying the corresponding source
 location. For example, the failed constraint "``Int`` conforms to
-``FloatLiteralConvertible``" can most specifically by centered on the
+``ExpressibleByFloatLiteral``" can most specifically by centered on the
 floating-point literal ``10.5``, but its locator is::
 
   function application -> apply argument -> tuple element #0

docs/proposals/Enums.rst

@@ -276,17 +276,17 @@ An enum can obtain a compiler-derived 'RawRepresentable' conformance by
 declaring "inheritance" from its raw type in the following
 circumstances:
 
-- The inherited raw type must be IntegerLiteralConvertible,
-  FloatLiteralConvertible, CharLiteralConvertible, and/or
-  StringLiteralConvertible.
+- The inherited raw type must be ExpressibleByIntegerLiteral,
+  ExpressibleByExtendedGraphemeClusterLiteral, ExpressibleByFloatLiteral,
+  and/or ExpressibleByStringLiteral.
 - None of the cases of the enum may have non-void payloads.
 
 If an enum declares a raw type, then its cases may declare raw
 values. raw values must be integer, float, character, or string
 literals, and must be unique within the enum. If the raw type is
-IntegerLiteralConvertible, then the raw values default to
+ExpressibleByIntegerLiteral, then the raw values default to
 auto-incrementing integer literal values starting from '0', as in C. If the
-raw type is not IntegerLiteralConvertible, the raw values must
+raw type is not ExpressibleByIntegerLiteral, the raw values must
 all be explicitly declared::
 
   enum Color : Int {
@@ -302,7 +302,7 @@ all be explicitly declared::
 
   enum NSChangeDictionaryKey : String {
     // All raw values are required because String is not
-    // IntegerLiteralConvertible
+    // ExpressibleByIntegerLiteral
     case NSKeyValueChangeKindKey = "NSKeyValueChangeKindKey"
     case NSKeyValueChangeNewKey = "NSKeyValueChangeNewKey"
     case NSKeyValueChangeOldKey = "NSKeyValueChangeOldKey"

include/swift/AST/DiagnosticsSema.def

@@ -1611,7 +1611,7 @@ ERROR(circular_enum_inheritance,none,
 ERROR(raw_type_not_first,none,
   "raw type %0 must appear first in the enum inheritance clause", (Type))
 ERROR(raw_type_not_literal_convertible,none,
-      "raw type %0 is not convertible from any literal",
+      "raw type %0 is not expressible by any literal",
       (Type))
 ERROR(enum_raw_type_not_equatable,none,
       "RawRepresentable 'init' cannot be synthesized because raw type %0 is not "
@@ -1639,8 +1639,8 @@ ERROR(objc_enum_raw_type_not_integer,none,
 ERROR(enum_non_integer_raw_value_auto_increment,none,
       "enum case must declare a raw value when the preceding raw value is not an integer", ())
 ERROR(enum_non_integer_convertible_raw_type_no_value,none,
-      "enum cases require explicit raw values when the raw type is not integer "
-      "or string literal convertible", ())
+      "enum cases require explicit raw values when the raw type is not "
+      "expressible by integer or string literal", ())
 ERROR(enum_raw_value_not_unique,none,
       "raw value for enum case is not unique", ())
 NOTE(enum_raw_value_used_here,none,
@@ -1663,7 +1663,7 @@ ERROR(broken_errortype_requirement,none,
 ERROR(broken_int_hashable_conformance,none,
       "Int type is broken: does not conform to Hashable", ())
 ERROR(broken_int_integer_literal_convertible_conformance,none,
-      "Int type is broken: does not conform to IntegerLiteralConvertible", ())
+      "Int type is broken: does not conform to ExpressibleByIntegerLiteral", ())
 ERROR(broken_equatable_eq_operator,none,
       "Equatable protocol is broken: no infix operator declaration for '=='", ())
 ERROR(no_equal_overload_for_int,none,
@@ -2014,10 +2014,10 @@ ERROR(optional_used_as_true_boolean,none,
       "test for '== nil' instead", (Type))
 
 ERROR(interpolation_missing_proto,none,
-      "string interpolation requires the protocol 'StringInterpolationConvertible' to be defined",
+      "string interpolation requires the protocol 'ExpressibleByStringInterpolation' to be defined",
       ())
 ERROR(interpolation_broken_proto,none,
-      "protocol 'StringInterpolationConvertible' is broken",
+      "protocol 'ExpressibleByStringInterpolation' is broken",
       ())
 
 ERROR(object_literal_broken_proto,none,
@@ -2049,44 +2049,44 @@ ERROR(specific_type_of_expression_is_ambiguous,none,
 ERROR(missing_protocol,none,
       "missing protocol %0", (Identifier))
 ERROR(nil_literal_broken_proto,none,
-      "protocol 'NilLiteralConvertible' is broken", ())
+      "protocol 'ExpressibleByNilLiteral' is broken", ())
 
 ERROR(builtin_integer_literal_broken_proto,none,
-      "protocol '_BuiltinIntegerLiteralConvertible' is broken", ())
+      "protocol '_ExpressibleByBuiltinIntegerLiteral' is broken", ())
 ERROR(integer_literal_broken_proto,none,
-      "protocol 'IntegerLiteralConvertible' is broken", ())
+      "protocol 'ExpressibleByIntegerLiteral' is broken", ())
 
 ERROR(builtin_float_literal_broken_proto,none,
-      "protocol '_BuiltinFloatLiteralConvertible' is broken", ())
+      "protocol '_ExpressibleByBuiltinFloatLiteral' is broken", ())
 ERROR(float_literal_broken_proto,none,
-      "protocol 'FloatLiteralConvertible' is broken", ())
+      "protocol 'ExpressibleByFloatLiteral' is broken", ())
 
 ERROR(builtin_boolean_literal_broken_proto,none,
-      "protocol '_BuiltinBooleanLiteralConvertible' is broken", ())
+      "protocol '_ExpressibleByBuiltinBooleanLiteral' is broken", ())
 ERROR(boolean_literal_broken_proto,none,
-      "protocol 'BooleanLiteralConvertible' is broken", ())
+      "protocol 'ExpressibleByBooleanLiteral' is broken", ())
 
 ERROR(builtin_unicode_scalar_literal_broken_proto,none,
-      "protocol '_BuiltinUnicodeScalarLiteralConvertible' is broken", ())
+      "protocol '_ExpressibleByBuiltinUnicodeScalarLiteral' is broken", ())
 ERROR(unicode_scalar_literal_broken_proto,none,
-      "protocol 'UnicodeScalarLiteralConvertible' is broken", ())
+      "protocol 'ExpressibleByUnicodeScalarLiteral' is broken", ())
 
 ERROR(builtin_extended_grapheme_cluster_literal_broken_proto,none,
-      "protocol '_BuiltinExtendedGraphemeClusterLiteralConvertible' is broken", ())
+      "protocol '_ExpressibleByBuiltinExtendedGraphemeClusterLiteral' is broken", ())
 ERROR(extended_grapheme_cluster_literal_broken_proto,none,
-      "protocol 'ExtendedGraphemeClusterLiteralConvertible' is broken", ())
+      "protocol 'ExpressibleByExtendedGraphemeClusterLiteral' is broken", ())
 
 ERROR(builtin_string_literal_broken_proto,none,
-      "protocol '_BuiltinStringLiteralConvertible' is broken", ())
+      "protocol '_ExpressibleByBuiltinStringLiteral' is broken", ())
 ERROR(string_literal_broken_proto,none,
-      "protocol 'StringLiteralConvertible' is broken", ())
+      "protocol 'ExpressibleByStringLiteral' is broken", ())
 
 ERROR(bool_type_broken,none,
       "could not find a Bool type defined for 'is'", ())
 
 // Array literals
 ERROR(array_protocol_broken,none,
-      "ArrayLiteralConvertible protocol definition is broken", ())
+      "ExpressibleByArrayLiteral protocol definition is broken", ())
 ERROR(type_is_not_array,none,
       "contextual type %0 cannot be used with array literal", (Type))
 NOTE(meant_dictionary_lit,none,
@@ -2096,7 +2096,7 @@ ERROR(should_use_empty_dictionary_literal,none,
 
 // Dictionary literals
 ERROR(dictionary_protocol_broken,none,
-      "DictionaryLiteralConvertible protocol definition is broken", ())
+      "ExpressibleByDictionaryLiteral protocol definition is broken", ())
 ERROR(type_is_not_dictionary,none,
       "contextual type %0 cannot be used with dictionary literal", (Type))