SYMBOL INDEX (1963 symbols across 226 files) FILE: build.rs function main (line 7) | fn main() { type RustVersion (line 55) | struct RustVersion { function rustc_version (line 60) | fn rustc_version() -> Option { FILE: demo/build.rs function main (line 1) | fn main() { FILE: demo/include/blobstore.h function namespace (line 5) | namespace org { FILE: demo/src/blobstore.cc type org (line 9) | namespace org { type blobstore (line 10) | namespace blobstore { class BlobstoreClient::impl (line 16) | class BlobstoreClient::impl { class BlobstoreClient::impl (line 25) | class BlobstoreClient::impl function BlobMetadata (line 55) | BlobMetadata BlobstoreClient::metadata(uint64_t blobid) const { function new_blobstore_client (line 66) | std::unique_ptr new_blobstore_client() { FILE: demo/src/main.rs type BlobMetadata (line 4) | struct BlobMetadata { function next_chunk (line 13) | fn next_chunk(buf: &mut MultiBuf) -> &[u8]; function new_blobstore_client (line 22) | fn new_blobstore_client() -> UniquePtr; function put (line 23) | fn put(&self, parts: &mut MultiBuf) -> u64; function tag (line 24) | fn tag(&self, blobid: u64, tag: &str); function metadata (line 25) | fn metadata(&self, blobid: u64) -> BlobMetadata; type MultiBuf (line 34) | pub struct MultiBuf { function next_chunk (line 38) | pub fn next_chunk(buf: &mut MultiBuf) -> &[u8] { function main (line 44) | fn main() { FILE: flags/src/impl.rs constant STD (line 2) | pub const STD: &str = { FILE: gen/build/src/cargo.rs type CargoEnv (line 11) | struct CargoEnv { method load (line 48) | fn load() -> Self { type CargoEnvCfgEvaluator (line 16) | pub(super) struct CargoEnvCfgEvaluator; method eval (line 19) | fn eval(&self, name: &str, query_value: Option<&str>) -> CfgResult { type Name (line 73) | struct Name(String); method borrow (line 105) | fn borrow(&self) -> &Lookup { method cmp (line 76) | fn cmp(&self, rhs: &Self) -> Ordering { method partial_cmp (line 82) | fn partial_cmp(&self, rhs: &Self) -> Option { method eq (line 90) | fn eq(&self, rhs: &Self) -> bool { type Lookup (line 96) | struct Lookup(str); method new (line 99) | fn new(name: &str) -> &Self { method cmp (line 111) | fn cmp(&self, rhs: &Self) -> Ordering { method partial_cmp (line 120) | fn partial_cmp(&self, rhs: &Self) -> Option { method eq (line 128) | fn eq(&self, rhs: &Self) -> bool { type CaseAgnosticByte (line 136) | struct CaseAgnosticByte(u8); method cmp (line 139) | fn cmp(&self, rhs: &Self) -> Ordering { method partial_cmp (line 145) | fn partial_cmp(&self, rhs: &Self) -> Option { method eq (line 153) | fn eq(&self, rhs: &Self) -> bool { FILE: gen/build/src/cfg.rs type Cfg (line 6) | pub struct Cfg<'a> { method fmt (line 319) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { type CurrentCfg (line 353) | struct CurrentCfg { method default (line 362) | fn default() -> Self { function current (line 380) | fn current() -> &'static RwLock { type Handle (line 402) | struct Handle(*const Cfg<'static>); function current (line 405) | fn current() -> super::Cfg<'a> { function handle (line 422) | const fn handle(self: &Cfg<'a>) -> Handle { type Cfg (line 429) | pub enum Cfg<'a> { method fmt (line 435) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { type Target (line 445) | type Target = super::Cfg<'a>; method deref (line 447) | fn deref(&self) -> &Self::Target { method deref_mut (line 463) | fn deref_mut(&mut self) -> &mut Self::Target { method drop (line 476) | fn drop(&mut self) { FILE: gen/build/src/deps.rs type Crate (line 7) | pub(crate) struct Crate { method print_to_cargo (line 19) | pub(crate) fn print_to_cargo(&self) { type HeaderDir (line 13) | pub(crate) struct HeaderDir { function direct_dependencies (line 41) | pub(crate) fn direct_dependencies() -> Vec { FILE: gen/build/src/error.rs type Result (line 8) | pub(super) type Result = std::result::Result; type Error (line 11) | pub(super) enum Error { method from (line 95) | fn from(err: fs::Error) -> Self { constant LINKS_DOCUMENTATION (line 30) | const LINKS_DOCUMENTATION: &str = method fmt (line 34) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { method source (line 86) | fn source(&self) -> Option<&(dyn StdError + 'static)> { FILE: gen/build/src/intern.rs type InternedString (line 5) | pub(crate) struct InternedString(&'static str); method str (line 8) | pub(crate) fn str(self) -> &'static str { function intern (line 13) | pub(crate) fn intern(s: &str) -> InternedString { FILE: gen/build/src/lib.rs function bridge (line 119) | pub fn bridge(rust_source_file: impl AsRef) -> Build { function bridges (line 134) | pub fn bridges(rust_source_files: impl IntoIterator Result { function build (line 212) | fn build(rust_source_files: &mut dyn Iterator>) ... function validate_cfg (line 239) | fn validate_cfg(prj: &Project) -> Result<()> { function make_this_crate (line 267) | fn make_this_crate(prj: &Project) -> Result { function make_crate_dir (line 363) | fn make_crate_dir(prj: &Project) -> PathBuf { function make_include_dir (line 382) | fn make_include_dir(prj: &Project) -> Result { function generate_bridge (line 396) | fn generate_bridge(prj: &Project, build: &mut Build, rust_source_file: &... function best_effort_copy_headers (line 432) | fn best_effort_copy_headers(src: &Path, dst: &Path, max_depth: usize) { function env_os (line 474) | fn env_os(key: impl AsRef) -> Result { FILE: gen/build/src/out.rs function write (line 7) | pub(crate) fn write(path: impl AsRef, content: &[u8]) -> Result<()> { function relative_symlink_file (line 32) | pub(crate) fn relative_symlink_file( function absolute_symlink_file (line 45) | pub(crate) fn absolute_symlink_file( function relative_symlink_dir (line 57) | pub(crate) fn relative_symlink_dir( function prepare_parent_directory_for_symlink (line 70) | fn prepare_parent_directory_for_symlink(link: &Path) -> fs::Result<()> { function symlink_file (line 80) | fn symlink_file( function symlink_dir (line 108) | fn symlink_dir( function best_effort_remove (line 121) | fn best_effort_remove(path: &Path) { function best_effort_relativize_symlink (line 156) | fn best_effort_relativize_symlink(original: impl AsRef, link: impl... function abstractly_relativize_symlink (line 180) | fn abstractly_relativize_symlink( function path_contains_intermediate_components (line 230) | fn path_contains_intermediate_components(path: impl AsRef) -> bool { function split_after_common_prefix (line 236) | fn split_after_common_prefix<'first, 'second>( function test_relativize_symlink_unix (line 272) | fn test_relativize_symlink_unix() { function test_relativize_symlink_windows (line 289) | fn test_relativize_symlink_windows() { FILE: gen/build/src/paths.rs function manifest_dir (line 6) | pub(crate) fn manifest_dir() -> Result { function out_dir (line 10) | pub(crate) fn out_dir() -> Result { function local_relative_path (line 18) | pub(crate) fn local_relative_path(path: &Path) -> PathBuf { type PathExt (line 30) | pub(crate) trait PathExt { method with_appended_extension (line 31) | fn with_appended_extension(&self, suffix: impl AsRef) -> PathBuf; method with_appended_extension (line 35) | fn with_appended_extension(&self, suffix: impl AsRef) -> PathBuf { function symlink_or_copy (line 43) | pub(crate) fn symlink_or_copy( function symlink_or_copy (line 52) | pub(crate) fn symlink_or_copy( function symlink_or_copy (line 69) | pub(crate) fn symlink_or_copy( FILE: gen/build/src/target.rs type TargetDir (line 5) | pub(crate) enum TargetDir { function find_target_dir (line 10) | pub(crate) fn find_target_dir(out_dir: &Path) -> TargetDir { FILE: gen/build/src/vec.rs type InternedVec (line 4) | pub(crate) trait InternedVec method vec (line 8) | fn vec(&self) -> Vec<&'static T>; function vec (line 15) | fn vec(&self) -> Vec<&'static T> { function intern (line 20) | pub(crate) fn intern(elements: &[&T]) -> Vec type Element (line 27) | pub(crate) trait Element { method intern (line 28) | fn intern(&self) -> InternedString; method unintern (line 29) | fn unintern(_: InternedString) -> &'static Self; method intern (line 33) | fn intern(&self) -> InternedString { method unintern (line 37) | fn unintern(interned: InternedString) -> &'static Self { method intern (line 43) | fn intern(&self) -> InternedString { method unintern (line 47) | fn unintern(interned: InternedString) -> &'static Self { FILE: gen/cmd/src/app.rs constant USAGE (line 17) | const USAGE: &str = "\ constant TEMPLATE (line 23) | const TEMPLATE: &str = "\ function app (line 34) | fn app() -> Command { constant INPUT (line 54) | const INPUT: &str = "input"; constant CFG (line 55) | const CFG: &str = "cfg"; constant CXX_IMPL_ANNOTATIONS (line 56) | const CXX_IMPL_ANNOTATIONS: &str = "cxx-impl-annotations"; constant HELP (line 57) | const HELP: &str = "help"; constant HEADER (line 58) | const HEADER: &str = "header"; constant INCLUDE (line 59) | const INCLUDE: &str = "include"; constant OUTPUT (line 60) | const OUTPUT: &str = "output"; constant VERSION (line 61) | const VERSION: &str = "version"; function from_args (line 63) | pub(super) fn from_args() -> Opt { function arg_input (line 122) | fn arg_input() -> Arg { function arg_cfg (line 129) | fn arg_cfg() -> Arg { function arg_cxx_impl_annotations (line 156) | fn arg_cxx_impl_annotations() -> Arg { function arg_header (line 171) | fn arg_header() -> Arg { function arg_help (line 178) | fn arg_help() -> Arg { function arg_include (line 185) | fn arg_include() -> Arg { function arg_output (line 199) | fn arg_output() -> Arg { function arg_version (line 212) | fn arg_version() -> Arg { FILE: gen/cmd/src/cfg.rs type CfgValue (line 8) | pub(crate) enum CfgValue { constant FALSE (line 14) | const FALSE: Self = CfgValue::Bool(false); constant TRUE (line 15) | const TRUE: Self = CfgValue::Bool(true); type FlagsCfgEvaluator (line 18) | pub(crate) struct FlagsCfgEvaluator { method new (line 23) | pub(crate) fn new(map: Map>) -> Self { method eval (line 29) | fn eval(&self, name: &str, value: Option<&str>) -> CfgResult { method fmt (line 68) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { function parse (line 76) | pub(crate) fn parse(input: ParseStream) -> syn::Result<(String, CfgValue... FILE: gen/cmd/src/main.rs type Opt (line 49) | struct Opt { function main (line 58) | fn main() { type Kind (line 65) | enum Kind { function try_main (line 71) | fn try_main() -> Result<()> { FILE: gen/cmd/src/output.rs type Output (line 4) | pub(crate) enum Output { method ends_with (line 10) | pub(crate) fn ends_with(&self, suffix: &str) -> bool { FILE: gen/cmd/src/test.rs constant EXPECTED (line 1) | const EXPECTED: &str = "\ function test_help (line 48) | fn test_help() { function test_cli (line 59) | fn test_cli() { FILE: gen/lib/src/error.rs type Error (line 9) | pub struct Error { method span (line 15) | pub fn span(&self) -> Option { method from (line 24) | fn from(err: crate::gen::Error) -> Self { method fmt (line 30) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { method fmt (line 36) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { method source (line 42) | fn source(&self) -> Option<&(dyn StdError + 'static)> { type Item (line 48) | type Item = Error; type IntoIter (line 49) | type IntoIter = IntoIter; method into_iter (line 51) | fn into_iter(self) -> Self::IntoIter { type IntoIter (line 59) | pub enum IntoIter { type Item (line 65) | type Item = Error; method next (line 67) | fn next(&mut self) -> Option { FILE: gen/lib/src/lib.rs function generate_header_and_cc (line 57) | pub fn generate_header_and_cc(rust_source: TokenStream, opt: &Opt) -> Re... FILE: gen/lib/tests/test.rs function test_positive (line 5) | fn test_positive() { function test_negative (line 24) | fn test_negative() { FILE: gen/src/block.rs type Block (line 4) | pub(crate) enum Block<'a> { function write_begin (line 13) | pub(crate) fn write_begin(self, out: &mut String) { function write_end (line 21) | pub(crate) fn write_end(self, out: &mut String) { function write_common (line 27) | fn write_common(self, out: &mut String) { FILE: gen/src/builtin.rs type Builtins (line 8) | pub(crate) struct Builtins<'a> { function new (line 44) | pub(crate) fn new() -> Self { function write (line 49) | pub(super) fn write(out: &mut OutFile) { function write_builtin (line 348) | fn write_builtin<'a>( function test_write_builtin (line 452) | fn test_write_builtin() { FILE: gen/src/builtin/alignmax.h function namespace (line 4) | namespace rust { FILE: gen/src/builtin/deleter_if.h function namespace (line 3) | namespace rust { FILE: gen/src/builtin/destroy.h function namespace (line 3) | namespace rust { FILE: gen/src/builtin/friend_impl.h function namespace (line 3) | namespace rust { FILE: gen/src/builtin/manually_drop.h function namespace (line 6) | namespace rust { FILE: gen/src/builtin/maybe_uninit.h function namespace (line 5) | namespace rust { FILE: gen/src/builtin/maybe_uninit_detail.h function namespace (line 5) | namespace rust { FILE: gen/src/builtin/ptr_len.h function namespace (line 4) | namespace rust { FILE: gen/src/builtin/relocatable_or_array.h function namespace (line 5) | namespace rust { FILE: gen/src/builtin/repr_fat.h function namespace (line 5) | namespace rust { FILE: gen/src/builtin/rust_error.h function namespace (line 6) | namespace rust { FILE: gen/src/builtin/rust_slice_uninit.h function namespace (line 4) | namespace rust { FILE: gen/src/builtin/rust_str_uninit.h function namespace (line 4) | namespace rust { FILE: gen/src/builtin/shared_ptr.h function namespace (line 5) | namespace rust { FILE: gen/src/builtin/trycatch.h function namespace (line 7) | namespace rust { FILE: gen/src/builtin/trycatch_detail.h function namespace (line 8) | namespace rust { FILE: gen/src/builtin/vector.h function namespace (line 6) | namespace rust { FILE: gen/src/cfg.rs type UnsupportedCfgEvaluator (line 10) | pub(super) struct UnsupportedCfgEvaluator; method eval (line 13) | fn eval(&self, name: &str, value: Option<&str>) -> CfgResult { function strip (line 21) | pub(super) fn strip( function eval (line 51) | pub(super) fn eval( function try_eval (line 70) | fn try_eval(cfg_evaluator: &dyn CfgEvaluator, expr: &CfgExpr) -> Result<... method from (line 123) | fn from(value: bool) -> Self { FILE: gen/src/check.rs function precheck (line 9) | pub(super) fn precheck(cx: &mut Errors, apis: &[Api], opt: &Opt) { function check_dot_includes (line 15) | fn check_dot_includes(cx: &mut Errors, apis: &[Api]) { FILE: gen/src/error.rs type Result (line 16) | pub(crate) type Result = std::result::Result; type Error (line 19) | pub(crate) enum Error { method from (line 49) | fn from(err: fs::Error) -> Self { method from (line 55) | fn from(err: syn::Error) -> Self { method fmt (line 27) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { method source (line 38) | fn source(&self) -> Option<&(dyn StdError + 'static)> { function format_err (line 60) | pub(super) fn format_err(path: &Path, source: &str, error: Error) -> ! { function report (line 85) | pub(crate) fn report(error: impl StdError) -> impl Display { function sort_syn_errors (line 105) | fn sort_syn_errors(error: syn::Error) -> Vec { function display_syn_error (line 114) | fn display_syn_error(stderr: &mut dyn WriteStyle, path: &Path, source: &... function diagnose (line 158) | fn diagnose(file: usize, range: Range, error: syn::Error) -> Diag... FILE: gen/src/file.rs type File (line 7) | pub(crate) struct File { method parse (line 12) | fn parse(input: ParseStream) -> Result { function parse (line 19) | fn parse(input: ParseStream, modules: &mut Vec) -> Result<()> { function parse_args (line 68) | fn parse_args(attr: &Attribute) -> Result { FILE: gen/src/fs.rs type Result (line 8) | pub(crate) type Result = std::result::Result; type Error (line 11) | pub(crate) struct Error { method kind (line 17) | pub(crate) fn kind(&self) -> io::ErrorKind { method fmt (line 26) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { method source (line 32) | fn source(&self) -> Option<&(dyn StdError + 'static)> { function copy (line 47) | pub(crate) fn copy(from: impl AsRef, to: impl AsRef) -> Resu... function create_dir_all (line 56) | pub(crate) fn create_dir_all(path: impl AsRef) -> Result<()> { function current_dir (line 64) | pub(crate) fn current_dir() -> Result { function exists (line 71) | pub(crate) fn exists(path: impl AsRef) -> bool { function read (line 78) | pub(crate) fn read(path: impl AsRef) -> Result> { function read_stdin (line 86) | pub(crate) fn read_stdin() -> Result> { function remove_file (line 94) | pub(crate) fn remove_file(path: impl AsRef) -> Result<()> { function remove_dir (line 102) | pub(crate) fn remove_dir(path: impl AsRef) -> Result<()> { function symlink (line 110) | fn symlink<'a>( function symlink_fail (line 126) | pub(crate) fn symlink_fail(original: impl AsRef, link: impl AsRef<... function symlink_file (line 144) | pub(crate) fn symlink_file(original: impl AsRef, link: impl AsRef<... function symlink_file (line 149) | pub(crate) fn symlink_file(original: impl AsRef, link: impl AsRef<... function symlink_dir (line 158) | pub(crate) fn symlink_dir(original: impl AsRef, link: impl AsRef, contents: impl AsRef<[u8]>) ... FILE: gen/src/guard.rs type Guard (line 6) | pub(crate) struct Guard { method new (line 12) | pub fn new(out: &mut OutFile, kind: &'static str, name: &Pair) -> Self { method fmt (line 20) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { FILE: gen/src/ifndef.rs function write (line 4) | pub(super) fn write(out: &mut Content, needed: bool, guard: &str) { function find_line (line 37) | fn find_line(mut offset: usize, line: &str) -> Option { FILE: gen/src/include.rs type Include (line 13) | pub struct Include { method from (line 203) | fn from(include: &syntax::Include) -> Self { type Includes (line 22) | pub(crate) struct Includes<'a> { function new (line 50) | pub(crate) fn new() -> Self { function insert (line 54) | pub(crate) fn insert(&mut self, include: impl Into) { function has_cxx_header (line 58) | pub(crate) fn has_cxx_header(&self) -> bool { function write (line 65) | pub(super) fn write(out: &mut OutFile) { function extend (line 197) | fn extend>(&mut self, iter: I) { type Target (line 212) | type Target = Content<'a>; method deref (line 214) | fn deref(&self) -> &Self::Target { method deref_mut (line 220) | fn deref_mut(&mut self) -> &mut Self::Target { FILE: gen/src/mod.rs type Opt (line 48) | pub struct Opt { type CfgEvaluator (line 70) | pub trait CfgEvaluator { method eval (line 73) | fn eval(&self, name: &str, value: Option<&str>) -> CfgResult; type CfgResult (line 77) | pub enum CfgResult { type GeneratedCode (line 91) | pub struct GeneratedCode { method default (line 99) | fn default() -> Self { function generate_from_path (line 112) | pub(super) fn generate_from_path(path: &Path, opt: &Opt) -> GeneratedCode { function read_to_string (line 123) | fn read_to_string(path: &Path) -> Result { function generate_from_string (line 135) | fn generate_from_string(source: &str, opt: &Opt) -> Result { function generate (line 145) | pub(super) fn generate(syntax: File, opt: &Opt) -> Result { FILE: gen/src/names.rs method to_fully_qualified (line 4) | pub(crate) fn to_fully_qualified(&self) -> String { FILE: gen/src/namespace.rs method namespace (line 5) | pub(crate) fn namespace(&self) -> &Namespace { FILE: gen/src/nested.rs type NamespaceEntries (line 5) | pub(crate) struct NamespaceEntries<'a> { function new (line 11) | pub(crate) fn new(apis: Vec<&'a Api>) -> Self { function direct_content (line 15) | pub(crate) fn direct_content(&self) -> &[&'a Api] { function nested_content (line 19) | pub(crate) fn nested_content( function sort_by_inner_namespace (line 26) | fn sort_by_inner_namespace(apis: Vec<&Api>, depth: usize) -> NamespaceEn... function test_ns_entries_sort (line 65) | fn test_ns_entries_sort() { function assert_ident (line 122) | fn assert_ident(api: &Api, expected: &str) { function make_api (line 130) | fn make_api(ns: Option<&str>, ident: &str) -> Api { FILE: gen/src/out.rs type OutFile (line 11) | pub(crate) struct OutFile<'a> { type Content (line 22) | pub(crate) struct Content<'a> { type BlockBoundary (line 32) | enum BlockBoundary<'a> { function new (line 38) | pub(crate) fn new(header: bool, opt: &'a Opt, types: &'a Types) -> Self { function next_section (line 51) | pub(crate) fn next_section(&mut self) { function suppress_next_section (line 55) | pub(crate) fn suppress_next_section(&mut self) { function begin_block (line 59) | pub(crate) fn begin_block(&mut self, block: Block<'a>) { function end_block (line 63) | pub(crate) fn end_block(&mut self, block: Block<'a>) { function set_namespace (line 67) | pub(crate) fn set_namespace(&mut self, namespace: &'a Namespace) { function content (line 71) | pub(crate) fn content(&mut self) -> Vec { function flush (line 104) | fn flush(&mut self) { method write_str (line 114) | fn write_str(&mut self, s: &str) -> fmt::Result { method eq (line 121) | fn eq(&self, _other: &Self) -> bool { function new (line 127) | pub(crate) fn new() -> Self { function next_section (line 131) | pub(crate) fn next_section(&mut self) { function suppress_next_section (line 135) | pub(crate) fn suppress_next_section(&mut self) { function begin_block (line 139) | pub(crate) fn begin_block(&mut self, block: Block<'a>) { function end_block (line 143) | pub(crate) fn end_block(&mut self, block: Block<'a>) { function set_namespace (line 147) | pub(crate) fn set_namespace(&mut self, namespace: &'a Namespace) { function write_fmt (line 157) | pub(crate) fn write_fmt(&mut self, args: Arguments) { function write (line 161) | fn write(&mut self, b: &str) { function push_block_boundary (line 176) | fn push_block_boundary(&mut self, boundary: BlockBoundary<'a>) { function flush (line 186) | fn flush(&mut self) { function flush_blocks (line 193) | fn flush_blocks(&mut self) { function rev (line 225) | fn rev(self) -> BlockBoundary<'a> { type InfallibleWrite (line 233) | pub(crate) trait InfallibleWrite { method write_fmt (line 234) | fn write_fmt(&mut self, args: Arguments); method write_fmt (line 238) | fn write_fmt(&mut self, args: Arguments) { method write_fmt (line 244) | fn write_fmt(&mut self, args: Arguments) { method write_fmt (line 250) | fn write_fmt(&mut self, args: Arguments) { FILE: gen/src/pragma.rs type Pragma (line 5) | pub(crate) struct Pragma<'a> { function new (line 17) | pub fn new() -> Self { function write (line 22) | pub(super) fn write(out: &mut OutFile) { FILE: gen/src/write.rs function gen (line 20) | pub(super) fn gen(apis: &[Api], types: &Types, opt: &Opt, header: bool) ... function write_macros (line 40) | fn write_macros(out: &mut OutFile, apis: &[Api]) { function write_forward_declarations (line 62) | fn write_forward_declarations(out: &mut OutFile, apis: &[Api]) { function write_data_structures (line 97) | fn write_data_structures<'a>(out: &mut OutFile<'a>, apis: &'a [Api]) { function write_functions (line 166) | fn write_functions<'a>(out: &mut OutFile<'a>, apis: &'a [Api]) { function write_std_specializations (line 194) | fn write_std_specializations(out: &mut OutFile, apis: &[Api]) { function pick_includes_and_builtins (line 227) | fn pick_includes_and_builtins(out: &mut OutFile, apis: &[Api]) { function write_doc (line 258) | fn write_doc(out: &mut OutFile, indent: &str, doc: &Doc) { function write_struct (line 277) | fn write_struct<'a>(out: &mut OutFile<'a>, strct: &'a Struct, methods: &... function write_struct_decl (line 383) | fn write_struct_decl(out: &mut OutFile, ident: &Pair) { function write_enum_decl (line 387) | fn write_enum_decl(out: &mut OutFile, enm: &Enum) { function write_struct_using (line 393) | fn write_struct_using(out: &mut OutFile, ident: &Pair) { function write_opaque_type (line 397) | fn write_opaque_type<'a>(out: &mut OutFile<'a>, ety: &'a ExternType, met... function write_enum (line 444) | fn write_enum<'a>(out: &mut OutFile<'a>, enm: &'a Enum) { function check_enum (line 469) | fn check_enum<'a>(out: &mut OutFile<'a>, enm: &'a Enum) { function write_discriminant (line 503) | fn write_discriminant(out: &mut OutFile, repr: Atom, discriminant: Discr... function write_binary_bitwise_op (line 515) | fn write_binary_bitwise_op(out: &mut OutFile, op: &str, enm: &Enum) { function write_enum_operators (line 529) | fn write_enum_operators(out: &mut OutFile, enm: &Enum) { function check_trivial_extern_type (line 546) | fn check_trivial_extern_type(out: &mut OutFile, alias: &TypeAlias, reaso... function write_struct_operator_decls (line 636) | fn write_struct_operator_decls<'a>(out: &mut OutFile<'a>, strct: &'a Str... function write_struct_operators (line 709) | fn write_struct_operators<'a>(out: &mut OutFile<'a>, strct: &'a Struct) { function write_opaque_type_layout_decls (line 797) | fn write_opaque_type_layout_decls<'a>(out: &mut OutFile<'a>, ety: &'a Ex... function write_opaque_type_layout (line 812) | fn write_opaque_type_layout<'a>(out: &mut OutFile<'a>, ety: &'a ExternTy... function begin_function_definition (line 841) | fn begin_function_definition(out: &mut OutFile) { function write_cxx_function_shim (line 847) | fn write_cxx_function_shim<'a>(out: &mut OutFile<'a>, efn: &'a ExternFn) { function write_function_pointer_trampoline (line 1026) | fn write_function_pointer_trampoline(out: &mut OutFile, efn: &ExternFn, ... function write_rust_function_decl (line 1048) | fn write_rust_function_decl<'a>(out: &mut OutFile<'a>, efn: &'a ExternFn) { function write_rust_function_decl_impl (line 1057) | fn write_rust_function_decl_impl( function write_rust_function_shim (line 1118) | fn write_rust_function_shim<'a>(out: &mut OutFile<'a>, efn: &'a ExternFn) { function write_rust_function_shim_decl (line 1141) | fn write_rust_function_shim_decl( function write_rust_function_shim_impl (line 1183) | fn write_rust_function_shim_impl( function write_return_type (line 1330) | fn write_return_type(out: &mut OutFile, ty: &Option) { function indirect_return (line 1337) | fn indirect_return(sig: &Signature, types: &Types, lang: Lang) -> bool { function write_indirect_return_type (line 1348) | fn write_indirect_return_type(out: &mut OutFile, ty: &Type) { function write_indirect_return_type_space (line 1365) | fn write_indirect_return_type_space(out: &mut OutFile, ty: &Type) { function write_extern_return_type_space (line 1374) | fn write_extern_return_type_space(out: &mut OutFile, sig: &Signature, la... function write_extern_arg (line 1396) | fn write_extern_arg(out: &mut OutFile, arg: &Var) { function write_type (line 1410) | fn write_type(out: &mut OutFile, ty: &Type) { function stringify_type (line 1414) | fn stringify_type(ty: &Type, types: &Types) -> String { function write_type_to_generic_writer (line 1420) | fn write_type_to_generic_writer(out: &mut impl InfallibleWrite, ty: &Typ... function write_atom (line 1505) | fn write_atom(out: &mut impl InfallibleWrite, atom: Atom) { function write_type_space (line 1526) | fn write_type_space(out: &mut OutFile, ty: &Type) { function write_type_space_to_generic_writer (line 1530) | fn write_type_space_to_generic_writer(out: &mut impl InfallibleWrite, ty... function write_space_after_type (line 1535) | fn write_space_after_type(out: &mut impl InfallibleWrite, ty: &Type) { function write_generic_instantiations (line 1553) | fn write_generic_instantiations(out: &mut OutFile) { function write_rust_box_extern (line 1587) | fn write_rust_box_extern(out: &mut OutFile, key: &NamedImplKey) { function write_rust_vec_extern (line 1610) | fn write_rust_vec_extern(out: &mut OutFile, key: &NamedImplKey) { function write_rust_box_impl (line 1659) | fn write_rust_box_impl(out: &mut OutFile, key: &NamedImplKey) { function write_rust_vec_impl (line 1692) | fn write_rust_vec_impl(out: &mut OutFile, key: &NamedImplKey) { function write_unique_ptr (line 1780) | fn write_unique_ptr(out: &mut OutFile, key: &NamedImplKey) { function write_unique_ptr_common (line 1785) | fn write_unique_ptr_common(out: &mut OutFile, ty: &Type) { function write_shared_ptr (line 1888) | fn write_shared_ptr(out: &mut OutFile, key: &NamedImplKey) { function write_weak_ptr (line 1985) | fn write_weak_ptr(out: &mut OutFile, key: &NamedImplKey) { function write_cxx_vector (line 2055) | fn write_cxx_vector(out: &mut OutFile, key: &NamedImplKey) { FILE: include/cxx.h type unsafe_bitcopy_t (line 34) | struct unsafe_bitcopy_t function class (line 44) | class String final { function class (line 120) | class Str final { FILE: macro/src/attrs.rs method all (line 7) | pub(crate) fn all(&self) -> PrintOtherAttrs { method cfg (line 16) | pub(crate) fn cfg(&self) -> PrintOtherAttrs { method cfg_and_lint (line 25) | pub(crate) fn cfg_and_lint(&self) -> PrintOtherAttrs { type PrintOtherAttrs (line 35) | pub(crate) struct PrintOtherAttrs<'a> { method to_tokens (line 43) | fn to_tokens(&self, tokens: &mut TokenStream) { function print_attrs_as_outer (line 56) | fn print_attrs_as_outer(attrs: &[Attribute], tokens: &mut TokenStream) { FILE: macro/src/cfg.rs function into_attr (line 7) | pub(crate) fn into_attr(&self) -> Option { function as_meta (line 25) | pub(crate) fn as_meta(&self) -> impl ToTokens + '_ { type Print (line 33) | struct Print<'a, Cfg> { method to_tokens (line 39) | fn to_tokens(&self, tokens: &mut TokenStream) { method to_tokens (line 73) | fn to_tokens(&self, tokens: &mut TokenStream) { FILE: macro/src/derive.rs function expand_struct (line 7) | pub(crate) fn expand_struct( function expand_enum (line 44) | pub(crate) fn expand_enum(enm: &Enum, actual_derives: &mut Option TokenStream { function struct_clone (line 118) | fn struct_clone(strct: &Struct, span: Span) -> TokenStream { function struct_debug (line 150) | fn struct_debug(strct: &Struct, span: Span) -> TokenStream { function struct_default (line 171) | fn struct_default(strct: &Struct, span: Span) -> TokenStream { function struct_ord (line 193) | fn struct_ord(strct: &Struct, span: Span) -> TokenStream { function struct_partial_ord (line 216) | fn struct_partial_ord(strct: &Struct, span: Span) -> TokenStream { function enum_bitand (line 250) | fn enum_bitand(enm: &Enum, span: Span) -> TokenStream { function enum_bitor (line 268) | fn enum_bitor(enm: &Enum, span: Span) -> TokenStream { function enum_bitxor (line 286) | fn enum_bitxor(enm: &Enum, span: Span) -> TokenStream { function enum_copy (line 304) | fn enum_copy(enm: &Enum, span: Span) -> TokenStream { function enum_clone (line 315) | fn enum_clone(enm: &Enum, span: Span) -> TokenStream { function enum_debug (line 331) | fn enum_debug(enm: &Enum, span: Span) -> TokenStream { function enum_default (line 357) | fn enum_default(enm: &Enum, span: Span) -> TokenStream { function enum_ord (line 379) | fn enum_ord(enm: &Enum, span: Span) -> TokenStream { function enum_partial_ord (line 394) | fn enum_partial_ord(enm: &Enum, span: Span) -> TokenStream { FILE: macro/src/expand.rs function bridge (line 28) | pub(crate) fn bridge(mut ffi: Module) -> Result { function expand (line 57) | fn expand(ffi: Module, doc: Doc, attrs: OtherAttrs, apis: &[Api], types:... function expand_struct (line 172) | fn expand_struct(strct: &Struct) -> TokenStream { function expand_struct_nonempty (line 221) | fn expand_struct_nonempty(strct: &Struct) -> TokenStream { function expand_struct_operators (line 248) | fn expand_struct_operators(strct: &Struct) -> TokenStream { function expand_struct_forbid_drop (line 363) | fn expand_struct_forbid_drop(strct: &Struct) -> TokenStream { function expand_enum (line 377) | fn expand_enum(enm: &Enum) -> TokenStream { function expand_cxx_type (line 439) | fn expand_cxx_type(ety: &ExternType) -> TokenStream { function expand_cxx_type_assert_pinned (line 482) | fn expand_cxx_type_assert_pinned(ety: &ExternType, types: &Types) -> Tok... function expand_extern_shared_struct (line 522) | fn expand_extern_shared_struct(ety: &ExternType, ffi: &Module) -> TokenS... function expand_associated_functions (line 594) | fn expand_associated_functions(self_type: &Ident, types: &Types) -> Toke... function expand_cxx_function_decl (line 673) | fn expand_cxx_function_decl(efn: &ExternFn, types: &Types) -> TokenStream { function expand_cxx_function_shim (line 725) | fn expand_cxx_function_shim(efn: &ExternFn, types: &Types) -> TokenStream { function expand_function_pointer_trampoline (line 993) | fn expand_function_pointer_trampoline( function expand_rust_type_import (line 1037) | fn expand_rust_type_import(ety: &ExternType) -> TokenStream { function expand_rust_type_impl (line 1048) | fn expand_rust_type_impl(ety: &ExternType) -> TokenStream { function expand_rust_type_assert_unpin (line 1082) | fn expand_rust_type_assert_unpin(ety: &ExternType, types: &Types) -> Tok... function expand_rust_type_layout (line 1095) | fn expand_rust_type_layout(ety: &ExternType, types: &Types) -> TokenStre... function expand_forbid (line 1142) | fn expand_forbid(impls: TokenStream) -> TokenStream { function expand_rust_function_shim (line 1154) | fn expand_rust_function_shim(efn: &ExternFn, types: &Types) -> TokenStre... function expand_rust_function_shim_impl (line 1179) | fn expand_rust_function_shim_impl( function expand_rust_function_shim_super (line 1383) | fn expand_rust_function_shim_super( function expand_type_alias (line 1439) | fn expand_type_alias(alias: &TypeAlias) -> TokenStream { function expand_type_alias_verify (line 1457) | fn expand_type_alias_verify(alias: &TypeAlias, types: &Types) -> TokenSt... function type_id (line 1643) | fn type_id(name: &Pair) -> TokenStream { function expand_rust_box (line 1652) | fn expand_rust_box( function expand_rust_vec (line 1707) | fn expand_rust_vec( function expand_unique_ptr (line 1819) | fn expand_unique_ptr( function expand_shared_ptr (line 1921) | fn expand_shared_ptr( function expand_weak_ptr (line 2025) | fn expand_weak_ptr( function expand_cxx_vector (line 2106) | fn expand_cxx_vector( function expand_return_type (line 2288) | fn expand_return_type(ret: &Option) -> TokenStream { function indirect_return (line 2295) | fn indirect_return(sig: &Signature, types: &Types, lang: Lang) -> bool { function expand_extern_type (line 2306) | fn expand_extern_type(ty: &Type, types: &Types, proper: bool) -> TokenSt... function expand_extern_return_type (line 2382) | fn expand_extern_return_type( function display_namespaced (line 2396) | pub(crate) fn display_namespaced(name: &Pair) -> impl Display + '_ { FILE: macro/src/generics.rs type ResolvedGenericType (line 9) | pub(crate) struct ResolvedGenericType<'a> { function split_for_impl (line 21) | pub(crate) fn split_for_impl<'a>( method to_tokens (line 40) | fn to_tokens(&self, tokens: &mut TokenStream) { function get_impl_generics (line 79) | fn get_impl_generics<'a>(ty: &Type, types: &Types<'a>) -> &'a Lifetimes { function format_for_prevent_unwind_label (line 87) | pub(crate) fn format_for_prevent_unwind_label(ty: &Type) -> TokenStream { function concise_rust_name (line 105) | pub(crate) fn concise_rust_name(ty: &Type) -> String { function concise_cxx_name (line 116) | pub(crate) fn concise_cxx_name(ty: &Type, types: &Types) -> String { type UnderscoreLifetimes (line 130) | pub(crate) struct UnderscoreLifetimes<'a> { method to_underscore_lifetimes (line 135) | pub(crate) fn to_underscore_lifetimes(&self) -> UnderscoreLifetimes { method to_tokens (line 141) | fn to_tokens(&self, tokens: &mut TokenStream) { FILE: macro/src/lib.rs function bridge (line 67) | pub fn bridge(args: TokenStream, input: TokenStream) -> TokenStream { function type_id (line 84) | pub fn type_id(input: TokenStream) -> TokenStream { FILE: macro/src/tests.rs function bridge (line 7) | fn bridge(cxx_bridge: TokenStream) -> String { function test_unique_ptr_with_elided_lifetime_implicit_impl (line 24) | fn test_unique_ptr_with_elided_lifetime_implicit_impl() { function test_unique_ptr_lifetimes_from_explicit_impl (line 51) | fn test_unique_ptr_lifetimes_from_explicit_impl() { function test_vec_string (line 69) | fn test_vec_string() { function test_mangling_covers_cpp_namespace_of_vec_elements (line 96) | fn test_mangling_covers_cpp_namespace_of_vec_elements() { function test_struct_with_lifetime (line 111) | fn test_struct_with_lifetime() { function test_original_lifetimes_used_in_impls (line 141) | fn test_original_lifetimes_used_in_impls() { function test_vec_of_box (line 162) | fn test_vec_of_box() { FILE: macro/src/tokens.rs type ReceiverType (line 6) | pub(crate) struct ReceiverType<'a>(&'a Receiver); type ReceiverTypeSelf (line 7) | pub(crate) struct ReceiverTypeSelf<'a>(&'a Receiver); method ty (line 11) | pub(crate) fn ty(&self) -> ReceiverType { method ty_self (line 16) | pub(crate) fn ty_self(&self) -> ReceiverTypeSelf { method to_tokens (line 22) | fn to_tokens(&self, tokens: &mut TokenStream) { method to_tokens (line 50) | fn to_tokens(&self, tokens: &mut TokenStream) { FILE: macro/src/type_id.rs type Crate (line 6) | pub(crate) enum Crate { method to_tokens (line 12) | fn to_tokens(&self, tokens: &mut TokenStream) { function expand (line 21) | pub(crate) fn expand(krate: Crate, arg: QualifiedName) -> TokenStream { FILE: src/cxx.cc function cxxbridge1$cxx_string$init (line 34) | void cxxbridge1$cxx_string$init(std::string *s, const std::uint8_t *ptr, function cxxbridge1$cxx_string$destroy (line 39) | void cxxbridge1$cxx_string$destroy(std::string *s) noexcept { function cxxbridge1$cxx_string$length (line 48) | std::size_t cxxbridge1$cxx_string$length(const std::string &s) noexcept { function cxxbridge1$cxx_string$clear (line 52) | void cxxbridge1$cxx_string$clear(std::string &s) noexcept { s.clear(); } function cxxbridge1$cxx_string$reserve_total (line 54) | void cxxbridge1$cxx_string$reserve_total(std::string &s, function cxxbridge1$cxx_string$push (line 59) | void cxxbridge1$cxx_string$push(std::string &s, const std::uint8_t *ptr, type rust (line 100) | namespace rust { type cxxbridge1 (line 101) | inline namespace cxxbridge1 { function is_aligned (line 116) | static bool is_aligned(const void *ptr) noexcept { function initString (line 133) | static void initString(String *self, const char *s, std::size_t len) { function initString (line 139) | static void initString(String *self, const char16_t *s, std::size_t ... type String::lossy_t (line 181) | struct String::lossy_t {} function String (line 196) | String String::lossy(const std::string &s) noexcept { function String (line 200) | String String::lossy(const char *s) noexcept { function String (line 205) | String String::lossy(const char *s, std::size_t len) noexcept { function String (line 210) | String String::lossy(const char16_t *s) noexcept { function String (line 216) | String String::lossy(const char16_t *s, std::size_t len) noexcept { function String (line 222) | String &String::operator=(const String &other) & noexcept { function String (line 230) | String &String::operator=(String &&other) & noexcept { function initStr (line 330) | static void initStr(Str *self, const char *ptr, std::size_t len) { function sliceInit (line 422) | void sliceInit(void *self, const void *ptr, std::size_t len) noexcept { function sliceLen (line 428) | std::size_t sliceLen(const void *self) noexcept { function Error (line 531) | Error &Error::operator=(const Error &other) & { function Error (line 544) | Error &Error::operator=(Error &&other) & noexcept { function MaybeUninit (line 560) | MaybeUninit() {} type repr (line 565) | namespace repr { type PtrLen (line 566) | struct PtrLen final { type detail (line 576) | namespace detail { type usize_ignore (line 584) | struct usize_ignore type isize_ignore (line 588) | struct isize_ignore type char_ignore (line 593) | struct char_ignore class Fail (line 595) | class Fail final { method Fail (line 599) | Fail(repr::PtrLen &throw$) noexcept : throw$(throw$) {} type cxxbridge1 (line 865) | inline namespace cxxbridge1 { function is_aligned (line 116) | static bool is_aligned(const void *ptr) noexcept { function initString (line 133) | static void initString(String *self, const char *s, std::size_t len) { function initString (line 139) | static void initString(String *self, const char16_t *s, std::size_t ... type String::lossy_t (line 181) | struct String::lossy_t {} function String (line 196) | String String::lossy(const std::string &s) noexcept { function String (line 200) | String String::lossy(const char *s) noexcept { function String (line 205) | String String::lossy(const char *s, std::size_t len) noexcept { function String (line 210) | String String::lossy(const char16_t *s) noexcept { function String (line 216) | String String::lossy(const char16_t *s, std::size_t len) noexcept { function String (line 222) | String &String::operator=(const String &other) & noexcept { function String (line 230) | String &String::operator=(String &&other) & noexcept { function initStr (line 330) | static void initStr(Str *self, const char *ptr, std::size_t len) { function sliceInit (line 422) | void sliceInit(void *self, const void *ptr, std::size_t len) noexcept { function sliceLen (line 428) | std::size_t sliceLen(const void *self) noexcept { function Error (line 531) | Error &Error::operator=(const Error &other) & { function Error (line 544) | Error &Error::operator=(Error &&other) & noexcept { function MaybeUninit (line 560) | MaybeUninit() {} type repr (line 565) | namespace repr { type PtrLen (line 566) | struct PtrLen final { type detail (line 576) | namespace detail { type usize_ignore (line 584) | struct usize_ignore type isize_ignore (line 588) | struct isize_ignore type char_ignore (line 593) | struct char_ignore class Fail (line 595) | class Fail final { method Fail (line 599) | Fail(repr::PtrLen &throw$) noexcept : throw$(throw$) {} function destroy (line 618) | void destroy(T *ptr) { function cxxbridge1$unique_ptr$std$string$null (line 624) | void cxxbridge1$unique_ptr$std$string$null( function cxxbridge1$unique_ptr$std$string$raw (line 628) | void cxxbridge1$unique_ptr$std$string$raw(std::unique_ptr *... function cxxbridge1$unique_ptr$std$string$drop (line 640) | void cxxbridge1$unique_ptr$std$string$drop( type rust (line 864) | namespace rust { type cxxbridge1 (line 101) | inline namespace cxxbridge1 { function is_aligned (line 116) | static bool is_aligned(const void *ptr) noexcept { function initString (line 133) | static void initString(String *self, const char *s, std::size_t len) { function initString (line 139) | static void initString(String *self, const char16_t *s, std::size_t ... type String::lossy_t (line 181) | struct String::lossy_t {} function String (line 196) | String String::lossy(const std::string &s) noexcept { function String (line 200) | String String::lossy(const char *s) noexcept { function String (line 205) | String String::lossy(const char *s, std::size_t len) noexcept { function String (line 210) | String String::lossy(const char16_t *s) noexcept { function String (line 216) | String String::lossy(const char16_t *s, std::size_t len) noexcept { function String (line 222) | String &String::operator=(const String &other) & noexcept { function String (line 230) | String &String::operator=(String &&other) & noexcept { function initStr (line 330) | static void initStr(Str *self, const char *ptr, std::size_t len) { function sliceInit (line 422) | void sliceInit(void *self, const void *ptr, std::size_t len) noexcept { function sliceLen (line 428) | std::size_t sliceLen(const void *self) noexcept { function Error (line 531) | Error &Error::operator=(const Error &other) & { function Error (line 544) | Error &Error::operator=(Error &&other) & noexcept { function MaybeUninit (line 560) | MaybeUninit() {} type repr (line 565) | namespace repr { type PtrLen (line 566) | struct PtrLen final { type detail (line 576) | namespace detail { type usize_ignore (line 584) | struct usize_ignore type isize_ignore (line 588) | struct isize_ignore type char_ignore (line 593) | struct char_ignore class Fail (line 595) | class Fail final { method Fail (line 599) | Fail(repr::PtrLen &throw$) noexcept : throw$(throw$) {} type cxxbridge1 (line 865) | inline namespace cxxbridge1 { function is_aligned (line 116) | static bool is_aligned(const void *ptr) noexcept { function initString (line 133) | static void initString(String *self, const char *s, std::size_t len) { function initString (line 139) | static void initString(String *self, const char16_t *s, std::size_t ... type String::lossy_t (line 181) | struct String::lossy_t {} function String (line 196) | String String::lossy(const std::string &s) noexcept { function String (line 200) | String String::lossy(const char *s) noexcept { function String (line 205) | String String::lossy(const char *s, std::size_t len) noexcept { function String (line 210) | String String::lossy(const char16_t *s) noexcept { function String (line 216) | String String::lossy(const char16_t *s, std::size_t len) noexcept { function String (line 222) | String &String::operator=(const String &other) & noexcept { function String (line 230) | String &String::operator=(String &&other) & noexcept { function initStr (line 330) | static void initStr(Str *self, const char *ptr, std::size_t len) { function sliceInit (line 422) | void sliceInit(void *self, const void *ptr, std::size_t len) noexcept { function sliceLen (line 428) | std::size_t sliceLen(const void *self) noexcept { function Error (line 531) | Error &Error::operator=(const Error &other) & { function Error (line 544) | Error &Error::operator=(Error &&other) & noexcept { function MaybeUninit (line 560) | MaybeUninit() {} type repr (line 565) | namespace repr { type PtrLen (line 566) | struct PtrLen final { type detail (line 576) | namespace detail { type usize_ignore (line 584) | struct usize_ignore type isize_ignore (line 588) | struct isize_ignore type char_ignore (line 593) | struct char_ignore class Fail (line 595) | class Fail final { method Fail (line 599) | Fail(repr::PtrLen &throw$) noexcept : throw$(throw$) {} FILE: src/cxx_string.rs function string_init (line 19) | fn string_init(this: &mut MaybeUninit, ptr: *const u8, len: u... function string_destroy (line 21) | fn string_destroy(this: &mut MaybeUninit); function string_data (line 23) | fn string_data(this: &CxxString) -> *const u8; function string_length (line 25) | fn string_length(this: &CxxString) -> usize; function string_clear (line 27) | fn string_clear(this: Pin<&mut CxxString>); function string_reserve_total (line 29) | fn string_reserve_total(this: Pin<&mut CxxString>, new_cap: usize); function string_push (line 31) | fn string_push(this: Pin<&mut CxxString>, ptr: *const u8, len: usize); type CxxString (line 45) | pub struct CxxString { method new (line 95) | pub fn new() -> Self { method len (line 104) | pub fn len(&self) -> usize { method is_empty (line 113) | pub fn is_empty(&self) -> bool { method as_bytes (line 118) | pub fn as_bytes(&self) -> &[u8] { method as_ptr (line 137) | pub fn as_ptr(&self) -> *const u8 { method as_c_str (line 150) | pub fn as_c_str(&self) -> &CStr { method to_str (line 157) | pub fn to_str(&self) -> Result<&str, Utf8Error> { method to_string_lossy (line 169) | pub fn to_string_lossy(&self) -> Cow { method clear (line 184) | pub fn clear(self: Pin<&mut Self>) { method reserve (line 208) | pub fn reserve(self: Pin<&mut Self>, additional: usize) { method push_str (line 217) | pub fn push_str(self: Pin<&mut Self>, s: &str) { method push_bytes (line 222) | pub fn push_bytes(self: Pin<&mut Self>, bytes: &[u8]) { method eq (line 252) | fn eq(&self, other: &str) -> bool { method fmt (line 228) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { method fmt (line 234) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { method eq (line 240) | fn eq(&self, other: &Self) -> bool { function eq (line 246) | fn eq(&self, other: &CxxString) -> bool { method partial_cmp (line 260) | fn partial_cmp(&self, other: &Self) -> Option { method cmp (line 266) | fn cmp(&self, other: &Self) -> Ordering { method hash (line 272) | fn hash(&self, state: &mut H) { function write_str (line 278) | fn write_str(&mut self, s: &str) -> fmt::Result { function write (line 286) | fn write(&mut self, buf: &[u8]) -> std::io::Result { function flush (line 291) | fn flush(&mut self) -> std::io::Result<()> { type StackString (line 298) | pub struct StackString { method new (line 305) | pub fn new() -> Self { method init (line 311) | pub unsafe fn init(&mut self, value: impl AsRef<[u8]>) -> Pin<&mut Cxx... method drop (line 322) | fn drop(&mut self) { FILE: src/cxx_vector.rs type CxxVector (line 26) | pub struct CxxVector { function new (line 44) | pub fn new() -> UniquePtr { function len (line 53) | pub fn len(&self) -> usize { function capacity (line 62) | pub fn capacity(&self) -> usize { function is_empty (line 71) | pub fn is_empty(&self) -> bool { function get (line 77) | pub fn get(&self, pos: usize) -> Option<&T> { function index_mut (line 91) | pub fn index_mut(self: Pin<&mut Self>, pos: usize) -> Option> { function get_unchecked (line 109) | pub unsafe fn get_unchecked(&self, pos: usize) -> &T { function index_unchecked_mut (line 132) | pub unsafe fn index_unchecked_mut(self: Pin<&mut Self>, pos: usize) -> P... function as_slice (line 140) | pub fn as_slice(&self) -> &[T] function as_mut_slice (line 162) | pub fn as_mut_slice(self: Pin<&mut Self>) -> &mut [T] function iter (line 176) | pub fn iter(&self) -> Iter { function iter_mut (line 181) | pub fn iter_mut(self: Pin<&mut Self>) -> IterMut { function push (line 190) | pub fn push(self: Pin<&mut Self>, value: T) function pop (line 203) | pub fn pop(self: Pin<&mut Self>) -> Option function reserve (line 239) | pub fn reserve(self: Pin<&mut Self>, additional: usize) { function extend (line 252) | fn extend(&mut self, iter: I) type Iter (line 267) | pub struct Iter<'a, T> { type Item (line 276) | type Item = &'a T; type IntoIter (line 277) | type IntoIter = Iter<'a, T>; method into_iter (line 279) | fn into_iter(self) -> Self::IntoIter { type Item (line 288) | type Item = &'a T; method next (line 290) | fn next(&mut self) -> Option { method size_hint (line 296) | fn size_hint(&self) -> (usize, Option) { method len (line 306) | fn len(&self) -> usize { type IterMut (line 316) | pub struct IterMut<'a, T> { type Item (line 325) | type Item = Pin<&'a mut T>; type IntoIter (line 326) | type IntoIter = IterMut<'a, T>; method into_iter (line 328) | fn into_iter(self) -> Self::IntoIter { type Item (line 337) | type Item = Pin<&'a mut T>; method next (line 339) | fn next(&mut self) -> Option { method size_hint (line 350) | fn size_hint(&self) -> (usize, Option) { method len (line 360) | fn len(&self) -> usize { method fmt (line 371) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { type VectorElement (line 408) | pub unsafe trait VectorElement: Sized { method __typename (line 410) | fn __typename(f: &mut fmt::Formatter) -> fmt::Result; method __vector_new (line 412) | fn __vector_new() -> *mut CxxVector; method __vector_size (line 414) | fn __vector_size(v: &CxxVector) -> usize; method __vector_capacity (line 416) | fn __vector_capacity(v: &CxxVector) -> usize; method __get_unchecked (line 418) | unsafe fn __get_unchecked(v: *mut CxxVector, pos: usize) -> *mut... method __reserve (line 420) | unsafe fn __reserve(v: Pin<&mut CxxVector>, new_cap: usize); method __push_back (line 422) | unsafe fn __push_back(v: Pin<&mut CxxVector>, value: &mut Manual... method __pop_back (line 430) | unsafe fn __pop_back(v: Pin<&mut CxxVector>, out: &mut MaybeUnin... method __unique_ptr_null (line 438) | fn __unique_ptr_null() -> MaybeUninit<*mut c_void>; method __unique_ptr_raw (line 440) | unsafe fn __unique_ptr_raw(raw: *mut CxxVector) -> MaybeUninit<*... method __unique_ptr_get (line 442) | unsafe fn __unique_ptr_get(repr: MaybeUninit<*mut c_void>) -> *const C... method __unique_ptr_release (line 444) | unsafe fn __unique_ptr_release(repr: MaybeUninit<*mut c_void>) -> *mut... method __unique_ptr_drop (line 446) | unsafe fn __unique_ptr_drop(repr: MaybeUninit<*mut c_void>); FILE: src/exception.rs type Exception (line 11) | pub struct Exception { method what (line 25) | pub fn what(&self) -> &str { method fmt (line 16) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { FILE: src/extern_type.rs type ExternType (line 101) | pub unsafe trait ExternType { type Opaque (line 164) | pub enum Opaque {} type Trivial (line 169) | pub enum Trivial {} type Kind (line 172) | pub trait Kind: private::Sealed {} type Sealed (line 178) | pub trait Sealed {} function verify_extern_type (line 184) | pub fn verify_extern_type, Id>() {} function verify_extern_kind (line 187) | pub fn verify_extern_kind, Kind: self::Kind>(... FILE: src/fmt.rs function display (line 3) | pub(crate) fn display(fmt: impl Fn(&mut fmt::Formatter) -> fmt::Result) ... type DisplayInvoke (line 7) | struct DisplayInvoke(T); method fmt (line 13) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { FILE: src/function.rs type FatFunction (line 6) | pub struct FatFunction { FILE: src/hash.rs function hash (line 4) | pub fn hash(value: &V) -> usize { FILE: src/lib.rs type String (line 480) | pub type String = CxxString; type Vector (line 487) | pub type Vector = CxxVector; type Private (line 513) | pub trait Private {} type void (line 533) | struct void(core::ffi::c_void); FILE: src/lossy.rs function display (line 5) | pub(crate) fn display(mut bytes: &[u8], f: &mut fmt::Formatter) -> fmt::... function debug (line 24) | pub(crate) fn debug(mut bytes: &[u8], f: &mut fmt::Formatter) -> fmt::Re... FILE: src/opaque.rs type Opaque (line 18) | pub struct Opaque { type SyncUnsafeCell (line 28) | struct SyncUnsafeCell(UnsafeCell); FILE: src/result.rs type PtrLen (line 15) | pub(crate) struct PtrLen { function r#try (line 26) | pub unsafe fn r#try(ret: *mut T, result: StdResult) -> Result function to_c_error (line 39) | unsafe fn to_c_error(msg: String) -> Result { method exception (line 54) | pub unsafe fn exception(self) -> StdResult<(), Exception> { FILE: src/rust_slice.rs type RustSlice (line 9) | pub struct RustSlice { method from_ref (line 14) | pub fn from_ref(slice: &[T]) -> Self { method from_mut (line 20) | pub fn from_mut(slice: &mut [T]) -> Self { method as_slice (line 26) | pub unsafe fn as_slice<'a, T>(self) -> &'a [T] { method as_mut_slice (line 32) | pub unsafe fn as_mut_slice<'a, T>(self) -> &'a mut [T] { method from_raw_parts (line 38) | pub(crate) fn from_raw_parts(ptr: NonNull, len: usize) -> Self { method as_non_null_ptr (line 46) | pub(crate) fn as_non_null_ptr(&self) -> NonNull { method len (line 52) | pub(crate) fn len(&self) -> usize { FILE: src/rust_str.rs type RustStr (line 9) | pub struct RustStr { method from (line 14) | pub fn from(repr: &str) -> Self { method as_str (line 19) | pub unsafe fn as_str<'a>(self) -> &'a str { FILE: src/rust_string.rs type RustString (line 10) | pub struct RustString { method from (line 15) | pub fn from(s: String) -> Self { method from_ref (line 19) | pub fn from_ref(s: &String) -> &Self { method from_mut (line 23) | pub fn from_mut(s: &mut String) -> &mut Self { method into_string (line 27) | pub fn into_string(self) -> String { method as_string (line 31) | pub fn as_string(&self) -> &String { method as_mut_string (line 35) | pub fn as_mut_string(&mut self) -> &mut String { method drop (line 41) | fn drop(&mut self) { FILE: src/rust_type.rs type RustType (line 8) | pub unsafe trait RustType {} type ImplBox (line 9) | pub unsafe trait ImplBox {} type ImplVec (line 10) | pub unsafe trait ImplVec {} function require_unpin (line 13) | pub fn require_unpin() {} function require_box (line 15) | pub fn require_box() {} function require_vec (line 16) | pub fn require_vec() {} type With (line 18) | pub struct With(PhantomData); type Without (line 19) | pub struct Without; method check_slice (line 49) | pub const fn check_slice>(&self) {} function with (line 21) | pub const fn with() -> With { function check_slice (line 27) | pub const fn check_slice(&self) {} type Target (line 31) | type Target = Without; method deref (line 32) | fn deref(&self) -> &Self::Target { type SliceOfExternType (line 37) | pub trait SliceOfExternType { type Kind (line 41) | type Kind = T::Kind; type Kind (line 44) | type Kind = T::Kind; FILE: src/rust_vec.rs type RustVec (line 12) | pub struct RustVec { function new (line 18) | pub fn new() -> Self { function from (line 22) | pub fn from(v: Vec) -> Self { function from_ref (line 26) | pub fn from_ref(v: &Vec) -> &Self { function from_mut (line 30) | pub fn from_mut(v: &mut Vec) -> &mut Self { function into_vec (line 34) | pub fn into_vec(self) -> Vec { function as_vec (line 38) | pub fn as_vec(&self) -> &Vec { function as_mut_vec (line 42) | pub fn as_mut_vec(&mut self) -> &mut Vec { function len (line 46) | pub fn len(&self) -> usize { function capacity (line 50) | pub fn capacity(&self) -> usize { function as_ptr (line 54) | pub fn as_ptr(&self) -> *const T { function reserve_total (line 58) | pub fn reserve_total(&mut self, new_cap: usize) { function set_len (line 66) | pub unsafe fn set_len(&mut self, len: usize) { function truncate (line 70) | pub fn truncate(&mut self, len: usize) { method drop (line 76) | fn drop(&mut self) { FILE: src/shared_ptr.rs type SharedPtr (line 46) | pub struct SharedPtr function null (line 61) | pub fn null() -> Self { function new (line 73) | pub fn new(value: T) -> Self function from_raw (line 109) | pub unsafe fn from_raw(raw: *mut T) -> Self { function is_null (line 131) | pub fn is_null(&self) -> bool { function as_ref (line 146) | pub fn as_ref(&self) -> Option<&T> { function pin_mut_unchecked (line 182) | pub unsafe fn pin_mut_unchecked(&mut self) -> Pin<&mut T> { function as_ptr (line 194) | pub fn as_ptr(&self) -> *const T { function as_mut_ptr (line 205) | pub fn as_mut_ptr(&self) -> *mut T { function downgrade (line 214) | pub fn downgrade(&self) -> WeakPtr method clone (line 235) | fn clone(&self) -> Self { method drop (line 254) | fn drop(&mut self) { type Target (line 264) | type Target = T; method deref (line 266) | fn deref(&self) -> &Self::Target { method fmt (line 281) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { method fmt (line 293) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { method eq (line 305) | fn eq(&self, other: &Self) -> bool { method partial_cmp (line 316) | fn partial_cmp(&self, other: &Self) -> Option { method cmp (line 325) | fn cmp(&self, other: &Self) -> Ordering { method hash (line 334) | fn hash(&self, hasher: &mut H) function from (line 346) | fn from(unique: UniquePtr) -> Self { type SharedPtrTarget (line 376) | pub unsafe trait SharedPtrTarget { method __typename (line 378) | fn __typename(f: &mut fmt::Formatter) -> fmt::Result; method __null (line 380) | unsafe fn __null(new: *mut c_void); method __new (line 382) | unsafe fn __new(value: Self, new: *mut c_void) method __raw (line 393) | unsafe fn __raw(new: *mut c_void, raw: *mut Self); method __clone (line 395) | unsafe fn __clone(this: *const c_void, new: *mut c_void); method __get (line 397) | unsafe fn __get(this: *const c_void) -> *const Self; method __drop (line 399) | unsafe fn __drop(this: *mut c_void); FILE: src/symbols/exception.rs function exception (line 10) | unsafe extern "C" fn exception(ptr: *const u8, len: usize) -> PtrLen { FILE: src/symbols/rust_slice.rs function slice_new (line 6) | unsafe extern "C" fn slice_new(this: &mut MaybeUninit, ptr: N... function slice_ptr (line 13) | unsafe extern "C" fn slice_ptr(this: &RustSlice) -> NonNull<()> { function slice_len (line 18) | unsafe extern "C" fn slice_len(this: &RustSlice) -> usize { FILE: src/symbols/rust_str.rs function str_new (line 9) | unsafe extern "C" fn str_new(this: &mut MaybeUninit<&str>) { function str_ref (line 16) | unsafe extern "C" fn str_ref<'a>(this: &mut MaybeUninit<&'a str>, string... function str_from (line 23) | unsafe extern "C" fn str_from(this: &mut MaybeUninit<&str>, ptr: *const ... function str_ptr (line 36) | unsafe extern "C" fn str_ptr(this: &&str) -> *const u8 { function str_len (line 41) | unsafe extern "C" fn str_len(this: &&str) -> usize { FILE: src/symbols/rust_string.rs function string_new (line 11) | unsafe extern "C" fn string_new(this: &mut MaybeUninit) { function string_clone (line 18) | unsafe extern "C" fn string_clone(this: &mut MaybeUninit, other:... function string_from_utf8 (line 25) | unsafe extern "C" fn string_from_utf8( function string_from_utf8_lossy (line 43) | unsafe extern "C" fn string_from_utf8_lossy( function string_from_utf16 (line 55) | unsafe extern "C" fn string_from_utf16( function string_from_utf16_lossy (line 72) | unsafe extern "C" fn string_from_utf16_lossy( function string_drop (line 84) | unsafe extern "C" fn string_drop(this: &mut ManuallyDrop) { function string_ptr (line 89) | unsafe extern "C" fn string_ptr(this: &String) -> *const u8 { function string_len (line 94) | unsafe extern "C" fn string_len(this: &String) -> usize { function string_capacity (line 99) | unsafe extern "C" fn string_capacity(this: &String) -> usize { function string_reserve_additional (line 104) | unsafe extern "C" fn string_reserve_additional(this: &mut String, additi... function string_reserve_total (line 109) | unsafe extern "C" fn string_reserve_total(this: &mut String, new_cap: us... FILE: src/unique_ptr.rs type UniquePtr (line 23) | pub struct UniquePtr function null (line 38) | pub fn null() -> Self { function new (line 46) | pub fn new(value: T) -> Self function is_null (line 59) | pub fn is_null(&self) -> bool { function as_ref (line 65) | pub fn as_ref(&self) -> Option<&T> { function as_mut (line 72) | pub fn as_mut(&mut self) -> Option> { function pin_mut (line 86) | pub fn pin_mut(&mut self) -> Pin<&mut T> { function as_ptr (line 98) | pub fn as_ptr(&self) -> *const T { function as_mut_ptr (line 109) | pub fn as_mut_ptr(&self) -> *mut T { function into_raw (line 116) | pub fn into_raw(self) -> *mut T { function from_raw (line 130) | pub unsafe fn from_raw(raw: *mut T) -> Self { method drop (line 149) | fn drop(&mut self) { type Target (line 158) | type Target = T; method deref (line 160) | fn deref(&self) -> &Self::Target { method deref_mut (line 175) | fn deref_mut(&mut self) -> &mut Self::Target { method fmt (line 190) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { method fmt (line 202) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { method eq (line 214) | fn eq(&self, other: &Self) -> bool { method partial_cmp (line 225) | fn partial_cmp(&self, other: &Self) -> Option { method cmp (line 234) | fn cmp(&self, other: &Self) -> Ordering { method hash (line 243) | fn hash(&self, hasher: &mut H) method read (line 261) | fn read(&mut self, buf: &mut [u8]) -> io::Result { method read_to_end (line 266) | fn read_to_end(&mut self, buf: &mut Vec) -> io::Result { method read_to_string (line 271) | fn read_to_string(&mut self, buf: &mut String) -> io::Result { method read_exact (line 276) | fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> { method seek (line 294) | fn seek(&mut self, pos: SeekFrom) -> io::Result { method rewind (line 299) | fn rewind(&mut self) -> io::Result<()> { method stream_position (line 304) | fn stream_position(&mut self) -> io::Result { method seek_relative (line 309) | fn seek_relative(&mut self, offset: i64) -> io::Result<()> { method write (line 327) | fn write(&mut self, buf: &[u8]) -> io::Result { method write_vectored (line 332) | fn write_vectored(&mut self, bufs: &[IoSlice]) -> io::Result { method flush (line 337) | fn flush(&mut self) -> io::Result<()> { method write_all (line 342) | fn write_all(&mut self, buf: &[u8]) -> io::Result<()> { method write_fmt (line 347) | fn write_fmt(&mut self, fmt: fmt::Arguments) -> io::Result<()> { type UniquePtrTarget (line 380) | pub unsafe trait UniquePtrTarget { method __typename (line 382) | fn __typename(f: &mut fmt::Formatter) -> fmt::Result; method __null (line 384) | fn __null() -> MaybeUninit<*mut c_void>; method __new (line 386) | fn __new(value: Self) -> MaybeUninit<*mut c_void> method __raw (line 396) | unsafe fn __raw(raw: *mut Self) -> MaybeUninit<*mut c_void>; method __get (line 398) | unsafe fn __get(repr: MaybeUninit<*mut c_void>) -> *const Self; method __release (line 400) | unsafe fn __release(repr: MaybeUninit<*mut c_void>) -> *mut Self; method __drop (line 402) | unsafe fn __drop(repr: MaybeUninit<*mut c_void>); method __typename (line 419) | fn __typename(f: &mut fmt::Formatter) -> fmt::Result { method __null (line 422) | fn __null() -> MaybeUninit<*mut c_void> { method __raw (line 429) | unsafe fn __raw(raw: *mut Self) -> MaybeUninit<*mut c_void> { method __get (line 434) | unsafe fn __get(repr: MaybeUninit<*mut c_void>) -> *const Self { method __release (line 437) | unsafe fn __release(mut repr: MaybeUninit<*mut c_void>) -> *mut Self { method __drop (line 440) | unsafe fn __drop(mut repr: MaybeUninit<*mut c_void>) { method __typename (line 449) | fn __typename(f: &mut fmt::Formatter) -> fmt::Result { method __null (line 452) | fn __null() -> MaybeUninit<*mut c_void> { method __raw (line 455) | unsafe fn __raw(raw: *mut Self) -> MaybeUninit<*mut c_void> { method __get (line 458) | unsafe fn __get(repr: MaybeUninit<*mut c_void>) -> *const Self { method __release (line 461) | unsafe fn __release(repr: MaybeUninit<*mut c_void>) -> *mut Self { method __drop (line 464) | unsafe fn __drop(repr: MaybeUninit<*mut c_void>) { function unique_ptr_std_string_null (line 407) | fn unique_ptr_std_string_null(this: *mut MaybeUninit<*mut c_void>); function unique_ptr_std_string_raw (line 409) | fn unique_ptr_std_string_raw(this: *mut MaybeUninit<*mut c_void>, raw: *... function unique_ptr_std_string_get (line 411) | fn unique_ptr_std_string_get(this: *const MaybeUninit<*mut c_void>) -> *... function unique_ptr_std_string_release (line 413) | fn unique_ptr_std_string_release(this: *mut MaybeUninit<*mut c_void>) ->... function unique_ptr_std_string_drop (line 415) | fn unique_ptr_std_string_drop(this: *mut MaybeUninit<*mut c_void>); FILE: src/unwind.rs function prevent_unwind (line 5) | pub fn prevent_unwind(label: &'static str, foreign_call: F) -> R type Guard (line 30) | struct Guard { method drop (line 36) | fn drop(&mut self) { FILE: src/weak_ptr.rs type WeakPtr (line 16) | pub struct WeakPtr function null (line 31) | pub fn null() -> Self { function upgrade (line 44) | pub fn upgrade(&self) -> SharedPtr method clone (line 65) | fn clone(&self) -> Self { method drop (line 80) | fn drop(&mut self) { method fmt (line 90) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { type WeakPtrTarget (line 100) | pub unsafe trait WeakPtrTarget { method __typename (line 102) | fn __typename(f: &mut fmt::Formatter) -> fmt::Result; method __null (line 104) | unsafe fn __null(new: *mut c_void); method __clone (line 106) | unsafe fn __clone(this: *const c_void, new: *mut c_void); method __downgrade (line 108) | unsafe fn __downgrade(shared: *const c_void, new: *mut c_void); method __upgrade (line 110) | unsafe fn __upgrade(weak: *const c_void, shared: *mut c_void); method __drop (line 112) | unsafe fn __drop(this: *mut c_void); FILE: syntax/atom.rs type Atom (line 6) | pub(crate) enum Atom { method from (line 26) | pub(crate) fn from(ident: &Ident) -> Option { method from_str (line 30) | pub(crate) fn from_str(s: &str) -> Option { method as_ref (line 61) | fn as_ref(&self) -> &str { method fmt (line 55) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { method eq (line 85) | fn eq(&self, atom: &Atom) -> bool { function eq (line 94) | fn eq(&self, atom: &Atom) -> bool { function eq (line 100) | fn eq(&self, atom: &Atom) -> bool { FILE: syntax/attrs.rs type Parser (line 29) | pub(crate) struct Parser<'a> { function parse (line 48) | pub(crate) fn parse(cx: &mut Errors, attrs: Vec, mut parser: ... type DocAttribute (line 204) | enum DocAttribute { function parse_doc_attribute (line 213) | fn parse_doc_attribute(meta: &Meta) -> Result { function parse_derive_attribute (line 231) | fn parse_derive_attribute(cx: &mut Errors, input: ParseStream) -> Result... function parse_default_attribute (line 247) | fn parse_default_attribute(meta: &Meta) -> Result<()> { function parse_cxx_name_attribute (line 259) | fn parse_cxx_name_attribute(meta: &Meta) -> Result { function parse_rust_ident_attribute (line 278) | fn parse_rust_ident_attribute(meta: &Meta) -> Result { type OtherAttrs (line 304) | pub(crate) struct OtherAttrs { method new (line 311) | pub(crate) fn new() -> Self { method extend (line 319) | pub(crate) fn extend(&mut self, other: Self) { FILE: syntax/cfg.rs type CfgExpr (line 10) | pub(crate) enum CfgExpr { method merge_and (line 26) | pub(crate) fn merge_and(&mut self, expr: CfgExpr) { type ComputedCfg (line 19) | pub(crate) enum ComputedCfg<'a> { function all (line 41) | pub(crate) fn all(one: &'a CfgExpr, two: &'a CfgExpr) -> Self { function merge_or (line 51) | pub(crate) fn merge_or(&mut self, other: impl Into>) { function from (line 72) | fn from(cfg: &'a CfgExpr) -> Self { method eq (line 80) | fn eq(&self, other: &Self) -> bool { method hash (line 102) | fn hash(&self, hasher: &mut H) { method eq (line 120) | fn eq(&self, other: &Self) -> bool { method hash (line 140) | fn hash(&self, hasher: &mut H) { function parse_attribute (line 150) | pub(crate) fn parse_attribute(attr: &Attribute) -> Result { function parse_single (line 158) | fn parse_single(input: ParseStream) -> Result { function parse_multiple (line 188) | fn parse_multiple(input: ParseStream) -> Result> { FILE: syntax/check.rs type Check (line 14) | pub(crate) struct Check<'a> { type Generator (line 21) | pub(crate) enum Generator { function typecheck (line 34) | pub(crate) fn typecheck(cx: &mut Errors, apis: &[Api], types: &Types, ge... function do_typecheck (line 43) | fn do_typecheck(cx: &mut Check) { function error (line 78) | pub(crate) fn error(&mut self, sp: impl ToTokens, msg: impl Display) { function check_type_ident (line 83) | fn check_type_ident(cx: &mut Check, name: &NamedType) { function check_type_box (line 96) | fn check_type_box(cx: &mut Check, ptr: &Ty1) { function check_type_rust_vec (line 114) | fn check_type_rust_vec(cx: &mut Check, ty: &Ty1) { function check_type_unique_ptr (line 146) | fn check_type_unique_ptr(cx: &mut Check, ptr: &Ty1) { function check_type_shared_ptr (line 164) | fn check_type_shared_ptr(cx: &mut Check, ptr: &Ty1) { function check_type_weak_ptr (line 187) | fn check_type_weak_ptr(cx: &mut Check, ptr: &Ty1) { function check_type_cxx_vector (line 210) | fn check_type_cxx_vector(cx: &mut Check, ptr: &Ty1) { function check_type_ref (line 233) | fn check_type_ref(cx: &mut Check, ty: &Ref) { function check_type_ptr (line 270) | fn check_type_ptr(cx: &mut Check, ty: &Ptr) { function check_type_slice_ref (line 283) | fn check_type_slice_ref(cx: &mut Check, ty: &SliceRef) { function check_type_array (line 307) | fn check_type_array(cx: &mut Check, ty: &Array) { function check_type_fn (line 315) | fn check_type_fn(cx: &mut Check, ty: &Signature) { function check_api_struct (line 332) | fn check_api_struct(cx: &mut Check, strct: &Struct) { function check_api_enum (line 390) | fn check_api_enum(cx: &mut Check, enm: &Enum) { function check_api_type (line 436) | fn check_api_type(cx: &mut Check, ety: &ExternType) { function check_api_fn (line 470) | fn check_api_fn(cx: &mut Check, efn: &ExternFn) { function check_api_type_alias (line 584) | fn check_api_type_alias(cx: &mut Check, alias: &TypeAlias) { function check_api_impl (line 593) | fn check_api_impl(cx: &mut Check, imp: &Impl) { function check_mut_return_restriction (line 623) | fn check_mut_return_restriction(cx: &mut Check, efn: &ExternFn) { function check_reserved_name (line 685) | fn check_reserved_name(cx: &mut Check, ident: &Ident) { function check_reserved_lifetime (line 699) | fn check_reserved_lifetime(cx: &mut Check, lifetime: &Lifetime) { function check_lifetimes (line 710) | fn check_lifetimes(cx: &mut Check, generics: &Lifetimes) { function check_generics (line 716) | fn check_generics(cx: &mut Check, generics: &Generics) { function is_unsized (line 724) | fn is_unsized(types: &Types, ty: &Type) -> bool { function span_for_struct_error (line 750) | fn span_for_struct_error(strct: &Struct) -> TokenStream { function span_for_enum_error (line 757) | fn span_for_enum_error(enm: &Enum) -> TokenStream { function span_for_receiver_error (line 764) | fn span_for_receiver_error(receiver: &Receiver) -> TokenStream { function span_for_generics_error (line 777) | fn span_for_generics_error(efn: &ExternFn) -> TokenStream { function describe (line 784) | fn describe(types: &Types, ty: &Type) -> String { FILE: syntax/derive.rs type Derive (line 5) | pub(crate) struct Derive { method from (line 30) | pub(crate) fn from(ident: &Ident) -> Option { method eq (line 55) | fn eq(&self, other: &Trait) -> bool { type Trait (line 11) | pub(crate) enum Trait { method as_ref (line 61) | fn as_ref(&self) -> &str { method fmt (line 83) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { function contains (line 88) | pub(crate) fn contains(derives: &[Derive], query: Trait) -> bool { FILE: syntax/discriminant.rs type DiscriminantSet (line 10) | pub(crate) struct DiscriminantSet { method new (line 29) | pub(crate) fn new(repr: Option) -> Self { method insert (line 37) | pub(crate) fn insert(&mut self, expr: &Expr) -> Result { method insert_next (line 64) | pub(crate) fn insert_next(&mut self) -> Result { method inferred_repr (line 88) | pub(crate) fn inferred_repr(&self) -> Result { type Discriminant (line 17) | pub(crate) struct Discriminant { method zero (line 152) | pub(crate) const fn zero() -> Self { method pos (line 159) | const fn pos(u: u64) -> Self { method neg (line 166) | const fn neg(i: i64) -> Self { type Sign (line 23) | enum Sign { function expr_to_discriminant (line 107) | fn expr_to_discriminant(expr: &Expr) -> Result<(Discriminant, Option Resu... method fmt (line 184) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { method to_tokens (line 193) | fn to_tokens(&self, tokens: &mut TokenStream) { type Err (line 202) | type Err = Error; method from_str (line 204) | fn from_str(mut s: &str) -> Result { method cmp (line 222) | fn cmp(&self, other: &Self) -> Ordering { method partial_cmp (line 234) | fn partial_cmp(&self, other: &Self) -> Option { function parse_int_suffix (line 239) | fn parse_int_suffix(suffix: &str) -> Result> { type Limits (line 254) | pub(crate) struct Limits { method of (line 261) | pub(crate) fn of(repr: Atom) -> Option { constant LIMITS (line 271) | const LIMITS: [Limits; 8] = [ FILE: syntax/doc.rs type Doc (line 5) | pub(crate) struct Doc { method new (line 11) | pub(crate) fn new() -> Self { method push (line 18) | pub(crate) fn push(&mut self, lit: LitStr) { method is_empty (line 23) | pub(crate) fn is_empty(&self) -> bool { method to_string (line 28) | pub(crate) fn to_string(&self) -> String { method to_tokens (line 39) | fn to_tokens(&self, tokens: &mut TokenStream) { FILE: syntax/error.rs type Error (line 4) | pub(crate) struct Error { method fmt (line 13) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { FILE: syntax/file.rs type Module (line 10) | pub(crate) struct Module { type Item (line 27) | pub(crate) enum Item { type ItemForeignMod (line 36) | pub(crate) struct ItemForeignMod { method parse (line 46) | fn parse(input: ParseStream) -> Result { method parse (line 88) | fn parse(input: ParseStream) -> Result { FILE: syntax/ident.rs function check (line 4) | fn check(cx: &mut Check, name: &Pair) { function check_all (line 27) | pub(crate) fn check_all(cx: &mut Check, apis: &[Api]) { FILE: syntax/impls.rs method eq (line 9) | fn eq(&self, other: &Self) -> bool { type Target (line 29) | type Target = Signature; method deref (line 31) | fn deref(&self) -> &Self::Target { method deref_mut (line 37) | fn deref_mut(&mut self) -> &mut Self::Target { method hash (line 43) | fn hash(&self, state: &mut H) { method eq (line 67) | fn eq(&self, other: &Self) -> bool { method eq (line 89) | fn eq(&self, other: &Self) -> bool { method hash (line 105) | fn hash(&self, state: &mut H) { method eq (line 121) | fn eq(&self, other: &Self) -> bool { method hash (line 139) | fn hash(&self, state: &mut H) { method eq (line 154) | fn eq(&self, other: &Self) -> bool { method hash (line 178) | fn hash(&self, state: &mut H) { method eq (line 198) | fn eq(&self, other: &Ptr) -> bool { method hash (line 218) | fn hash(&self, state: &mut H) { method eq (line 234) | fn eq(&self, other: &Self) -> bool { method hash (line 256) | fn hash(&self, state: &mut H) { method eq (line 274) | fn eq(&self, other: &Self) -> bool { method hash (line 294) | fn hash(&self, state: &mut H) { method eq (line 310) | fn eq(&self, other: &Self) -> bool { method hash (line 366) | fn hash(&self, state: &mut H) { method eq (line 402) | fn eq(&self, other: &Self) -> bool { method hash (line 432) | fn hash(&self, state: &mut H) { FILE: syntax/improper.rs type ImproperCtype (line 7) | pub(crate) enum ImproperCtype<'a> { function determine_improper_ctype (line 14) | pub(crate) fn determine_improper_ctype( FILE: syntax/instantiate.rs type ImplKey (line 9) | pub(crate) enum ImplKey<'a> { function is_implicit_impl_ok (line 28) | pub(crate) fn is_implicit_impl_ok(&self, types: &Types) -> bool { function inner (line 36) | fn inner(&self) -> &'a Type { type NamedImplKey (line 49) | pub(crate) struct NamedImplKey<'a> { method impl_key (line 64) | pub(crate) fn impl_key(&self, res: &UnorderedMap<&Ident, Resolution>) ->... method eq (line 78) | fn eq(&self, other: &Self) -> bool { method hash (line 86) | fn hash(&self, hasher: &mut H) { function new (line 92) | fn new(outer: &'a Type, ty1: &'a Ty1, res: &UnorderedMap<&Ident, Resolut... FILE: syntax/mangle.rs constant CXXBRIDGE (line 77) | const CXXBRIDGE: &str = "cxxbridge1"; constant CXXVERSION (line 78) | const CXXVERSION: &str = env!("CARGO_PKG_VERSION_PATCH"); function extern_fn (line 86) | pub(crate) fn extern_fn(efn: &ExternFn, types: &Types) -> Symbol { function operator (line 102) | pub(crate) fn operator(receiver: &Pair, operator: &'static str) -> Symbol { function c_trampoline (line 114) | pub(crate) fn c_trampoline(efn: &ExternFn, var: &Pair, types: &Types) ->... function r_trampoline (line 119) | pub(crate) fn r_trampoline(efn: &ExternFn, var: &Pair, types: &Types) ->... function typename (line 133) | pub(crate) fn typename(t: &Type, res: &UnorderedMap<&Ident, Resolution>)... FILE: syntax/map.rs type OrderedMap (line 13) | pub(crate) struct OrderedMap(indexmap::IndexMap); function new (line 16) | pub(crate) fn new() -> Self { function keys (line 20) | pub(crate) fn keys(&self) -> indexmap::map::Keys { function contains_key (line 24) | pub(crate) fn contains_key(&self, key: &Q) -> bool function insert (line 36) | pub(crate) fn insert(&mut self, key: K, value: V) -> Option { function entry (line 40) | pub(crate) fn entry(&mut self, key: K) -> indexmap::map::Entry { type Item (line 46) | type Item = (&'a K, &'a V); type IntoIter (line 47) | type IntoIter = indexmap::map::Iter<'a, K, V>; method into_iter (line 48) | fn into_iter(self) -> Self::IntoIter { type UnorderedMap (line 62) | pub(crate) struct UnorderedMap(HashMap); function new (line 65) | pub(crate) fn new() -> Self { function insert (line 74) | pub(crate) fn insert(&mut self, key: K, value: V) -> Option { function contains_key (line 78) | pub(crate) fn contains_key(&self, key: &Q) -> bool function get (line 86) | pub(crate) fn get(&self, key: &Q) -> Option<&V> function entry (line 94) | pub(crate) fn entry(&mut self, key: K) -> Entry { function remove (line 99) | pub(crate) fn remove(&mut self, key: &Q) -> Option function keys (line 107) | pub(crate) fn keys(&self) -> UnorderedSet method default (line 121) | fn default() -> Self { type Output (line 131) | type Output = V; function index (line 133) | fn index(&self, key: &Q) -> &V { FILE: syntax/message.rs type Message (line 5) | pub(crate) struct Message(String); method new (line 8) | pub fn new() -> Self { method write_fmt (line 12) | pub fn write_fmt(&mut self, args: fmt::Arguments) { method fmt (line 18) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { method to_tokens (line 24) | fn to_tokens(&self, tokens: &mut TokenStream) { FILE: syntax/mod.rs type Api (line 57) | pub(crate) enum Api { type Include (line 70) | pub(crate) struct Include { type IncludeKind (line 82) | pub enum IncludeKind { type ExternType (line 89) | pub(crate) struct ExternType { type Struct (line 109) | pub(crate) struct Struct { type Enum (line 124) | pub(crate) struct Enum { type EnumRepr (line 140) | pub(crate) struct EnumRepr { type ExternFn (line 145) | pub(crate) struct ExternFn { type TypeAlias (line 159) | pub(crate) struct TypeAlias { type Impl (line 179) | pub(crate) struct Impl { type Lifetimes (line 193) | pub(crate) struct Lifetimes { type Signature (line 199) | pub(crate) struct Signature { type FnKind (line 213) | pub(crate) enum FnKind { type Var (line 222) | pub(crate) struct Var { type Receiver (line 235) | pub(crate) struct Receiver { type Variant (line 250) | pub(crate) struct Variant { type Type (line 263) | pub(crate) enum Type { type Ty1 (line 280) | pub(crate) struct Ty1 { type Ref (line 287) | pub(crate) struct Ref { type Ptr (line 297) | pub(crate) struct Ptr { type SliceRef (line 305) | pub(crate) struct SliceRef { type Array (line 314) | pub(crate) struct Array { type Lang (line 323) | pub(crate) enum Lang { type Pair (line 332) | pub(crate) struct Pair { type NamedType (line 341) | pub(crate) struct NamedType { FILE: syntax/names.rs type ForeignName (line 11) | pub(crate) struct ForeignName { method parse (line 38) | pub(crate) fn parse(text: &str, span: Span) -> Result { method eq (line 58) | fn eq(&self, rhs: &str) -> bool { method to_symbol (line 16) | pub(crate) fn to_symbol(&self) -> Symbol { method new (line 27) | pub(crate) fn new(rust: Ident) -> Self { method fmt (line 52) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { FILE: syntax/namespace.rs type Namespace (line 11) | pub(crate) struct Namespace { constant ROOT (line 16) | pub(crate) const ROOT: Self = Namespace { method iter (line 20) | pub(crate) fn iter(&self) -> Iter { method parse_bridge_attr_namespace (line 24) | pub(crate) fn parse_bridge_attr_namespace(input: ParseStream) -> Resul... method parse_meta (line 36) | pub(crate) fn parse_meta(meta: &Meta) -> Result { method from_iter (line 91) | fn from_iter(idents: I) -> Self method default (line 69) | fn default() -> Self { method parse (line 76) | fn parse(input: ParseStream) -> Result { type Item (line 83) | type Item = &'a Ident; type IntoIter (line 84) | type IntoIter = Iter<'a, Ident>; method into_iter (line 85) | fn into_iter(self) -> Self::IntoIter { FILE: syntax/parse.rs function parse_items (line 31) | pub(crate) fn parse_items( function parse_struct (line 59) | fn parse_struct(cx: &mut Errors, mut item: ItemStruct, namespace: &Names... function parse_enum (line 203) | fn parse_enum(cx: &mut Errors, item: ItemEnum, namespace: &Namespace) ->... function parse_variant (line 299) | fn parse_variant( function parse_foreign_mod (line 354) | fn parse_foreign_mod( function parse_lang (line 457) | fn parse_lang(abi: &Abi) -> Result { function parse_extern_type (line 476) | fn parse_extern_type( function parse_extern_fn (line 534) | fn parse_extern_fn( function parse_extern_verbatim (line 733) | fn parse_extern_verbatim( function parse_extern_verbatim_type (line 770) | fn parse_extern_verbatim_type( function extern_type_lifetimes (line 822) | fn extern_type_lifetimes(cx: &mut Errors, generics: Generics) -> Lifetim... function parse_extern_verbatim_fn (line 862) | fn parse_extern_verbatim_fn(input: ParseStream) -> Result { function parse_type_alias (line 868) | fn parse_type_alias( function parse_extern_type_bounded (line 930) | fn parse_extern_type_bounded( function parse_impl (line 1019) | fn parse_impl(cx: &mut Errors, imp: ItemImpl) -> Result { function parse_include (line 1109) | fn parse_include(input: ParseStream) -> Result { function parse_type (line 1155) | fn parse_type(ty: &RustType) -> Result { function parse_type_reference (line 1167) | fn parse_type_reference(ty: &TypeReference) -> Result { function parse_type_ptr (line 1210) | fn parse_type_ptr(ty: &TypePtr) -> Result { function parse_type_path (line 1227) | fn parse_type_path(ty: &TypePath) -> Result { function parse_type_array (line 1347) | fn parse_type_array(ty: &TypeArray) -> Result { function parse_type_fn (line 1378) | fn parse_type_fn(ty: &TypeBareFn) -> Result { function parse_return_type (line 1450) | fn parse_return_type( function visibility_pub (line 1482) | fn visibility_pub(vis: &Visibility, inherited: Span) -> Token![pub] { function pair (line 1490) | fn pair( FILE: syntax/pod.rs function is_guaranteed_pod (line 6) | pub(crate) fn is_guaranteed_pod(&self, ty: impl Into>) -> ... FILE: syntax/primitive.rs type PrimitiveKind (line 4) | pub(crate) enum PrimitiveKind { function kind (line 10) | pub(crate) fn kind(ty: &Type) -> Option { FILE: syntax/qualified.rs type QualifiedName (line 5) | pub(crate) struct QualifiedName { method parse_quoted (line 10) | pub(crate) fn parse_quoted(lit: &LitStr) -> Result { method parse_unquoted (line 22) | pub(crate) fn parse_unquoted(input: ParseStream) -> Result { method parse_quoted_or_unquoted (line 27) | pub(crate) fn parse_quoted_or_unquoted(input: ParseStream) -> Result Result { function from (line 22) | fn from(query: &'a NamedType) -> Self { function from (line 28) | fn from(query: &'a Type) -> Self { FILE: syntax/report.rs type Errors (line 5) | pub(crate) struct Errors { method new (line 10) | pub(crate) fn new() -> Self { method error (line 14) | pub(crate) fn error(&mut self, sp: impl ToTokens, msg: impl Display) { method push (line 18) | pub(crate) fn push(&mut self, error: Error) { method propagate (line 22) | pub(crate) fn propagate(&mut self) -> Result<()> { FILE: syntax/repr.rs type Repr (line 6) | pub(crate) enum Repr { method parse (line 12) | fn parse(input: ParseStream) -> Result { FILE: syntax/resolve.rs type Resolution (line 6) | pub(crate) struct Resolution<'a> { function resolve (line 14) | pub(crate) fn resolve(&self, ident: &impl UnresolvedName) -> Resolution<... function try_resolve (line 22) | pub(crate) fn try_resolve(&self, ident: &impl UnresolvedName) -> Option<... type UnresolvedName (line 28) | pub(crate) trait UnresolvedName { method ident (line 29) | fn ident(&self) -> &Ident; method ident (line 33) | fn ident(&self) -> &Ident { method ident (line 39) | fn ident(&self) -> &Ident { FILE: syntax/set.rs type OrderedSet (line 11) | pub(crate) struct OrderedSet { function new (line 20) | pub(crate) fn new() -> Self { function insert (line 27) | pub(crate) fn insert(&mut self, value: &'a T) -> bool { function is_empty (line 37) | pub(crate) fn is_empty(&self) -> bool { function iter (line 41) | pub(crate) fn iter(&self) -> Iter<'_, 'a, T> { type Item (line 47) | type Item = &'a T; type IntoIter (line 48) | type IntoIter = Iter<'s, 'a, T>; method into_iter (line 49) | fn into_iter(self) -> Self::IntoIter { type Item (line 55) | type Item = &'a T; type IntoIter (line 56) | type IntoIter = as IntoIterator>::IntoIter; method into_iter (line 57) | fn into_iter(self) -> Self::IntoIter { type UnorderedSet (line 70) | pub(crate) struct UnorderedSet(HashSet); function new (line 76) | pub(crate) fn new() -> Self { function insert (line 80) | pub(crate) fn insert(&mut self, value: T) -> bool { function contains (line 84) | pub(crate) fn contains(&self, value: &Q) -> bool function get (line 93) | pub(crate) fn get(&self, value: &Q) -> Option<&T> function retain (line 101) | pub(crate) fn retain(&mut self, f: impl FnMut(&T) -> bool) { function extend (line 106) | pub(crate) fn extend(&mut self, iter: impl IntoIterator) { type Iter (line 114) | pub(crate) struct Iter<'s, 'a, T>(slice::Iter<'s, &'a T>); type Item (line 117) | type Item = &'a T; method next (line 119) | fn next(&mut self) -> Option { method size_hint (line 123) | fn size_hint(&self) -> (usize, Option) { method fmt (line 132) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { FILE: syntax/signature.rs method receiver (line 7) | pub fn receiver(&self) -> Option<&Receiver> { method receiver_mut (line 14) | pub fn receiver_mut(&mut self) -> Option<&mut Receiver> { method self_type (line 21) | pub fn self_type(&self) -> Option<&Ident> { method undeclared_lifetimes (line 30) | pub fn undeclared_lifetimes<'a>(&'a self) -> OrderedSet<&'a Lifetime> { FILE: syntax/symbol.rs type Symbol (line 10) | pub(crate) struct Symbol(String); method push (line 25) | fn push(&mut self, segment: &dyn Display) { method from_idents (line 34) | pub(crate) fn from_idents<'a>(it: impl Iterator bool { method fmt (line 13) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { method to_tokens (line 19) | fn to_tokens(&self, tokens: &mut TokenStream) { type Segment (line 49) | pub(crate) trait Segment { method write (line 50) | fn write(&self, symbol: &mut Symbol); method write (line 54) | fn write(&self, symbol: &mut Symbol) { method write (line 60) | fn write(&self, symbol: &mut Symbol) { method write (line 66) | fn write(&self, symbol: &mut Symbol) { method write (line 72) | fn write(&self, symbol: &mut Symbol) { method write (line 78) | fn write(&self, symbol: &mut Symbol) { method write (line 86) | fn write(&self, symbol: &mut Symbol) { method write (line 93) | fn write(&self, symbol: &mut Symbol) { method write (line 104) | fn write(&self, symbol: &mut Symbol) { function join (line 109) | pub(crate) fn join(segments: &[&dyn Segment]) -> Symbol { FILE: syntax/tokens.rs method to_tokens (line 11) | fn to_tokens(&self, tokens: &mut TokenStream) { method to_tokens (line 43) | fn to_tokens(&self, tokens: &mut TokenStream) { method to_tokens (line 60) | fn to_tokens(&self, tokens: &mut TokenStream) { method to_tokens (line 88) | fn to_tokens(&self, tokens: &mut TokenStream) { method to_tokens (line 113) | fn to_tokens(&self, tokens: &mut TokenStream) { method to_tokens (line 129) | fn to_tokens(&self, tokens: &mut TokenStream) { method to_tokens (line 148) | fn to_tokens(&self, tokens: &mut TokenStream) { method to_tokens (line 165) | fn to_tokens(&self, tokens: &mut TokenStream) { method to_tokens (line 171) | fn to_tokens(&self, tokens: &mut TokenStream) { method to_tokens (line 177) | fn to_tokens(&self, tokens: &mut TokenStream) { method to_tokens (line 186) | fn to_tokens(&self, tokens: &mut TokenStream) { method to_tokens (line 195) | fn to_tokens(&self, tokens: &mut TokenStream) { method to_tokens (line 204) | fn to_tokens(&self, tokens: &mut TokenStream) { method to_tokens (line 213) | fn to_tokens(&self, tokens: &mut TokenStream) { method to_tokens (line 222) | fn to_tokens(&self, tokens: &mut TokenStream) { method to_tokens (line 242) | fn to_tokens(&self, tokens: &mut TokenStream) { method to_tokens (line 255) | fn to_tokens(&self, tokens: &mut TokenStream) { method to_tokens (line 293) | fn to_tokens(&self, tokens: &mut TokenStream) { method to_tokens (line 300) | fn to_tokens(&self, tokens: &mut TokenStream) { FILE: syntax/toposort.rs type Mark (line 5) | enum Mark { function sort (line 10) | pub(crate) fn sort<'a>(cx: &mut Errors, apis: &'a [Api], types: &Types<'... function visit (line 21) | fn visit<'a>( FILE: syntax/trivial.rs type TrivialReason (line 12) | pub(crate) enum TrivialReason<'a> { function required_trivial_reasons (line 30) | pub(crate) fn required_trivial_reasons<'a>( function as_what (line 117) | pub(crate) fn as_what<'a>(name: &'a Pair, reasons: &'a [TrivialReason]) ... FILE: syntax/types.rs type Types (line 20) | pub(crate) struct Types<'a> { type ConditionalImpl (line 39) | pub(crate) struct ConditionalImpl<'a> { function collect (line 48) | pub(crate) fn collect(cx: &mut Errors, apis: &'a [Api]) -> Self { function needs_indirect_abi (line 302) | pub(crate) fn needs_indirect_abi(&self, ty: impl Into>) ->... function is_considered_improper_ctype (line 323) | pub(crate) fn is_considered_improper_ctype(&self, ty: impl Into bool { function contains_elided_lifetime (line 347) | pub(crate) fn contains_elided_lifetime(&self, ty: &Type) -> bool { function is_local (line 371) | pub(crate) fn is_local(&self, ty: &Type) -> bool { type Item (line 399) | type Item = &'a Type; type IntoIter (line 400) | type IntoIter = std::iter::Copied Self::IntoIter { function from (line 407) | fn from(cfg: ComputedCfg<'a>) -> Self { function from (line 416) | fn from(imp: &'a Impl) -> Self { type ItemName (line 424) | enum ItemName<'a> { function duplicate_name (line 429) | fn duplicate_name(cx: &mut Errors, sp: impl ToTokens, name: ItemName) { FILE: syntax/unpin.rs type UnpinReason (line 8) | pub(crate) enum UnpinReason<'a> { function required_unpin_reasons (line 14) | pub(crate) fn required_unpin_reasons<'a>( FILE: syntax/visit.rs type Visit (line 3) | pub(crate) trait Visit<'a> { method visit_type (line 4) | fn visit_type(&mut self, ty: &'a Type) { function visit_type (line 9) | pub(crate) fn visit_type<'a, V>(visitor: &mut V, ty: &'a Type) FILE: tests/compiletest.rs function ui (line 6) | fn ui() { FILE: tests/cpp_compile/mod.rs type Test (line 18) | pub struct Test { method new (line 48) | pub fn new(cxx_bridge: TokenStream) -> Self { method write_file (line 74) | pub fn write_file(&self, filename: impl AsRef, contents: &str) { method compile (line 85) | pub fn compile(&self) -> CompilationResult { type CompilationResult (line 121) | pub struct CompilationResult(process::Output); method stdout (line 124) | fn stdout(&self) -> Cow { method stderr (line 128) | fn stderr(&self) -> Cow { method dump_output_and_panic (line 132) | fn dump_output_and_panic(&self, msg: &str) -> ! { method error_lines (line 138) | fn error_lines(&self) -> Vec { method assert_success (line 163) | pub fn assert_success(&self) { method expect_single_error (line 180) | pub fn expect_single_error(&self) -> String { FILE: tests/cpp_compile/smoke_test.rs function test_success (line 6) | fn test_success() { function test_failure (line 26) | fn test_failure() { function test_unexpected_extra_error (line 47) | fn test_unexpected_extra_error() { FILE: tests/cpp_ui_tests.rs function test_unique_ptr_of_incomplete_foward_declared_pointee (line 9) | fn test_unique_ptr_of_incomplete_foward_declared_pointee() { FILE: tests/cxx_gen.rs constant CXXPREFIX (line 4) | const CXXPREFIX: &str = concat!("cxxbridge1$", env!("CARGO_PKG_VERSION_P... constant BRIDGE0 (line 6) | const BRIDGE0: &str = r#" function test_extern_c_function (line 16) | fn test_extern_c_function() { function test_impl_annotation (line 27) | fn test_impl_annotation() { constant BRIDGE1 (line 38) | const BRIDGE1: &str = r#" function test_extern_rust_method_on_c_type (line 62) | fn test_extern_rust_method_on_c_type() { FILE: tests/cxx_string.rs function test_async_cxx_string (line 11) | fn test_async_cxx_string() { function test_display (line 25) | fn test_display() { function test_debug (line 32) | fn test_debug() { function test_fmt_write (line 39) | fn test_fmt_write() { function test_io_write (line 48) | fn test_io_write() { FILE: tests/cxx_vector.rs function test_cxx_vector_new (line 4) | fn test_cxx_vector_new() { FILE: tests/ffi/build.rs function main (line 6) | fn main() { FILE: tests/ffi/cast.rs function c_char_to_unsigned (line 4) | pub fn c_char_to_unsigned(slice: &[c_char]) -> &[u8] { function unsigned_to_c_char (line 10) | pub fn unsigned_to_c_char(slice: &[u8]) -> &[c_char] { FILE: tests/ffi/lib.rs type Shared (line 39) | struct Shared { type SharedString (line 45) | struct SharedString { type Enum (line 50) | enum Enum { type AShared (line 60) | struct AShared { type AEnum (line 66) | enum AEnum { type ABEnum (line 73) | enum ABEnum { type ABShared (line 81) | struct ABShared { type First (line 86) | struct First { type Second (line 92) | struct Second { type WithArray (line 97) | pub struct WithArray { type OveralignedStruct (line 103) | pub struct OveralignedStruct { type StructWithLifetime (line 108) | pub struct StructWithLifetime<'a> { function c_return_primitive (line 115) | fn c_return_primitive() -> usize; function c_return_shared (line 116) | fn c_return_shared() -> Shared; function c_return_box (line 117) | fn c_return_box() -> Box; function c_return_unique_ptr (line 118) | fn c_return_unique_ptr() -> UniquePtr; function c_return_shared_ptr (line 119) | fn c_return_shared_ptr() -> SharedPtr; function c_return_ref (line 120) | fn c_return_ref(shared: &Shared) -> &usize; function c_return_mut (line 121) | fn c_return_mut(shared: &mut Shared) -> &mut usize; function c_return_str (line 122) | fn c_return_str(shared: &Shared) -> &str; function c_return_slice_char (line 123) | fn c_return_slice_char(shared: &Shared) -> &[c_char]; function c_return_mutsliceu8 (line 124) | fn c_return_mutsliceu8(slice: &mut [u8]) -> &mut [u8]; function c_return_rust_string (line 125) | fn c_return_rust_string() -> String; function c_return_rust_string_lossy (line 126) | fn c_return_rust_string_lossy() -> String; function c_return_unique_ptr_string (line 127) | fn c_return_unique_ptr_string() -> UniquePtr; function c_return_unique_ptr_vector_u8 (line 128) | fn c_return_unique_ptr_vector_u8() -> UniquePtr>; function c_return_unique_ptr_vector_f64 (line 129) | fn c_return_unique_ptr_vector_f64() -> UniquePtr>; function c_return_unique_ptr_vector_string (line 130) | fn c_return_unique_ptr_vector_string() -> UniquePtr>; function c_return_unique_ptr_vector_shared (line 131) | fn c_return_unique_ptr_vector_shared() -> UniquePtr>; function c_return_unique_ptr_vector_opaque (line 132) | fn c_return_unique_ptr_vector_opaque() -> UniquePtr>; function c_return_ref_vector (line 133) | fn c_return_ref_vector(c: &C) -> &CxxVector; function c_return_mut_vector (line 134) | fn c_return_mut_vector(c: Pin<&mut C>) -> Pin<&mut CxxVector>; function c_return_rust_vec_u8 (line 135) | fn c_return_rust_vec_u8() -> Vec; function c_return_ref_rust_vec (line 136) | fn c_return_ref_rust_vec(c: &C) -> &Vec; function c_return_mut_rust_vec (line 137) | fn c_return_mut_rust_vec(c: Pin<&mut C>) -> &mut Vec; function c_return_rust_vec_string (line 138) | fn c_return_rust_vec_string() -> Vec; function c_return_rust_vec_bool (line 139) | fn c_return_rust_vec_bool() -> Vec; function c_return_identity (line 140) | fn c_return_identity(_: usize) -> usize; function c_return_sum (line 141) | fn c_return_sum(_: usize, _: usize) -> usize; function c_return_enum (line 142) | fn c_return_enum(n: u16) -> Enum; function c_return_ns_ref (line 143) | fn c_return_ns_ref(shared: &AShared) -> &usize; function c_return_nested_ns_ref (line 144) | fn c_return_nested_ns_ref(shared: &ABShared) -> &usize; function c_return_ns_enum (line 145) | fn c_return_ns_enum(n: u16) -> AEnum; function c_return_nested_ns_enum (line 146) | fn c_return_nested_ns_enum(n: u16) -> ABEnum; function c_return_const_ptr (line 147) | fn c_return_const_ptr(n: usize) -> *const C; function c_return_mut_ptr (line 148) | fn c_return_mut_ptr(n: usize) -> *mut C; function c_take_primitive (line 150) | fn c_take_primitive(n: usize); function c_take_shared (line 151) | fn c_take_shared(shared: Shared); function c_take_box (line 152) | fn c_take_box(r: Box); function c_take_ref_r (line 153) | fn c_take_ref_r(r: &R); function c_take_ref_c (line 154) | fn c_take_ref_c(c: &C); function c_take_str (line 155) | fn c_take_str(s: &str); function c_take_slice_char (line 156) | fn c_take_slice_char(s: &[c_char]); function c_take_slice_shared (line 157) | fn c_take_slice_shared(s: &[Shared]); function c_take_slice_shared_sort (line 158) | fn c_take_slice_shared_sort(s: &mut [Shared]); function c_take_slice_r (line 159) | fn c_take_slice_r(s: &[R]); function c_take_slice_r_sort (line 160) | fn c_take_slice_r_sort(s: &mut [R]); function c_take_rust_string (line 161) | fn c_take_rust_string(s: String); function c_take_unique_ptr_string (line 162) | fn c_take_unique_ptr_string(s: UniquePtr); function c_take_unique_ptr_vector_u8 (line 163) | fn c_take_unique_ptr_vector_u8(v: UniquePtr>); function c_take_unique_ptr_vector_f64 (line 164) | fn c_take_unique_ptr_vector_f64(v: UniquePtr>); function c_take_unique_ptr_vector_string (line 165) | fn c_take_unique_ptr_vector_string(v: UniquePtr>); function c_take_unique_ptr_vector_shared (line 166) | fn c_take_unique_ptr_vector_shared(v: UniquePtr>); function c_take_ref_vector (line 167) | fn c_take_ref_vector(v: &CxxVector); function c_take_rust_vec (line 168) | fn c_take_rust_vec(v: Vec); function c_take_rust_vec_shared (line 169) | fn c_take_rust_vec_shared(v: Vec); function c_take_rust_vec_string (line 170) | fn c_take_rust_vec_string(v: Vec); function c_take_rust_vec_index (line 171) | fn c_take_rust_vec_index(v: Vec); function c_take_rust_vec_shared_index (line 172) | fn c_take_rust_vec_shared_index(v: Vec); function c_take_rust_vec_shared_push (line 173) | fn c_take_rust_vec_shared_push(v: Vec); function c_take_rust_vec_shared_truncate (line 174) | fn c_take_rust_vec_shared_truncate(v: Vec); function c_take_rust_vec_shared_clear (line 175) | fn c_take_rust_vec_shared_clear(v: Vec); function c_take_rust_vec_shared_forward_iterator (line 176) | fn c_take_rust_vec_shared_forward_iterator(v: Vec); function c_take_rust_vec_shared_sort (line 177) | fn c_take_rust_vec_shared_sort(v: Vec); function c_take_ref_rust_vec (line 178) | fn c_take_ref_rust_vec(v: &Vec); function c_take_ref_rust_vec_string (line 179) | fn c_take_ref_rust_vec_string(v: &Vec); function c_take_ref_rust_vec_index (line 180) | fn c_take_ref_rust_vec_index(v: &Vec); function c_take_ref_rust_vec_copy (line 181) | fn c_take_ref_rust_vec_copy(v: &Vec); function c_take_ref_shared_string (line 182) | fn c_take_ref_shared_string(s: &SharedString) -> &SharedString; function c_take_callback (line 183) | fn c_take_callback(callback: fn(String) -> usize); function c_take_callback_ref (line 184) | fn c_take_callback_ref(callback: fn(&String)); function c_take_callback_ref_lifetime (line 186) | fn c_take_callback_ref_lifetime<'a>(callback: fn(&'a String)); function c_take_callback_mut (line 187) | fn c_take_callback_mut(callback: fn(&mut String)); function c_take_enum (line 188) | fn c_take_enum(e: Enum); function c_take_ns_enum (line 189) | fn c_take_ns_enum(e: AEnum); function c_take_nested_ns_enum (line 190) | fn c_take_nested_ns_enum(e: ABEnum); function c_take_ns_shared (line 191) | fn c_take_ns_shared(shared: AShared); function c_take_nested_ns_shared (line 192) | fn c_take_nested_ns_shared(shared: ABShared); function c_take_rust_vec_ns_shared (line 193) | fn c_take_rust_vec_ns_shared(v: Vec); function c_take_rust_vec_nested_ns_shared (line 194) | fn c_take_rust_vec_nested_ns_shared(v: Vec); function c_take_const_ptr (line 195) | unsafe fn c_take_const_ptr(c: *const C) -> usize; function c_take_mut_ptr (line 196) | unsafe fn c_take_mut_ptr(c: *mut C) -> usize; function c_try_return_void (line 198) | fn c_try_return_void() -> Result<()>; function c_try_return_primitive (line 199) | fn c_try_return_primitive() -> Result; function c_fail_return_primitive (line 200) | fn c_fail_return_primitive() -> Result; function c_try_return_box (line 201) | fn c_try_return_box() -> Result>; function c_try_return_ref (line 202) | fn c_try_return_ref(s: &String) -> Result<&String>; function c_try_return_str (line 203) | fn c_try_return_str(s: &str) -> Result<&str>; function c_try_return_sliceu8 (line 204) | fn c_try_return_sliceu8(s: &[u8]) -> Result<&[u8]>; function c_try_return_mutsliceu8 (line 205) | fn c_try_return_mutsliceu8(s: &mut [u8]) -> Result<&mut [u8]>; function c_try_return_rust_string (line 206) | fn c_try_return_rust_string() -> Result; function c_try_return_unique_ptr_string (line 207) | fn c_try_return_unique_ptr_string() -> Result>; function c_try_return_rust_vec (line 208) | fn c_try_return_rust_vec() -> Result>; function c_try_return_rust_vec_string (line 209) | fn c_try_return_rust_vec_string() -> Result>; function c_try_return_ref_rust_vec (line 210) | fn c_try_return_ref_rust_vec(c: &C) -> Result<&Vec>; function get (line 212) | fn get(self: &C) -> usize; function set (line 213) | fn set(self: Pin<&mut C>, n: usize) -> usize; function get2 (line 214) | fn get2(&self) -> usize; function getRef (line 215) | fn getRef(self: &C) -> &usize; function getMut (line 216) | fn getMut(self: Pin<&mut C>) -> &mut usize; function set_succeed (line 217) | fn set_succeed(self: Pin<&mut C>, n: usize) -> Result; function get_fail (line 218) | fn get_fail(self: Pin<&mut C>) -> Result; function c_method_on_shared (line 219) | fn c_method_on_shared(self: &Shared) -> usize; function c_method_ref_on_shared (line 220) | fn c_method_ref_on_shared(self: &Shared) -> &usize; function c_method_mut_on_shared (line 221) | fn c_method_mut_on_shared(self: &mut Shared) -> &mut usize; function c_static_method_on_shared (line 223) | fn c_static_method_on_shared() -> usize; function c_set_array (line 224) | fn c_set_array(self: &mut WithArray, value: i32); function c_get_use_count (line 226) | fn c_get_use_count(weak: &WeakPtr) -> usize; function cOverloadedMethod (line 229) | fn cOverloadedMethod(&self, x: i32) -> String; function cOverloadedMethod (line 231) | fn cOverloadedMethod(&self, x: &str) -> String; function cOverloadedFunction (line 233) | fn cOverloadedFunction(x: i32) -> String; function cOverloadedFunction (line 235) | fn cOverloadedFunction(x: &str) -> String; function ns_c_take_ns_shared (line 238) | fn ns_c_take_ns_shared(shared: AShared); function c_static_method (line 241) | fn c_static_method() -> usize; type ContainsOpaqueRust (line 244) | struct ContainsOpaqueRust<'a> { type Job (line 255) | type Job = crate::module::ffi::Job; type OpaqueRust (line 256) | type OpaqueRust = crate::module::OpaqueRust; function c_return_borrow (line 267) | fn c_return_borrow<'a>(s: &'a CxxString) -> UniquePtr>; function c_return_borrow (line 271) | fn c_return_borrow(s: &CxxString) -> UniquePtr; function const_member (line 273) | fn const_member(self: &Borrow); function nonconst_member (line 274) | fn nonconst_member(self: Pin<&mut Borrow>); type COwnedEnum (line 279) | enum COwnedEnum { type Buffer (line 287) | type Buffer = crate::Buffer; function r_return_primitive (line 293) | fn r_return_primitive() -> usize; function r_return_shared (line 294) | fn r_return_shared() -> Shared; function r_return_box (line 295) | fn r_return_box() -> Box; function r_return_unique_ptr (line 296) | fn r_return_unique_ptr() -> UniquePtr; function r_return_shared_ptr (line 297) | fn r_return_shared_ptr() -> SharedPtr; function r_return_ref (line 298) | fn r_return_ref(shared: &Shared) -> &usize; function r_return_mut (line 299) | fn r_return_mut(shared: &mut Shared) -> &mut usize; function r_return_str (line 300) | fn r_return_str(shared: &Shared) -> &str; function r_return_str_via_out_param (line 301) | unsafe fn r_return_str_via_out_param<'a>(shared: &'a Shared, out_param: ... function r_return_sliceu8 (line 302) | fn r_return_sliceu8(shared: &Shared) -> &[u8]; function r_return_mutsliceu8 (line 303) | fn r_return_mutsliceu8(slice: &mut [u8]) -> &mut [u8]; function r_return_rust_string (line 304) | fn r_return_rust_string() -> String; function r_return_unique_ptr_string (line 305) | fn r_return_unique_ptr_string() -> UniquePtr; function r_return_rust_vec (line 306) | fn r_return_rust_vec() -> Vec; function r_return_rust_vec_string (line 307) | fn r_return_rust_vec_string() -> Vec; function r_return_rust_vec_extern_struct (line 308) | fn r_return_rust_vec_extern_struct() -> Vec; function r_return_rust_vec_box (line 310) | fn r_return_rust_vec_box() -> Vec>; function r_return_rust_vec_box_other_module_type (line 312) | fn r_return_rust_vec_box_other_module_type() -> Vec>; function r_return_ref_rust_vec (line 313) | fn r_return_ref_rust_vec(shared: &Shared) -> &Vec; function r_return_mut_rust_vec (line 314) | fn r_return_mut_rust_vec(shared: &mut Shared) -> &mut Vec; function r_return_identity (line 315) | fn r_return_identity(_: usize) -> usize; function r_return_sum (line 316) | fn r_return_sum(_: usize, _: usize) -> usize; function r_return_enum (line 317) | fn r_return_enum(n: u32) -> Enum; function r_take_primitive (line 319) | fn r_take_primitive(n: usize); function r_take_shared (line 320) | fn r_take_shared(shared: Shared); function r_take_box (line 321) | fn r_take_box(r: Box); function r_take_unique_ptr (line 322) | fn r_take_unique_ptr(c: UniquePtr); function r_take_shared_ptr (line 323) | fn r_take_shared_ptr(c: SharedPtr); function r_take_ref_r (line 324) | fn r_take_ref_r(r: &R); function r_take_ref_c (line 325) | fn r_take_ref_c(c: &C); function r_take_str (line 326) | fn r_take_str(s: &str); function r_take_slice_char (line 327) | fn r_take_slice_char(s: &[c_char]); function r_take_rust_string (line 328) | fn r_take_rust_string(s: String); function r_take_unique_ptr_string (line 329) | fn r_take_unique_ptr_string(s: UniquePtr); function r_take_ref_vector (line 330) | fn r_take_ref_vector(v: &CxxVector); function r_take_ref_empty_vector (line 331) | fn r_take_ref_empty_vector(v: &CxxVector); function r_take_rust_vec (line 332) | fn r_take_rust_vec(v: Vec); function r_take_rust_vec_string (line 333) | fn r_take_rust_vec_string(v: Vec); function r_take_ref_rust_vec (line 334) | fn r_take_ref_rust_vec(v: &Vec); function r_take_ref_rust_vec_string (line 335) | fn r_take_ref_rust_vec_string(v: &Vec); function r_take_enum (line 336) | fn r_take_enum(e: Enum); function r_try_return_void (line 338) | fn r_try_return_void() -> Result<()>; function r_try_return_primitive (line 339) | fn r_try_return_primitive() -> Result; function r_try_return_box (line 340) | fn r_try_return_box() -> Result>; function r_fail_return_primitive (line 341) | fn r_fail_return_primitive() -> Result; function r_try_return_sliceu8 (line 342) | fn r_try_return_sliceu8(s: &[u8]) -> Result<&[u8]>; function r_try_return_mutsliceu8 (line 343) | fn r_try_return_mutsliceu8(s: &mut [u8]) -> Result<&mut [u8]>; function get (line 345) | fn get(self: &R) -> usize; function set (line 346) | fn set(self: &mut R, n: usize) -> usize; function r_method_on_shared (line 347) | fn r_method_on_shared(self: &Shared) -> String; function r_get_array_sum (line 348) | fn r_get_array_sum(self: &WithArray) -> i32; function r_method_on_c_get_mut (line 350) | fn r_method_on_c_get_mut(self: Pin<&mut C>) -> &mut usize; function r_aliased_function (line 353) | fn r_aliased_function(x: i32) -> String; function r_static_method_on_shared (line 356) | fn r_static_method_on_shared() -> usize; function r_static_method (line 359) | fn r_static_method() -> usize; function c_member_function_on_rust_type (line 363) | fn c_member_function_on_rust_type(self: &R); type Dag0 (line 366) | struct Dag0 { type Dag1 (line 370) | struct Dag1 { type Dag2 (line 375) | struct Dag2 { type Dag3 (line 379) | struct Dag3 { type Dag4 (line 383) | struct Dag4 { type StructWithLifetime2 (line 400) | pub struct StructWithLifetime2<'a> { function r_take_unique_ptr_of_struct_with_lifetime2 (line 404) | fn r_take_unique_ptr_of_struct_with_lifetime2(_: UniquePtr usize { method set (line 468) | fn set(&mut self, n: usize) -> usize { method r_static_method (line 473) | fn r_static_method() -> usize { type Reference (line 478) | pub struct Reference<'a>(pub &'a String); function r_method_on_shared (line 481) | fn r_method_on_shared(&self) -> String { function r_static_method_on_shared (line 485) | fn r_static_method_on_shared() -> usize { function r_get_array_sum (line 491) | pub fn r_get_array_sum(&self) -> i32 { function r_method_on_c_get_mut (line 498) | pub fn r_method_on_c_get_mut(self: core::pin::Pin<&mut Self>) -> &mut us... type Buffer (line 505) | pub struct Buffer([c_char; 12]); type Id (line 508) | type Id = type_id!("tests::Buffer"); type Kind (line 509) | type Kind = cxx::kind::Trivial; type Error (line 513) | struct Error; method fmt (line 518) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { function r_return_primitive (line 523) | fn r_return_primitive() -> usize { function r_return_shared (line 527) | fn r_return_shared() -> ffi::Shared { function r_return_box (line 531) | fn r_return_box() -> Box { function r_return_unique_ptr (line 535) | fn r_return_unique_ptr() -> UniquePtr { function r_return_shared_ptr (line 543) | fn r_return_shared_ptr() -> SharedPtr { function r_return_ref (line 556) | fn r_return_ref(shared: &ffi::Shared) -> &usize { function r_return_mut (line 560) | fn r_return_mut(shared: &mut ffi::Shared) -> &mut usize { function r_return_str (line 564) | fn r_return_str(shared: &ffi::Shared) -> &str { function r_return_str_via_out_param (line 569) | fn r_return_str_via_out_param<'a>(shared: &'a ffi::Shared, out_param: &m... function r_return_sliceu8 (line 574) | fn r_return_sliceu8(shared: &ffi::Shared) -> &[u8] { function r_return_mutsliceu8 (line 579) | fn r_return_mutsliceu8(slice: &mut [u8]) -> &mut [u8] { function r_return_rust_string (line 583) | fn r_return_rust_string() -> String { function r_return_unique_ptr_string (line 587) | fn r_return_unique_ptr_string() -> UniquePtr { function r_return_rust_vec (line 595) | fn r_return_rust_vec() -> Vec { function r_return_rust_vec_string (line 599) | fn r_return_rust_vec_string() -> Vec { function r_return_rust_vec_extern_struct (line 603) | fn r_return_rust_vec_extern_struct() -> Vec { function r_return_rust_vec_box (line 608) | fn r_return_rust_vec_box() -> Vec> { function r_return_rust_vec_box_other_module_type (line 613) | fn r_return_rust_vec_box_other_module_type() -> Vec &Vec { function r_return_mut_rust_vec (line 622) | fn r_return_mut_rust_vec(shared: &mut ffi::Shared) -> &mut Vec { function r_return_identity (line 627) | fn r_return_identity(n: usize) -> usize { function r_return_sum (line 631) | fn r_return_sum(n1: usize, n2: usize) -> usize { function r_return_enum (line 635) | fn r_return_enum(n: u32) -> ffi::Enum { function r_take_primitive (line 645) | fn r_take_primitive(n: usize) { function r_take_shared (line 649) | fn r_take_shared(shared: ffi::Shared) { function r_take_box (line 653) | fn r_take_box(r: Box) { function r_take_unique_ptr (line 657) | fn r_take_unique_ptr(c: UniquePtr) { function r_take_shared_ptr (line 661) | fn r_take_shared_ptr(c: SharedPtr) { function r_take_ref_r (line 665) | fn r_take_ref_r(r: &R) { function r_take_ref_c (line 669) | fn r_take_ref_c(c: &ffi::C) { function r_take_str (line 673) | fn r_take_str(s: &str) { function r_take_rust_string (line 677) | fn r_take_rust_string(s: String) { function r_take_slice_char (line 681) | fn r_take_slice_char(s: &[c_char]) { function r_take_unique_ptr_string (line 687) | fn r_take_unique_ptr_string(s: UniquePtr) { function r_take_ref_vector (line 691) | fn r_take_ref_vector(v: &CxxVector) { function r_take_ref_empty_vector (line 696) | fn r_take_ref_empty_vector(v: &CxxVector) { function r_take_rust_vec (line 701) | fn r_take_rust_vec(v: Vec) { function r_take_rust_vec_string (line 705) | fn r_take_rust_vec_string(v: Vec) { function r_take_ref_rust_vec (line 709) | fn r_take_ref_rust_vec(v: &Vec) { function r_take_ref_rust_vec_string (line 713) | fn r_take_ref_rust_vec_string(v: &Vec) { function r_take_enum (line 717) | fn r_take_enum(e: ffi::Enum) { function r_take_unique_ptr_of_struct_with_lifetime2 (line 721) | fn r_take_unique_ptr_of_struct_with_lifetime2( function r_try_return_void (line 726) | fn r_try_return_void() -> Result<(), Error> { function r_try_return_primitive (line 730) | fn r_try_return_primitive() -> Result { function r_try_return_box (line 734) | fn r_try_return_box() -> Result, Error> { function r_fail_return_primitive (line 738) | fn r_fail_return_primitive() -> Result { function r_try_return_sliceu8 (line 742) | fn r_try_return_sliceu8(slice: &[u8]) -> Result<&[u8], Error> { function r_try_return_mutsliceu8 (line 746) | fn r_try_return_mutsliceu8(slice: &mut [u8]) -> Result<&mut [u8], Error> { function r_aliased_function (line 750) | fn r_aliased_function(x: i32) -> String { FILE: tests/ffi/module.rs type OpaqueRust (line 3) | pub struct OpaqueRust(pub i32); type Job (line 7) | struct Job { type C (line 14) | type C = crate::ffi::C; function c_take_unique_ptr (line 16) | fn c_take_unique_ptr(c: UniquePtr); function c_lifetime_elision_member_fn (line 17) | fn c_lifetime_elision_member_fn(self: &C) -> &CxxVector; function c_lifetime_elision_fn (line 18) | fn c_lifetime_elision_fn(c: &C) -> &CxxVector; type D (line 37) | type D = crate::other::D; type E (line 38) | type E = crate::other::E; type F (line 40) | type F = crate::other::f::F; type G (line 42) | type G = crate::other::G; function c_take_trivial_ptr (line 47) | fn c_take_trivial_ptr(d: UniquePtr); function c_take_trivial_ref (line 48) | fn c_take_trivial_ref(d: &D); function c_take_trivial_mut_ref (line 49) | fn c_take_trivial_mut_ref(d: &mut D); function c_take_trivial_pin_ref (line 50) | fn c_take_trivial_pin_ref(d: Pin<&D>); function c_take_trivial_pin_mut_ref (line 51) | fn c_take_trivial_pin_mut_ref(d: Pin<&mut D>); function c_take_trivial_ref_method (line 52) | fn c_take_trivial_ref_method(self: &D); function c_take_trivial_mut_ref_method (line 53) | fn c_take_trivial_mut_ref_method(self: &mut D); function c_take_trivial (line 54) | fn c_take_trivial(d: D); function c_take_trivial_ns_ptr (line 55) | fn c_take_trivial_ns_ptr(g: UniquePtr); function c_take_trivial_ns_ref (line 56) | fn c_take_trivial_ns_ref(g: &G); function c_take_trivial_ns (line 57) | fn c_take_trivial_ns(g: G); function c_take_opaque_ptr (line 58) | fn c_take_opaque_ptr(e: UniquePtr); function c_take_opaque_ref (line 59) | fn c_take_opaque_ref(e: &E); function c_take_opaque_ref_method (line 60) | fn c_take_opaque_ref_method(self: &E); function c_take_opaque_mut_ref_method (line 61) | fn c_take_opaque_mut_ref_method(self: Pin<&mut E>); function c_take_opaque_ns_ptr (line 62) | fn c_take_opaque_ns_ptr(e: UniquePtr); function c_take_opaque_ns_ref (line 63) | fn c_take_opaque_ns_ref(e: &F); function c_return_trivial_ptr (line 64) | fn c_return_trivial_ptr() -> UniquePtr; function c_return_trivial (line 65) | fn c_return_trivial() -> D; function c_return_trivial_ns_ptr (line 66) | fn c_return_trivial_ns_ptr() -> UniquePtr; function c_return_trivial_ns (line 67) | fn c_return_trivial_ns() -> G; function c_return_opaque_ptr (line 68) | fn c_return_opaque_ptr() -> UniquePtr; function c_return_opaque_mut_pin (line 69) | fn c_return_opaque_mut_pin(e: Pin<&mut E>) -> Pin<&mut E>; function c_return_ns_opaque_ptr (line 70) | fn c_return_ns_opaque_ptr() -> UniquePtr; function c_return_ns_unique_ptr (line 71) | fn c_return_ns_unique_ptr() -> UniquePtr; function c_take_ref_ns_c (line 72) | fn c_take_ref_ns_c(h: &H); function ns_c_take_trivial (line 75) | fn ns_c_take_trivial(d: D); function ns_c_return_trivial (line 77) | fn ns_c_return_trivial() -> D; function get (line 82) | fn get(self: &I) -> u32; function ns_c_return_unique_ptr_ns (line 85) | fn ns_c_return_unique_ptr_ns() -> UniquePtr; FILE: tests/ffi/tests.cc type tests (line 24) | namespace tests { function c_return_primitive (line 67) | size_t c_return_primitive() { return 2020; } function Shared (line 69) | Shared c_return_shared() { return Shared{2020}; } function c_return_ns_shared (line 71) | ::A::AShared c_return_ns_shared() { return ::A::AShared{2020}; } function c_return_nested_ns_shared (line 73) | ::A::B::ABShared c_return_nested_ns_shared() { return ::A::B::ABShared... function c_return_box (line 75) | rust::Box c_return_box() { function c_return_unique_ptr (line 87) | std::unique_ptr c_return_unique_ptr() { function c_return_shared_ptr (line 91) | std::shared_ptr c_return_shared_ptr() { function c_return_ns_unique_ptr (line 95) | std::unique_ptr<::H::H> c_return_ns_unique_ptr() { function c_return_str (line 111) | rust::Str c_return_str(const Shared &shared) { function c_return_slice_char (line 116) | rust::Slice c_return_slice_char(const Shared &shared) { function c_return_mutsliceu8 (line 121) | rust::Slice c_return_mutsliceu8(rust::Slice slice) { function c_return_rust_string (line 125) | rust::String c_return_rust_string() { return "2020"; } function c_return_rust_string_lossy (line 127) | rust::String c_return_rust_string_lossy() { function c_return_unique_ptr_string (line 131) | std::unique_ptr c_return_unique_ptr_string() { function c_return_unique_ptr_vector_u8 (line 135) | std::unique_ptr> c_return_unique_ptr_vector_u8() { function c_return_unique_ptr_vector_f64 (line 144) | std::unique_ptr> c_return_unique_ptr_vector_f64() { function c_return_unique_ptr_vector_string (line 153) | std::unique_ptr> c_return_unique_ptr_vector_s... function c_return_unique_ptr_vector_shared (line 158) | std::unique_ptr> c_return_unique_ptr_vector_shared... function c_return_unique_ptr_vector_opaque (line 165) | std::unique_ptr> c_return_unique_ptr_vector_opaque() { function c_return_rust_vec_u8 (line 175) | rust::Vec c_return_rust_vec_u8() { function c_return_rust_vec_string (line 190) | rust::Vec c_return_rust_vec_string() { function c_return_rust_vec_bool (line 194) | rust::Vec c_return_rust_vec_bool() { return {true, true, false}; } function c_return_identity (line 196) | size_t c_return_identity(size_t n) { return n; } function c_return_sum (line 198) | size_t c_return_sum(size_t n1, size_t n2) { return n1 + n2; } function Enum (line 200) | Enum c_return_enum(uint16_t n) { function c_return_ns_enum (line 210) | ::A::AEnum c_return_ns_enum(uint16_t n) { function c_return_nested_ns_enum (line 220) | ::A::B::ABEnum c_return_nested_ns_enum(uint16_t n) { function C (line 230) | const C *c_return_const_ptr(size_t c) { return new C(c); } function C (line 232) | C *c_return_mut_ptr(size_t c) { return new C(c); } function c_return_borrow (line 240) | std::unique_ptr c_return_borrow(const std::string &s) { function c_take_primitive (line 244) | void c_take_primitive(size_t n) { function c_take_shared (line 250) | void c_take_shared(Shared shared) { function c_take_ns_shared (line 256) | void c_take_ns_shared(::A::AShared shared) { function c_take_nested_ns_shared (line 262) | void c_take_nested_ns_shared(::A::B::ABShared shared) { function c_take_box (line 268) | void c_take_box(rust::Box r) { function c_take_unique_ptr (line 274) | void c_take_unique_ptr(std::unique_ptr c) { function c_take_ref_r (line 280) | void c_take_ref_r(const R &r) { function c_take_ref_c (line 286) | void c_take_ref_c(const C &c) { function c_take_ref_ns_c (line 292) | void c_take_ref_ns_c(const ::H::H &h) { function c_take_str (line 298) | void c_take_str(rust::Str s) { function c_take_slice_char (line 304) | void c_take_slice_char(rust::Slice s) { function c_take_slice_shared (line 310) | void c_take_slice_shared(rust::Slice s) { function c_take_slice_shared_sort (line 317) | void c_take_slice_shared_sort(rust::Slice s) { function c_take_slice_r (line 326) | void c_take_slice_r(rust::Slice s) { function c_take_slice_r_sort (line 334) | void c_take_slice_r_sort(rust::Slice s) { function c_take_rust_string (line 346) | void c_take_rust_string(rust::String s) { function c_take_unique_ptr_string (line 352) | void c_take_unique_ptr_string(std::unique_ptr s) { function c_take_unique_ptr_vector_u8 (line 358) | void c_take_unique_ptr_vector_u8(std::unique_ptr>... function c_take_unique_ptr_vector_f64 (line 364) | void c_take_unique_ptr_vector_f64(std::unique_ptr>... function c_take_unique_ptr_vector_string (line 370) | void c_take_unique_ptr_vector_string( function c_take_unique_ptr_vector_shared (line 376) | void c_take_unique_ptr_vector_shared(std::unique_ptr &v) { function c_take_rust_vec (line 388) | void c_take_rust_vec(rust::Vec v) { c_take_ref_rust_vec(v); } function c_take_rust_vec_index (line 390) | void c_take_rust_vec_index(rust::Vec v) { function c_take_rust_vec_shared (line 401) | void c_take_rust_vec_shared(rust::Vec v) { function c_take_rust_vec_ns_shared (line 411) | void c_take_rust_vec_ns_shared(rust::Vec<::A::AShared> v) { function c_take_rust_vec_nested_ns_shared (line 421) | void c_take_rust_vec_nested_ns_shared(rust::Vec<::A::B::ABShared> v) { function c_take_rust_vec_string (line 431) | void c_take_rust_vec_string(rust::Vec v) { function c_take_rust_vec_shared_forward_iterator (line 436) | void c_take_rust_vec_shared_forward_iterator(rust::Vec v) { function c_take_rust_vec_shared_sort (line 451) | void c_take_rust_vec_shared_sort(rust::Vec v) { function c_take_rust_vec_shared_index (line 460) | void c_take_rust_vec_shared_index(rust::Vec v) { function c_take_rust_vec_shared_push (line 467) | void c_take_rust_vec_shared_push(rust::Vec v) { function c_take_rust_vec_shared_truncate (line 475) | void c_take_rust_vec_shared_truncate(rust::Vec v) { function c_take_rust_vec_shared_clear (line 485) | void c_take_rust_vec_shared_clear(rust::Vec v) { function c_take_ref_rust_vec (line 492) | void c_take_ref_rust_vec(const rust::Vec &v) { function c_take_ref_rust_vec_string (line 499) | void c_take_ref_rust_vec_string(const rust::Vec &v) { function c_take_ref_rust_vec_index (line 504) | void c_take_ref_rust_vec_index(const rust::Vec &v) { function c_take_ref_rust_vec_copy (line 511) | void c_take_ref_rust_vec_copy(const rust::Vec &v) { function SharedString (line 523) | const SharedString &c_take_ref_shared_string(const SharedString &s) { function c_take_callback (line 530) | void c_take_callback(rust::Fn callback) { function c_take_callback_ref (line 534) | void c_take_callback_ref(rust::Fn callback) { function c_take_callback_mut (line 539) | void c_take_callback_mut(rust::Fn callback) { function c_take_enum (line 544) | void c_take_enum(Enum e) { function c_take_ns_enum (line 550) | void c_take_ns_enum(::A::AEnum e) { function c_take_nested_ns_enum (line 556) | void c_take_nested_ns_enum(::A::B::ABEnum e) { function c_take_const_ptr (line 562) | size_t c_take_const_ptr(const C *c) { return c->get(); } function c_take_mut_ptr (line 564) | size_t c_take_mut_ptr(C *c) { function c_try_return_void (line 570) | void c_try_return_void() {} function c_try_return_primitive (line 572) | size_t c_try_return_primitive() { return 2020; } function c_fail_return_primitive (line 574) | size_t c_fail_return_primitive() { throw std::logic_error("logic error... function c_try_return_box (line 576) | rust::Box c_try_return_box() { return c_return_box(); } function c_try_return_str (line 580) | rust::Str c_try_return_str(rust::Str s) { return s; } function c_try_return_sliceu8 (line 582) | rust::Slice c_try_return_sliceu8(rust::Slice c_try_return_mutsliceu8(rust::Slice s) { function c_try_return_rust_string (line 590) | rust::String c_try_return_rust_string() { return c_return_rust_string(... function c_try_return_unique_ptr_string (line 592) | std::unique_ptr c_try_return_unique_ptr_string() { function c_try_return_rust_vec (line 596) | rust::Vec c_try_return_rust_vec() { function c_try_return_rust_vec_string (line 600) | rust::Vec c_try_return_rust_vec_string() { function c_get_use_count (line 609) | size_t c_get_use_count(const std::weak_ptr &weak) noexcept { function C (line 613) | C *cxx_test_suite_get_unique_ptr() noexcept { function cxx_test_suite_get_shared_ptr (line 617) | void function cOverloadedFunction (line 642) | rust::String cOverloadedFunction(int x) { function cOverloadedFunction (line 646) | rust::String cOverloadedFunction(rust::Str x) { function c_take_trivial_ptr (line 652) | void c_take_trivial_ptr(std::unique_ptr d) { function c_take_trivial_ref (line 658) | void c_take_trivial_ref(const D &d) { function c_take_trivial_mut_ref (line 664) | void c_take_trivial_mut_ref(D &d) { (void)d; } function c_take_trivial_pin_ref (line 666) | void c_take_trivial_pin_ref(const D &d) { (void)d; } function c_take_trivial_pin_mut_ref (line 668) | void c_take_trivial_pin_mut_ref(D &d) { (void)d; } function c_take_trivial (line 682) | void c_take_trivial(D d) { function c_take_trivial_ns_ptr (line 688) | void c_take_trivial_ns_ptr(std::unique_ptr<::G::G> g) { function c_take_trivial_ns_ref (line 694) | void c_take_trivial_ns_ref(const ::G::G &g) { function c_take_trivial_ns (line 700) | void c_take_trivial_ns(::G::G g) { function c_take_opaque_ptr (line 706) | void c_take_opaque_ptr(std::unique_ptr e) { function c_take_opaque_ns_ptr (line 712) | void c_take_opaque_ns_ptr(std::unique_ptr<::F::F> f) { function c_take_opaque_ref (line 718) | void c_take_opaque_ref(const E &e) { function c_take_opaque_ns_ref (line 736) | void c_take_opaque_ns_ref(const ::F::F &f) { function c_return_trivial_ptr (line 742) | std::unique_ptr c_return_trivial_ptr() { function D (line 748) | D c_return_trivial() { function c_return_trivial_ns_ptr (line 754) | std::unique_ptr<::G::G> c_return_trivial_ns_ptr() { function c_return_trivial_ns (line 760) | ::G::G c_return_trivial_ns() { function c_return_opaque_ptr (line 766) | std::unique_ptr c_return_opaque_ptr() { function E (line 773) | E &c_return_opaque_mut_pin(E &e) { return e; } function c_return_ns_opaque_ptr (line 775) | std::unique_ptr<::F::F> c_return_ns_opaque_ptr() { type other (line 1013) | namespace other { function ns_c_take_trivial (line 1014) | void ns_c_take_trivial(::tests::D d) { function ns_c_return_trivial (line 1020) | ::tests::D ns_c_return_trivial() { function ns_c_take_ns_shared (line 1026) | void ns_c_take_ns_shared(::A::AShared shared) { type I (line 1033) | namespace I { function ns_c_return_unique_ptr_ns (line 1036) | std::unique_ptr ns_c_return_unique_ptr_ns() { class rust::Box (line 1049) | class rust::Box class rust::Slice (line 1050) | class rust::Slice class rust::Slice (line 1051) | class rust::Slice class rust::Slice (line 1052) | class rust::Slice class rust::Slice (line 1053) | class rust::Slice class rust::Slice (line 1054) | class rust::Slice class rust::Slice (line 1055) | class rust::Slice class rust::Slice (line 1056) | class rust::Slice class rust::Vec (line 1057) | class rust::Vec class rust::Vec (line 1058) | class rust::Vec class rust::Vec (line 1059) | class rust::Vec class rust::Fn (line 1060) | class rust::Fn FILE: tests/ffi/tests.h function namespace (line 6) | namespace A { function namespace (line 15) | namespace F { function namespace (line 22) | namespace G { function namespace (line 28) | namespace H { function class (line 39) | class Private { type Unmovable (line 44) | struct Unmovable { type R (line 50) | struct R type Shared (line 51) | struct Shared type SharedString (line 52) | struct SharedString type class (line 53) | enum class function get (line 58) | size_t get() const; function namespace (line 246) | namespace I { FILE: tests/test.rs function cxx_test_suite_set_correct (line 23) | extern "C" fn cxx_test_suite_set_correct() { function test_c_return (line 36) | fn test_c_return() { function test_c_try_return (line 104) | fn test_c_try_return() { function test_c_take (line 120) | fn test_c_take() { function test_c_callback (line 213) | fn test_c_callback() { function test_c_call_r (line 241) | fn test_c_call_r() { function test_c_method_calls (line 256) | fn test_c_method_calls() { function test_shared_ptr_weak_ptr (line 288) | fn test_shared_ptr_weak_ptr() { function test_unique_to_shared_ptr_string (line 302) | fn test_unique_to_shared_ptr_string() { function test_unique_to_shared_ptr_cpp_type (line 311) | fn test_unique_to_shared_ptr_cpp_type() { function test_unique_to_shared_ptr_null (line 319) | fn test_unique_to_shared_ptr_null() { function test_shared_ptr_from_raw (line 327) | fn test_shared_ptr_from_raw() { function test_shared_ptr_from_raw_undefined (line 334) | fn test_shared_ptr_from_raw_undefined() { function test_shared_ptr_from_raw_private (line 340) | fn test_shared_ptr_from_raw_private() { function test_vector_reserve_unmovable (line 346) | fn test_vector_reserve_unmovable() { function test_c_ns_method_calls (line 352) | fn test_c_ns_method_calls() { function test_enum_representations (line 360) | fn test_enum_representations() { function test_enum_default (line 367) | fn test_enum_default() { function test_struct_repr_align (line 372) | fn test_struct_repr_align() { function test_debug (line 377) | fn test_debug() { function cxx_test_suite_get_box (line 384) | extern "C" fn cxx_test_suite_get_box() -> *mut R { function cxx_test_suite_r_is_correct (line 389) | unsafe extern "C" fn cxx_test_suite_r_is_correct(r: *const R) -> bool { function test_rust_name_attribute (line 394) | fn test_rust_name_attribute() { function test_extern_trivial (line 403) | fn test_extern_trivial() { function test_extern_opaque (line 426) | fn test_extern_opaque() { function test_raw_ptr (line 439) | fn test_raw_ptr() { function test_unwind_safe (line 456) | fn test_unwind_safe() { FILE: tests/ui/array_len_expr.rs type Shared (line 3) | struct Shared { function main (line 10) | fn main() {} FILE: tests/ui/array_len_suffix.rs function array (line 4) | fn array() -> [String; 12u16]; function main (line 8) | fn main() {} FILE: tests/ui/async_fn.rs function f (line 4) | async fn f(); function g (line 8) | async fn g(); function f (line 12) | async fn f() {} function main (line 14) | fn main() {} FILE: tests/ui/bad_explicit_impl.rs type S (line 3) | struct S { function main (line 10) | fn main() {} FILE: tests/ui/by_value_not_supported.rs type S (line 3) | struct S { function f (line 16) | fn f(c: C) -> C; function g (line 17) | fn g(r: R) -> R; function h (line 18) | fn h(s: CxxString) -> CxxString; function main (line 22) | fn main() {} FILE: tests/ui/const_fn.rs function f (line 4) | const fn f(); function f (line 8) | const fn f() {} function main (line 10) | fn main() {} FILE: tests/ui/cxx_crate_name_qualified_cxx_string.rs function foo (line 4) | fn foo(x: CxxString); function bar (line 5) | fn bar(x: &cxx::CxxString); function foo (line 9) | fn foo(_: &cxx::CxxString) { function bar (line 13) | fn bar(_: &cxx::CxxString) { function main (line 17) | fn main() {} FILE: tests/ui/data_enums.rs type A (line 3) | enum A { function main (line 8) | fn main() {} FILE: tests/ui/deny_elided_lifetimes.rs type Alias (line 7) | struct Alias<'a> { type Id (line 13) | type Id = cxx::type_id!("Alias"); type Kind (line 14) | type Kind = cxx::kind::Trivial; type Struct (line 20) | struct Struct<'a> { type Alias (line 30) | type Alias<'a> = crate::Alias<'a>; function lifetime_named (line 32) | fn lifetime_named<'a>(s: &'a i32) -> UniquePtr>; function lifetime_underscore (line 34) | fn lifetime_underscore(s: &i32) -> UniquePtr>; function lifetime_elided (line 36) | fn lifetime_elided(s: &i32) -> UniquePtr; type Rust (line 40) | pub struct Rust<'a>(&'a i32); function main (line 42) | fn main() {} FILE: tests/ui/deny_missing_docs.rs type UndocumentedStruct (line 11) | pub struct UndocumentedStruct { type DocumentedStruct (line 16) | pub struct DocumentedStruct { type UndocumentedEnum (line 21) | pub enum UndocumentedEnum { type DocumentedEnum (line 26) | pub enum DocumentedEnum { function undocumented_rust_fn (line 37) | pub fn undocumented_rust_fn() -> u8; function documented_rust_fn (line 40) | pub fn documented_rust_fn() -> u8; type UndocumentedTypeAlias (line 49) | pub type UndocumentedTypeAlias = crate::bindgen::UndocumentedTypeAlias; type DocumentedTypeAlias (line 52) | pub type DocumentedTypeAlias = crate::bindgen::DocumentedTypeAlias; function undocumented_foreign_fn (line 54) | pub fn undocumented_foreign_fn() -> u8; function documented_foreign_fn (line 57) | pub fn documented_foreign_fn() -> u8; type SuppressUndocumentedStruct (line 61) | pub struct SuppressUndocumentedStruct { type UndocumentedRustType (line 66) | struct UndocumentedRustType; type DocumentedRustType (line 67) | struct DocumentedRustType; type UndocumentedTypeAlias (line 72) | pub struct UndocumentedTypeAlias; type DocumentedTypeAlias (line 73) | pub struct DocumentedTypeAlias; type Id (line 76) | type Id = type_id!("UndocumentedTypeAlias"); type Kind (line 77) | type Kind = cxx::kind::Opaque; type Id (line 81) | type Id = type_id!("DocumentedTypeAlias"); type Kind (line 82) | type Kind = cxx::kind::Opaque; function undocumented_rust_fn (line 86) | fn undocumented_rust_fn() -> u8 { function documented_rust_fn (line 90) | fn documented_rust_fn() -> u8 { function main (line 94) | fn main() {} FILE: tests/ui/derive_bit_struct.rs type Struct (line 4) | struct Struct { function main (line 9) | fn main() {} FILE: tests/ui/derive_default.rs type NoDefault (line 4) | enum NoDefault { type MultipleDefault (line 12) | enum MultipleDefault { type BadDefault (line 25) | enum BadDefault { function main (line 33) | fn main() {} FILE: tests/ui/derive_duplicate.rs type Struct (line 4) | struct Struct { function main (line 9) | fn main() {} FILE: tests/ui/derive_noncopy.rs type TryCopy (line 4) | struct TryCopy { type Other (line 8) | struct Other { function main (line 13) | fn main() {} FILE: tests/ui/drop_shared.rs type Shared (line 3) | struct Shared { method drop (line 9) | fn drop(&mut self) { function main (line 14) | fn main() {} FILE: tests/ui/duplicate_method.rs function t_method (line 5) | fn t_method(&self); function t_method (line 6) | fn t_method(&self); function u_method (line 14) | fn u_method(&self); function u_method (line 15) | fn u_method(&mut self); function main (line 19) | fn main() {} FILE: tests/ui/empty_enum.rs type A (line 3) | enum A {} function main (line 6) | fn main() {} FILE: tests/ui/empty_struct.rs type Empty (line 5) | struct Empty {} type ConditionallyEmpty (line 10) | struct ConditionallyEmpty { function main (line 18) | fn main() {} FILE: tests/ui/enum_assoc.rs type Enum (line 3) | enum Enum { function f (line 8) | fn f(); function f (line 13) | fn f() {} function main (line 16) | fn main() {} FILE: tests/ui/enum_inconsistent.rs type Bad (line 3) | enum Bad { function main (line 9) | fn main() {} FILE: tests/ui/enum_match_without_wildcard.rs type A (line 3) | enum A { function main (line 9) | fn main() {} function matcher (line 11) | fn matcher(a: ffi::A) -> u32 { FILE: tests/ui/enum_out_of_bounds.rs type Bad1 (line 4) | enum Bad1 { type Bad2 (line 7) | enum Bad2 { function main (line 13) | fn main() {} FILE: tests/ui/enum_overflows.rs type Good1 (line 3) | enum Good1 { type Good2 (line 6) | enum Good2 { type Bad (line 10) | enum Bad { function main (line 17) | fn main() {} FILE: tests/ui/enum_receiver.rs type Enum (line 3) | enum Enum { function f (line 7) | fn f(self: &Enum); function main (line 11) | fn main() {} FILE: tests/ui/enum_unsatisfiable.rs type Bad (line 3) | enum Bad { function main (line 9) | fn main() {} FILE: tests/ui/expected_named.rs function borrowed (line 5) | fn borrowed() -> UniquePtr; function main (line 9) | fn main() {} FILE: tests/ui/explicit_impl_of_bad_unique_ptr.rs function main (line 6) | fn main() {} FILE: tests/ui/extern_fn_abi.rs function f (line 4) | extern "Java" fn f(); function main (line 8) | fn main() {} FILE: tests/ui/extern_shared_struct.rs type StructX (line 5) | struct StructX { function main (line 15) | fn main() {} FILE: tests/ui/extern_type_bound.rs function main (line 15) | fn main() {} FILE: tests/ui/extern_type_generic.rs function main (line 8) | fn main() {} FILE: tests/ui/extern_type_lifetime_bound.rs function main (line 8) | fn main() {} FILE: tests/ui/fallible_fnptr.rs function f (line 4) | fn f(callback: fn() -> Result<()>); function main (line 8) | fn main() {} FILE: tests/ui/function_with_body.rs function f (line 4) | fn f() {} function main (line 8) | fn main() {} FILE: tests/ui/generic_enum.rs type A (line 3) | enum A { type B (line 7) | enum B where T: Copy { type C (line 11) | enum C where void: Copy { function main (line 16) | fn main() {} FILE: tests/ui/impl_trait_for_type.rs type S (line 3) | struct S { function main (line 10) | fn main() {} FILE: tests/ui/include.rs function main (line 12) | fn main() {} FILE: tests/ui/lifetime_extern_cxx.rs function f (line 5) | unsafe fn f<'a>(&'a self, arg: &str) -> &'a str; function main (line 9) | fn main() {} FILE: tests/ui/lifetime_extern_rust.rs function f (line 5) | fn f<'a>(&'a self, arg: &str) -> &'a str; type Opaque (line 9) | pub struct Opaque; method f (line 12) | fn f(&self, _arg: &str) -> &str { function main (line 17) | fn main() {} FILE: tests/ui/missing_unsafe.rs function f (line 4) | fn f(x: i32); function f (line 8) | unsafe fn f(_x: i32) {} function main (line 10) | fn main() {} FILE: tests/ui/multiple_parse_error.rs type Monad (line 3) | struct Monad; function main (line 8) | fn main() {} FILE: tests/ui/mut_return.rs function f (line 10) | fn f(t: &Thing) -> Pin<&mut CxxString>; function g (line 11) | unsafe fn g(t: &Thing) -> Pin<&mut CxxString>; function h (line 12) | fn h(t: Box) -> Pin<&mut CxxString>; function i (line 13) | fn i<'a>(t: Box>) -> Pin<&'a mut CxxString>; function j (line 14) | fn j(t: &Thing) -> &mut [u8]; function main (line 18) | fn main() {} FILE: tests/ui/non_integer_discriminant_enum.rs type A (line 3) | enum A { function main (line 8) | fn main() {} FILE: tests/ui/nonempty_impl_block.rs type S (line 3) | struct S { function new (line 8) | fn new() -> Self; function main (line 12) | fn main() {} FILE: tests/ui/nonlocal_rust_type.rs type MyBuilder (line 1) | pub struct MyBuilder<'a> { type OptBuilder (line 5) | type OptBuilder<'a> = Option>; type MyBuilder (line 13) | struct MyBuilder<'a> { function main (line 18) | fn main() {} FILE: tests/ui/opaque_autotraits.rs function assert_send (line 8) | fn assert_send() {} function assert_sync (line 9) | fn assert_sync() {} function assert_unpin (line 10) | fn assert_unpin() {} function main (line 12) | fn main() { FILE: tests/ui/opaque_not_sized.rs type TypeR (line 8) | struct TypeR(str); function main (line 10) | fn main() {} FILE: tests/ui/pin_mut_alias.rs type Arg (line 5) | struct Arg(PhantomPinned); type Id (line 8) | type Id = cxx::type_id!("Arg"); type Kind (line 9) | type Kind = cxx::kind::Opaque; type ArgLife (line 12) | struct ArgLife<'a>(PhantomPinned, PhantomData<&'a ()>); type Id (line 15) | type Id = cxx::type_id!("ArgLife"); type Kind (line 16) | type Kind = cxx::kind::Opaque; type Arg (line 22) | type Arg = crate::arg::Arg; function f (line 23) | fn f(arg: &mut Arg); type ArgLife (line 30) | type ArgLife<'a> = crate::arg::ArgLife<'a>; function fl (line 31) | fn fl<'b, 'c>(arg: &'b mut ArgLife<'c>); type Receiver (line 40) | struct Receiver(PhantomPinned); type Id (line 43) | type Id = cxx::type_id!("Receiver"); type Kind (line 44) | type Kind = cxx::kind::Opaque; type ReceiverLife (line 47) | struct ReceiverLife<'a>(PhantomPinned, PhantomData<&'a ()>); type Id (line 50) | type Id = cxx::type_id!("ReceiverLife"); type Kind (line 51) | type Kind = cxx::kind::Opaque; type Receiver (line 57) | type Receiver = crate::receiver::Receiver; function g (line 58) | fn g(&mut self); type ReceiverLife (line 65) | type ReceiverLife<'a> = crate::receiver::ReceiverLife<'a>; function g (line 66) | fn g<'b>(&'b mut self); type Receiver2 (line 75) | struct Receiver2(PhantomPinned); type Id (line 78) | type Id = cxx::type_id!("Receiver2"); type Kind (line 79) | type Kind = cxx::kind::Opaque; type ReveiverLife2 (line 82) | struct ReveiverLife2<'a>(PhantomPinned, PhantomData<&'a ()>); type Id (line 85) | type Id = cxx::type_id!("ReveiverLife2"); type Kind (line 86) | type Kind = cxx::kind::Opaque; type Receiver2 (line 92) | type Receiver2 = crate::receiver2::Receiver2; function h (line 93) | fn h(self: &mut Receiver2); type ReveiverLife2 (line 100) | type ReveiverLife2<'a> = crate::receiver2::ReveiverLife2<'a>; function h (line 101) | fn h<'b, 'c>(self: &'b mut ReveiverLife2<'c>); function main (line 106) | fn main() {} FILE: tests/ui/pin_mut_opaque.rs function f (line 5) | fn f(arg: &mut Opaque); function g (line 6) | fn g(&mut self); function h (line 7) | fn h(self: &mut Opaque); function s (line 8) | fn s(s: &mut CxxString); function v (line 9) | fn v(v: &mut CxxVector); function main (line 13) | fn main() {} FILE: tests/ui/ptr_in_fnptr.rs function f (line 4) | fn f(callback: fn(p: *const u8)); function main (line 8) | fn main() {} FILE: tests/ui/ptr_missing_unsafe.rs function not_unsafe_ptr (line 6) | fn not_unsafe_ptr(c: *mut C); function main (line 10) | fn main() {} FILE: tests/ui/ptr_no_const_mut.rs function get_neither_const_nor_mut (line 6) | fn get_neither_const_nor_mut() -> *C; function main (line 10) | fn main() {} FILE: tests/ui/ptr_unsupported.rs function get_ptr_to_reference (line 6) | fn get_ptr_to_reference() -> *mut &C; function get_uniqueptr_to_ptr (line 7) | fn get_uniqueptr_to_ptr() -> UniquePtr<*mut C>; function get_vector_of_ptr (line 8) | fn get_vector_of_ptr() -> UniquePtr>; function main (line 12) | fn main() {} FILE: tests/ui/raw_ident_namespace.rs type QuotedRaw (line 4) | pub struct QuotedRaw(usize); type Id (line 7) | type Id = type_id!("org::r#box::implementation::QuotedRaw"); type Kind (line 8) | type Kind = cxx::kind::Trivial; type QuotedKeyword (line 12) | pub struct QuotedKeyword(usize); type Id (line 15) | type Id = type_id!("org::box::implementation::QuotedKeyword"); type Kind (line 16) | type Kind = cxx::kind::Trivial; type UnquotedRaw (line 20) | pub struct UnquotedRaw(usize); type Id (line 23) | type Id = type_id!(org::r#box::implementation::UnquotedRaw); type Kind (line 24) | type Kind = cxx::kind::Trivial; type UnquotedKeyword (line 28) | pub struct UnquotedKeyword(usize); type Id (line 31) | type Id = type_id!(org::box::implementation::UnquotedKeyword); type Kind (line 32) | type Kind = cxx::kind::Trivial; type QuotedRaw (line 39) | type QuotedRaw = crate::QuotedRaw; type QuotedKeyword (line 42) | type QuotedKeyword = crate::QuotedKeyword; type UnquotedRaw (line 45) | type UnquotedRaw = crate::UnquotedRaw; function main (line 53) | fn main() {} FILE: tests/ui/reference_to_reference.rs function repro_c (line 5) | fn repro_c(t: &&ThingC); function repro_r (line 9) | fn repro_r(t: &&ThingR); function main (line 13) | fn main() {} FILE: tests/ui/repr_align_suffixed.rs type StructSuffix (line 4) | struct StructSuffix { function main (line 9) | fn main() {} FILE: tests/ui/repr_unsupported.rs type EnumAlign (line 4) | enum EnumAlign { type StructInt (line 9) | struct StructInt { type StructExpr (line 14) | struct StructExpr { function main (line 19) | fn main() {} FILE: tests/ui/reserved_lifetime.rs function logger (line 6) | fn logger<'static>() -> Pin<&'static Logger>; function main (line 10) | fn main() {} FILE: tests/ui/reserved_name.rs type UniquePtr (line 3) | struct UniquePtr { function main (line 16) | fn main() {} FILE: tests/ui/result_no_display.rs function f (line 4) | fn f() -> Result<()>; type NonError (line 8) | pub struct NonError; function f (line 10) | fn f() -> Result<(), NonError> { function main (line 14) | fn main() {} FILE: tests/ui/root_namespace.rs function main (line 13) | fn main() {} FILE: tests/ui/rust_pinned.rs type Pinned (line 10) | pub struct Pinned { function main (line 14) | fn main() {} FILE: tests/ui/self_lifetimes.rs function zero (line 6) | fn zero(self: &Thing<>); function one (line 7) | fn one<'a>(self: &Thing<'a>); function three (line 8) | fn three<'a, 'b, 'c>(self: &Thing<'a, 'b, 'c>); function main (line 12) | fn main() {} FILE: tests/ui/self_type_and_receiver.rs function method (line 7) | fn method(self: &T); function main (line 11) | fn main() {} FILE: tests/ui/slice_of_pinned.rs type Pinned (line 5) | struct Pinned(usize, PhantomPinned); type Pinned (line 10) | type Pinned = crate::Pinned; function f (line 11) | fn f(_: &[Pinned], _: &mut [Pinned]); type Id (line 16) | type Id = type_id!("Pinned"); type Kind (line 17) | type Kind = cxx::kind::Trivial; function main (line 20) | fn main() {} FILE: tests/ui/slice_of_type_alias.rs type ElementTrivial (line 4) | struct ElementTrivial(usize); type ElementOpaque (line 7) | struct ElementOpaque(usize); type ElementTrivial (line 12) | type ElementTrivial = crate::ElementTrivial; type ElementOpaque (line 13) | type ElementOpaque = crate::ElementOpaque; function f (line 15) | fn f(slice: &mut [ElementTrivial]); function g (line 16) | fn g(slice: &[ElementOpaque]); type Id (line 21) | type Id = type_id!("ElementTrivial"); type Kind (line 22) | type Kind = cxx::kind::Trivial; type Id (line 26) | type Id = type_id!("ElementOpaque"); type Kind (line 27) | type Kind = cxx::kind::Opaque; function main (line 30) | fn main() {} FILE: tests/ui/slice_unsupported.rs function f (line 6) | fn f(_: &mut [Opaque]); function main (line 10) | fn main() {} FILE: tests/ui/struct_align.rs type SharedA (line 4) | struct SharedA { type SharedB (line 10) | struct SharedB { type SharedC (line 15) | struct SharedC { function main (line 20) | fn main() {} FILE: tests/ui/struct_cycle.rs type Node0 (line 3) | struct Node0 { type Node1 (line 7) | struct Node1 { type Node2 (line 12) | struct Node2 { type Node3 (line 16) | struct Node3 { type Node4 (line 20) | struct Node4 { type Node5 (line 25) | struct Node5 { type Node6 (line 29) | struct Node6 { function main (line 34) | fn main() {} FILE: tests/ui/type_alias_rust.rs type Alias (line 5) | type Alias = crate::Type; function main (line 9) | fn main() {} FILE: tests/ui/undeclared_lifetime.rs function f0 (line 4) | fn f0(_: &'a CxxString); function g0 (line 5) | fn g0<'a>(_: &'b CxxString); function f1 (line 8) | fn f1(self: &This, _: &'a CxxString); function g1 (line 9) | fn g1<'a>(self: &This, _: &'b CxxString); function f2 (line 10) | fn f2(self: &'a This); function g2 (line 11) | fn g2<'a>(self: &'b This); function f3 (line 12) | fn f3(self: &This<'a>); function g3 (line 13) | fn g3<'a>(self: &This<'b>); function main (line 17) | fn main() {} FILE: tests/ui/unique_ptr_as_mut.rs type Shared (line 5) | struct Shared { function main (line 17) | fn main() { FILE: tests/ui/unique_ptr_to_opaque.rs type C (line 3) | pub struct C { type Id (line 7) | type Id = cxx::type_id!("C"); type Kind (line 8) | type Kind = cxx::kind::Opaque; type C (line 15) | type C = crate::outside::C; type Id (line 7) | type Id = cxx::type_id!("C"); type Kind (line 8) | type Kind = cxx::kind::Opaque; function main (line 21) | fn main() { FILE: tests/ui/unique_ptr_twice.rs type C (line 13) | type C = crate::here::C; function main (line 19) | fn main() {} FILE: tests/ui/unnamed_receiver.rs function f (line 6) | fn f(&mut self); function f (line 10) | fn f(self: &Self); function main (line 14) | fn main() {} FILE: tests/ui/unpin_impl.rs function main (line 10) | fn main() {} FILE: tests/ui/unrecognized_receiver.rs function f (line 4) | fn f(self: &Unrecognized); function main (line 8) | fn main() {} FILE: tests/ui/unsupported_elided.rs function f (line 8) | fn f(t: &T) -> &str; type T (line 12) | pub struct T<'a> { function f (line 16) | fn f<'a>(_t: &T<'a>) -> &'a str { function main (line 20) | fn main() {} FILE: tests/ui/vec_opaque.rs function f (line 15) | fn f() -> Vec; type Job (line 22) | type Job = crate::handle::Job; function f (line 26) | fn f() -> Vec; function f (line 30) | fn f() -> Vec { function main (line 34) | fn main() {} FILE: tests/ui/vector_autotraits.rs function assert_send (line 16) | fn assert_send() {} function main (line 18) | fn main() { FILE: tests/ui/wrong_type_id.rs type ByteRange (line 11) | type ByteRange = crate::here::StringPiece; function main (line 15) | fn main() {} FILE: tests/unique_ptr.rs function test_deref_null (line 5) | fn test_deref_null() { FILE: tools/cargo/build.rs constant MISSING (line 9) | const MISSING: &str = " constant DENIED (line 31) | const DENIED: &str = " function main (line 50) | fn main() {