Hiding instance variables in the auto-generated `#inspect`

[HertzDevil]

Reference#inspect and Struct#inspect iterate over all instance variables, printing them one by one. There are some cases where we do not want every single instance variable shown:

• The field contains sensitive information. (You should not hold these objects in memory for too long, either way.)
• The field is strictly unused, for example it solely exists to control member alignment. This is common in C, e.g. most of our bindings for LibC::Stat contain a few of these fields.
• The field is part of an encompassing data structure, in particular it could be the adjacent node(s) in an intrusive linked list; inspecting one node would end up printing out the rest of the entire chain of nodes.

#15829 is an example where #inspect is explicitly overridden to handle the last case. Doing so, however, requires consciously replicating the logic in the base implementation, or using a different output format altogether. It would be great if the standard library offers some flexibility in controlling the output exactly as we wanted.

In a nod to the serialization support in the standard library, I am proposing an Object::Field instance variable annotation that accepts an ignore named argument. If this argument is true, then the default #inspect will not print this instance variable:

annotation Object::Field
end

class Foo
  @x = 1

  @[Object::Field(ignore: true)]
  @y = 2

  @z = 3

  @[Field(ignore: true)]
  protected getter password = "foo"
end

Foo.new # => #<Foo:0x10318afa0 @x=1, @z=3>

This could be extended to #pretty_print too. The annotation is open for future extensions; for example, it might have a different parameter controlling whether the instance variable is accessed in the default Struct#== and #hash, useful for the padding fields described above.

A potential problem of the naming is that you don't need the Object:: part of the name and actually just @[Field] will do, because almost every type inherits from Object.

[ysbaddaden]

I like the concept. I'm not sure of the Field name, but I'm at a loss to propose something...

[straight-shoota]

I had similar thoughts when I saw #15829. Thanks for writing it down 😆👍

I share concerns about the name, though. Adding anything into the Object namespace is super intrusive. I don't think we should do that. If annotations had a separate namespace, it might be fine.

Maybe PrettyPrint::Field could be an option? #inspect is not pretty printing, but it's similar from a user perspective. It can be understood as a primitive form without using the PrettyPrint interface.

I would be harder to argue for adding other concerns unrelated to inspect/prettyprinting, though. But that may be okay. Perhaps this should use a separate annotation. I can see that there's likely an overlap between fields that should be ignored for printing and ignored for other purposes, though.

For a more generic name, I can only think of Crystal::Field 🤷

[n-rodriguez]

Coincidentally Ruby has the same issue : https://bugs.ruby-lang.org/issues/21219 at the same time 😀

[n-rodriguez]

Maybe Inspectable::Field could do it?