TODO lang:Rust lang:Rust · rust-lang/rust — 1,905 matches

compiler/rustc_ast_lowering/src/errors.rs RUST 1 matches view file →

    #[suggestion(
        "add a body after the pattern",
        code = " => todo!(),",
        applicability = "has-placeholders"
    )]

compiler/rustc_ast_passes/src/errors.rs RUST 2 matches view file →

    #[primary_span]
    pub span: Span,
    // We include the braces around `todo!()` so that a comma is optional, and we don't have to have
    // any logic looking at the arm being replaced if there was a comma already or not for the
    // resulting code to be correct.

· · ·

    #[suggestion(
        "add a body after the pattern",
        code = " => {{ todo!() }}",
        applicability = "has-placeholders",
        style = "verbose"

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs RUST 1 matches view file →

                    // FIXME: We make sure that this is a normal top-level binding,
                    // but we could suggest `todo!()` for all uninitialized bindings in the pattern
                    if let hir::StmtKind::Let(hir::LetStmt { span, ty, init: None, pat, .. }) =
                        &ex.kind

compiler/rustc_borrowck/src/places_conflict.rs RUST 1 matches view file →

        (ProjectionElem::UnwrapUnsafeBinder(_), _) => {
            todo!()
        }
    }

compiler/rustc_borrowck/src/universal_regions.rs RUST 1 matches view file →

            }
            DefiningTy::CoroutineClosure(..) => {
                todo!()
            }
            DefiningTy::Coroutine(def_id, args) => {

compiler/rustc_builtin_macros/src/autodiff.rs RUST 1 matches view file →

                .map(|arg| match arg.pat.kind {
                    PatKind::Ident(_, ident, _) => ecx.expr_path(ecx.path_ident(span, ident)),
                    _ => todo!(),
                })
                .collect::<ThinVec<_>>()

compiler/rustc_codegen_cranelift/build_system/main.rs RUST 6 matches · showing 5 view file →

mod shared_utils;
mod tests;
mod todo;
mod utils;

· · ·

    AbiCafe,
    Bench,
    CheckTodo,
}

· · ·

        Some("abi-cafe") => Command::AbiCafe,
        Some("bench") => Command::Bench,
        Some("check-todo") => Command::CheckTodo,
        Some(flag) if flag.starts_with('-') => arg_error!("Expected command found flag {}", flag),
        Some(command) => arg_error!("Unknown command {}", command),

· · ·

    }
    if command == Command::CheckTodo {
        todo::run();
    }

· · ·

        todo::run();
    }

+ 1 more matches in this file

compiler/rustc_codegen_cranelift/build_system/todo.rs RUST 4 matches view file →

    let mut error_count = 0;
    // Avoid embedding the task marker in source so greps only find real occurrences.
    let todo_marker = "todo".to_ascii_uppercase();
    for file in files {

· · ·

        for (i, line) in contents.split('\n').enumerate() {
            let trimmed = line.trim();
            if trimmed.contains(&todo_marker) {
                eprintln!(
                    "{}:{}: {} is used for tasks that should be done before merging a PR; if you want to leave a message in the codebase use FIXME",

· · ·

                    file.display(),
                    i + 1,
                    todo_marker
                );
                error_count += 1;

· · ·

    }
    eprintln!("found {} {}(s)", error_count, todo_marker);
    process::exit(1);
}

compiler/rustc_codegen_cranelift/example/std_example.rs RUST 1 matches view file →

        impl<T: ?Sized> Foo<T> {
            pub fn new() -> Box<Foo<T>> {
                todo!()
            }
        }

compiler/rustc_codegen_cranelift/src/constant.rs RUST 12 matches · showing 5 view file →

pub(crate) struct ConstantCx {
    todo: Vec<TodoItem>,
    anon_allocs: FxHashMap<AllocId, DataId>,
}

· · ·

#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
enum TodoItem {
    Alloc(AllocId),
    Static(DefId),

· · ·

impl ConstantCx {
    pub(crate) fn new() -> Self {
        ConstantCx { todo: vec![], anon_allocs: FxHashMap::default() }
    }

· · ·

pub(crate) fn codegen_static(tcx: TyCtxt<'_>, module: &mut dyn Module, def_id: DefId) -> DataId {
    let mut constants_cx = ConstantCx::new();
    constants_cx.todo.push(TodoItem::Static(def_id));
    constants_cx.finalize(tcx, module);

· · ·

    mutability: rustc_hir::Mutability,
) -> DataId {
    cx.todo.push(TodoItem::Alloc(alloc_id));
    *cx.anon_allocs
        .entry(alloc_id)

+ 7 more matches in this file

compiler/rustc_codegen_cranelift/src/debuginfo/unwind.rs RUST 1 matches view file →

compiler/rustc_codegen_cranelift/src/driver/aot.rs RUST 3 matches view file →

    let disable_incr_cache = disable_incr_cache();
    let (todo_cgus, done_cgus) =
        cgus.iter().enumerate().partition::<Vec<_>, _>(|&(i, _)| match cgu_reuse[i] {
            _ if disable_incr_cache => true,

· · ·

        });
    let concurrency_limiter = IntoDynSyncSend(ConcurrencyLimiter::new(todo_cgus.len()));
    let modules: Vec<_> =

· · ·

        tcx.sess.time("codegen mono items", || {
            let modules: Vec<_> = par_map(todo_cgus, |(_, cgu)| {
                let dep_node = cgu.codegen_dep_node(tcx);
                let (module, _) = tcx.dep_graph.with_task(

compiler/rustc_codegen_cranelift/src/intrinsics/llvm_x86.rs RUST 2 matches view file →

                _CMP_NGE_US | _CMP_NGE_UQ => FloatCC::UnorderedOrLessThan,
                _CMP_NGT_US | _CMP_NGT_UQ => FloatCC::UnorderedOrLessThanOrEqual,
                _CMP_FALSE_OQ | _CMP_FALSE_OS => todo!(),
                _CMP_NEQ_OQ | _CMP_NEQ_OS => FloatCC::OrderedNotEqual,
                _CMP_GE_OS | _CMP_GE_OQ => FloatCC::GreaterThanOrEqual,

· · ·

                _CMP_GT_OS | _CMP_GT_OQ => FloatCC::GreaterThan,
                _CMP_TRUE_UQ | _CMP_TRUE_US => todo!(),
                kind => unreachable!("kind {:?}", kind),

compiler/rustc_codegen_gcc/src/type_of.rs RUST 2 matches view file →

        }
        BackendRepr::Memory { .. } => {}
        BackendRepr::SimdScalableVector { .. } => todo!(),
    }

· · ·

            BackendRepr::Scalar(_) | BackendRepr::SimdVector { .. } => true,
            // FIXME(rustc_scalable_vector): Not yet implemented in rustc_codegen_gcc.
            BackendRepr::SimdScalableVector { .. } => todo!(),
            BackendRepr::ScalarPair(..) | BackendRepr::Memory { .. } => false,
        }

compiler/rustc_codegen_ssa/src/back/linker.rs RUST 1 matches view file →

    fn export_symbols(&mut self, _: &Path, _: CrateType, _: &[(String, SymbolExportKind)]) {
        // ToDo, not implemented, copy from GCC
        self.sess.dcx().emit_warn(errors::L4BenderExportingSymbolsUnimplemented);
    }

compiler/rustc_const_eval/src/interpret/intern.rs RUST 4 matches view file →

    };
    // Intern the base allocation, and initialize todo list for recursive interning.
    let base_alloc_id = ret.ptr().provenance.unwrap().alloc_id();
    trace!(?base_alloc_id, ?base_mutability);

· · ·

    // This gives us the initial set of nested allocations, which will then all be processed
    // recursively in the loop below.
    let mut todo: Vec<_> = if is_static {
        assert!(disambiguator.is_some());
        // Do not steal the root allocation, we need it later to create the return value of `eval_static_initializer`.

· · ·

    // interning has better coverage since it "sees" *all* pointers, including raw pointers and
    // references stored in unions.
    while let Some(prov) = todo.pop() {
        trace!(?prov);
        let alloc_id = prov.alloc_id();

· · ·

        just_interned.insert(alloc_id);
        let next = intern_shallow(ecx, alloc_id, inner_mutability, disambiguator.as_deref_mut())?;
        todo.extend(next);
    }
    if found_bad_mutable_ptr {

compiler/rustc_const_eval/src/interpret/memory.rs RUST 8 matches · showing 5 view file →

    ) -> InterpResult<'tcx> {
        let mut done = FxHashSet::default();
        let mut todo = start;
        while let Some(id) = todo.pop() {
            if !done.insert(id) {

· · ·

        while let Some(id) = todo.pop() {
            if !done.insert(id) {
                // We already saw this allocation before, don't process it again.

· · ·

                for prov in alloc.provenance().provenances() {
                    if let Some(id) = prov.get_alloc_id() {
                        todo.push(id);
                    }
                }

· · ·

            let mut reachable = FxHashSet::default();
            let global_kind = M::GLOBAL_KIND.map(MemoryKind::Machine);
            let mut todo: Vec<_> =
                self.memory.alloc_map.filter_map_collect(move |&id, &(kind, _)| {
                    if Some(kind) == global_kind { Some(id) } else { None }

· · ·

                });
            todo.extend(static_roots(self));
            while let Some(id) = todo.pop() {
                if reachable.insert(id) {

+ 3 more matches in this file

compiler/rustc_const_eval/src/interpret/validity.rs RUST 7 matches · showing 5 view file →

pub struct RefTracking<T, PATH = ()> {
    seen: FxHashSet<T>,
    todo: Vec<(T, PATH)>,
}

· · ·

impl<T: Clone + Eq + Hash + std::fmt::Debug, PATH> RefTracking<T, PATH> {
    pub fn empty() -> Self {
        RefTracking { seen: FxHashSet::default(), todo: vec![] }
    }
    pub fn next(&mut self) -> Option<(T, PATH)> {

· · ·

        self.todo.pop()
    }

· · ·

            let path = path();
            // Remember to come back to this later.
            self.todo.push((val, path));
        }
    }

· · ·

    pub fn new(val: T, ty: Ty<'tcx>) -> Self {
        let mut ref_tracking_for_consts =
            RefTracking { seen: FxHashSet::default(), todo: vec![(val.clone(), Path::new(ty))] };
        ref_tracking_for_consts.seen.insert(val);
        ref_tracking_for_consts

+ 2 more matches in this file

compiler/rustc_data_structures/src/tagged_ptr/tests.rs RUST 2 matches view file →

///     const BITS: u32 = 2;
///
///     fn into_usize(self) -> usize { todo!() }
///     unsafe fn from_usize(tag: usize) -> Self { todo!() }
/// }

· · ·

///     unsafe fn from_usize(tag: usize) -> Self { todo!() }
/// }
///

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

    }
    fn as_target(&self) -> Target {
        todo!();
    }
}

compiler/rustc_hir/src/def.rs RUST 1 matches view file →

    ///         let _: Self;        // SelfTyAlias
    ///
    ///         todo!()
    ///     }
    /// }

compiler/rustc_hir_analysis/src/check/mod.rs RUST 1 matches view file →

    // fill in a significant portion of the missing code, and other subsequent
    // suggestions can help the user fix the code.
    format!("{safety}{asyncness}fn {ident}{generics}({args}){output}{where_clauses} {{ todo!() }}")
}

compiler/rustc_hir_typeck/src/cast.rs RUST 1 matches view file →

            },
            ty::UnsafeBinder(_) => todo!("FIXME(unsafe_binder)"),
            // Pointers to foreign types are thin, despite being unsized

compiler/rustc_hir_typeck/src/closure.rs RUST 1 matches view file →

                    }
                    hir::CoroutineDesugaring::AsyncGen => {
                        todo!("`async gen` closures not supported yet")
                    }
                };

compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs RUST 1 matches view file →

            //         x => dbg!(x),
            //     }
            //     todo!()
            // }
            // -------------^^^^^^^-

`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