rename object_id to objectid

Author: JeffBezanson

base/asyncmap.jl

@@ -23,11 +23,11 @@ then be a function that must accept a `Vector` of argument tuples and must
 return a vector of results. The input vector will have a length of `batch_size` or less.
 
 The following examples highlight execution in different tasks by returning
-the `object_id` of the tasks in which the mapping function is executed.
+the `objectid` of the tasks in which the mapping function is executed.
 
 First, with `ntasks` undefined, each element is processed in a different task.
 ```
-julia> tskoid() = object_id(current_task());
+julia> tskoid() = objectid(current_task());
 
 julia> asyncmap(x->tskoid(), 1:5)
 5-element Array{UInt64,1}:

base/deprecated.jl

@@ -2799,6 +2799,8 @@ end
 
 @deprecate method_exists hasmethod
 
+@deprecate object_id objectid
+
 # issue #9053
 if Sys.iswindows()
 function Filesystem.tempname(uunique::UInt32)

base/exports.jl

@@ -788,7 +788,7 @@ export
     isimmutable,
     isless,
     ifelse,
-    object_id,
+    objectid,
     sizeof,
 
 # tasks and conditions

base/hashing.jl

@@ -20,7 +20,7 @@ hash(w::WeakRef, h::UInt) = hash(w.value, h)
 
 ## hashing general objects ##
 
-hash(@nospecialize(x), h::UInt) = hash_uint(3h - object_id(x))
+hash(@nospecialize(x), h::UInt) = hash_uint(3h - objectid(x))
 
 ## core data hashing functions ##
 

base/irrationals.jl

@@ -114,7 +114,7 @@ isinteger(::AbstractIrrational) = false
 iszero(::AbstractIrrational) = false
 isone(::AbstractIrrational) = false
 
-hash(x::Irrational, h::UInt) = 3*object_id(x) - h
+hash(x::Irrational, h::UInt) = 3*objectid(x) - h
 
 widen(::Type{T}) where {T<:Irrational} = T
 

base/namedtuple.jl

@@ -101,7 +101,7 @@ isequal(a::NamedTuple, b::NamedTuple) = false
 _nt_names(::NamedTuple{names}) where {names} = names
 _nt_names(::Type{T}) where {names,T<:NamedTuple{names}} = names
 
-hash(x::NamedTuple, h::UInt) = xor(object_id(_nt_names(x)), hash(Tuple(x), h))
+hash(x::NamedTuple, h::UInt) = xor(objectid(_nt_names(x)), hash(Tuple(x), h))
 
 isless(a::NamedTuple{n}, b::NamedTuple{n}) where {n} = isless(Tuple(a), Tuple(b))
 # TODO: case where one argument's names are a prefix of the other's

base/reflection.jl

@@ -216,11 +216,11 @@ macro isdefined(s::Symbol)
 end
 
 """
-    object_id(x)
+    objectid(x)
 
-Get a hash value for `x` based on object identity. `object_id(x)==object_id(y)` if `x === y`.
+Get a hash value for `x` based on object identity. `objectid(x)==objectid(y)` if `x === y`.
 """
-object_id(@nospecialize(x)) = ccall(:jl_object_id, UInt, (Any,), x)
+objectid(@nospecialize(x)) = ccall(:jl_object_id, UInt, (Any,), x)
 
 struct DataTypeLayout
     nfields::UInt32

doc/src/base/base.md

@@ -114,7 +114,7 @@ Core.typeassert
 Core.typeof
 Core.tuple
 Base.ntuple
-Base.object_id
+Base.objectid
 Base.hash
 Base.finalizer
 Base.finalize

doc/src/manual/modules.md

@@ -299,7 +299,7 @@ are a trickier case.  In the common case where the keys are numbers, strings, sy
 `Expr`, or compositions of these types (via arrays, tuples, sets, pairs, etc.) they are safe to
 precompile.  However, for a few other key types, such as `Function` or `DataType` and generic
 user-defined types where you haven't defined a `hash` method, the fallback `hash` method depends
-on the memory address of the object (via its `object_id`) and hence may change from run to run.
+on the memory address of the object (via its `objectid`) and hence may change from run to run.
 If you have one of these key types, or if you aren't sure, to be safe you can initialize this
 dictionary from within your `__init__` function. Alternatively, you can use the `ObjectIdDict`
 dictionary type, which is specially handled by precompilation so that it is safe to initialize
@@ -328,7 +328,7 @@ Other known potential failure scenarios include:
    at the end of compilation. All subsequent usages of this incrementally compiled module will start
    from that same counter value.
 
-   Note that `object_id` (which works by hashing the memory pointer) has similar issues (see notes
+   Note that `objectid` (which works by hashing the memory pointer) has similar issues (see notes
    on `Dict` usage below).
 
    One alternative is to use a macro to capture [`@__MODULE__`](@ref) and store it alone with the current `counter` value,

stdlib/Distributed/src/clusterserialize.jl

@@ -14,7 +14,7 @@ mutable struct ClusterSerializer{I<:IO} <: AbstractSerializer
 
     pid::Int                                     # Worker we are connected to.
     tn_obj_sent::Set{UInt64}                     # TypeName objects sent
-    glbs_sent::Dict{UInt64, UInt64}              # (key,value) -> (object_id, hash_value)
+    glbs_sent::Dict{UInt64, UInt64}              # (key,value) -> (objectid, hash_value)
     glbs_in_tnobj::Dict{UInt64, Vector{Symbol}}  # Track globals referenced in
                                                  # anonymous functions.
     anonfunc_id::UInt64
@@ -116,7 +116,7 @@ function serialize(s::ClusterSerializer, g::GlobalRef)
 end
 
 # Send/resend a global object if
-# a) has not been sent previously, i.e., we are seeing this object_id for the first time, or,
+# a) has not been sent previously, i.e., we are seeing this objectid for the first time, or,
 # b) hash value has changed or
 # c) is a bits type
 function syms_2b_sent(s::ClusterSerializer, identifier)
@@ -128,7 +128,7 @@ function syms_2b_sent(s::ClusterSerializer, identifier)
         if isbits(v)
             push!(lst, sym)
         else
-            oid = object_id(v)
+            oid = objectid(v)
             if haskey(s.glbs_sent, oid)
                 # We have sent this object before, see if it has changed.
                 s.glbs_sent[oid] != hash(sym, hash(v)) && push!(lst, sym)
@@ -143,7 +143,7 @@ end
 function serialize_global_from_main(s::ClusterSerializer, sym)
     v = getfield(Main, sym)
 
-    oid = object_id(v)
+    oid = objectid(v)
     record_v = true
     if isbits(v)
         record_v = false
@@ -179,7 +179,7 @@ function deserialize_global_from_main(s::ClusterSerializer, sym)
 end
 
 function delete_global_tracker(s::ClusterSerializer, v)
-    oid = object_id(v)
+    oid = objectid(v)
     if haskey(s.glbs_sent, oid)
         delete!(s.glbs_sent, oid)
     end

stdlib/Distributed/test/distributed_exec.jl

@@ -1161,8 +1161,8 @@ v6 = FooModEverywhere
         Base.Serializer.serialize_type(s, TestSerCnt)
         serialize(s, t.v)
         global testsercnt_d
-        cnt = get!(testsercnt_d, object_id(t), 0)
-        testsercnt_d[object_id(t)] = cnt+1
+        cnt = get!(testsercnt_d, objectid(t), 0)
+        testsercnt_d[objectid(t)] = cnt+1
     end
 
     Base.deserialize(s::AbstractSerializer, ::Type{TestSerCnt}) = TestSerCnt(deserialize(s))
@@ -1174,22 +1174,22 @@ for i in 1:5
     remotecall_fetch(()->tsc, id_other)
 end
 # should have been serialized only once
-@test testsercnt_d[object_id(tsc)] == 1
+@test testsercnt_d[objectid(tsc)] == 1
 
 # hash values are changed
 n=5
-testsercnt_d[object_id(tsc)] = 0
+testsercnt_d[objectid(tsc)] = 0
 for i in 1:n
     tsc.v[i] = i
     remotecall_fetch(()->tsc, id_other)
 end
 # should have been serialized as many times as the loop
-@test testsercnt_d[object_id(tsc)] == n
+@test testsercnt_d[objectid(tsc)] == n
 
 # Multiple references in a closure should be serialized only once.
 global mrefs = TestSerCnt(fill(1.,10))
 @test remotecall_fetch(()->(mrefs.v, 2*mrefs.v, 3*mrefs.v), id_other) == (fill(1.,10), fill(2.,10), fill(3.,10))
-@test testsercnt_d[object_id(mrefs)] == 1
+@test testsercnt_d[objectid(mrefs)] == 1
 
 
 # nested anon functions
@@ -1239,9 +1239,9 @@ global ids_func = ()->ids_cleanup
 clust_ser = (Distributed.worker_from_id(id_other)).w_serializer
 @test remotecall_fetch(ids_func, id_other) == ids_cleanup
 
-@test haskey(clust_ser.glbs_sent, object_id(ids_cleanup))
+@test haskey(clust_ser.glbs_sent, objectid(ids_cleanup))
 finalize(ids_cleanup)
-@test !haskey(clust_ser.glbs_sent, object_id(ids_cleanup))
+@test !haskey(clust_ser.glbs_sent, objectid(ids_cleanup))
 
 # TODO Add test for cleanup from `clust_ser.glbs_in_tnobj`
 

stdlib/SharedArrays/test/runtests.jl

@@ -284,7 +284,7 @@ finalize(d)
 let
     aorig = a1 = SharedArray{Float64}((3, 3))
     a1 = remotecall_fetch(fill!, id_other, a1, 1.0)
-    @test object_id(aorig) == object_id(a1)
+    @test objectid(aorig) == objectid(a1)
     id = a1.id
     aorig = nothing
     a1 = remotecall_fetch(fill!, id_other, a1, 1.0)

test/asyncmap.jl

@@ -3,13 +3,13 @@
 using Random
 
 # Test asyncmap
-@test allunique(asyncmap(x->(sleep(1.0);object_id(current_task())), 1:10))
+@test allunique(asyncmap(x->(sleep(1.0);objectid(current_task())), 1:10))
 
 # num tasks
-@test length(unique(asyncmap(x->(yield();object_id(current_task())), 1:20; ntasks=5))) == 5
+@test length(unique(asyncmap(x->(yield();objectid(current_task())), 1:20; ntasks=5))) == 5
 
 # default num tasks
-@test length(unique(asyncmap(x->(yield();object_id(current_task())), 1:200))) == 100
+@test length(unique(asyncmap(x->(yield();objectid(current_task())), 1:200))) == 100
 
 # ntasks as a function
 let nt=0
@@ -18,7 +18,7 @@ let nt=0
                                            # nt_func() will be called initally once and then for every
                                            # iteration
 end
-@test length(unique(asyncmap(x->(yield();object_id(current_task())), 1:200; ntasks=nt_func))) == 7
+@test length(unique(asyncmap(x->(yield();objectid(current_task())), 1:200; ntasks=nt_func))) == 7
 
 # batch mode tests
 let ctr=0

test/core.jl

@@ -3477,7 +3477,7 @@ const const_array_int2 = Array{Int}
 test_eq_array_int() = ===(const_array_int1, const_array_int2)
 @test test_eq_array_int()
 
-# object_id of haspadding field
+# objectid of haspadding field
 struct HasPadding
     x::Bool
     y::Int
@@ -3489,7 +3489,7 @@ let hashaspadding = Ref(HasHasPadding(HasPadding(true,1))),
     hashaspadding2 = Ref(HasHasPadding(HasPadding(true,1)))
     unsafe_store!(convert(Ptr{UInt8},pointer_from_objref(hashaspadding)), 0x12, 2)
     unsafe_store!(convert(Ptr{UInt8},pointer_from_objref(hashaspadding2)), 0x21, 2)
-    @test object_id(hashaspadding[]) == object_id(hashaspadding2[])
+    @test objectid(hashaspadding[]) == objectid(hashaspadding2[])
 end
 
 # issue #12517
@@ -3800,7 +3800,7 @@ let
 end
 
 # issue #14564
-@test isa(object_id(Tuple.name.cache), Integer)
+@test isa(objectid(Tuple.name.cache), Integer)
 
 # issue #14691
 mutable struct T14691; a::UInt; end
@@ -5636,7 +5636,7 @@ let x5 = UnionField5(nothing, Int8(3))
     @test x5 == x5
     @test x5 === x5copy
     @test x5 == x5copy
-    @test object_id(x5) === object_id(x5copy)
+    @test objectid(x5) === objectid(x5copy)
     @test hash(x5) === hash(x5copy)
 end
 
@@ -5667,7 +5667,7 @@ let
     @test b === b2 === b3
     @test compare(b, b2)
     @test compare(b, b3)
-    @test object_id(b) === object_id(b2) == object_id(b3)
+    @test objectid(b) === objectid(b2) == objectid(b3)
     @test b.x === Int8(91)
     @test b.z === Int8(23)
     @test b.y === A23367((Int8(1), Int8(2), Int8(3), Int8(4), Int8(5), Int8(6), Int8(7)))

test/hashing.jl

@@ -207,7 +207,7 @@ end
 # issue #20744
 @test hash(:c, hash(:b, hash(:a))) != hash(:a, hash(:b, hash(:c)))
 
-# issue #5849, object_id of types
+# issue #5849, objectid of types
 @test Vector === (Array{T,1} where T)
 @test (Pair{A,B} where A where B) !== (Pair{A,B} where B where A)
 let vals_expr = :(Any[Vector, (Array{T,1} where T), 1, 2, Union{Int, String}, Union{String, Int},
@@ -219,6 +219,6 @@ let vals_expr = :(Any[Vector, (Array{T,1} where T), 1, 2, Union{Int, String}, Un
     vals_b = eval(vals_expr)
     for (i, a) in enumerate(vals_a), (j, b) in enumerate(vals_b)
         @test i != j || (a === b)
-        @test (a === b) == (object_id(a) == object_id(b))
+        @test (a === b) == (objectid(a) == objectid(b))
     end
 end

test/strings/basic.jl

@@ -18,7 +18,7 @@ using Random
     @test codegen_egal_of_strings(string("ab", 'c'), "abc") === (true, false)
     let strs = ["", "a", "a b c", "до свидания"]
         for x in strs, y in strs
-            @test (x === y) == (object_id(x) == object_id(y))
+            @test (x === y) == (objectid(x) == objectid(y))
         end
     end
 end