Helper function to wrap a probe arg in its correspondong wrapper without contorting one's fingers typing angle brackets

Sets the specified environment variables for the current process, and keeps them set until the returned guard object is dropped. Once it's dropped, t

Similar to `cache_file_computation`, except the computation is not on the contents of a file but rather on some arbitrary object with a name and a has

Given an iterable sequence of `TokenStream`s, produces a new `TokenStream` which will be a tuple expression with each element of the tuple correspondi

Alas, the types in `syn` and `proc_macro2` aren't Send+Sync, which means they can't be used as statics. So the trait test data must be re-created by

Given the path to a file, and a function that takes as an argument a `String` with the contents of that file and returns the (serializable) result of

Returns the name of the module in which most of the implementation code for this trait will be located.

Loads the `BuildInfo` and based on its contents creates and returns the applicable `CodeGenerator` implementation

Given the path to some root directory, generates a path to a subdirectory which is suitable for use as a cache. This automatically adds the version o

The name of this provider (in snake_case) combined with the hash of the provider's contents. Eg: `my_provider_deadc0de1918df`

In the `tracers` macro implementation there are some cases where, given a `Type` instance, I want to recursively visit all nested types. For example,

Helper method which takes as input an `Ident` which represents a variable or type name, appends a given suffix to that name, and returns it as a new `

Called from the `build.rs` of all crates which have a direct dependency on `tracers` and `tracers_macros`. This determines the compile-time configura

Lower-level caching function. Given some arbitrary file name (and optional path components) relative to the cache path, if the file exists, returns t

Compute the path of the directory within the cache path which contains all results related to a specific input path and hash.

Looking at the methods defined on the trait, deduce from those methods the probes that we will need to define, including their arg counts and arg type

Scans the AST of a Rust source file, finding all traits marked with the `tracer` attribute, parses the contents of the trait, and deduces the provider

Identical to `cache_object_computation` except this is read-only; if the computation does not exist in the cache it returns an error

The name of the struct type within the impl module which represents the provider, eg `MyProbesProviderImpl`. Note that this is not the same as the str

Convert this error into a `TokenStream` such that when the compiler consumes the token stream it will evaluate to a compile error, with the span corre

`Path` is something of a special case that is complex enough to require its own function and which appears in multiple places.

Returns the Rust AST representation of this argument's type, with lifetime annotations added for every reference type. See `add_lifetimes_to_syn_type

Like the method above constructs a tuple type corresponding to the types of the arguments of this probe. Unlike the above method, this tuple type is a

Gets all of the lifetime parameters for all of the reference args for this probe, in a `Vec` for convenient post-processing. For example: ```noexecu

Pick an argument type for argument `n`. Returns tuple containing: Name of the arg Rust data type of the arg C format string to use for the arg bool

Generates the standard provider init call. Some implementations may use a different one but this is the typical impl.

When generating a comment with `#[doc]` if the string is multi-lined then `quote_spanned` seems to get confused and puts the rest of the lines of the

Generates the `#[deprecated...]` attribute which triggers a warning if anyone tries to call the probe method directly, not through the `probe!` attrib

Generates a doc comment to attach to the probe's method. This includes additional information about how to work with this probe on various platforms.

Each probe has a corresponding field in the struct that we build for the provider. That field is an instance of `ProviderProbe` which is a type-safe

Generates the an additional doc comment for the generated provider trait/struct/whatever, which provides some helpful information about how to use tha

Generates the declaration (but *NOT* the *implementation*) of the `__try_init_provider` method. This includes a detailed doc comment. Each generator

Gets a string which contains the C type for use generating C/C++ code. For example if the `CType` is `VoidPtr`, this function returns `void *`

Scans an already-parsed AST and finds the source dependencies within the file

Checks the cache to see if the provider described by `provider` has already been processed by the native code generator and produced a native lib and

Returns the name of the module in which most of the implementation code for this trait will be located.

Given the path to a Cargo manifest and the name of a package, invokes `cargo metadata` and parses the output to find all of the targets of that packag

Gets test data, where each test case is a tuple with the input type, and the output type with all references given a lifetime of `'mylife'`

Scans the argument's type information after it has been annotated with explicit lifetimes for every reference, and returns a vector of a copy of those

Given the path to a source file and a previously-discovered dependency, attempts to resolve that dependency to an existing source file.

Consumes this spec and returns the same spec with all probes removed, and instead the probes vector is returned separately. This is a convenient way

This function is the counterpart to `build`, which is intended to be invoked in the `tracers` `build.rs` script. It reads the feature flags enabled o

Helper method with takes a path (eg `foo/bar/baz.lib`) and a hash code (eg `0xBADF00D`), and produces a version of that path with the hash added to th

Build a tuple type expression whose elements correspond to the arguments of this probe. This includes only the type of each argument, and has no expli

Build a tuple value expression, consisting of the names of the probe arguments in a tuple. For example: ```noexecute fn probe(arg0: &str, arg1: usize

Helper which converts any type in the `quote/proc_macro2/syn` crates which implements `ToTokens` (that is to say, anything that can be placed inside a

Given the path to a source file containing a `mod` item, and the name of the module, attempts to find the source file which contains that module. It

Fires the probe. Note that it's assumed higher level code has tested `is_enabled()` already. If the probe isnt' enabled, it's not an error to attempt