Sema: cap depth of value printing in type names #19682
Merged
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Certain types (notably, `std.ComptimeStringMap`) were resulting in excessively long type names when instantiated, which in turn resulted in excessively long symbol names. These are problematic for two reasons: * Symbol names are sometimes read by humans -- they ought to be readable. * Some other applications (looking at you, xcode) trip on very long symbol names. To work around this for now, we cap the depth of value printing at 1, as opposed to the normal 3. This doesn't guarantee anything -- there could still be, for instance, an incredibly long aggregate -- but it works around the issue in practice for the time being.
|
I can confirm that this fixes Ghostty's build issues from |
|
@mlugg would it be helpful to have a different version of std.ComptimeStringMap which takes only a single type param and moves the I mention because I've just been working on that here. Currently i've got all the original tests passing and also added |
travisstaloch
added a commit
to travisstaloch/zig
that referenced
this pull request
Apr 21, 2024
this patch makes ComptimeStringMap accept only a single type parameter and return a known struct type instead of an anonymous struct. initial motivation for these changes was to reduce the 'very long type names' issue described here ziglang#19682. * move `kvs_list` param from type param to an `init()` param * adds new public methods which i'm not sure belong but have left in for now incase they are deemed useful. * `getPartial(str)`, `getIndexPartial(str)`, `initRuntime(allocator)`, `deinit(allocator)` * includes test coverage for all * performance notes: * i posted some benchmarking results here: https://github.com/travisstaloch/comptime-string-map-revised/issues/1 * i noticed speedup reducing the size of the struct from 48 to 32 bytes and thus use u32s instead of usize for all length fields * i noticed speedup storing KVs as a struct of arrays * latest benchmark shows these wall_time improvements for debug/safe/small/fast builds: -6.6% / -10.2% / -19.1% / -8.9%
travisstaloch
added a commit
to travisstaloch/zig
that referenced
this pull request
Apr 21, 2024
this patch makes ComptimeStringMap accept only a single type parameter and return a known struct type instead of an anonymous struct. initial motivation for these changes was to reduce the 'very long type names' issue described here ziglang#19682. this breaks the previous API. users will now need to write: `const map = std.ComptimeStringMap(T).init(kvs_list);` * move `kvs_list` param from type param to an `init()` param * adds new public methods which i'm not sure belong but have left in for now incase they are deemed useful. * `getPartial(str)`, `getIndexPartial(str)`, `initRuntime(allocator)`, `deinit(allocator)` * includes test coverage for all * performance notes: * i posted some benchmarking results here: https://github.com/travisstaloch/comptime-string-map-revised/issues/1 * i noticed speedup reducing the size of the struct from 48 to 32 bytes and thus use u32s instead of usize for all length fields * i noticed speedup storing KVs as a struct of arrays * latest benchmark shows these wall_time improvements for debug/safe/small/fast builds: -6.6% / -10.2% / -19.1% / -8.9%
travisstaloch
added a commit
to travisstaloch/zig
that referenced
this pull request
Apr 21, 2024
this patch makes ComptimeStringMap accept only a single type parameter and return a known struct type instead of an anonymous struct. initial motivation for these changes was to reduce the 'very long type names' issue described here ziglang#19682. this breaks the previous API. users will now need to write: `const map = std.ComptimeStringMap(T).init(kvs_list);` * move `kvs_list` param from type param to an `init()` param * adds new public convenience helpers `keys()` and `values()` * adds new public methods which i'm not sure belong but have left in for now incase they are deemed useful. * `getPartial(str)`, `getIndexPartial(str)`, `initRuntime(allocator)`, `deinit(allocator)` * includes test coverage for all * performance notes: * i posted some benchmarking results here: https://github.com/travisstaloch/comptime-string-map-revised/issues/1 * i noticed speedup reducing the size of the struct from 48 to 32 bytes and thus use u32s instead of usize for all length fields * i noticed speedup storing KVs as a struct of arrays * latest benchmark shows these wall_time improvements for debug/safe/small/fast builds: -6.6% / -10.2% / -19.1% / -8.9%
travisstaloch
added a commit
to travisstaloch/zig
that referenced
this pull request
Apr 21, 2024
this patch makes ComptimeStringMap accept only a single type parameter and return a known struct type instead of an anonymous struct. initial motivation for these changes was to reduce the 'very long type names' issue described here ziglang#19682. this breaks the previous API. users will now need to write: `const map = std.ComptimeStringMap(T).init(kvs_list);` * move `kvs_list` param from type param to an `init()` param * adds new public convenience helpers `keys()` and `values()` * adds new public methods which i'm not sure belong but have left in for now incase they are deemed useful. * `getPartial(str)`, `getIndexPartial(str)`, `initRuntime(allocator)`, `deinit(allocator)` * includes test coverage for all * performance notes: * i posted some benchmarking results here: https://github.com/travisstaloch/comptime-string-map-revised/issues/1 * i noticed speedup reducing the size of the struct from 48 to 32 bytes and thus use u32s instead of usize for all length fields * i noticed speedup storing KVs as a struct of arrays * latest benchmark shows these wall_time improvements for debug/safe/small/fast builds: -6.6% / -10.2% / -19.1% / -8.9%. full poop output in link above.
travisstaloch
added a commit
to travisstaloch/zig
that referenced
this pull request
Apr 21, 2024
this patch renames ComptimeStringMap to StaticStringMap, makes it accept only a single type parameter, and return a known struct type instead of an anonymous struct. initial motivation for these changes was to reduce the 'very long type names' issue described here ziglang#19682. this breaks the previous API. users will now need to write: `const map = std.ComptimeStringMap(T).initComptime(kvs_list);` * move `kvs_list` param from type param to an `initComptime()` param * adds new public convenience helpers `keys()` and `values()` * adds new public methods which i'm not sure belong but have left in for now incase they are deemed useful. * `getPartial(str)`, `getIndexPartial(str)`, `init(allocator)`, `deinit(allocator)` * includes test coverage for all * performance notes: * i posted some benchmarking results here: https://github.com/travisstaloch/comptime-string-map-revised/issues/1 * i noticed speedup reducing the size of the struct from 48 to 32 bytes and thus use u32s instead of usize for all length fields * i noticed speedup storing KVs as a struct of arrays * latest benchmark shows these wall_time improvements for debug/safe/small/fast builds: -6.6% / -10.2% / -19.1% / -8.9%. full poop output in link above.
travisstaloch
added a commit
to travisstaloch/zig
that referenced
this pull request
Apr 21, 2024
this patch renames ComptimeStringMap to StaticStringMap, makes it accept only a single type parameter, and return a known struct type instead of an anonymous struct. initial motivation for these changes was to reduce the 'very long type names' issue described here ziglang#19682. this breaks the previous API. users will now need to write: `const map = std.StaticStringMap(T).initComptime(kvs_list);` * move `kvs_list` param from type param to an `initComptime()` param * adds new public convenience helpers `keys()` and `values()` * adds new public methods which i'm not sure belong but have left in for now incase they are deemed useful. * `getPartial(str)`, `getIndexPartial(str)`, `init(allocator)`, `deinit(allocator)` * includes test coverage for all * performance notes: * i posted some benchmarking results here: https://github.com/travisstaloch/comptime-string-map-revised/issues/1 * i noticed speedup reducing the size of the struct from 48 to 32 bytes and thus use u32s instead of usize for all length fields * i noticed speedup storing KVs as a struct of arrays * latest benchmark shows these wall_time improvements for debug/safe/small/fast builds: -6.6% / -10.2% / -19.1% / -8.9%. full poop output in link above.
travisstaloch
added a commit
to travisstaloch/zig
that referenced
this pull request
Apr 21, 2024
this patch renames ComptimeStringMap to StaticStringMap, makes it accept only a single type parameter, and return a known struct type instead of an anonymous struct. initial motivation for these changes was to reduce the 'very long type names' issue described here ziglang#19682. this breaks the previous API. users will now need to write: `const map = std.StaticStringMap(T).initComptime(kvs_list);` * move `kvs_list` param from type param to an `initComptime()` param * adds new public convenience helpers `keys()` and `values()` * adds new public methods which i'm not sure belong but have left in for now incase they are deemed useful. * `getPartial(str)`, `getIndexPartial(str)`, `initRuntime(allocator)`, `deinit(allocator)` * includes test coverage for all * performance notes: * i posted some benchmarking results here: https://github.com/travisstaloch/comptime-string-map-revised/issues/1 * i noticed speedup reducing the size of the struct from 48 to 32 bytes and thus use u32s instead of usize for all length fields * i noticed speedup storing KVs as a struct of arrays * latest benchmark shows these wall_time improvements for debug/safe/small/fast builds: -6.6% / -10.2% / -19.1% / -8.9%. full poop output in link above.
travisstaloch
added a commit
to travisstaloch/zig
that referenced
this pull request
Apr 21, 2024
this patch renames ComptimeStringMap to StaticStringMap, makes it accept only a single type parameter, and return a known struct type instead of an anonymous struct. initial motivation for these changes was to reduce the 'very long type names' issue described here ziglang#19682. this breaks the previous API. users will now need to write: `const map = std.StaticStringMap(T).initComptime(kvs_list);` * move `kvs_list` param from type param to an `initComptime()` param * adds new public convenience helpers `keys()` and `values()` * adds new public methods which i'm not sure belong but have left in for now incase they are deemed useful. * `getPartial(str)`, `getIndexPartial(str)`, `initRuntime(allocator)`, `deinit(allocator)` * includes test coverage for all * performance notes: * i posted some benchmarking results here: https://github.com/travisstaloch/comptime-string-map-revised/issues/1 * i noticed speedup reducing the size of the struct from 48 to 32 bytes and thus use u32s instead of usize for all length fields * i noticed speedup storing KVs as a struct of arrays * latest benchmark shows these wall_time improvements for debug/safe/small/fast builds: -6.6% / -10.2% / -19.1% / -8.9%. full poop output in link above.
travisstaloch
added a commit
to travisstaloch/zig
that referenced
this pull request
Apr 21, 2024
this patch renames ComptimeStringMap to StaticStringMap, makes it accept only a single type parameter, and return a known struct type instead of an anonymous struct. initial motivation for these changes was to reduce the 'very long type names' issue described here ziglang#19682. this breaks the previous API. users will now need to write: `const map = std.StaticStringMap(T).initComptime(kvs_list);` * move `kvs_list` param from type param to an `initComptime()` param * adds new public convenience helpers `keys()` and `values()` * adds new public methods which i'm not sure belong but have left in for now incase they are deemed useful. * `getPartial(str)`, `getIndexPartial(str)`, `initRuntime(allocator)`, `deinit(allocator)` * includes test coverage for all * performance notes: * i posted some benchmarking results here: https://github.com/travisstaloch/comptime-string-map-revised/issues/1 * i noticed speedup reducing the size of the struct from 48 to 32 bytes and thus use u32s instead of usize for all length fields * i noticed speedup storing KVs as a struct of arrays * latest benchmark shows these wall_time improvements for debug/safe/small/fast builds: -6.6% / -10.2% / -19.1% / -8.9%. full poop output in link above.
travisstaloch
added a commit
to travisstaloch/zig
that referenced
this pull request
Apr 21, 2024
this patch renames ComptimeStringMap to StaticStringMap, makes it accept only a single type parameter, and return a known struct type instead of an anonymous struct. initial motivation for these changes was to reduce the 'very long type names' issue described here ziglang#19682. this breaks the previous API. users will now need to write: `const map = std.StaticStringMap(T).initComptime(kvs_list);` * move `kvs_list` param from type param to an `initComptime()` param * adds new public convenience helpers `keys()` and `values()` * adds new public methods which i'm not sure belong but have left in for now incase they are deemed useful. * `getPartial(str)`, `getIndexPartial(str)`, `initRuntime(allocator)`, `deinit(allocator)` * includes test coverage for all * performance notes: * i posted some benchmarking results here: https://github.com/travisstaloch/comptime-string-map-revised/issues/1 * i noticed speedup reducing the size of the struct from 48 to 32 bytes and thus use u32s instead of usize for all length fields * i noticed speedup storing KVs as a struct of arrays * latest benchmark shows these wall_time improvements for debug/safe/small/fast builds: -6.6% / -10.2% / -19.1% / -8.9%. full poop output in link above.
travisstaloch
added a commit
to travisstaloch/zig
that referenced
this pull request
Apr 21, 2024
this patch renames ComptimeStringMap to StaticStringMap, makes it accept only a single type parameter, and return a known struct type instead of an anonymous struct. initial motivation for these changes was to reduce the 'very long type names' issue described here ziglang#19682. this breaks the previous API. users will now need to write: `const map = std.StaticStringMap(T).initComptime(kvs_list);` * move `kvs_list` param from type param to an `initComptime()` param * adds new public convenience helpers `keys()` and `values()` * adds new public methods which i'm not sure belong but have left in for now incase they are deemed useful. * `getPartial(str)`, `getIndexPartial(str)`, `initRuntime(allocator)`, `deinit(allocator)` * includes test coverage for all * performance notes: * i posted some benchmarking results here: https://github.com/travisstaloch/comptime-string-map-revised/issues/1 * i noticed speedup reducing the size of the struct from 48 to 32 bytes and thus use u32s instead of usize for all length fields * i noticed speedup storing KVs as a struct of arrays * latest benchmark shows these wall_time improvements for debug/safe/small/fast builds: -6.6% / -10.2% / -19.1% / -8.9%. full poop output in link above.
travisstaloch
added a commit
to travisstaloch/zig
that referenced
this pull request
Apr 21, 2024
this patch renames ComptimeStringMap to StaticStringMap, makes it accept only a single type parameter, and return a known struct type instead of an anonymous struct. initial motivation for these changes was to reduce the 'very long type names' issue described here ziglang#19682. this breaks the previous API. users will now need to write: `const map = std.StaticStringMap(T).initComptime(kvs_list);` * move `kvs_list` param from type param to an `initComptime()` param * new public methods * `keys()`, `values()` helpers * `init(allocator)`, `deinit(allocator)` for runtime data * `getLongestPrefix(str)`, `getLongestPrefixIndex(str)` - i'm not sure these belong but have left in for now incase they are deemed useful * performance notes: * i posted some benchmarking results here: https://github.com/travisstaloch/comptime-string-map-revised/issues/1 * i noticed a speedup reducing the size of the struct from 48 to 32 bytes and thus use u32s instead of usize for all length fields * i noticed speedup storing KVs as a struct of arrays * latest benchmark shows these wall_time improvements for debug/safe/small/fast builds: -6.6% / -10.2% / -19.1% / -8.9%. full output in link above.
travisstaloch
added a commit
to travisstaloch/zig
that referenced
this pull request
Apr 21, 2024
this patch renames ComptimeStringMap to StaticStringMap, makes it accept only a single type parameter, and return a known struct type instead of an anonymous struct. initial motivation for these changes was to reduce the 'very long type names' issue described here ziglang#19682. this breaks the previous API. users will now need to write: `const map = std.StaticStringMap(T).initComptime(kvs_list);` * move `kvs_list` param from type param to an `initComptime()` param * new public methods * `keys()`, `values()` helpers * `init(allocator)`, `deinit(allocator)` for runtime data * `getLongestPrefix(str)`, `getLongestPrefixIndex(str)` - i'm not sure these belong but have left in for now incase they are deemed useful * performance notes: * i posted some benchmarking results here: https://github.com/travisstaloch/comptime-string-map-revised/issues/1 * i noticed a speedup reducing the size of the struct from 48 to 32 bytes and thus use u32s instead of usize for all length fields * i noticed speedup storing KVs as a struct of arrays * latest benchmark shows these wall_time improvements for debug/safe/small/fast builds: -6.6% / -10.2% / -19.1% / -8.9%. full output in link above.
travisstaloch
added a commit
to travisstaloch/zig
that referenced
this pull request
Apr 22, 2024
this patch renames ComptimeStringMap to StaticStringMap, makes it accept only a single type parameter, and return a known struct type instead of an anonymous struct. initial motivation for these changes was to reduce the 'very long type names' issue described here ziglang#19682. this breaks the previous API. users will now need to write: `const map = std.StaticStringMap(T).initComptime(kvs_list);` * move `kvs_list` param from type param to an `initComptime()` param * new public methods * `keys()`, `values()` helpers * `init(allocator)`, `deinit(allocator)` for runtime data * `getLongestPrefix(str)`, `getLongestPrefixIndex(str)` - i'm not sure these belong but have left in for now incase they are deemed useful * performance notes: * i posted some benchmarking results here: https://github.com/travisstaloch/comptime-string-map-revised/issues/1 * i noticed a speedup reducing the size of the struct from 48 to 32 bytes and thus use u32s instead of usize for all length fields * i noticed speedup storing KVs as a struct of arrays * latest benchmark shows these wall_time improvements for debug/safe/small/fast builds: -6.6% / -10.2% / -19.1% / -8.9%. full output in link above.
andrewrk
pushed a commit
that referenced
this pull request
Apr 22, 2024
this patch renames ComptimeStringMap to StaticStringMap, makes it accept only a single type parameter, and return a known struct type instead of an anonymous struct. initial motivation for these changes was to reduce the 'very long type names' issue described here #19682. this breaks the previous API. users will now need to write: `const map = std.StaticStringMap(T).initComptime(kvs_list);` * move `kvs_list` param from type param to an `initComptime()` param * new public methods * `keys()`, `values()` helpers * `init(allocator)`, `deinit(allocator)` for runtime data * `getLongestPrefix(str)`, `getLongestPrefixIndex(str)` - i'm not sure these belong but have left in for now incase they are deemed useful * performance notes: * i posted some benchmarking results here: https://github.com/travisstaloch/comptime-string-map-revised/issues/1 * i noticed a speedup reducing the size of the struct from 48 to 32 bytes and thus use u32s instead of usize for all length fields * i noticed speedup storing KVs as a struct of arrays * latest benchmark shows these wall_time improvements for debug/safe/small/fast builds: -6.6% / -10.2% / -19.1% / -8.9%. full output in link above.
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Certain types (notably,
std.ComptimeStringMap) were resulting in excessively long type names when instantiated, which in turn resulted in excessively long symbol names. These are problematic for two reasons:To work around this for now, we cap the depth of value printing at 1, as opposed to the normal 3. This doesn't guarantee anything -- there could still be, for instance, an incredibly long aggregate -- but it works around the issue in practice for the time being.