vdbg! macro #4868
Merged
vdbg! macro #4868
Conversation
This file contains 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
|
The latest updates on your projects. Learn more about Vercel for Git ↗︎
10 Ignored Deployments
|
🟢 CI successful 🟢Thanks |
|
This change may fail to build |
alexkirsz
force-pushed
the
alexkirsz/web-520-improve-dbg-ergonomics
branch
from
7725bc0
to
734916b
Compare
jridgewell
approved these changes
May 8, 2023
There was a problem hiding this comment.
Can we add a default impl for items which implement #4868 (comment)Debug but don't implement ValueDebugFormat specifically?
|
@jridgewell isn't this already the case? |
|
Ohh, I didn't read the comments and thought we still needed an |
alexkirsz
added
the
pr: automerge
|
This PR could not be merged because the GitHub API returned an internal server error. To enable Kodiak on this pull request please remove the When the GitHub API returns an internal server error (HTTP status code 500), it is not safe for Kodiak to retry merging. For more information please see https://kodiakhq.com/docs/troubleshooting#merge-errors If you need help, you can open a GitHub issue, check the docs, or reach us privately at support@kodiakhq.com. |
NicholasLYang
pushed a commit
to NicholasLYang/turbo
that referenced
this pull request
May 9, 2023
### Description
The `vdbg!` macro works the same way as the `dbg!` macro, with the
additional benefit of automatically calling `ValueDebugFormat`
implementations.
This means that you can do:
```rust
vdbg!(42, asset_ident_vc);
vdbg!(42, asset_ident_vc; depth = 1);
```
and the macro will print out
```rust
[src/main.rs:10] 42 = 42
[src/main.rs:10] some_vc = AssetIdent {
path: FileSystemPath {
fs: FileSystem(DiskFileSystem {
name: "project",
root: "...",
}),
path: "...",
},
query: None,
fragment: None,
assets: [],
modifiers: [],
part: None,
}
```
```rust
[src/main.rs:10] 42 = 42
[src/main.rs:10] asset_ident_vc = AssetIdent {
path: FileSystemPath,
query: core::option::Option<turbo_tasks::primitives::StringVc>,
fragment: core::option::Option<turbo_tasks::primitives::StringVc>,
assets: alloc::vec::Vec<(turbo_tasks::primitives::StringVc, turbopack_core::ident::AssetIdentVc)>,
modifiers: alloc::vec::Vec<turbo_tasks::primitives::StringVc>,
part: core::option::Option<turbopack_core::resolve::ModulePartVc>,
}
```
This is an ergonomic improvement over having to call `.dbg()` or
`.dbg_depth()` manually in four major ways:
1. No need to be in an async context and call `.await?`: the macro will
spawn a task on its own. This means that it is no longer necessary to
convert a `turbo_tasks::function` to async just to debug one of its
arguments.
2. No need to import the `turbo_tasks::debug::ValueDebug` trait. You can
call `turbo_tasks::vdbg!(...)` directly, of `vdbg!(...)` if you have it
imported already.
3. No need to call `eprintln!` or `dbg!`: `vdbg!` calls `eprintln!`
directly under the hood, with the same format as `dbg!`.
4. It's just one macro, with support for the `depth` argument baked in.
### Testing Instructions
N/A
link WEB-520
ForsakenHarmony
pushed a commit
to vercel/next.js
that referenced
this pull request
Jul 25, 2024
### Description
The `vdbg!` macro works the same way as the `dbg!` macro, with the
additional benefit of automatically calling `ValueDebugFormat`
implementations.
This means that you can do:
```rust
vdbg!(42, asset_ident_vc);
vdbg!(42, asset_ident_vc; depth = 1);
```
and the macro will print out
```rust
[src/main.rs:10] 42 = 42
[src/main.rs:10] some_vc = AssetIdent {
path: FileSystemPath {
fs: FileSystem(DiskFileSystem {
name: "project",
root: "...",
}),
path: "...",
},
query: None,
fragment: None,
assets: [],
modifiers: [],
part: None,
}
```
```rust
[src/main.rs:10] 42 = 42
[src/main.rs:10] asset_ident_vc = AssetIdent {
path: FileSystemPath,
query: core::option::Option<turbo_tasks::primitives::StringVc>,
fragment: core::option::Option<turbo_tasks::primitives::StringVc>,
assets: alloc::vec::Vec<(turbo_tasks::primitives::StringVc, turbopack_core::ident::AssetIdentVc)>,
modifiers: alloc::vec::Vec<turbo_tasks::primitives::StringVc>,
part: core::option::Option<turbopack_core::resolve::ModulePartVc>,
}
```
This is an ergonomic improvement over having to call `.dbg()` or
`.dbg_depth()` manually in four major ways:
1. No need to be in an async context and call `.await?`: the macro will
spawn a task on its own. This means that it is no longer necessary to
convert a `turbo_tasks::function` to async just to debug one of its
arguments.
2. No need to import the `turbo_tasks::debug::ValueDebug` trait. You can
call `turbo_tasks::vdbg!(...)` directly, of `vdbg!(...)` if you have it
imported already.
3. No need to call `eprintln!` or `dbg!`: `vdbg!` calls `eprintln!`
directly under the hood, with the same format as `dbg!`.
4. It's just one macro, with support for the `depth` argument baked in.
### Testing Instructions
N/A
link WEB-520
ForsakenHarmony
pushed a commit
to vercel/next.js
that referenced
this pull request
Jul 29, 2024
### Description
The `vdbg!` macro works the same way as the `dbg!` macro, with the
additional benefit of automatically calling `ValueDebugFormat`
implementations.
This means that you can do:
```rust
vdbg!(42, asset_ident_vc);
vdbg!(42, asset_ident_vc; depth = 1);
```
and the macro will print out
```rust
[src/main.rs:10] 42 = 42
[src/main.rs:10] some_vc = AssetIdent {
path: FileSystemPath {
fs: FileSystem(DiskFileSystem {
name: "project",
root: "...",
}),
path: "...",
},
query: None,
fragment: None,
assets: [],
modifiers: [],
part: None,
}
```
```rust
[src/main.rs:10] 42 = 42
[src/main.rs:10] asset_ident_vc = AssetIdent {
path: FileSystemPath,
query: core::option::Option<turbo_tasks::primitives::StringVc>,
fragment: core::option::Option<turbo_tasks::primitives::StringVc>,
assets: alloc::vec::Vec<(turbo_tasks::primitives::StringVc, turbopack_core::ident::AssetIdentVc)>,
modifiers: alloc::vec::Vec<turbo_tasks::primitives::StringVc>,
part: core::option::Option<turbopack_core::resolve::ModulePartVc>,
}
```
This is an ergonomic improvement over having to call `.dbg()` or
`.dbg_depth()` manually in four major ways:
1. No need to be in an async context and call `.await?`: the macro will
spawn a task on its own. This means that it is no longer necessary to
convert a `turbo_tasks::function` to async just to debug one of its
arguments.
2. No need to import the `turbo_tasks::debug::ValueDebug` trait. You can
call `turbo_tasks::vdbg!(...)` directly, of `vdbg!(...)` if you have it
imported already.
3. No need to call `eprintln!` or `dbg!`: `vdbg!` calls `eprintln!`
directly under the hood, with the same format as `dbg!`.
4. It's just one macro, with support for the `depth` argument baked in.
### Testing Instructions
N/A
link WEB-520
ForsakenHarmony
pushed a commit
to vercel/next.js
that referenced
this pull request
Aug 1, 2024
### Description
The `vdbg!` macro works the same way as the `dbg!` macro, with the
additional benefit of automatically calling `ValueDebugFormat`
implementations.
This means that you can do:
```rust
vdbg!(42, asset_ident_vc);
vdbg!(42, asset_ident_vc; depth = 1);
```
and the macro will print out
```rust
[src/main.rs:10] 42 = 42
[src/main.rs:10] some_vc = AssetIdent {
path: FileSystemPath {
fs: FileSystem(DiskFileSystem {
name: "project",
root: "...",
}),
path: "...",
},
query: None,
fragment: None,
assets: [],
modifiers: [],
part: None,
}
```
```rust
[src/main.rs:10] 42 = 42
[src/main.rs:10] asset_ident_vc = AssetIdent {
path: FileSystemPath,
query: core::option::Option<turbo_tasks::primitives::StringVc>,
fragment: core::option::Option<turbo_tasks::primitives::StringVc>,
assets: alloc::vec::Vec<(turbo_tasks::primitives::StringVc, turbopack_core::ident::AssetIdentVc)>,
modifiers: alloc::vec::Vec<turbo_tasks::primitives::StringVc>,
part: core::option::Option<turbopack_core::resolve::ModulePartVc>,
}
```
This is an ergonomic improvement over having to call `.dbg()` or
`.dbg_depth()` manually in four major ways:
1. No need to be in an async context and call `.await?`: the macro will
spawn a task on its own. This means that it is no longer necessary to
convert a `turbo_tasks::function` to async just to debug one of its
arguments.
2. No need to import the `turbo_tasks::debug::ValueDebug` trait. You can
call `turbo_tasks::vdbg!(...)` directly, of `vdbg!(...)` if you have it
imported already.
3. No need to call `eprintln!` or `dbg!`: `vdbg!` calls `eprintln!`
directly under the hood, with the same format as `dbg!`.
4. It's just one macro, with support for the `depth` argument baked in.
### Testing Instructions
N/A
link WEB-520
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.
Description
The
vdbg!macro works the same way as thedbg!macro, with the additional benefit of automatically callingValueDebugFormatimplementations.This means that you can do:
and the macro will print out
This is an ergonomic improvement over having to call
.dbg()or.dbg_depth()manually in four major ways:.await?: the macro will spawn a task on its own. This means that it is no longer necessary to convert aturbo_tasks::functionto async just to debug one of its arguments.turbo_tasks::debug::ValueDebugtrait. You can callturbo_tasks::vdbg!(...)directly, ofvdbg!(...)if you have it imported already.eprintln!ordbg!:vdbg!callseprintln!directly under the hood, with the same format asdbg!.depthargument baked in.Testing Instructions
N/A
link WEB-520