error lang: · rust-lang/rust — 376 matches

compiler/rustc_codegen_llvm/src/llvm/ffi.rs RUST 12 matches · showing 5 view file →

    pub(crate) fn to_rust(self) -> T
    where
        T::Error: Debug,
    {
        // If this fails, the Rust-side enum is out of sync with LLVM's enum.

· · ·

///
/// In order for Rust-C LTO to work, we must specify behaviors compatible with Clang. Notably,
/// 'Error' and 'Warning' cannot be mixed for a given flag.
///
/// There is a stable LLVM-C version of this enum (`LLVMModuleFlagBehavior`),

· · ·

#[repr(C)]
pub(crate) enum ModuleFlagMergeBehavior {
    Error = 1,
    Warning = 2,
    Require = 3,

· · ·

#[allow(dead_code)] // Variants constructed by C++.
pub(crate) enum DiagnosticLevel {
    Error,
    Warning,
    Note,

· · ·

pub(crate) type GetSymbolsCallback =
    unsafe extern "C" fn(*mut c_void, *const c_char) -> *mut c_void;
pub(crate) type GetSymbolsErrorCallback = unsafe extern "C" fn(*const c_char) -> *mut c_void;
unsafe extern "C" {

+ 7 more matches in this file

compiler/rustc_error_messages/src/lib.rs RUST 6 matches · showing 5 view file →

pub use fluent_bundle::types::FluentType;
pub use fluent_bundle::{self, FluentArgs, FluentError, FluentValue};
use rustc_macros::{Decodable, Encodable, StableHash};
use rustc_span::Span;

· · ·

        .add_function("STREQ", |positional, _named| match positional {
            [FluentValue::String(a), FluentValue::String(b)] => format!("{}", (a == b)).into(),
            _ => FluentValue::Error,
        })
        .expect("Failed to add a function to the bundle.");

· · ·

///
/// - They can be *primary spans*. In this case they are the locus of
///   the error, and would be rendered with `^^^`.
/// - They can have a *label*. In this case, the label is written next
///   to the mark in the snippet when we render.

· · ·

}
fn icu_locale_from_unic_langid(lang: LanguageIdentifier) -> Option<icu_locale::Locale> {
    icu_locale::Locale::try_from_str(&lang.to_string()).ok()
}

· · ·

    impl intl_memoizer::Memoizable for MemoizableListFormatter {
        type Args = ();
        type Error = ();
        fn construct(lang: LanguageIdentifier, _args: Self::Args) -> Result<Self, Self::Error> {

+ 1 more matches in this file

compiler/rustc_target/src/spec/mod.rs RUST 31 matches · showing 5 view file →

use rustc_abi::{
    Align, CVariadicStatus, CanonAbi, Endian, ExternAbi, Integer, Size, TargetDataLayout,
    TargetDataLayoutError,
};
use rustc_data_structures::fx::{FxHashSet, FxIndexSet};

· · ·

use rustc_error_messages::{DiagArgValue, IntoDiagArg, into_diag_arg_using_display};
use rustc_fs_util::try_canonicalize;
use rustc_macros::{BlobDecodable, Decodable, Encodable, StableHash};

· · ·

    }
    parse_error_type = "LLD flavor";
}

· · ·

    /// At this point the target's reference linker flavor doesn't yet exist and we need to infer
    /// it. The inference always succeeds and gives some result, and we don't report any flavor
    /// incompatibility errors for json target specs. The CLI flavor is used as the main source
    /// of truth, other flags are used in case of ambiguities.
    fn from_cli_json(cli: LinkerFlavorCli, lld_flavor: LldFlavor, is_gnu: bool) -> LinkerFlavor {

· · ·

impl LinkSelfContainedDefault {
    /// Returns whether the target spec has self-contained linking explicitly disabled. Used to emit
    /// errors if the user then enables it on the CLI.
    pub fn is_disabled(self) -> bool {
        self == LinkSelfContainedDefault::False

+ 26 more matches in this file

library/compiler-builtins/compiler-builtins/build.rs RUST 4 matches view file →

        let build = &mut cc::Build::new();
        // AArch64 GCCs exit with an error condition when they encounter any kind of floating point
        // code if the `nofp` and/or `nosimd` compiler flags have been set.
        //

· · ·

            build.flag("-ffreestanding");
            // Avoid the following warning appearing once **per file**:
            // clang: warning: optimization flag '-fomit-frame-pointer' is not supported for target 'armv7' [-Wignored-optimization-argument]
            //
            // Note that compiler-rt's build system also checks

· · ·

            if let "aarch64" | "arm64ec" = cfg.target_arch.as_str() {
                // FIXME(llvm20): Older GCCs on A64 fail to build with
                // -Werror=implicit-function-declaration due to a compiler-rt bug.
                // With a newer LLVM we should be able to enable the flag everywhere.
                // https://github.com/llvm/llvm-project/commit/8aa9d6206ce55bdaaf422839c351fbd63f033b89

· · ·

            } else {
                // Avoid implicitly creating references to undefined functions
                build.flag("-Werror=implicit-function-declaration");
            }
        }

library/core/src/panicking.rs RUST 4 matches view file →

#[cfg(feature = "panic_immediate_abort")]
compile_error!(
    "panic_immediate_abort is now a real panic strategy! \
    Enable it with `panic = \"immediate-abort\"` in Cargo.toml, \

· · ·

// reducing binary size impact.
macro_rules! panic_const {
    ($($lang:ident = $message:expr,)+) => {
        $(
            /// This is a panic called with a message that's a result of a MIR-produced Assert.

· · ·

/// Like `panic`, but without unwinding and track_caller to reduce the impact on codesize on the caller.
/// If you want `#[track_caller]` for nicer errors, call `panic_nounwind_fmt` directly.
#[cfg_attr(not(panic = "immediate-abort"), inline(never), cold)]
#[cfg_attr(panic = "immediate-abort", inline)]

· · ·

#[rustc_diagnostic_item = "unreachable_display"] // needed for `non-fmt-panics` lint
pub fn unreachable_display<T: fmt::Display>(x: &T) -> ! {
    panic_fmt(format_args!("internal error: entered unreachable code: {}", *x));
}

src/bootstrap/src/core/build_steps/compile.rs RUST 12 matches · showing 5 view file →

    } else if target.is_windows_gnu() || target.is_windows_gnullvm() {
        for obj in ["crt2.o", "dllcrt2.o"].iter() {
            let src = compiler_file(builder, &builder.cc(target), target, CLang::C, obj);
            let dst = libdir_self_contained.join(obj);
            builder.copy_link(&src, &dst, FileType::NativeLibrary);

· · ·

    // If the rustc output is piped to e.g. `head -n1` we want the process to be killed, rather than
    // having an error bubble up and cause a panic.
    //
    // FIXME(jieyouxu): this flag is load-bearing for rustc to not ICE on broken pipes, because

· · ·

    // rustc internally sometimes uses std `println!` -- but std `println!` by default will panic on
    // broken pipes, and uncaught panics will manifest as an ICE. The compiler *should* handle this
    // properly, but this flag is set in the meantime to paper over the I/O errors.
    //
    // See <https://github.com/rust-lang/rust/issues/131059> for details.

· · ·

    //
    // Also see the discussion for properly handling I/O errors related to broken pipes, i.e. safe
    // variants of `println!` in
    // <https://rust-lang.zulipchat.com/#narrow/stream/131828-t-compiler/topic/Internal.20lint.20for.20raw.20.60print!.60.20and.20.60println!.60.3F>.

· · ·

    // Building with protected visibility reduces the number of dynamic relocations needed, giving
    // us a faster startup time. However GNU ld < 2.40 will error if we try to link a shared object
    // with direct references to protected symbols, so for now we only use protected symbols if
    // linking with LLD is enabled.

+ 7 more matches in this file

src/bootstrap/src/core/build_steps/doc.rs RUST 11 matches · showing 5 view file →

macro_rules! book {
    ($($name:ident, $path:expr, $book_name:expr, $lang:expr ;)+) => {
        $(
        #[derive(Debug, Clone, Hash, PartialEq, Eq)]

· · ·

#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub struct ErrorIndex {
    compilers: RustcPrivateCompilers,
}

· · ·

impl Step for ErrorIndex {
    type Output = ();
    const IS_HOST: bool = true;

· · ·

    fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
        run.path("src/tools/error_index_generator")
    }

· · ·

    fn make_run(run: RunConfig<'_>) {
        run.builder.ensure(ErrorIndex {
            compilers: RustcPrivateCompilers::new(run.builder, run.builder.top_stage, run.target),
        });

+ 6 more matches in this file

src/bootstrap/src/core/build_steps/llvm.rs RUST 11 matches · showing 5 view file →

            || target.contains("apple-visionos")
        {
            // Prevent cmake from adding -bundle to CFLAGS automatically, which leads to a compiler error because "-bitcode_bundle" also gets added.
            cfg.define("LLVM_ENABLE_PLUGINS", "OFF");
            // Zlib fails to link properly, leading to a compiler error.

· · ·

            // Zlib fails to link properly, leading to a compiler error.
            cfg.define("LLVM_ENABLE_ZLIB", "OFF");
        }

· · ·

    if builder.config.quiet {
        // Only log errors and warnings from `cmake`.
        cfg.define("CMAKE_MESSAGE_LOG_LEVEL", "WARNING");

· · ·

                cfg.define("CMAKE_SYSTEM_NAME", "Darwin");
                // These two defines prevent CMake from automatically trying to add a MacOSX sysroot, which leads to a compiler error.
                cfg.define("CMAKE_OSX_SYSROOT", "/");
                cfg.define("CMAKE_OSX_DEPLOYMENT_TARGET", "");

· · ·

    // https://github.com/llvm/llvm-project/issues/88780 to be fixed.
    for flag in builder
        .cc_handled_clags(target, CLang::C)
        .into_iter()
        .chain(builder.cc_unhandled_cflags(target, GitRepo::Llvm, CLang::C))

+ 6 more matches in this file

src/bootstrap/src/core/build_steps/test.rs RUST 25 matches · showing 5 view file →

        if run.builder.top_stage == 0 {
            eprintln!(
                "ERROR: running cargotest with stage 0 is currently unsupported. Use at least stage 1."
            );
            exit!(1);

· · ·

        // Miri has its own "target dir" for ui test dependencies. Make sure it gets cleared when
        // the sysroot gets rebuilt, to avoid "found possibly newer version of crate `std`" errors.
        if !builder.config.dry_run() {
            // This has to match `CARGO_TARGET_TMPDIR` in Miri's `ui.rs`.

· · ·

            // `MIRI_SKIP_UI_CHECKS` and `RUSTC_BLESS` are incompatible
            cargo.env_remove("RUSTC_BLESS");
            // Optimizations can change error locations and remove UB so don't run `fail` tests.
            cargo.args(["tests/pass", "tests/panic"]);

· · ·

        if builder.top_stage == 0 && !builder.config.compiletest_allow_stage0 {
            eprintln!("\
ERROR: `--stage 0` causes compiletest to query information from the stage0 (precompiled) compiler, instead of the in-tree compiler, which can cause some tests to fail inappropriately
NOTE: if you're sure you want to do this, please open an issue as to why. In the meantime, you can override this with `--set build.compiletest-allow-stage0=true`."
            );

· · ·

        let _guard = builder.msg_test("clippy", target, target_compiler.stage);
        // Clippy reports errors if it blessed the outputs
        if cargo.allow_failure().run(builder) {
            // The tests succeeded; nothing to do.

+ 20 more matches in this file

src/bootstrap/src/core/builder/cargo.rs RUST 10 matches · showing 5 view file →

            let env = format!("CFLAGS_{triple_underscored}");
            let mut cflags =
                builder.cc_unhandled_cflags(target, GitRepo::Rustc, CLang::C).join(" ");
            if let Ok(var) = std::env::var(&env) {
                cflags.push(' ');

· · ·

                let env = format!("CXXFLAGS_{triple_underscored}");
                let mut cxxflags =
                    builder.cc_unhandled_cflags(target, GitRepo::Rustc, CLang::Cxx).join(" ");
                if let Ok(var) = std::env::var(&env) {
                    cxxflags.push(' ');

· · ·

        // Bootstrap only supports modern FIFO jobservers. Older pipe-based jobservers can run into
        // "invalid file descriptor" errors, as the jobserver file descriptors are not inherited by
        // scripts like bootstrap.py, while the environment variable is propagated. So, we pass
        // MAKEFLAGS only if we detect a FIFO jobserver, otherwise we clear it.

· · ·

                // supported by the target.
                if target != compiler.host && cmd_kind != Kind::Check {
                    let error = self
                        .rustc_cmd(compiler)
                        .arg("--target")

· · ·

                        .stderr();
                    let not_supported = error
                        .lines()
                        .any(|line| line.contains("unsupported crate type `proc-macro`"));

+ 5 more matches in this file

src/bootstrap/src/core/config/config.rs RUST 30 matches · showing 5 view file →

    pub skip: Vec<PathBuf>,
    pub include_default_paths: bool,
    pub rustc_error_format: Option<String>,
    pub json_output: bool,
    pub compile_time_deps: bool,

· · ·

    pub llvm_allow_old_toolchain: bool,
    pub llvm_polly: bool,
    pub llvm_clang: bool,
    pub llvm_enable_warnings: bool,
    pub llvm_from_ci: bool,

· · ·

    pub(crate) fn parse_inner(
        flags: Flags,
        get_toml: impl Fn(&Path) -> Result<TomlConfig, toml::de::Error>,
    ) -> Config {
        // Destructure flags to ensure that we use all its fields

· · ·

            skip: flags_skip,
            include_default_paths: flags_include_default_paths,
            rustc_error_format: flags_rustc_error_format,
            on_fail: flags_on_fail,
            dry_run: flags_dry_run,

· · ·

            offload_clang_dir: llvm_clang_dir,
            polly: llvm_polly,
            clang: llvm_clang,
            enable_warnings: llvm_enable_warnings,
            download_ci_llvm: llvm_download_ci_llvm,

+ 25 more matches in this file

src/bootstrap/src/core/config/toml/llvm.rs RUST 2 matches view file →

        polly: Option<bool> = "polly",
        offload_clang_dir: Option<String> = "offload-clang-dir",
        clang: Option<bool> = "clang",
        enable_warnings: Option<bool> = "enable-warnings",
        download_ci_llvm: Option<StringOrBool> = "download-ci-llvm",

· · ·

                if Some(current) != $expected.as_ref() {
                    return Err(format!(
                        "ERROR: Setting `llvm.{}` is incompatible with `llvm.download-ci-llvm`. \
                        Current value: {:?}, Expected value(s): {}{:?}",
                        stringify!($expected).replace("_", "-"),

src/bootstrap/src/lib.rs RUST 13 matches · showing 5 view file →

            Some(_sudo_user) => {
                // SAFETY: getuid() system call is always successful and no return value is reserved
                // to indicate an error.
                //
                // For more context, see https://man7.org/linux/man-pages/man2/geteuid.2.html

· · ·

            crate::core::sanity::check(&mut build);
            // Make sure we update these before gathering metadata so we don't get an error about missing
            // Cargo.toml files.
            let rust_submodules = ["library/backtrace"];

· · ·

                } else {
                    // Return the most normal file name, even though
                    // it doesn't exist, so that any error message
                    // refers to that.
                    filecheck

· · ·

        }
        let base = match c {
            CLang::C => self.cc[&target].clone(),
            CLang::Cxx => self.cxx[&target].clone(),
        };

· · ·

            CLang::Cxx => self.cxx[&target].clone(),
        };

+ 8 more matches in this file

src/bootstrap/src/utils/cc_detect.rs RUST 5 matches view file →

    build.cc.insert(target, compiler.clone());
    let mut cflags = build.cc_handled_clags(target, CLang::C);
    cflags.extend(build.cc_unhandled_cflags(target, GitRepo::Rustc, CLang::C));

· · ·

    cflags.extend(build.cc_unhandled_cflags(target, GitRepo::Rustc, CLang::C));
    // If we use llvm-libunwind, we will need a C++ compiler as well for all targets

· · ·

    build.do_if_verbose(|| println!("CFLAGS_{} = {cflags:?}", target.triple));
    if let Ok(cxx) = build.cxx(target) {
        let mut cxxflags = build.cc_handled_clags(target, CLang::Cxx);
        cxxflags.extend(build.cc_unhandled_cflags(target, GitRepo::Rustc, CLang::Cxx));
        build.do_if_verbose(|| println!("CXX_{} = {cxx:?}", target.triple));

· · ·

        cxxflags.extend(build.cc_unhandled_cflags(target, GitRepo::Rustc, CLang::Cxx));
        build.do_if_verbose(|| println!("CXX_{} = {cxx:?}", target.triple));
        build.do_if_verbose(|| println!("CXXFLAGS_{} = {cxxflags:?}", target.triple));

· · ·

            } else {
                if build.config.is_running_on_ci() {
                    panic!("ERROR: WASI_SDK_PATH must be configured for a -wasi target on CI");
                }
                println!("WARNING: WASI_SDK_PATH not set, using default cc/cxx compiler");

src/bootstrap/src/utils/helpers.rs RUST 4 matches view file →

/// * The file/line of the panic
/// * The expression that failed
/// * The error itself
///
/// This is currently used judiciously throughout the build system rather than

· · ·

pub fn move_file<P: AsRef<Path>, Q: AsRef<Path>>(from: P, to: Q) -> io::Result<()> {
    match fs::rename(&from, &to) {
        Err(e) if e.kind() == io::ErrorKind::CrossesDevices => {
            std::fs::copy(&from, &to)?;
            std::fs::remove_file(&from)

· · ·

///
/// When `clang-cl` is used with instrumentation, we need to add clang's runtime library resource
/// directory to the linker flags, otherwise there will be linker errors about the profiler runtime
/// missing. This function returns the path to that directory.
pub fn get_clang_cl_resource_dir(builder: &Builder<'_>, clang_cl_path: &str) -> PathBuf {

· · ·

    // - we ask `clang-cl` to locate the `clang_rt.builtins` lib.
    let mut builtins_locator = command(clang_cl_path);
    builtins_locator.args(["/clang:-print-libgcc-file-name", "/clang:--rtlib=compiler-rt"]);
    let clang_rt_builtins = builtins_locator.run_capture_stdout(builder).stdout();

src/doc/rustc/src/linker-plugin-lto.md MARKDOWN 5 matches view file →

You will want to make sure your rust major LLVM version matches your installed LLVM tooling version,
otherwise it is likely you will get linker errors:
```bat

· · ·

```
If you are compiling any proc-macros, you will get this error:
```bash

· · ·

error: Linker plugin based LTO is not supported together with `-C prefer-dynamic` when
targeting Windows-like targets
```

· · ·

set CC=clang-cl
set CXX=clang-cl
set CFLAGS=/clang:-flto=thin /clang:-fuse-ld=lld-link
set CXXFLAGS=/clang:-flto=thin /clang:-fuse-ld=lld-link
REM Needed because msvc's lib.exe crashes on LLVM LTO .obj files

· · ·

set CXXFLAGS=/clang:-flto=thin /clang:-fuse-ld=lld-link
REM Needed because msvc's lib.exe crashes on LLVM LTO .obj files
set AR=llvm-lib

src/tools/clippy/clippy_lints/src/doc/mod.rs RUST 13 matches · showing 5 view file →

use clippy_utils::{is_entrypoint_fn, is_trait_impl_item};
use rustc_data_structures::fx::FxHashSet;
use rustc_errors::Applicability;
use rustc_hir::{Attribute, FieldDef, ImplItemKind, ItemKind, Node, Safety, TraitItemKind};
use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintContext};

· · ·

    /// ### What it does
    /// Checks the doc comments of publicly visible functions that
    /// return a `Result` type and warns if there is no `# Errors` section.
    ///
    /// ### Why is this bad?

· · ·

    /// Documenting the type of errors that can be returned from a
    /// function can help callers write code to handle the errors appropriately.
    ///

· · ·

    /// function can help callers write code to handle the errors appropriately.
    ///
    /// ### Examples

· · ·

    /// Since the following function returns a `Result` it has an `# Errors` section in
    /// its doc comment:
    ///

+ 8 more matches in this file

src/tools/miri/src/shims/unix/freebsd/sync.rs RUST 7 matches · showing 5 view file →

                            let Some(umtx_time) = this.read_umtx_time(&umtx_time_place)? else {
                                return this.set_errno_and_return_neg1(LibcError("EINVAL"), dest);
                            };

· · ·

                            let timespec = this.ptr_to_mplace(uaddr2, timespec_layout);
                            let Some(duration) = this.read_timespec(&timespec)? else {
                                return this.set_errno_and_return_neg1(LibcError("EINVAL"), dest);
                            };

· · ·

                            // code (umtx_copyin_umtx_time() in kern_umtx.c), it seems to default to CLOCK_REALTIME,
                            // so that's what we also do.
                            // Discussion in golang: https://github.com/golang/go/issues/17168#issuecomment-250235271
                            Some(this.machine.timeout(
                                TimeoutClock::RealTime,

· · ·

                            ))
                        } else {
                            return this.set_errno_and_return_neg1(LibcError("EINVAL"), dest);
                        }
                    };

· · ·

                                }
                                UnblockKind::TimedOut => {
                                    ecx.set_errno_and_return_neg1(LibcError("ETIMEDOUT"), &dest)
                                }
                            }

+ 2 more matches in this file

src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower.rs RUST 33 matches · showing 5 view file →

        // FIXME: Keyword check?
        let lifetime_ref = match &*lifetime.text() {
            "" | "'" => LifetimeRef::Error,
            "'static" => LifetimeRef::Static,
            "'_" => LifetimeRef::Placeholder,

· · ·

                .and_then(|it| self.lower_path(it, impl_trait_lower_fn))
                .map(TypeRef::Path)
                .unwrap_or(TypeRef::Error),
            ast::Type::PtrType(inner) => {
                let inner_ty = self.lower_type_ref_opt(inner.ty(), impl_trait_lower_fn);

· · ·

                if self.outer_impl_trait {
                    // Disallow nested impl traits
                    TypeRef::Error
                } else {
                    return self.with_outer_impl_trait_scope(true, |this| {

· · ·

                    return id;
                }
                None => TypeRef::Error,
            },
        };

· · ·

    pub(crate) fn lower_type_ref_disallow_impl_trait(&mut self, node: ast::Type) -> TypeRefId {
        self.lower_type_ref(node, &mut Self::impl_trait_error_allocator)
    }

+ 28 more matches in this file

src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower/format_args.rs RUST 3 matches view file →

        // Ensure all argument indexes actually fit in 16 bits, as we truncated them to 16 bits before.
        if argmap.len() > u16::MAX as usize {
            // FIXME: Emit an error.
            // ctx.dcx().span_err(macsp, "too many format arguments");
        }

· · ·

                let new_fn = self.store.exprs.alloc(Expr::Path(new_fn));
                if let Some(arg_ptr) = arg_ptr {
                    // Trait errors (the argument does not implement the expected fmt trait) will show
                    // on this path, so to not end up with synthetic syntax we insert this mapping. We
                    // don't want to insert the other way's mapping in order to not override the source

· · ·

    fn ty_rel_lang_path_desugared_expr(
        &mut self,
        lang: Option<impl Into<LangItemTarget>>,
        relative_name: Symbol,
    ) -> ExprId {

src/tools/rust-analyzer/crates/ide-completion/src/context.rs RUST 2 matches view file →

            .generic_def()
            .and_then(|def| ty.try_rebase_into_owner(self.db, def))
            .unwrap_or_else(|| ty.instantiate_with_errors())
    }
}

· · ·

}
const OP_TRAIT_LANG: &[hir::LangItem] = &[
    hir::LangItem::AddAssign,
    hir::LangItem::Add,

src/tools/rust-analyzer/editors/code/src/config.ts TYPESCRIPT 3 matches view file →

    readonly extensionId = "rust-lang.rust-analyzer";
    configureLang: vscode.Disposable | undefined;
    workspaceState: vscode.Memento;

· · ·

    }
    get useRustcErrorCode() {
        return this.get<boolean>("diagnostics.useRustcErrorCode");
    }

· · ·

        return this.get<boolean>("diagnostics.useRustcErrorCode");
    }

src/tools/rustbook/src/main.rs RUST 8 matches · showing 5 view file →

use clap::{ArgMatches, Command, arg, crate_version};
use mdbook_driver::MDBook;
use mdbook_driver::errors::Result as Result3;
use mdbook_i18n_helpers::preprocessors::Gettext;
use mdbook_spec::Spec;

· · ·

        Some(("build", sub_matches)) => {
            if let Err(e) = build(sub_matches) {
                handle_error(e);
            }
        }

· · ·

        Some(("test", sub_matches)) => {
            if let Err(e) = test(sub_matches) {
                handle_error(e);
            }
        }

· · ·

    book_dir: &Path,
    dest_dir: Option<&PathBuf>,
    lang: Option<&String>,
    rust_root: Option<PathBuf>,
) -> Result3<MDBook> {

· · ·

    }
    // NOTE: Replacing preprocessors using this technique causes error
    // messages to be displayed when the original preprocessor doesn't work
    // (but it otherwise succeeds).

+ 3 more matches in this file

src/tools/tidy/src/extra_checks/mod.rs RUST 87 matches · showing 5 view file →

    macro_rules! extra_check {
        ($lang:ident, $kind:ident) => {
            lint_args.iter().any(|arg| arg.matches(ExtraCheckLang::$lang, ExtraCheckKind::$kind))
        };

· · ·

            lint_args.iter().any(|arg| arg.matches(ExtraCheckLang::$lang, ExtraCheckKind::$kind))
        };
    }

· · ·

        Ok(p) => Some(p),
        Err(e) => {
            check.error(e);
            None
        }

· · ·

    if let Err(e) = rustdoc_js::npm_install(root_path, outdir, npm) {
        check.error(e.to_string());
        return None;
    }

· · ·

    {
        show_bless_help("spellcheck", "fix typos", bless);
        check.error(e);
    }
}

+ 82 more matches in this file

src/tools/tidy/src/extra_checks/tests.rs RUST 16 matches · showing 5 view file →

use std::str::FromStr;
use crate::extra_checks::{ExtraCheckArg, ExtraCheckKind, ExtraCheckLang, ExtraCheckParseError};
#[test]

· · ·

                auto: true,
                if_installed: true,
                lang: ExtraCheckLang::Spellcheck,
                kind: None,
            },

· · ·

                auto: true,
                if_installed: true,
                lang: ExtraCheckLang::Spellcheck,
                kind: None,
            },

· · ·

                auto: true,
                if_installed: false,
                lang: ExtraCheckLang::Spellcheck,
                kind: None,
            },

· · ·

                auto: false,
                if_installed: true,
                lang: ExtraCheckLang::Spellcheck,
                kind: None,
            },

+ 11 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