Cleanup some TODOs

src/analyses/compare.rs

@@ -77,7 +77,7 @@ impl<'a> ComparisonState<'a> {
         while let Continue(pred) = state {
             *state = match ruleset {
                 RuleSet::BindingModeBased(conf) => {
-                    match analyze_with_formality(a, conf, current_req) {
+                    match typecheck_with_formality(a, conf, current_req) {
                         TypingResult::TypeError(TypeError::OverlyGeneral(deepening)) => {
                             return Some(deepening)
                         }
@@ -316,12 +316,6 @@ fn compare() {
                 c
             }),
         ),
-        (
-            "rpjohnst",
-            TypeBased(RuleOptions::RPJOHNST),
-            Somewhat.expect(Equal).shallower().shallower(),
-            BindingModeBased(Conf::rpjohnst_2024()),
-        ),
         (
             "ergo2024_nonbreaking_transition_bm_based",
             BindingModeBased(Conf::rfc_3627_2024_min()),

src/analyses/compute_rules.rs

@@ -373,7 +373,6 @@ impl<'a> TypingRule<'a> {
         cstrs
     }
 
-    // TODO: deprecate `BindingMode` style
     fn make_renderable(
         &'a self,
         a: &'a Arenas<'a>,

src/rulesets/ty_based.rs

@@ -71,7 +71,6 @@ pub struct RuleOptions {
     /// What happens with a `mut x` binding and an inherited reference.
     pub mut_binding_on_inherited: MutBindingOnInheritedBehavior,
     pub always_inspect_bm: bool,
-    // TODO: double_ref: Last | Min
 }
 
 impl RuleOptions {
@@ -414,12 +413,6 @@ impl RuleOptions {
         ..Self::ERGO2024
     };
 
-    pub const RPJOHNST: Self = RuleOptions {
-        // TODO: double_ref: Last | Min
-        allow_ref_pat_on_ref_mut: false,
-        ..Self::STATELESS
-    };
-
     pub fn get_bundle_name(self) -> Option<&'static str> {
         RuleSet::TypeBased(self).get_bundle_name()
     }

src/solvers/bm_based.rs

@@ -123,7 +123,7 @@ pub fn trace_with_formality<'a>(conf: Conf, req: &TypingRequest<'a>) -> String {
     out
 }
 
-pub fn analyze_with_formality<'a>(
+pub fn typecheck_with_formality<'a>(
     a: &'a Arenas<'a>,
     conf: Conf,
     req: &TypingRequest<'a>,

src/solvers/mod.rs

@@ -18,10 +18,10 @@ pub enum TypingResult<'a> {
 }
 
 impl RuleSet {
-    pub fn analyze<'a>(&self, a: &'a Arenas<'a>, req: &TypingRequest<'a>) -> TypingResult<'a> {
+    pub fn typecheck<'a>(&self, a: &'a Arenas<'a>, req: &TypingRequest<'a>) -> TypingResult<'a> {
         match *self {
-            RuleSet::TypeBased(options) => analyze_with_this_crate(a, options, req),
-            RuleSet::BindingModeBased(conf) => analyze_with_formality(a, conf, req),
+            RuleSet::TypeBased(options) => typecheck_with_this_crate(a, options, req),
+            RuleSet::BindingModeBased(conf) => typecheck_with_formality(a, conf, req),
         }
     }
 

src/solvers/ty_based.rs

@@ -120,8 +120,7 @@ pub fn trace_solver<'a>(
     trace
 }
 
-// TODO: rename, "analyze" isn't clear
-pub fn analyze_with_this_crate<'a>(
+pub fn typecheck_with_this_crate<'a>(
     a: &'a Arenas<'a>,
     options: RuleOptions,
     req: &TypingRequest<'a>,

web/src/components/Solver.jsx

@@ -287,8 +287,6 @@ export function CompareDisplay({optionsLeft, optionsRight}) {
     </Stack>
 }
 
-// TODO: tab the options container to support bm-based Solver
-// TODO: add offcanvas with predicate and rules explanations
 export default function Solver() {
     // Decoding function that simply checks that the value is in the given array.
     function validateIn(allowed) {