Add custom format support for struct/union/enum types

[tgschultz]

fmt.format will now call a custom format fn for struct/union/enum types if one is defined publicly in their namespace and roughly matches the signature:

pub fn format(self: &SelfType, comptime fmt: []const u8, context: var, 
                comptime Errors: type, output: fn(@typeOf(context), []const u8)Errors!void) 
                Errors!void 

I say 'roughly' because types stored by @typeinfo() seem to only be able to be checked for equality against themselves and I had to hack in a check on the typename instead for now.
The format function will be passed the type format specifiers that occur within the matching {} in the format string to handle however it wants.

To make this easier I ended up refactoring the way fmt.format works, moving all the type format specifier parsing out of format and into relevant type-specific functions.

[tgschultz]

I have no idea why MacOS build on CI isn't hitting this margin.

[andrewrk]

Thanks for the PR! I'm into this idea. Give me a couple days to go over the changes and merge.

Don't worry about the conflict

[thejoshwolfe]

could this be used by a debugger script to pretty print a representation of a runtime value?

[Hejsil]

Looks awesome! Can't wait to implement a way to give structs a default formatter >:). Something like this:

const S = struct {
    a: u8,

    const format = defaultFormatter(S);
};

[andrewrk]

We can also add a default formatter directly to std.fmt. If there's no format function specified, then iterate over the fields, etc

[andrewrk]

@thejoshwolfe related: #25

[tgschultz]

Coincidentally I threw this function together recently. As you can see, the additions of @typeInfo and @field make this sort of thing pretty trivial.

pub fn printStruct(ptr: var) void
{
    const PtrType = @typeOf(ptr);
    const PtrTypeId = @typeId(PtrType);
    if(PtrTypeId != builtin.TypeId.Pointer) @compileError("Arg is not a struct");
    const StructTypeId = @typeId(PtrType.Child);
    if(StructTypeId != builtin.TypeId.Struct) @compileError("Arg is not a struct");
    const struct_name = @typeName(PtrType.Child);
    warn("{} = {{\n", struct_name);
    const info = @typeInfo(PtrType.Child);
    
    inline for(info.Struct.fields) |*field_info|
    {
        const name = field_info.name;
        const FieldType = field_info.field_type;
        warn("  {}: {} = {},\n", name, @typeName(FieldType), @field(ptr, name));
    }
    warn("}};\n");
}

[tiehuis]

Do we want a default formatter for everything or is it better to be more explicit? For example, I like Rust's approach of not providing a default formatter in {}, but providing a debug formatter (e.g. {?}, {#?}) that can be used to inspect types. Reasoning being that having every type be printable would make it trivially easy for unintended internal information of structs to end up in user output. If we use a different format specifier, at least the caller acknowledges this explicitly on their end.

Anyway, the general idea of custom formatters is good and I agree. This is more an aside and could be discussed on another PR/issue.

[andrewrk]

Apologies for the delay, I wanted to get my Pointer Reform commit done before context switching. I'll have a look at this first thing tomorrow.

I agree with you @tiehuis about opting in to struct field introspection.