Compilation error: can't find crate for `core`

Question

I'm using Rust 1.35.0 to try out some Rust examples and I could not get it to compile, as I keep getting the following message:

error[E0463]: can't find crate for `core`

I ran rustc --explain E0463 and I see the following message:

You need to link your code to the relevant crate in order to be able to use it
(through Cargo or the `-L` option of rustc example). Plugins are crates as
well, and you link to them the same way.

Here is my Cargo.toml:

[package]
name = "sensor-node"
version = "0.1.0"
authors = ["joesan <email@gmail.com>"]
edition = "2018"

[dependencies]
dwm1001 = "0.1.0"
panic-halt = "0.2.0"
nb = "0.1.1"

Here is my main.rs:

fn main() {
    let s = String::from("hello");  // s comes into scope

    takes_ownership(s);             // s's value moves into the function...
                                    // ... and so is no longer valid here

    let x = 5;                      // x comes into scope

    makes_copy(x);                  // x would move into the function,
                                    // but i32 is Copy, so it’s okay to still
                                    // use x afterward

} // Here, x goes out of scope, then s. But because s's value was moved, nothing
  // special happens.

fn takes_ownership(some_string: String) { // some_string comes into scope
    println!("{}", some_string);
} // Here, some_string goes out of scope and `drop` is called. The backing
  // memory is freed.

fn makes_copy(some_integer: i32) { // some_integer comes into scope
    println!("{}", some_integer);
} // Here, some_integer goes out of scope. Nothing special happens.

Answer 1

Your code works fine on the Rust playground, so I recommend checking your Rust installation and environment settings.

---

You may want to use the preconfigured Rust Docker image to run your app. Have Docker installed, then:

docker pull rust

Go to your project folder and run:

docker run --rm --user "$(id -u)":"$(id -g)" -v "$PWD":/usr/src/myapp -w /usr/src/myapp rust cargo run

Output:

hello
5

---

For your simple example on a PC, you don't need any of these dependencies:

[dependencies]
dwm1001 = "0.1.0"
panic-halt = "0.2.0"
nb = "0.1.1"

Here are my steps to test your sample on Linux:

cargo new hello
cd hello
code .

Open main.rs and paste your sample main.rs and save:

fn main() {
    let s = String::from("hello"); // s comes into scope

    takes_ownership(s); // s's value moves into the function...
                        // ... and so is no longer valid here

    let x = 5; // x comes into scope

    makes_copy(x); // x would move into the function,
                   // but i32 is Copy, so it’s okay to still
                   // use x afterward
} // Here, x goes out of scope, then s. But because s's value was moved, nothing
  // special happens.

fn takes_ownership(some_string: String) {
    // some_string comes into scope
    println!("{}", some_string);
} // Here, some_string goes out of scope and `drop` is called. The backing
  // memory is freed.

fn makes_copy(some_integer: i32) {
    // some_integer comes into scope
    println!("{}", some_integer);
} // Here, some_integer goes out of scope. Nothing special happens.

In a terminal inside the hello folder, run:

cargo run

And the output is good:

hello
5

---

This may help:

1. Shell command

   rustup component list --installed
   

   Output:

   cargo-x86_64-unknown-linux-gnu
   clippy-x86_64-unknown-linux-gnu
   rls-x86_64-unknown-linux-gnu
   rust-analysis-x86_64-unknown-linux-gnu
   rust-docs-x86_64-unknown-linux-gnu
   rust-src
   rust-std-x86_64-unknown-linux-gnu
   rustc-x86_64-unknown-linux-gnu
   rustfmt-x86_64-unknown-linux-gnu
   

2. Shell command:

   rustup show
   

   Output:

   Default host: x86_64-unknown-linux-gnu
   
   installed toolchains
   --------------------
   
   stable-x86_64-unknown-linux-gnu (default)
   nightly-x86_64-unknown-linux-gnu
   
   active toolchain
   ----------------
   
   stable-x86_64-unknown-linux-gnu (default)
   rustc 1.35.0 (3c235d560 2019-05-20)
   

Answer 2

I solved this in my case with:

rustup target add wasm32-unknown-unknown

Answer 3

When you first install a toolchain, rustup installs only the standard library for your host platform - that is, the architecture and operating system you are presently running. To compile to other platforms you must install other target platforms. This is done with the rustup target add command. For example, to add the Android target:

See The Rustup Book - Cross-compilation

For example:

$ rustup target add aarch64-unknown-linux-gnu
info: downloading component 'rust-std' for 'aarch64-unknown-linux-gnu'
info: installing component 'rust-std' for 'aarch64-unknown-linux-gnu'

To get the target string on the target machine, if rust is installed, you can run:

rustc -vV

e.g. output

rustc 1.67.1 (d5a82bbd2 2023-02-07)
binary: rustc
commit-hash: d5a82bbd26e1ad8b7401f6a718a9c57c96905483
commit-date: 2023-02-07
host: aarch64-unknown-linux-gnu
release: 1.67.1
LLVM version: 15.0.6

The host field can be used as the argument to rustup target add

Note: You may run into linker issues, in which case you can configure your linker, see Cargo Book - Configuration - Target