Add support for automatically calling unsafe_load() in getproperty() #502

JamesWrigley · 2024-07-06T19:21:07Z

Copying the description from the code:

By default the getproperty!(x::Ptr, ::Symbol) methods created for wrapped
types will return pointers (Ptr{T}) to the struct fields. That behaviour is
useful for accessing nested struct fields but it does require explicitly
calling unsafe_load() every time. When enabled this option will automatically
call unsafe_load() for you except on nested struct fields and arrays, which
should make explicitly calling unsafe_load() unnecessary in most cases.

Here's the generated code for the struct-properties.h header in the tests:

using CEnum: CEnum, @cenum                                                                                                                                                                                                           [75/97867]
                                                                                                                                                                                                                                               
struct TypedefStruct                                                                                                                                                                                                                           
    i::Cint                                                                                                                                                                                                                                    
end                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                               
struct Other                                                                                                                                                                                                                                   
    i::Cint                                                                                                                                                                                                                                    
end                                                                                                                                                                                                                                            
function _getptr(x::Ptr{Other}, f::Symbol)                                                                                                                                                                                                     
    f === :i && return Ptr{Cint}(x + 0)                                                                                                                                                                                                        
    error("Unrecognized field of type `Other`" * ": $(f)")                                                                                                                                                                                     
end                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                               
function Base.getproperty(x::Ptr{Other}, f::Symbol)                                                                                                                                                                                            
    f === :i && return unsafe_load(_getptr(x, f))                                                                                                                                                                                              
    return getfield(x, f)                                                                                                                                                                                                                      
end                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                               
function Base.setproperty!(x::Ptr{Other}, f::Symbol, v)                                                                                                                                                                                        
    unsafe_store!(_getptr(x, f), v)                                                                                                                                                                                                            
end                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                               
mutable struct WithFields                                                                                                                                                                                                                      
    int_value::Cint                                                                                                                                                                                                                            
    int_ptr::Ptr{Cint}                                                                                                                                                                                                                         
    struct_value::Other                                                                                                                                                                                                                        
    struct_ptr::Ptr{Other}                                                                                                                                                                                                                     
    typedef_struct_value::TypedefStruct                                                                                                                                                                                                        
    array::NTuple{2, Cint}                                                                                                                                                                                                                     
end                                                                                                                                                                                                                                            
function _getptr(x::Ptr{WithFields}, f::Symbol)
    f === :int_value && return Ptr{Cint}(x + 0)
    f === :int_ptr && return Ptr{Ptr{Cint}}(x + 8)
    f === :struct_value && return Ptr{Other}(x + 16)
    f === :struct_ptr && return Ptr{Ptr{Other}}(x + 24)
    f === :typedef_struct_value && return Ptr{TypedefStruct}(x + 32)
    f === :array && return Ptr{NTuple{2, Cint}}(x + 36)
    error("Unrecognized field of type `WithFields`" * ": $(f)")
end

function Base.getproperty(x::Ptr{WithFields}, f::Symbol)
    f === :int_value && return unsafe_load(_getptr(x, f))
    f === :int_ptr && return unsafe_load(_getptr(x, f))
    f === :struct_value && return _getptr(x, f)
    f === :struct_ptr && return unsafe_load(_getptr(x, f))
    f === :typedef_struct_value && return _getptr(x, f)
    f === :array && return _getptr(x, f)
    return getfield(x, f)
end

function Base.setproperty!(x::Ptr{WithFields}, f::Symbol, v)
    unsafe_store!(_getptr(x, f), v)
end

I've also tested it with CImGui.jl: JuliaImGui/CImGui.jl#131
I will admit the code is a bit hairy 🐙 Not sure if it's the cleanest implementation.

EDIT: marked as a draft because JET.jl found some issues with it.

JamesWrigley · 2024-07-07T23:54:47Z

The problem JET found was in how bitfields are handled, I believe that's fixed now. My approach was to:

Move the get/set code for bitfields into standalone functions in 129555d.
Have Base.getproperty(x::T, f) and Base.getproperty(x::Ptr{T}, f) both call those functions, so they should both behave the same.

One downside I noticed when playing around with the new wrappers in CImGui is that when we want to write to the struct we really do want to get a pointer instead of unsafe_load()'ing it automatically, e.g.:

# io.ConfigFlags is now a Cint, but we really want a Ptr{Cint}
CImGui.CheckboxFlags("io.ConfigFlags: NavEnableKeyboard", io.ConfigFlags, CImGui.ImGuiConfigFlags_NavEnableKeyboard)

The simple fix there would be to use _getptr(io, :ConfigFlags), but that's rather unsatisfying. So I had an evil thought 😛 What if we add a third parameter to our Base.getproperty() methods, like Base.getproperty(x::Ptr{T}, f::Symbol, as_ptr::Bool=false), and implement a @ptr macro that turns @ptr foo.bar into Base.getproperty(foo, :bar, true)? Then folks could write e.g. @ptr io.ConfigFlags whenever they want a pointer.

On a side note, turns out that all of our wrappers are fantastically inferrable so JET is very good at finding problems with them :)

Gnimuc · 2024-07-08T10:51:15Z

What's the behavior of loading a chain of pointers?

JamesWrigley · 2024-07-08T12:21:04Z

There's an example of that in the tests with @test obj_ptr.struct_value.i == obj.struct_value.i. The rule is that the dereferencing only occurs if the field type isn't a struct or array, so if there's a chain of nested structs Base.getproperty() will return a pointer to each of them just like the current behaviour. But if there's a non-struct/array type at the end of the chain, like an int, then that field will be dereferenced and Base.getproperty() on it will return a Cint.

Gnimuc · 2024-07-08T12:30:32Z

The rule is that the dereferencing only occurs if the field type isn't a struct or array,

I'm pretty sure this gonna confuse newbies, probably LLMs too...

Gnimuc · 2024-07-08T12:38:49Z

see https://giordano.github.io/blog/2019-05-03-julia-get-pointer-value/ for a hack of dereference operator in Julia.

JamesWrigley · 2024-07-08T12:53:52Z

I'm pretty sure this gonna confuse newbies, probably LLMs too...

I actually think it'll make it easier for newbies since they can blindly access nested properties and always get the right result. A good example of this is something like an ImVec2 field:

struct Foo
    vec::ImVec2
end

Currently to access .x and .y they would need to do:

vec = unsafe_load(obj.vec)
vec.x, vec.y

Whereas with this PR they can simply do obj.vec.x and obj.vec.y. In any case, the feature is off by default so folks will have to explicitly opt in to use it. And I confess I don't care very much about LLM's 😛

see https://giordano.github.io/blog/2019-05-03-julia-get-pointer-value/ for a hack of dereference operator in Julia.

That's interesting, but it still makes reading fields harder than writing to them. In my experience fields are read more often than written to, so I think it makes sense to sacrifice some write syntax for the sake of making reads simpler.

Gnimuc · 2024-07-08T13:17:30Z

hmm... I kinda agree, but if some packages adopt one rule but not the other, there could be a Vim-vs-Emacs war in the future... 😄 however, I don't think that's something we can control. and it's not easy to implement this feature out of the source tree, so it's ok to merge I guess.

JamesWrigley · 2024-07-08T13:25:27Z

I would actually like to make this the default at some point in the future 👀 But that would be wildly breaking so we should probably wait to see if people actually like it first.

But getting a pointer to a field is still a bit tricky :\ What do you think about this idea?

The simple fix there would be to use _getptr(io, :ConfigFlags), but that's rather unsatisfying. So I had an evil thought 😛 What if we add a third parameter to our Base.getproperty() methods, like Base.getproperty(x::Ptr{T}, f::Symbol, as_ptr::Bool=false), and implement a @ptr macro that turns @ptr foo.bar into Base.getproperty(foo, :bar, true)? Then folks could write e.g. @ptr io.ConfigFlags whenever they want a pointer.

Gnimuc · 2024-07-08T13:41:10Z

If it needs another macro anyway, I would rather integrate auto-dereference in the macro as well.

I implemented @c macro in https://github.com/Gnimuc/CSyntax.jl to mimic the & operator in C.

Maybe it can be extended to call some particular field access methods generated by Clang.jl. In this way, the field access behavior are kept as-is, and end users get a handy macro.

Gnimuc · 2024-07-08T13:43:56Z

the main point here is that we can turn @ptr foo.bar into any custom function call, there is not necessary to pirates Base.getproperty.

JamesWrigley · 2024-07-08T14:09:58Z

Yeah @c would actually be perfect 🤔 Unless I'm mistaken, I think we do need to use Base.getproperty() though? The reason is that some code living outside of the bindings has no other way to know which getptr() function to call. For example:

module MyPackage

module lib
include("../bindings.jl")
end

using CSyntax
x() = @c lib.foo().bar

Presumably the field access methods are in lib, but @c has no idea about that so it can't know it has to put in a call to lib.getptr instead of getptr. An alternative would be to define methods of functions defined in either Clang.jl or CSyntax.jl or CEnum.jl, but that would make either package a hard dependency.

Gnimuc · 2024-07-08T14:27:56Z

Presumably the field access methods are in lib, but @c has no idea about that so it can't know it has to put in a call to lib.getptr instead of getptr. An alternative would be to define methods of functions defined in either Clang.jl or CSyntax.jl or CEnum.jl, but that would make either package a hard dependency.

parentmodule(typeof(Foo())).getptr can do the trick.

Gnimuc · 2024-07-08T14:39:23Z

julia> module Foo
         struct Bar
            x::Int
         end
         getx(x::Bar) = "x"
         export Bar
       end
Main.Foo

julia> using .Foo

julia> @generated function getxxx(x::T) where {T}
         mod = parentmodule(T)
         :($mod.getx(x))
       end
getxxx (generic function with 1 method)

julia> macro c(x, ex...)
        :(getxxx($(esc(x))))
       end
@c (macro with 1 method)

julia> @c Bar(1)
"x"

JamesWrigley · 2024-07-08T14:45:32Z

Ah, nice 👍 And with luck that'll constant fold away.

JamesWrigley · 2024-07-15T21:21:54Z

I ended up implementing @ptr in the module itself in 89be1a6 because then we can just use @__MODULE__.

Latest codegen

using CEnum: CEnum, @cenum

macro ptr(expr)
    if !isa(expr, Expr) || expr.head != :.
        error("Expression is not a property access")
    end

    quote
        local penultimate_obj = $(esc(expr.args[1]))
        (@__MODULE__).getptr(penultimate_obj, $(esc(expr.args[2])))
    end
end

struct TypedefStruct
    i::Cint
end

struct Other
    i::Cint
end
function getptr(x::Ptr{Other}, f::Symbol)
    f === :i && return Ptr{Cint}(x + 0)
    error("Unrecognized field of type `Other`" * ": $(f)")
end

function Base.getproperty(x::Ptr{Other}, f::Symbol)
    f === :i && return unsafe_load(getptr(x, f))
    return getfield(x, f)
end

function Base.setproperty!(x::Ptr{Other}, f::Symbol, v)
    unsafe_store!(getptr(x, f), v)
end


mutable struct WithFields
    int_value::Cint
    int_ptr::Ptr{Cint}
    struct_value::Other
    struct_ptr::Ptr{Other}
    typedef_struct_value::TypedefStruct
    array::NTuple{2, Cint}
end
function getptr(x::Ptr{WithFields}, f::Symbol)
    f === :int_value && return Ptr{Cint}(x + 0)
    f === :int_ptr && return Ptr{Ptr{Cint}}(x + 8)
    f === :struct_value && return Ptr{Other}(x + 16)
    f === :struct_ptr && return Ptr{Ptr{Other}}(x + 24)
    f === :typedef_struct_value && return Ptr{TypedefStruct}(x + 32)
    f === :array && return Ptr{NTuple{2, Cint}}(x + 36)
    error("Unrecognized field of type `WithFields`" * ": $(f)")
end

function Base.getproperty(x::Ptr{WithFields}, f::Symbol)
    f === :int_value && return unsafe_load(getptr(x, f))
    f === :int_ptr && return unsafe_load(getptr(x, f))
    f === :struct_value && return getptr(x, f)
    f === :struct_ptr && return unsafe_load(getptr(x, f))
    f === :typedef_struct_value && return getptr(x, f)
    f === :array && return getptr(x, f)
    return getfield(x, f)
end

function Base.setproperty!(x::Ptr{WithFields}, f::Symbol, v)
    unsafe_store!(getptr(x, f), v)
end

I want to play around with it a bit more in CImGui.jl before merging, but what do you think?

JamesWrigley · 2024-07-15T21:28:47Z

Hmm, looks like nightly is broken:

Because BinaryBuilderBase.jl is broken on nightly: https://github.com/JuliaPackaging/BinaryBuilderBase.jl/blob/406ec5c26348a7965cdc35aba15c03f84c02b525/src/BinaryBuilderBase.jl#L226
- Because nightly just bumped Pkg: 🤖 [master] Bump the Pkg stdlib from 8c996799b to 046df8ce4 JuliaLang/julia#55112
  - And Pkg just changed an internal variable: Use historical stdlib dependency information JuliaLang/Pkg.jl#3911

Gnimuc · 2024-07-16T14:16:42Z

IIUC, with the new flag off, we can get the same output as before, right?

JamesWrigley · 2024-07-16T20:35:34Z

Almost the same, the only difference is that with 129555d the logic for bitfields will be in standalone getbitfieldproperty()/setbitfieldproperty!() functions instead of being inline with Base.getproperty()/Base.setproperty!(). But the behaviour should be identical 🤞 I already added a test for that in the bitfield tests in 2e7e00d, but I'll add some more to make it doesn't regress.

EDIT: added some tests for the default behaviour in 73ed7ff.

Gnimuc · 2024-07-17T12:19:00Z

I don't know how many people are using this package. But let’s take a poll and see if there are any unexpected problems.

This PR provides an alternative method for field access.

The default behavior is that accessing a field always returns a Ptr and one needs to call unsafe_load manually to load/copy the value.

The opt-in behavior provided by this PR is that:

Accessing a field will automatically call unsafe_load to load/copy the value if the field type isn't a struct or array.
When a pointer is needed, the macro @ptr needs to be called manually.
The rest of the behavior is the same as the default behavior.

Please leave a 👍🏻 or 👎🏻 reaction, and any feedback is appreciated.

JamesWrigley · 2024-07-17T15:47:42Z

Sounds good :) In the meantime I'll try fixing nightly.

JamesWrigley · 2024-07-21T17:42:36Z

Alrighty, now we're back in the green 🟢

Old tarballs from previous Julia versions would otherwise screw up the use of `only()` to find the latest tarball.

This makes them easier to re-use elsewhere.

Copying the description from the code: > By default the getproperty!(x::Ptr, ::Symbol) methods created for wrapped > types will return pointers (Ptr{T}) to the struct fields. That behaviour is > useful for accessing nested struct fields but it does require explicitly > calling unsafe_load() every time. When enabled this option will automatically > call unsafe_load() for you *except on nested struct fields and arrays*, which > should make explicitly calling unsafe_load() unnecessary in most cases.

JamesWrigley · 2024-08-20T15:33:57Z

Gentle bump, I rebased this and fixed a lingering bug in @ptr after some more testing with JuliaImGui/CImGui.jl#131.

This reverts commit 9c77fd6. Now the tests fail for a different reason :')

JamesWrigley · 2024-08-20T16:07:47Z

CI should be fixed with 5f8a145 (reverts #504), unfortunately we're now hitting this: JuliaLang/julia#54664

…erty()

JamesWrigley · 2024-08-20T16:43:50Z

I noticed some warnings on nightly about the field access exception type changing to FieldError: JuliaLang/julia#54504
Fixed in ff9c955, though the formatting isn't the best:

Latest codegen

using CEnum: CEnum, @cenum                                                                                                                                                                                                                                                                                                     
                                                                                                                                                                                                                                                                                                                               
macro ptr(expr)                                                                                                                                                                                                                                                                                                                
    if !Meta.isexpr(expr, :.)                                                                                                                                                                                                                                                                                                  
        error("Expression is not a property access, cannot use @ptr on it.")                                                                                                                                                                                                                                                   
    end                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                               
    quote                                                                                                                                                                                                                                                                                                                      
        local penultimate_obj = $(esc(expr.args[1]))                                                                                                                                                                                                                                                                           
        getptr(penultimate_obj, $(esc(expr.args[2])))                                                                                                                                                                                                                                                                          
    end                                                                                                                                                                                                                                                                                                                        
end                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                               
struct TypedefStruct                                                                                                                                                                                                                                                                                                           
    i::Cint                                                                                                                                                                                                                                                                                                                    
end                                                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                                                  
struct Other                                                                                                                                                                                                                                                                      
    i::Cint                                                                                                                                                                                                                                                                       
end                                                                                                                                                                                                                                                                               
function getptr(x::Ptr{Other}, f::Symbol)                                                                                                                                                                                                                                         
    f === :i && return Ptr{Cint}(x + 0)                                                                                                                                                                                                                                           
    @static if VERSION >= v"1.12.0-DEV"                                                                                                                                                                                                                                           
            throw(FieldError(Other, f))                                                                                                                                                                                                                                           
        else                                                                                                                                                                                                                                                                      
            error("Unrecognized field of type `Other`" * ": $(f)")                                                                                                                                                                                                                
        end                                                                                                                                                                                                                                                                       
end                                                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                                                  
function Base.getproperty(x::Ptr{Other}, f::Symbol)                                                                                                                                                                                                                               
    f === :i && return unsafe_load(getptr(x, f))                                                                                                                                                                                                                                  
    return getfield(x, f)                                                                                                                                                                                                                                                         
end                                                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                                                  
function Base.setproperty!(x::Ptr{Other}, f::Symbol, v)                                                                                                                                                                                                                           
    unsafe_store!(getptr(x, f), v)                                                                                                                                                                                                                                                
end                                                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  
mutable struct WithFields                                                                                                                                                                                                                                                         
    int_value::Cint                                                                                                                                                                                                                                                               
    int_ptr::Ptr{Cint}                                                                                                                                                                                                                                                            
    struct_value::Other                                                                                                                                                                                                                                                           
    struct_ptr::Ptr{Other}                                                                                                                                                                                                                                                        
    typedef_struct_value::TypedefStruct                                                                                                                                                                                                                                           
    array::NTuple{2, Cint}                                                                                                                                                                                                                                                        
end                                                                                                                                                                                                                                                                               
function getptr(x::Ptr{WithFields}, f::Symbol)                                                                                                                                                                                                                                    
    f === :int_value && return Ptr{Cint}(x + 0)                                                                                                                                                                                                                                   
    f === :int_ptr && return Ptr{Ptr{Cint}}(x + 8)                                                                                                                                                                                                                                
    f === :struct_value && return Ptr{Other}(x + 16)                                                                                                                                                                                           
    f === :struct_ptr && return Ptr{Ptr{Other}}(x + 24)                                                                                                                                                                                        
    f === :typedef_struct_value && return Ptr{TypedefStruct}(x + 32)                                                                                                                                                                           
    f === :array && return Ptr{NTuple{2, Cint}}(x + 36)                                                                                                                                                                                        
    @static if VERSION >= v"1.12.0-DEV"                                                                                                                                                                                                        
            throw(FieldError(WithFields, f))                                                                                                                                                                                                   
        else                                                                                                                                                                                                                                   
            error("Unrecognized field of type `WithFields`" * ": $(f)")                                                                                                                                                                        
        end                                                                                                                                                                                                                                    
end                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                               
function Base.getproperty(x::Ptr{WithFields}, f::Symbol)                                                                                                                                                                                       
    f === :int_value && return unsafe_load(getptr(x, f))                                                                                                                                                                                       
    f === :int_ptr && return unsafe_load(getptr(x, f))                         
    f === :struct_value && return getptr(x, f)                                 
    f === :struct_ptr && return unsafe_load(getptr(x, f))                      
    f === :typedef_struct_value && return getptr(x, f)                         
    f === :array && return getptr(x, f)                                        
    return getfield(x, f)                                                      
end                                                                            

function Base.setproperty!(x::Ptr{WithFields}, f::Symbol, v)                                                                                                   
    unsafe_store!(getptr(x, f), v)                                             
end

Gnimuc · 2024-08-21T14:57:54Z

@JamesWrigley

https://github.com/cjdoris/UnsafePointers.jl overloads getindex/[] to eliminate the use of unsafe_load, which is a good way to solve the problem that this PR is gonna solve.

Gnimuc · 2024-08-21T15:00:25Z

maybe we should also adopt the way to overload setproperty! and setindex!

JamesWrigley · 2024-08-21T15:07:56Z

Just to clarify, are you saying that obj.foo.x should return the pointer and obj.foo.x[] should call unsafe_load()?

Gnimuc · 2024-08-21T15:08:52Z

This is what I'm currently thinking about:

x::Ptr{T} 
- `x[]` calls `unsafe_load(x)`
- `x[] = y` calls `unsafe_store!(x, y)`
-  `x.a` always returns a `Ptr`, so `x.a[]` and `x.a[] = b` are valid
- `x.a = b` should be removed

JamesWrigley · 2024-08-21T15:17:53Z

I see 🤔 But yeah that sounds reasonable, and it's kinda nice to share some syntax with Ref. I'll take a shot at it later in the week.

Gnimuc · 2024-08-21T15:22:38Z

The following equality holds for all types T in Julia and passing Refs as input parameters to the C function is prevalent. It could be better if Ptr and Ref work similarly for all types of T.

julia> x = Ref{Cint}(0)
Base.RefValue{Int32}(0)

julia> x[] == unsafe_load(Base.unsafe_convert(Ptr{Cint}, x))
true

JamesWrigley self-assigned this Jul 6, 2024

JamesWrigley marked this pull request as draft July 6, 2024 21:59

JamesWrigley force-pushed the auto-deref branch 3 times, most recently from f9a668d to 2e7e00d Compare July 7, 2024 23:38

JamesWrigley marked this pull request as ready for review July 7, 2024 23:54

Gnimuc added the Poll label Jul 17, 2024

JamesWrigley mentioned this pull request Jul 19, 2024

Add compat with HistoricalStdlibVersions v2 JuliaPackaging/BinaryBuilderBase.jl#384

Merged

JamesWrigley force-pushed the auto-deref branch from 73ed7ff to 3475e51 Compare August 20, 2024 15:26

JamesWrigley added 3 commits August 20, 2024 17:32

Always delete old BinaryBuilder tarballs before building

4b9d282

Old tarballs from previous Julia versions would otherwise screw up the use of `only()` to find the latest tarball.

Move the bitfield get/set code into their own functions

a226276

This makes them easier to re-use elsewhere.

JamesWrigley force-pushed the auto-deref branch from 3475e51 to d901cb7 Compare August 20, 2024 15:32

Revert "Remove test workaround (#504)"

5f8a145

This reverts commit 9c77fd6. Now the tests fail for a different reason :')

fixup! Add support for automatically calling unsafe_load() in getprop…

ff9c955

…erty()

JamesWrigley mentioned this pull request Aug 21, 2024

Modules support (finish #425) #505

Merged

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Add support for automatically calling unsafe_load() in getproperty() #502

Add support for automatically calling unsafe_load() in getproperty() #502

JamesWrigley commented Jul 6, 2024 •

edited

Loading

JamesWrigley commented Jul 7, 2024

Gnimuc commented Jul 8, 2024

JamesWrigley commented Jul 8, 2024

Gnimuc commented Jul 8, 2024

Gnimuc commented Jul 8, 2024

JamesWrigley commented Jul 8, 2024

Gnimuc commented Jul 8, 2024

JamesWrigley commented Jul 8, 2024

Gnimuc commented Jul 8, 2024 •

edited

Loading

Gnimuc commented Jul 8, 2024

JamesWrigley commented Jul 8, 2024

Gnimuc commented Jul 8, 2024

Gnimuc commented Jul 8, 2024

JamesWrigley commented Jul 8, 2024

JamesWrigley commented Jul 15, 2024

JamesWrigley commented Jul 15, 2024

Gnimuc commented Jul 16, 2024

JamesWrigley commented Jul 16, 2024 •

edited

Loading

Gnimuc commented Jul 17, 2024

JamesWrigley commented Jul 17, 2024

JamesWrigley commented Jul 21, 2024

JamesWrigley commented Aug 20, 2024

JamesWrigley commented Aug 20, 2024

JamesWrigley commented Aug 20, 2024

Gnimuc commented Aug 21, 2024

Gnimuc commented Aug 21, 2024

JamesWrigley commented Aug 21, 2024

Gnimuc commented Aug 21, 2024

JamesWrigley commented Aug 21, 2024

Gnimuc commented Aug 21, 2024

Add support for automatically calling unsafe_load() in getproperty() #502

Are you sure you want to change the base?

Add support for automatically calling unsafe_load() in getproperty() #502

Conversation

JamesWrigley commented Jul 6, 2024 • edited Loading

JamesWrigley commented Jul 7, 2024

Gnimuc commented Jul 8, 2024

JamesWrigley commented Jul 8, 2024

Gnimuc commented Jul 8, 2024

Gnimuc commented Jul 8, 2024

JamesWrigley commented Jul 8, 2024

Gnimuc commented Jul 8, 2024

JamesWrigley commented Jul 8, 2024

Gnimuc commented Jul 8, 2024 • edited Loading

Gnimuc commented Jul 8, 2024

JamesWrigley commented Jul 8, 2024

Gnimuc commented Jul 8, 2024

Gnimuc commented Jul 8, 2024

JamesWrigley commented Jul 8, 2024

JamesWrigley commented Jul 15, 2024

JamesWrigley commented Jul 15, 2024

Gnimuc commented Jul 16, 2024

JamesWrigley commented Jul 16, 2024 • edited Loading

Gnimuc commented Jul 17, 2024

JamesWrigley commented Jul 17, 2024

JamesWrigley commented Jul 21, 2024

JamesWrigley commented Aug 20, 2024

JamesWrigley commented Aug 20, 2024

JamesWrigley commented Aug 20, 2024

Gnimuc commented Aug 21, 2024

Gnimuc commented Aug 21, 2024

JamesWrigley commented Aug 21, 2024

Gnimuc commented Aug 21, 2024

JamesWrigley commented Aug 21, 2024

Gnimuc commented Aug 21, 2024

JamesWrigley commented Jul 6, 2024 •

edited

Loading

Gnimuc commented Jul 8, 2024 •

edited

Loading

JamesWrigley commented Jul 16, 2024 •

edited

Loading