error · rust-lang/rust — 170,461 matches

.github/ISSUE_TEMPLATE/diagnostics.yaml YAML 1 matches view file →

name: Diagnostic issue
description: Create a bug report or feature request for a change to `rustc`'s error output
labels: ["A-diagnostics", "T-compiler"]
body:

.github/ISSUE_TEMPLATE/ice.md MARKDOWN 4 matches view file →

---
name: Internal Compiler Error
about: Create a report for an internal compiler error in rustc.
labels: C-bug, I-ICE, T-compiler

· · ·

about: Create a report for an internal compiler error in rustc.
labels: C-bug, I-ICE, T-compiler
title: "[ICE]: "

· · ·

---
<!--
Thank you for finding an Internal Compiler Error! 🧊  If possible, try to provide
a minimal verifiable example. You can read "Rust Bug Minimization Patterns" for
how to create smaller examples.

· · ·

```
### Error output
```

.github/ISSUE_TEMPLATE/ice.yaml YAML 3 matches view file →

name: Internal Compiler Error (for use by automated tooling)
description: For now, you'll want to use the other ICE template, as GitHub forms have strict limits on the size of fields so backtraces cannot be pasted directly.
labels: ["C-bug", "I-ICE", "T-compiler"]

· · ·

    attributes:
      value: |
        Thank you for finding an Internal Compiler Error! 🧊
        If possible, try to provide a minimal verifiable example.

· · ·

    id: output
    attributes:
      label: Current error output
      description: Please provide the `rustc` output you see
      placeholder: output

.github/ISSUE_TEMPLATE/tracking_issue_future.md MARKDOWN 3 matches view file →

-->
This is the **tracking issue** for the `YOUR_LINT_NAME_HERE` future-compatibility warning and other related errors. The goal of this page is to describe why this change was made and how you can fix code that is affected by it. It also provides a place to ask questions or register a complaint if you feel the change should not be made. For more information on the policy around future-compatibility warnings, see our [breaking change policy guidelines][guidelines].
[guidelines]: https://rustc-dev-guide.rust-lang.org/bug-fix-procedure.html

· · ·

*Give some recommendations on how a user can avoid the lint.*
### When will this warning become a hard error?
*If known, describe the future plans. For example, how long you anticipate this being a warning, or if there are other factors that will influence the anticipated closure.*

· · ·

- [ ] Raise lint level to deny
- [ ] Change the lint to report in dependencies
- [ ] Switch to a hard error
### Implementation history

.github/workflows/ci.yml YAML 5 matches view file →

      SCCACHE_REGION: us-west-1
      CACHE_DOMAIN: ci-caches.rust-lang.org
    continue-on-error: ${{ matrix.continue_on_error || false }}
    strategy:
      # If the user starts multiple jobs in a try build, let them all finish.

· · ·

      # Actions build on its own, so a hint in the log message is needed to
      # point it in the right direction.
      - name: configure the PR in which the error message will be posted
        run: echo "[CI_PR_NUMBER=$num]"
        env:

· · ·

        # adding the condition is helpful as this way CI will not silently skip
        # deploying artifacts from a dist builder if the variables are misconfigured,
        # erroring about invalid credentials instead.
        if: github.event_name == 'push' || env.DEPLOY == '1' || env.DEPLOY_ALT == '1'

· · ·

        # This step is not critical, and if some I/O problem happens, we don't want
        # to cancel the build.
        continue-on-error: true
        run: |
          if [ -f build/metrics.json ]; then

· · ·

        # This step is not critical, and if some I/O problem happens, we don't want
        # to cancel the build.
        continue-on-error: true
        if: needs.calculate_matrix.outputs.run_type != 'pr'
        env:

.github/workflows/dependencies.yml YAML 3 matches view file →

          WAITING_ON_BORS=$(echo "$JSON" | jq '.labels[] | any(.name == "S-waiting-on-bors"; .)')
          # Exit with error if open and S-waiting-on-bors
          if [[ "$STATE" == "OPEN" && "$WAITING_ON_BORS" == "true" ]]; then
            exit 1

· · ·

        id: edit
        # Don't fail job if we need to open new PR
        continue-on-error: true
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

· · ·

        run: |
          # Exit with error if PR is closed
          STATE=$(gh pr view cargo_update --repo $GITHUB_REPOSITORY --json state --jq '.state')
          if [[ "$STATE" != "OPEN" ]]; then

CONTRIBUTING.md MARKDOWN 1 matches view file →

## Bug reports
Did a compiler error message tell you to come here? If you want to create an ICE report,
refer to [this section][contributing-bug-reports] and [open an issue][issue template].

Cargo.lock 66 matches · showing 5 view file →

 "serde-untagged",
 "serde-value",
 "thiserror 2.0.17",
 "toml 0.8.23",
 "unicode-xid",

· · ·

 "serde",
 "serde_json",
 "thiserror 1.0.69",
]

· · ·

 "serde",
 "serde_json",
 "thiserror 2.0.17",
]

· · ·

 "serde",
 "serde_json",
 "thiserror 2.0.17",
]

· · ·

 "once_cell",
 "owo-colors",
 "tracing-error",
]

+ 61 more matches in this file

INSTALL.md MARKDOWN 1 matches view file →

the instructions in step 2 to get them on PATH.
Using Windows native Python can be helpful if you get errors when building LLVM.
You may also want to use Git for Windows, as it is often *much* faster. Turning
off real-time protection in the Windows Virus & Threat protections settings can

LICENSES/CC-BY-SA-4.0.txt PLAIN TEXT 1 matches view file →

     WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR
     PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS,
     ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT
     KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT
     ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU.

RELEASES.md MARKDOWN 369 matches · showing 5 view file →

-------------------
- [Array coercions may now result in less inference constraints than before](https://github.com/rust-lang/rust/pull/140283)
- Importing `$crate` without renaming, i.e. `use $crate::{self};`, is now no longer permitted due to stricter error checking for `self` imports.
- [const-eval: be more consistent in the behavior of padding during typed copies.](https://github.com/rust-lang/rust/pull/148967)
  In very rare cases, this may cause compilation errors due to bytes from parts of a pointer ending up in the padding bytes of a `const` or `static`.

· · ·

  In very rare cases, this may cause compilation errors due to bytes from parts of a pointer ending up in the padding bytes of a `const` or `static`.
- [A future-incompatibility warning lint `ambiguous_glob_imported_traits` is now reported when using an ambiguously glob imported trait](https://github.com/rust-lang/rust/pull/149058)
- [Check lifetime bounds of types mentioning only type parameters](https://github.com/rust-lang/rust/pull/149389)

· · ·

- [Report more visibility-related ambiguous import errors](https://github.com/rust-lang/rust/pull/149596)
- [Deprecate `Eq::assert_receiver_is_total_eq` and emit future compatibility warnings on manual impls](https://github.com/rust-lang/rust/pull/149978)
- [powerpc64: Use the ELF ABI version set in target spec instead of guessing](https://github.com/rust-lang/rust/pull/150468) (fixes the ELF ABI used by the OpenBSD target)

· · ·

- [Add warn-by-default `unused_visibilities` lint for visibility on `const _` declarations](https://github.com/rust-lang/rust/pull/147136)
- [Update to Unicode 17](https://github.com/rust-lang/rust/pull/148321)
- [Avoid incorrect lifetime errors for closures](https://github.com/rust-lang/rust/pull/148329)
<a id="1.94.0-Platform-Support"></a>

· · ·

  Some finer details of how precise closure captures get affected by pattern matching have been changed. In some cases, this can cause a non-move closure that was previously capturing an entire variable by move, to now capture only part of that variable by move, and other parts by borrow. This can cause the borrow checker to complain where it previously didn't, or cause `Drop` to run at a different point in time.
- [Standard library macros are now imported via prelude, not via injected `#[macro_use]`](https://github.com/rust-lang/rust/pull/139493)
  This will raise an error if macros of the same name are glob imported.
  For example if a crate defines their own `matches` macro and then glob imports that,
  it's now ambiguous whether the custom or standard library `matches` is meant and

+ 364 more matches in this file

bootstrap.example.toml TOML 5 matches view file →

#
# Under Windows this should be `yarn.cmd` or path to it (verified on nodejs v18.06), or
# error will be emitted.
#build.yarn = "yarn"

· · ·

#rust.optimize-tests = true
# Flag indicating whether codegen tests will be run or not. If you get an error
# saying that the FileCheck executable is missing, you may want to disable this.
# Also see the target's llvm-filecheck option.

· · ·

# Whether to deny warnings in crates. Set to `false` to avoid
# error: warnings are denied by `build.warnings` configuration
#rust.deny-warnings = true

· · ·

# Print backtrace on internal compiler errors during bootstrap
#rust.backtrace-on-ice = false

· · ·

#rust.std-features = ["panic_unwind"]
# Trigger a `DebugBreak` after an internal compiler error during bootstrap on Windows
#rust.break-on-ice = true

compiler/rustc/build.rs RUST 1 matches view file →

    println!("cargo:rustc-link-arg-bin=rustc-main=/MANIFEST:EMBED");
    println!("cargo:rustc-link-arg-bin=rustc-main=/MANIFESTINPUT:{}", manifest.to_str().unwrap());
    // Turn linker warnings into errors.
    println!("cargo:rustc-link-arg-bin=rustc-main=/WX");
}

compiler/rustc_abi/Cargo.toml TOML 4 matches view file →

rand_xoshiro = { version = "0.7.0", optional = true }
rustc_data_structures = { path = "../rustc_data_structures", optional = true }
rustc_error_messages = { path = "../rustc_error_messages", optional = true }
rustc_errors = { path = "../rustc_errors", optional = true }
rustc_hashes = { path = "../rustc_hashes" }

· · ·

rustc_errors = { path = "../rustc_errors", optional = true }
rustc_hashes = { path = "../rustc_hashes" }
rustc_index = { path = "../rustc_index", default-features = false }

· · ·

nightly = [
    "dep:rustc_data_structures",
    "dep:rustc_error_messages",
    "dep:rustc_errors",
    "dep:rustc_macros",

· · ·

    "dep:rustc_errors",
    "dep:rustc_macros",
    "dep:rustc_serialize",

compiler/rustc_abi/src/callconv.rs RUST 1 matches view file →

}
/// Error from the `homogeneous_aggregate` test function, indicating
/// there are distinct leaf fields passed in different ways,
/// or this is uninhabited.

compiler/rustc_abi/src/canon_abi.rs RUST 1 matches view file →

        // convert to the ExternAbi that *shares a string* with this CanonAbi.
        // FIXME: ideally we'd avoid printing `CanonAbi`, and preserve `ExternAbi` everywhere
        // that we need to generate error messages.
        let erased_abi = match self {
            CanonAbi::C => ExternAbi::C { unwind: false },

compiler/rustc_abi/src/extern_abi.rs RUST 1 matches view file →

#[cfg(feature = "nightly")]
rustc_error_messages::into_diag_arg_using_display!(ExternAbi);
#[cfg(feature = "nightly")]

compiler/rustc_abi/src/layout.rs RUST 20 matches · showing 5 view file →

#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum LayoutCalculatorError<F> {
    /// An unsized type was found in a location where a sized type was expected.
    ///

· · ·

    /// This is not always a compile error, for example if there is a `[T]: Sized`
    /// bound in a where clause.
    ///

· · ·

}
impl<F> LayoutCalculatorError<F> {
    pub fn without_payload(&self) -> LayoutCalculatorError<()> {
        use LayoutCalculatorError::*;

· · ·

    pub fn without_payload(&self) -> LayoutCalculatorError<()> {
        use LayoutCalculatorError::*;
        match *self {

· · ·

        use LayoutCalculatorError::*;
        match *self {
            UnexpectedUnsized(_) => UnexpectedUnsized(()),

+ 15 more matches in this file

compiler/rustc_abi/src/lib.rs RUST 39 matches · showing 5 view file →

#[cfg(feature = "nightly")]
use std::iter::Step;
use std::num::{NonZeroUsize, ParseIntError};
use std::ops::{Add, AddAssign, Deref, Mul, RangeFull, RangeInclusive, Sub};
use std::str::FromStr;

· · ·

use rustc_data_structures::stable_hasher::StableOrd;
#[cfg(feature = "nightly")]
use rustc_error_messages::{DiagArgValue, IntoDiagArg};
#[cfg(feature = "nightly")]
use rustc_errors::{Diag, DiagCtxtHandle, Diagnostic, EmissionGuarantee, Level, msg};

· · ·

use rustc_errors::{Diag, DiagCtxtHandle, Diagnostic, EmissionGuarantee, Level, msg};
use rustc_hashes::Hash64;
use rustc_index::{Idx, IndexSlice, IndexVec};

· · ·

pub use extern_abi::CVariadicStatus;
pub use extern_abi::{ExternAbi, all_names};
pub use layout::{FIRST_VARIANT, FieldIdx, LayoutCalculator, LayoutCalculatorError, VariantIdx};
#[cfg(feature = "nightly")]
pub use layout::{Layout, TyAbiInterface, TyAndLayout};

· · ·

}
pub enum TargetDataLayoutError<'a> {
    InvalidAddressSpace { addr_space: &'a str, cause: &'a str, err: ParseIntError },
    InvalidBits { kind: &'a str, bit: &'a str, cause: &'a str, err: ParseIntError },

+ 34 more matches in this file

compiler/rustc_ast/src/ast.rs RUST 19 matches · showing 5 view file →

pub use rustc_span::AttrId;
use rustc_span::{
    ByteSymbol, DUMMY_SP, ErrorGuaranteed, Ident, Span, Spanned, Symbol, kw, respan, sym,
};
use thin_vec::{ThinVec, thin_vec};

· · ·

    /// Whether this could be a never pattern, taking into account that a macro invocation can
    /// return a never pattern. Used to inform errors during parsing.
    pub fn could_be_never_pattern(&self) -> bool {
        let mut could_be_never_pattern = false;

· · ·

    }
    /// Whether this contains a `!` pattern. This in particular means that a feature gate error will
    /// be raised if the feature is off. Used to avoid gating the feature twice.
    pub fn contains_never_pattern(&self) -> bool {

· · ·

    /// Placeholder for a pattern that wasn't syntactically well formed in some way.
    Err(ErrorGuaranteed),
}

· · ·

    /// `module::StructName { field, ..}`
    Rest(Span),
    /// `module::StructName { field, syntax error }`
    Recovered(ErrorGuaranteed),
    /// `module::StructName { field }`

+ 14 more matches in this file

compiler/rustc_ast/src/attr/mod.rs RUST 1 matches view file →

            AttrArgs::Eq { expr, .. } => match expr.kind {
                ExprKind::Lit(token_lit) => {
                    // Turn failures to `None`, we'll get parse errors elsewhere.
                    MetaItemLit::from_token_lit(token_lit, expr.span)
                        .ok()

compiler/rustc_ast/src/expand/allocator.rs RUST 1 matches view file →

}
pub const ALLOC_ERROR_HANDLER: Symbol = sym::alloc_error_handler;
pub const NO_ALLOC_SHIM_IS_UNSTABLE: &str = "__rust_no_alloc_shim_is_unstable_v2";

compiler/rustc_ast/src/expand/autodiff_attrs.rs RUST 7 matches · showing 5 view file →

#[derive(Clone, Copy, Eq, PartialEq, Encodable, Decodable, Debug, StableHash)]
pub enum DiffMode {
    /// No autodiff is applied (used during error handling).
    Error,
    /// The primal function which we will differentiate.

· · ·

    Error,
    /// The primal function which we will differentiate.
    Source,

· · ·

    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            DiffMode::Error => write!(f, "Error"),
            DiffMode::Source => write!(f, "Source"),
            DiffMode::Forward => write!(f, "Forward"),

· · ·

/// Const is valid for all cases and means that we don't compute derivatives wrt. this output.
/// That usually means we have a &mut or *mut T output and compute derivatives wrt. that arg,
/// but this is too complex to verify here. Also it's just a logic error if users get this wrong.
pub fn valid_ret_activity(mode: DiffMode, activity: DiffActivity) -> bool {
    if activity == DiffActivity::None {

· · ·

    }
    match mode {
        DiffMode::Error => false,
        DiffMode::Source => false,
        DiffMode::Forward => activity.is_dual_or_const(),

+ 2 more matches in this file

compiler/rustc_ast/src/format.rs RUST 1 matches view file →

        } else if self.names.is_empty() {
            // Only count the unnamed args before the first named arg.
            // (Any later ones are errors.)
            self.num_unnamed_args += 1;
        }

compiler/rustc_ast/src/token.rs RUST 6 matches · showing 5 view file →

use rustc_span::edition::Edition;
use rustc_span::symbol::IdentPrintMode;
use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span, kw, sym};
#[allow(clippy::useless_attribute)] // FIXME: following use of `hidden_glob_reexports` incorrectly triggers `useless_attribute` lint.
#[allow(hidden_glob_reexports)]

· · ·

    CStr,
    CStrRaw(u8),
    Err(ErrorGuaranteed),
}

· · ·

            ByteStr | ByteStrRaw(..) => "byte string",
            CStr | CStrRaw(..) => "C string",
            Err(_) => "error",
        }
    }

· · ·

    /// Returns tokens that are likely to be typed accidentally instead of the current token.
    /// Enables better error recovery when the wrong token is found.
    pub fn similar_tokens(&self) -> &[TokenKind] {
        match self {

· · ·

            And                               | // reference
            AndAnd                            | // double reference
            // DotDotDot is no longer supported, but we need some way to display the error
            DotDot | DotDotDot | DotDotEq     | // range notation
            Lt | Shl                          | // associated path

+ 1 more matches in this file

`auth login`	both terms (AND is implicit)
`auth OR login`	either term
`NOT path:vendor`	exclude matches
`"exact phrase"`	quoted exact match
`/func\s+Test/`	regex
`handler~1`	fuzzy (Levenshtein 1)
`file:*_test.go`	filename glob
`path:pkg/auth/**`	full path glob
`lang:go`	language filter

Search any public repo from your terminal