Add some aliasing warnings to docstrings for mutating functions in Base

base/abstractarray.jl

@@ -3340,7 +3340,7 @@ end
 Like [`map`](@ref), but stores the result in `destination` rather than a new
 collection. `destination` must be at least as large as the smallest collection.
 
-Note that since the `map!` function is intended to operate without making any allocations, the target `destination` must not share memory with any of the sources in `collection...`.
+Note that the order in which the `collection`s are iterated is undefined. This means you should be careful whenever the target `destination` shares memory with any of the `collection`s, because you may get an incorrect result.
 
 See also: [`map`](@ref), [`foreach`](@ref), [`zip`](@ref), [`copyto!`](@ref).
 

base/accumulate.jl

@@ -43,7 +43,7 @@ end
 
 Cumulative sum of `A` along the dimension `dims`, storing the result in `B`. See also [`cumsum`](@ref).
 
-Note that since the `cumsum!` function is intended to operate without making any allocations, the target `B` must not share memory with the source `A`.
+Note that the target `B` must not share memory with the source `A`, otherwise the behavior is undefined.
 """
 cumsum!(B::AbstractArray{T}, A; dims::Integer) where {T} =
     accumulate!(add_sum, B, A, dims=dims)
@@ -153,7 +153,7 @@ cumsum(itr) = accumulate(add_sum, itr)
 Cumulative product of `A` along the dimension `dims`, storing the result in `B`.
 See also [`cumprod`](@ref).
 
-Note that since the `cumprod!` function is intended to operate without making any allocations, the target `B` must not share memory with the source `A`.
+Note that the target `B` must not share memory with the source `A`, otherwise the behavior is undefined.
 """
 cumprod!(B::AbstractArray{T}, A; dims::Integer) where {T} =
     accumulate!(mul_prod, B, A, dims=dims)
@@ -164,7 +164,7 @@ cumprod!(B::AbstractArray{T}, A; dims::Integer) where {T} =
 Cumulative product of a vector `x`, storing the result in `y`.
 See also [`cumprod`](@ref).
 
-Note that since the `cumprod!` function is intended to operate without making any allocations, the target `y` must not share memory with the source `x`.
+Note that the target `y` must not share memory with the source `x`, otherwise the behavior is undefined.
 """
 cumprod!(y::AbstractVector, x::AbstractVector) = cumprod!(y, x, dims=1)
 
@@ -307,7 +307,7 @@ Cumulative operation `op` on `A` along the dimension `dims`, storing the result
 Providing `dims` is optional for vectors.  If the keyword argument `init` is given, its
 value is used to instantiate the accumulation.
 
-Note that since the `accumulate!` function is intended to operate without making any allocations, the target `B` must not share memory with the source `A`.
+Note that the target `B` must not share memory with the source `A`, otherwise the behavior is undefined.
 
 See also [`accumulate`](@ref), [`cumsum!`](@ref), [`cumprod!`](@ref).
 

base/reducedim.jl

@@ -448,7 +448,7 @@ _count(f, A::AbstractArrayOrBroadcasted, dims, init) = mapreduce(_bool(f), add_s
 Count the number of elements in `A` for which `f` returns `true` over the
 singleton dimensions of `r`, writing the result into `r` in-place.
 
-Note that since the `count!` function is intended to operate without making any allocations, the target `r` must not share memory with the source `A`.
+Note that the target `r` must not share memory with the source `A`, otherwise the behavior is undefined.
 
 !!! compat "Julia 1.5"
     inplace `count!` was added in Julia 1.5.
@@ -528,7 +528,7 @@ sum(f, A::AbstractArray; dims)
 
 Sum elements of `A` over the singleton dimensions of `r`, and write results to `r`.
 
-Note that since the `sum!` function is intended to operate without making any allocations, the target `r` must not share memory with the source `A`.
+Note that the target `r` must not share memory with the source `A`, otherwise the behavior is undefined.
 
 # Examples
 ```jldoctest
@@ -603,7 +603,7 @@ prod(f, A::AbstractArray; dims)
 
 Multiply elements of `A` over the singleton dimensions of `r`, and write results to `r`.
 
-Note that since the `prod!` function is intended to operate without making any allocations, the target `r` must not share memory with the source `A`.
+Note that the target `r` must not share memory with the source `A`, otherwise the behavior is undefined.
 
 # Examples
 ```jldoctest
@@ -899,7 +899,7 @@ all(::Function, ::AbstractArray; dims)
 
 Test whether all values in `A` along the singleton dimensions of `r` are `true`, and write results to `r`.
 
-Note that since the `all!` function is intended to operate without making any allocations, the target `r` must not share memory with the source `A`.
+Note that the target `r` must not share memory with the source `A`, otherwise the behavior is undefined.
 
 # Examples
 ```jldoctest
@@ -974,7 +974,7 @@ any(::Function, ::AbstractArray; dims)
 Test whether any values in `A` along the singleton dimensions of `r` are `true`, and write
 results to `r`.
 
-Note that since the `any!` function is intended to operate without making any allocations, the target `r` must not share memory with the source `A`.
+Note that the target `r` must not share memory with the source `A`, otherwise the behavior is undefined.
 
 # Examples
 ```jldoctest

stdlib/LinearAlgebra/src/matmul.jl

@@ -216,7 +216,7 @@ end
 
 Calculates the matrix-matrix or matrix-vector product `AB` and stores the result in `Y`, overwriting the existing value of `Y`.
 
-Note that `Y` must not share memory with either `A` or `B`.
+Note that the target `Y` must not share memory with either `A` or `B`, otherwise the behavior is undefined.
 
 # Examples
 ```jldoctest