[stdlib] Add "Mutable" to [Autoreleasing]UnsafePointer

UnsafePointer becomes UnsafeMutablePointer
AutoreleasingUnsafePointer becomes AutoreleasingUnsafeMutablePointer

Swift SVN r20316

Author: Dave Abrahams

docs/proposals/C Pointer Argument Interop.rst

@@ -13,12 +13,12 @@ arguments:
 
 - Const pointer arguments ``const int *``, including const pointers to ObjC
   classes ``NSFoo * const *``, can be used as "in" array arguments, 
-  as ``inout`` scalar arguments, or as ``UnsafePointer`` arguments.
+  as ``inout`` scalar arguments, or as ``UnsafeMutablePointer`` arguments.
 - Non-const pointer arguments to C types, ``int *``, can be used as ``inout``
-  array or scalar arguments, or as ``UnsafePointer`` arguments.
+  array or scalar arguments, or as ``UnsafeMutablePointer`` arguments.
 - Non-const pointer arguments to ObjC class types, ``NSFoo **``, can be used as
   ``inout`` scalar arguments or passed ``nil``. (They cannot be used as
-  array arguments or as ``UnsafePointer`` arguments.)
+  array arguments or as ``UnsafeMutablePointer`` arguments.)
 - ``const void *`` and ``void *`` pointers can be used in the same ways as
   pointers to any C type (but not ObjC types).
 
@@ -162,7 +162,7 @@ Pointer Return Values
 ---------------------
 
 This proposal does not address the handling of return values, which should still
-be imported into Swift as ``UnsafePointer`` values.
+be imported into Swift as ``UnsafeMutablePointer`` values.
 
 
 Library Features
@@ -178,17 +178,17 @@ their implicit conversions. The necessary types are as follows:
 - ``CConstPointer<T>`` is the imported representation of a ``const T *``
   argument. It is implicitly convertible from ``inout T`` by inout address
   conversion and from ``Array<T>`` by immutable interior pointer
-  conversion. It is also implicitly convertible to and from ``UnsafePointer<T>``
+  conversion. It is also implicitly convertible to and from ``UnsafeMutablePointer<T>``
   by normal conversion.
 - ``CMutablePointer<T>`` is the imported representation of a ``T *``
   argument for a POD C type ``T``. It is implicitly convertible from
   ``inout T`` by inout address conversion and from ``inout Array<T>`` by mutating
   interior pointer conversion. It is also implicitly convertible to and from
-  ``UnsafePointer<T>`` by normal conversion.
+  ``UnsafeMutablePointer<T>`` by normal conversion.
 - ``ObjCInOut<T>`` is the imported representation of a ``T **``
   argument for an ObjC class type ``T``. It is implicitly convertible from
   ``inout T`` by inout writeback conversion and is implicitly convertible
-  from ``nil``. It cannot be converted from an array or to ``UnsafePointer``.
+  from ``nil``. It cannot be converted from an array or to ``UnsafeMutablePointer``.
 
 New Language Features
 =====================

docs/proposals/C Pointer Interop Language Model.rst

@@ -4,7 +4,7 @@ We have a pretty good user model for C pointer interop now, but the language
 model still needs improvement. Building the user model on top of implicit
 conversions has a number of undesirable side effects. We end up with a mess of
 pointer types—the intended user-facing, one-word pointer types
-``UnsafePointer`` and ``COpaquePointer``, which expose a full pointer-ish API
+``UnsafeMutablePointer`` and ``COpaquePointer``, which expose a full pointer-ish API
 and are naturally ABI-compatible with C pointers; and the bridging pointer
 types, ``ObjCMutablePointer``, ``CMutablePointer``, ``CConstPointer``,
 ``CMutableVoidPointer``, and ``CConstVoidPointer``, which have no real API yet
@@ -25,18 +25,18 @@ The Pointer Types
 In the standard library, we provide three pointer types:
 
 - ``ConstUnsafePointer<T>``, corresponding to ``T const *`` in C and ARC,
-- ``UnsafePointer<T>``, corresponding to ``T *`` in C, and ``T* __strong *`` in
+- ``UnsafeMutablePointer<T>``, corresponding to ``T *`` in C, and ``T* __strong *`` in
   ARC for class types, and
-- ``AutoreleasingUnsafePointer<T>`` (for all ``T: AnyObject``), corresponding
+- ``AutoreleasingUnsafeMutablePointer<T>`` (for all ``T: AnyObject``), corresponding
   to ``T* __autoreleasing *`` in ARC.
 
 These types are all one word, have no ownership semantics, and share a common
 interface. ``ConstUnsafePointer`` does not expose operations for storing to the
-referenced memory. ``UnsafePointer`` and ``AutoreleasingUnsafePointer`` differ
-in store behavior: ``UnsafePointer`` assumes that the pointed-to reference has
+referenced memory. ``UnsafeMutablePointer`` and ``AutoreleasingUnsafeMutablePointer`` differ
+in store behavior: ``UnsafeMutablePointer`` assumes that the pointed-to reference has
 ownership semantics, so ``ptr.initialize(x)`` consumes a reference to ``x``,
 and ``ptr.assign(x)`` releases the originally stored value before storing the
-new value.  ``AutoreleasingUnsafePointer`` assumes that the pointed-to
+new value.  ``AutoreleasingUnsafeMutablePointer`` assumes that the pointed-to
 reference does not have ownership semantics, so values are autoreleased before
 being stored by either initialize() or assign(), and no release is done on
 reassignment. Loading from any of the three kinds of pointer does a strong
@@ -47,31 +47,31 @@ Conversion behavior for pointer arguments
 
 The user model for pointer arguments becomes an inherent capability of function applications. The rules are:
 
-UnsafePointer<T>
-----------------
+UnsafeMutablePointer<T>
+-----------------------
 
-When a function is declared as taking an ``UnsafePointer<T>`` argument, it can
+When a function is declared as taking an ``UnsafeMutablePointer<T>`` argument, it can
 accept any of the following:
 
 - ``nil``, which is passed as a null pointer,
-- an ``UnsafePointer<T>`` value, which is passed verbatim,
+- an ``UnsafeMutablePointer<T>`` value, which is passed verbatim,
 - an inout expression whose operand is a stored lvalue of type ``T``, which is
   passed as the address of the lvalue, or
 - an inout ``Array<T>`` value, which is passed as a pointer to the start of the
   array, and lifetime-extended for the duration of the callee.
 
 As a special case, when a function is declared as taking an
-``UnsafePointer<Void>`` argument, it can accept the same operands as
-``UnsafePointer<T>`` for any type T.
+``UnsafeMutablePointer<Void>`` argument, it can accept the same operands as
+``UnsafeMutablePointer<T>`` for any type T.
 
 So if you have a function declared::
 
-  func foo(x: UnsafePointer<Float>)
+  func foo(x: UnsafeMutablePointer<Float>)
 
 You can call it as any of::
 
   var x: Float = 0.0
-  var p: UnsafePointer<Float> = nil
+  var p: UnsafeMutablePointer<Float> = nil
   var a: Float[] = [1.0, 2.0, 3.0]
   foo(nil)
   foo(p)
@@ -80,12 +80,12 @@ You can call it as any of::
 
 And if you have a function declared::
 
-  func bar(x: UnsafePointer<Void>)
+  func bar(x: UnsafeMutablePointer<Void>)
 
 You can call it as any of::
 
   var x: Float = 0.0, y: Int = 0
-  var p: UnsafePointer<Float> = nil, q: UnsafePointer<Int> = nil
+  var p: UnsafeMutablePointer<Float> = nil, q: UnsafeMutablePointer<Int> = nil
   var a: Float[] = [1.0, 2.0, 3.0], b: Int = [1, 2, 3]
   bar(nil)
   bar(p)
@@ -95,14 +95,14 @@ You can call it as any of::
   bar(&a)
   bar(&b)
 
-AutoreleasingUnsafePointer<T>
------------------------------
+AutoreleasingUnsafeMutablePointer<T>
+------------------------------------
 
-When a function is declared as taking an ``AutoreleasingUnsafePointer<T>``, it
+When a function is declared as taking an ``AutoreleasingUnsafeMutablePointer<T>``, it
 can accept any of the following:
 
 - nil, which is passed as a null pointer,
-- an ``AutoreleasingUnsafePointer<T>`` value, which is passed verbatim, or
+- an ``AutoreleasingUnsafeMutablePointer<T>`` value, which is passed verbatim, or
 - an inout expression, whose operand is primitive-copied to a temporary
   nonowning buffer. The address of that buffer is passed to the callee, and on
   return, the value in the buffer is loaded, retained, and reassigned into the
@@ -112,25 +112,25 @@ Note that the above list does not include arrays, since implicit autoreleasing-t
 
 So if you have a function declared::
 
-  func bas(x: AutoreleasingUnsafePointer<NSBas?>)
+  func bas(x: AutoreleasingUnsafeMutablePointer<NSBas?>)
 
 You can call it as any of::
 
   var x: NSBas? = nil
-  var p: AutoreleasingUnsafePointer<NSBas?> = nil
+  var p: AutoreleasingUnsafeMutablePointer<NSBas?> = nil
   bas(nil)
   bas(p)
   bas(&x)
 
 ConstUnsafePointer<T>
 ---------------------
 
-When a function is declared as taking an ``UnsafePointer<T>`` argument, it can
+When a function is declared as taking an ``UnsafeMutablePointer<T>`` argument, it can
 accept any of the following:
 
 - nil, which is passed as a null pointer,
-- an ``UnsafePointer<T>``, ``ConstUnsafePointer<T>``, or
-  ``AutoreleasingUnsafePointer<T>`` value, which is converted to
+- an ``UnsafeMutablePointer<T>``, ``ConstUnsafePointer<T>``, or
+  ``AutoreleasingUnsafeMutablePointer<T>`` value, which is converted to
   ``ConstUnsafePointer<T>`` if necessary and passed verbatim,
 - an inout expression whose operand is an lvalue of type ``T``, which is passed
   as the address of (the potentially temporary writeback buffer of) the lvalue,

docs/proposals/C Pointer Interop.rst

@@ -13,12 +13,12 @@ arguments:
 
 - Const pointer arguments ``const int *``, including const pointers to ObjC
   classes ``NSFoo * const *``, can be used as "in" array arguments, 
-  as ``inout`` scalar arguments, or as ``UnsafePointer`` arguments.
+  as ``inout`` scalar arguments, or as ``UnsafeMutablePointer`` arguments.
 - Non-const pointer arguments to C types, ``int *``, can be used as ``inout``
-  array or scalar arguments, or as ``UnsafePointer`` arguments.
+  array or scalar arguments, or as ``UnsafeMutablePointer`` arguments.
 - Non-const pointer arguments to ObjC class types, ``NSFoo **``, can be used as
   ``inout`` scalar arguments or passed ``nil``. (They cannot be used as
-  array arguments or as ``UnsafePointer`` arguments.)
+  array arguments or as ``UnsafeMutablePointer`` arguments.)
 - ``const void *`` and ``void *`` pointers can be used in the same ways as
   pointers to any C type (but not ObjC types).
 
@@ -105,7 +105,7 @@ Pointer Return Values
 ---------------------
 
 This proposal does not address the handling of return values, which should still
-be imported into Swift as ``UnsafePointer`` values.
+be imported into Swift as ``UnsafeMutablePointer`` values.
 
 
 Library Features
@@ -122,13 +122,13 @@ types are as follows:
 - ``CConstPointer<T>`` is the imported representation of a ``const T *``
   argument. It is implicitly convertible from ``inout T`` by inout address
   conversion and from ``Array<T>`` by immutable interior pointer
-  conversion. It is also implicitly convertible to and from ``UnsafePointer<T>``
+  conversion. It is also implicitly convertible to and from ``UnsafeMutablePointer<T>``
   by normal conversion.
 - ``CMutablePointer<T>`` is the imported representation of a ``T *``
   argument for a POD C type ``T``. It is implicitly convertible from
   ``inout T`` by inout address conversion and from ``inout Array<T>`` by mutating
   interior pointer conversion. It is also implicitly convertible to and from
-  ``UnsafePointer<T>`` by normal conversion.
+  ``UnsafeMutablePointer<T>`` by normal conversion.
 - ``CConstVoidPointer`` and ``CMutableVoidPointer`` are the imported
   representations of ``const void *`` and ``void *`` respectively.
   They are implicitly convertible by normal conversion from, respectively,
@@ -137,7 +137,7 @@ types are as follows:
 - ``ObjCInOut<T>`` is the imported representation of a ``T **``
   argument for an ObjC class type ``T``. It is implicitly convertible from
   ``inout T`` by inout writeback conversion and is implicitly convertible
-  from ``nil``. It cannot be converted from an array or to ``UnsafePointer``.
+  from ``nil``. It cannot be converted from an array or to ``UnsafeMutablePointer``.
 
 New Language Features
 =====================

docs/proposals/DocumentationComments.rst

@@ -255,7 +255,7 @@ through C interfaces.
 Proposed syntax::
 
   /// \param [out] extraResult Set to zero if...
-  func foo(extraResult: UnsafePointer<Int>) -> Int {
+  func foo(extraResult: UnsafeMutablePointer<Int>) -> Int {
   }
 
 [P4] documentation for parameters of closures that are function parameters

include/swift/AST/ASTContext.h

@@ -373,14 +373,14 @@ class ASTContext {
   EnumElementDecl *getOptionalSomeDecl(OptionalTypeKind kind) const;
   EnumElementDecl *getOptionalNoneDecl(OptionalTypeKind kind) const;
 
-  /// Retrieve the declaration of Swift.UnsafePointer<T>.
-  NominalTypeDecl *getUnsafePointerDecl() const;
+  /// Retrieve the declaration of Swift.UnsafeMutablePointer<T>.
+  NominalTypeDecl *getUnsafeMutablePointerDecl() const;
 
   /// Retrieve the declaration of Swift.ConstUnsafePointer<T>.
   NominalTypeDecl *getConstUnsafePointerDecl() const;
 
-  /// Retrieve the declaration of Swift.AutoreleasingUnsafePointer<T>.
-  NominalTypeDecl *getAutoreleasingUnsafePointerDecl() const;
+  /// Retrieve the declaration of Swift.AutoreleasingUnsafeMutablePointer<T>.
+  NominalTypeDecl *getAutoreleasingUnsafeMutablePointerDecl() const;
 
   /// Retrieve the declaration of Swift.CFunctionPointer<T>.
   NominalTypeDecl *getCFunctionPointerDecl() const;
@@ -422,7 +422,7 @@ class ASTContext {
   bool hasOptionalIntrinsics(LazyResolver *resolver) const;
 
   /// Check whether the standary library provides all the correct
-  /// intrinsic support for UnsafePointer<T> function arguments.
+  /// intrinsic support for UnsafeMutablePointer<T> function arguments.
   ///
   /// If this is true, the methods to getConvert*ToPointerArgument
   bool hasPointerArgumentIntrinsics(LazyResolver *resolver) const;

include/swift/AST/Decl.h

@@ -2428,9 +2428,9 @@ enum { NumOptionalTypeKinds = 2 };
 
 // Kinds of pointer types.
 enum PointerTypeKind : unsigned {
-  PTK_UnsafePointer,
+  PTK_UnsafeMutablePointer,
   PTK_ConstUnsafePointer,
-  PTK_AutoreleasingUnsafePointer,
+  PTK_AutoreleasingUnsafeMutablePointer,
 };
 
 /// An implicitly created member decl, used when importing a Clang enum type.

include/swift/AST/DiagnosticsSema.def

@@ -1306,7 +1306,7 @@ ERROR(optional_intrinsics_not_found,sema_tct,none,
       "Optional<T>", ())
 ERROR(pointer_argument_intrinsics_not_found,sema_tct,none,
       "broken standard library: cannot find intrinsic operations on "
-      "UnsafePointer<T>", ())
+      "UnsafeMutablePointer<T>", ())
 ERROR(bool_intrinsics_not_found,sema_tct,none,
       "broken standard library: cannot find intrinsic operations on Bool", ())
 ERROR(unchecked_not_optional_type,sema_tct,none,

include/swift/AST/Types.h

@@ -417,8 +417,8 @@ class alignas(8) TypeBase {
   /// its list of protocols.
   void getAnyExistentialTypeProtocols(SmallVectorImpl<ProtocolDecl *> &protocols);
 
-  /// Determines the element type of a known *UnsafePointer variant, or returns
-  /// null if the type is not a pointer.
+  /// Determines the element type of a known *UnsafeMutablePointer
+  /// variant, or returns null if the type is not a pointer.
   Type getAnyPointerElementType(PointerTypeKind &PTK);
   Type getAnyPointerElementType() {
     PointerTypeKind Ignore;

include/swift/Runtime/Reflection.h

@@ -36,7 +36,7 @@ extern "C" Mirror
 swift_reflectAny(OpaqueValue *value, const Metadata *T);
 
 /// func unsafeReflect<T>(owner: Builtin.NativeObject,
-///                       x: UnsafePointer<T>) -> Mirror
+///                       x: UnsafeMutablePointer<T>) -> Mirror
 ///
 /// Produce a mirror for any value. If the value's type conforms to Reflectable,
 /// invoke its getMirror() method; otherwise, fall back to an implementation

lib/AST/ASTContext.cpp

@@ -83,14 +83,14 @@ struct ASTContext::Implementation {
   /// The declaration of Swift.ImplicitlyUnwrappedOptional<T>.None.
   EnumElementDecl *ImplicitlyUnwrappedOptionalNoneDecl = nullptr;
 
-  /// The declaration of Swift.UnsafePointer<T>.
-  NominalTypeDecl *UnsafePointerDecl = nullptr;
+  /// The declaration of Swift.UnsafeMutablePointer<T>.
+  NominalTypeDecl *UnsafeMutablePointerDecl = nullptr;
 
   /// The declaration of Swift.ConstUnsafePointer<T>.
   NominalTypeDecl *ConstUnsafePointerDecl = nullptr;
 
-  /// The declaration of Swift.AutoreleasingUnsafePointer<T>.
-  NominalTypeDecl *AutoreleasingUnsafePointerDecl = nullptr;
+  /// The declaration of Swift.AutoreleasingUnsafeMutablePointer<T>.
+  NominalTypeDecl *AutoreleasingUnsafeMutablePointerDecl = nullptr;
 
   /// The declaration of Swift.CFunctionPointer<T -> U>.
   NominalTypeDecl *CFunctionPointerDecl = nullptr;
@@ -533,11 +533,12 @@ EnumElementDecl *ASTContext::getImplicitlyUnwrappedOptionalNoneDecl() const {
   return Impl.ImplicitlyUnwrappedOptionalNoneDecl;
 }
 
-NominalTypeDecl *ASTContext::getUnsafePointerDecl() const {
-  if (!Impl.UnsafePointerDecl)
-    Impl.UnsafePointerDecl = findSyntaxSugarImpl(*this, "UnsafePointer");
+NominalTypeDecl *ASTContext::getUnsafeMutablePointerDecl() const {
+  if (!Impl.UnsafeMutablePointerDecl)
+    Impl.UnsafeMutablePointerDecl = findSyntaxSugarImpl(
+      *this, "UnsafeMutablePointer");
 
-  return Impl.UnsafePointerDecl;
+  return Impl.UnsafeMutablePointerDecl;
 }
 
 NominalTypeDecl *ASTContext::getConstUnsafePointerDecl() const {
@@ -548,12 +549,12 @@ NominalTypeDecl *ASTContext::getConstUnsafePointerDecl() const {
   return Impl.ConstUnsafePointerDecl;
 }
 
-NominalTypeDecl *ASTContext::getAutoreleasingUnsafePointerDecl() const {
-  if (!Impl.AutoreleasingUnsafePointerDecl)
-    Impl.AutoreleasingUnsafePointerDecl
-      = findSyntaxSugarImpl(*this, "AutoreleasingUnsafePointer");
+NominalTypeDecl *ASTContext::getAutoreleasingUnsafeMutablePointerDecl() const {
+  if (!Impl.AutoreleasingUnsafeMutablePointerDecl)
+    Impl.AutoreleasingUnsafeMutablePointerDecl
+      = findSyntaxSugarImpl(*this, "AutoreleasingUnsafeMutablePointer");
 
-  return Impl.AutoreleasingUnsafePointerDecl;
+  return Impl.AutoreleasingUnsafeMutablePointerDecl;
 }
 
 NominalTypeDecl *ASTContext::getCFunctionPointerDecl() const {
@@ -884,9 +885,9 @@ bool ASTContext::hasOptionalIntrinsics(LazyResolver *resolver) const {
 }
 
 bool ASTContext::hasPointerArgumentIntrinsics(LazyResolver *resolver) const {
-  return getUnsafePointerDecl()
+  return getUnsafeMutablePointerDecl()
     && getConstUnsafePointerDecl()
-    && getAutoreleasingUnsafePointerDecl()
+    && getAutoreleasingUnsafeMutablePointerDecl()
     && getConvertPointerToPointerArgument(resolver)
     && getConvertMutableArrayToPointerArgument(resolver)
     && getConvertConstArrayToPointerArgument(resolver)