pastiche 0.2.0

A library for exposing non public types, fields, and functions from a crate
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

A library for exposing non public types, fields, and functions from a crate.

The libraries I use often expose *most* of their lower level details but forget
to mark a few structs or fields as public. Necessitating me to copy over the
struct, a load of traits, all the methods I need, everything those traits
and methods need to import, and all the crates they use. Just for me to be able
to add "`pub`" in front of it.

Most functionality is implemented but this is mainly meant for testing or
debugging and is still a work in progress. So don't use this for production
code.

# Features and Roadmap
- [x] copy definition
- [x] change visibility
- [x] most items: `const`, `enum`, `fn`, `macro_rules`, `static`, `struct`, `trait`, `union`
- [~] attributes
- [x] std library crates
- ~~[ ] support not specifying crate verion/dont use file system paths~~
    - [ ] support not specifying rustc version
- [?] copying modules
- [ ] re-exports
- [ ] recursivly copying item dependancies
- [ ] "safe"-ish transmutes

## Ideas
- enforcing, changing, adding, removing, ignoring:
    - [x] items variant (`Struct`, `fn`, etc)
    - [ ] field names
    - [ ] field types
    - [ ] field size, alignment
    - [ ] associated types and constants
    - [ ] method arguments
    - [ ] method return value

# Example

```rust
use pastiche::pastiche_attr;
use std::num::IntErrorKind;
use std::str::FromStr;

/// A new type that shadows the definition and attributes at
/// [`core::num::ParseIntError`].
/// Internally it searches the fs and copy-pastes the definition.
#[pastiche_attr]
#[pastiche_crate = "stable@1.82.0"]
// NOTE: doesn't support re-exports rn, so we have to specify the
// "real" module path
#[pastiche_path = "core::num::error::ParseIntError"]
#[pastiche_sub_vis(pub)] // set fields to public
pub struct MyParseIntError {
    // body is ignored for now
}

fn main() {
    // We can now directly construct a ParseIntError.
    let my_error = MyParseIntError { kind: IntErrorKind::InvalidDigit };
    dbg!(&my_error);

    // Rather than having to fail a parse. :/
    let std_error = i32::from_str("baddbeef").unwrap_err();
    dbg!(&std_error);

    assert_eq!(&my_error.kind, std_error.kind());
}
```

## License

Licensed under either of

- Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or https://www.apache.org/licenses/LICENSE-2.0)
- MIT license ([LICENSE-MIT](LICENSE-MIT) or https://opensource.org/licenses/MIT)

at your option.

### Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted
for inclusion in the work by you, as defined in the Apache-2.0 license, shall be
dual licensed as above, without any additional terms or conditions.