Change:
Now, run the following You get the following error: A simple fix to this is to add at the beginning of , but that should not be unnecessary. Reproduces on nightly.
This is currently working as intended, the flags only work for specifying the immediate set of dependencies (those listed in ), and transitive dependencies must be found through paths. You can use to make sure that only transitive dependencies are found in those paths.
If that is the intended behavior, then please reopen this issue and mark it as a documentation problem. I cannot find where this distinction is explained. This section of would imply that: / are for use with native libraries only, not even mentioning the KIND. by itself will not actually search for crates in that directory. should be used for telling rust where to locate any crate and is an intuitive solution to errors like For reference, how do you thus indicate to rust where to locate a crate whose filename does not follow the pattern?
Yeah seems reasonable to leave open as a docs issue. Not sure exhaustive documentation should go into the message but the man page could certainly be up. That... can't actually be done I don't think. The only way the compiler looks for transitive dependencies is via where is the name of the crate.

Discussion:
$ make && make install ``` <ins> ## Building Documentation If you’d like to build the documentation, it’s almost the same: ```sh ./configure $ make docs ``` Building the documentation requires building the compiler, so the above details will apply. Once you have the compiler built, you can ```sh $ make docs NO_REBUILD=1 ``` To make sure you don’t re-build the compiler because you made a change to some documentation. The generated documentation will appear in a top-level `doc` directory, created by the `make` rule. </ins> ## Notes Since the Rust compiler is written in Rust, it must be built by a

`"mips"`, `"powerpc"`, `"arm"`, or `"aarch64"`. * `target_endian = "..."`. Endianness of the target CPU, either `"little"` or `"big"`. <ins> * `target_env = ".."` - an option provided by the compiler by default describing the runtime environment of the target platform. Some examples of this are `musl` for builds targeting the MUSL libc implementation, `msvc` for Windows builds targeting MSVC, and `gnu` frequently the rest of the time. This option may also be blank on some platforms. </ins> * `target_family = "..."`. Operating system family of the target, e. g. `"unix"` or `"windows"`. The value of this configuration option is defined as a configuration itself, like `unix` or `windows`.

`panic!` is a macro, similar to `println!()` that we’ve already seen. Unlike `println!()`, `panic!()` causes the current thread of execution to crash with <del> the given message. </del> <ins> the given message. Because this function will cause a crash, it will never return, and so it has the type ‘`!`’, which is read ‘diverges’. </ins> <del> Because this function will cause a crash, it will never return, and so it has the type ‘`!`’, which is read ‘diverges’. A diverging function can be used as any type: </del> <ins> If you add a main function that calls `diverges()` and run it, you’ll get some output that looks like this: ```text thread ‘<main>’ panicked at ‘This function never returns!’, hello.rs:2 ``` If you want more information, you can get a backtrace by setting the `RUST_BACKTRACE` environment variable: ```text $ RUST_BACKTRACE=1 ./diverges thread '<main>' panicked at 'This function never returns!', hello.rs:2 stack backtrace: 1:     0x7f402773a829 - sys::backtrace::write::h0942de78b6c02817K8r 2:     0x7f402773d7fc - panicking::on_panic::h3f23f9d0b5f4c91bu9w 3:     0x7f402773960e - rt::unwind::begin_unwind_inner::h2844b8c5e81e79558Bw 4:     0x7f4027738893 - rt::unwind::begin_unwind::h4375279447423903650 5:     0x7f4027738809 - diverges::h2266b4c4b850236beaa 6:     0x7f40277389e5 - main::h19bb1149c2f00ecfBaa 7:     0x7f402773f514 - rt::unwind::try::try_fn::h13186883479104382231 8:     0x7f402773d1d8 - __rust_try 9:     0x7f402773f201 - rt::lang_start::ha172a3ce74bb453aK5w 10:     0x7f4027738a19 - main 11:     0x7f402694ab44 - __libc_start_main 12:     0x7f40277386c8 - <unknown> 13:                0x0 - <unknown> ``` `RUST_BACKTRACE` also works with Cargo’s `run` command: ```text $ RUST_BACKTRACE=1 cargo run Running `target/debug/diverges` thread '<main>' panicked at 'This function never returns!', hello.rs:2 stack backtrace: 1:     0x7f402773a829 - sys::backtrace::write::h0942de78b6c02817K8r 2:     0x7f402773d7fc - panicking::on_panic::h3f23f9d0b5f4c91bu9w 3:     0x7f402773960e - rt::unwind::begin_unwind_inner::h2844b8c5e81e79558Bw 4:     0x7f4027738893 - rt::unwind::begin_unwind::h4375279447423903650 5:     0x7f4027738809 - diverges::h2266b4c4b850236beaa 6:     0x7f40277389e5 - main::h19bb1149c2f00ecfBaa 7:     0x7f402773f514 - rt::unwind::try::try_fn::h13186883479104382231 8:     0x7f402773d1d8 - __rust_try 9:     0x7f402773f201 - rt::lang_start::ha172a3ce74bb453aK5w 10:     0x7f4027738a19 - main 11:     0x7f402694ab44 - __libc_start_main 12:     0x7f40277386c8 - <unknown> 13:                0x0 - <unknown> ``` A diverging function can be used as any type: </ins> ```should_panic # fn diverges() -> ! {

// y.method(); (y.vtable.method)(y.data); ``` <ins> ## Object Safety Not every trait can be used to make a trait object. For example, vectors implement `Clone`, but if we try to make a trait object: ```ignore let v = vec![1, 2, 3]; let o = &v as &Clone; ``` We get an error: ```text error: cannot convert to a trait object because trait `core::clone::Clone` is not object-safe [E0038] let o = &v as &Clone; ^~ note: the trait cannot require that `Self : Sized` let o = &v as &Clone; ^~ ``` The error says that `Clone` is not ‘object-safe’. Only traits that are object-safe can be made into trait objects. A trait is object-safe if both of these are true: * the trait does not require that `Self: Sized` * all of its methods are object-safe So what makes a method object-safe? Each method must require that `Self: Sized` or all of the following: * must not have any type parameters * must not use `Self` Whew! As we can see, almost all of these rules talk about `Self`. A good intuition is “except in special circumstances, if your trait’s method uses `Self`, it is not object-safe.” </ins>

//!     //                  7 //!     //          +-----------------+ //!     //          |                 | <del> //!     //          v   1        2    | </del> <ins> //!     //          v   1        2    |  2 </ins> //!     //          0 -----> 1 -----> 3 ---> 4 //!     //          |        ^        ^      ^ //!     //          |        | 1      |      |

/// A seek beyond the end of a stream is allowed, but implementation /// defined. /// <del> /// The behavior when seeking past the end of the stream is implementation /// defined. /// </del> /// If the seek operation completed successfully, /// this method returns the new position from the start of the stream. /// That position can be used later with `SeekFrom::Start`.