Fix some comments

Author: folkertdev

compiler/rustc_mir_build/src/builder/expr/into.rs

@@ -259,7 +259,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 this.cfg.goto(block, source_info, loop_block);
 
                 this.in_breakable_scope(Some(loop_block), destination, expr_span, |this| {
-                    // logic for `loop`
+                    // Logic for `loop`.
                     let mut body_block = this.cfg.start_new_block();
                     this.cfg.terminate(
                         loop_block,
@@ -303,12 +303,12 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
                     let state_place = scrutinee_place_builder.to_place(this);
 
-                    // this is logic for the labeled block: a block is a drop scope, hence
+                    // This is logic for the labeled block: a block is a drop scope, hence
                     // `in_scope`, and a labeled block can be broken out of with a `break 'label`,
                     // hence the `in_breakable_scope`.
                     //
-                    // Inside of that information for #[const_continue] is stored, and the match is
-                    // lowered in the standard way.
+                    // Then `in_const_continuable_scope` stores information for the lowering of
+                    // #[const_continue], and finally the match is lowered in the standard way.
                     unpack!(
                         body_block = this.in_scope(
                             (region_scope, source_info),

compiler/rustc_mir_build/src/builder/matches/mod.rs

@@ -2880,8 +2880,9 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
             if let rustc_pattern_analysis::rustc::Constructor::Or = pat.ctor() {
                 for pat in pat.iter_fields() {
-                    // when the bindings are the same, the sub_branch is only stored once,
-                    // so we must repeat it manually.
+                    // For top-level or-patterns (the only ones we accept right now), when the
+                    // bindings are the same (e.g. there are none), the sub_branch is stored just
+                    // once.
                     let sub_branch = branch
                         .sub_branches
                         .get(pat.idx)

compiler/rustc_mir_build/src/builder/scope.rs

@@ -180,10 +180,10 @@ struct BreakableScope<'tcx> {
 
 #[derive(Debug)]
 struct ConstContinuableScope<'tcx> {
-    /// The if-then scope or arm scope
+    /// The if-then scope or arm scope.
     region_scope: region::Scope,
     /// The destination of the loop/block expression itself (i.e., where to put
-    /// the result of a `break` or `return` expression)
+    /// the result of a `break` or `return` expression).
     state_place: Place<'tcx>,
 
     arms: Box<[ArmId]>,
@@ -571,7 +571,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         }
     }
 
-    ///  Start a const-continuable scope, which tracks where `#[const_continue] break` should
+    /// Start a const-continuable scope, which tracks where `#[const_continue] break` should
     /// branch to.
     pub(crate) fn in_const_continuable_scope<F>(
         &mut self,
@@ -846,7 +846,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             _ => todo!(),
         };
 
-        // the PatCtxt is normally used in pattern exhaustiveness checking, but reused here
+        // The PatCtxt is normally used in pattern exhaustiveness checking, but reused here
         // because it performs normalization and const evaluation.
         let dropless_arena = rustc_arena::DroplessArena::default();
         let typeck_results = self.tcx.typeck(self.def_id);
@@ -900,8 +900,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
         self.cfg.terminate(imaginary_target, source_info, TerminatorKind::UnwindResume);
 
-        // FIXME add to drop tree for loop_head
-
         let region_scope = scope.region_scope;
         let scope_index = self.scopes.scope_index(region_scope, span);
         let mut drops = DropTree::new();

compiler/rustc_passes/src/loops.rs

@@ -39,7 +39,7 @@ enum Context {
     AnonConst,
     /// E.g. `const { ... }`.
     ConstBlock,
-    /// #[loop_match] loop { state = 'label: { /* ... */ } }
+    /// `#[loop_match] loop { state = 'label: { /* ... */ } }`
     LoopMatch {
         /// The label of the labeled block (so not the loop!)
         labeled_block: Label,