hecks 2.8.0 → 3.0.0

data/lib/rubocop/cop/hecks/thread_shared_ivar_mutation.rb

@@ -1,65 +1,15 @@
 module RuboCop
   module Cop
     module Hecks
-      # Flags plain `@ivar` mutation inside a class this codebase already
-      # knows is a thread-shared singleton — one `Dispatcher`/`Registry`
-      # instance lives for the life of a boot and is dispatched through
-      # from every thread of a Puma worker pool (or any other multi-
-      # threaded host), so a plain instance variable on either class is
-      # shared, mutable state with no per-thread or mutex-guarded
-      # isolation at all.
-      #
-      # ## The bug this follows up on
-      #
-      # This is the mechanical follow-up to a real bug already fixed here
-      # (see `dispatcher.rb`'s own `#reenter` comment, and
-      # `spec/runtime/dispatcher_spec.rb`): a plain `@reaction_depth` ivar on
-      # `Dispatcher` let two threads' concurrent top-level
-      # dispatches corrupt each other's view of "how deep into a
-      # reaction cascade am I". The fix moved that one ivar to
-      # `Thread.current[:hecks_reaction_depth]`. This cop exists so the
-      # next plain ivar someone adds to either class gets flagged before
-      # it becomes the next instance of the same bug, rather than after.
-      #
-      # ## Scoped narrowly on purpose
-      #
-      # By class name
-      # (`Hecks::Runtime::Dispatcher`/`Hecks::Runtime::Registry`), not by
-      # blanket-flagging every ivar mutation in the codebase. Most classes
-      # in this codebase are not shared across threads (a fresh value
-      # object per call, a builder used once at boot) and ivar mutation
-      # there is completely ordinary Ruby with no hazard behind it at
-      # all — flagging it everywhere would be noise nobody trusts, the
-      # same reasoning `.rubocop.yml`'s own header gives for every other
-      # cop in this repo.
-      #
-      # ## What counts as "plain"
-      #
-      # `@ivar = ...`, `@ivar ||= ...`, `@ivar +=
-      # ...`, `@ivar << ...`, `@ivar[k] = v`. `initialize` is exempt — an
-      # ivar being set up for the first time, before any other thread can
-      # possibly hold a reference to this object, is not the hazard (see
-      # `Registry#initialize`'s own `@saga_mutex = Mutex.new`, which this
-      # cop must not flag). `Thread.current[...]`-backed state and a
-      # `Mutex`-guarded critical section are exactly the two idioms this
-      # codebase has already established for this — see `Dispatcher
-      # #reenter` and `Registry#saga_mutex` respectively — so the message
-      # points at both rather than inventing a third.
+      # Flags plain `@ivar` mutation inside the thread-shared `Dispatcher` and `Registry` classes.
+      # `initialize` is exempt; use `Thread.current[...]` or a `Mutex` elsewhere.
       #
       # @example
       #   # bad
-      #   class Dispatcher
-      #     def reenter(verb)
-      #       @reaction_depth = @reaction_depth.to_i + 1
-      #     end
-      #   end
+      #   @reaction_depth = @reaction_depth.to_i + 1
       #
       #   # good
-      #   class Dispatcher
-      #     def reenter(verb)
-      #       Thread.current[:hecks_reaction_depth] = Thread.current[:hecks_reaction_depth].to_i + 1
-      #     end
-      #   end
+      #   Thread.current[:hecks_reaction_depth] = Thread.current[:hecks_reaction_depth].to_i + 1
       class ThreadSharedIvarMutation < Base
         MSG = "`%<ivar>s` is a plain instance variable mutated outside `initialize` on " \
               "%<klass>s, which is shared across every thread dispatching through it " \
@@ -73,59 +23,33 @@ module RuboCop
 
         RESTRICT_ON_SEND = [:<<, :[]=].freeze
 
-        # Flags a plain `@ivar = ...` assignment inside a thread-shared class.
-        #
-        # @param node [RuboCop::AST::IvasgnNode] the ivar-assignment node being visited
-        # @return [void]
         def on_ivasgn(node)
-          # A plain `@x = 1` parses as `(ivasgn :@x (int 1))` — two
-          # children. The commissioner also visits the bare `(ivasgn :@x)`
-          # node nested one level inside an `op_asgn`/`or_asgn` (`@x += 1`,
-          # `@x ||= 1`) as its own `ivasgn` node with only one child — that
-          # one is handled by `on_op_asgn`/`on_or_asgn` below instead, so
-          # it's skipped here to avoid double-reporting the same mutation.
+          # Skips the bare one-child `ivasgn` nested in `op_asgn`/`or_asgn`; those handlers
+          # report it, so this avoids a double offense.
           return unless node.children.size == 2
 
           check(node, node.children.first)
         end
 
-        # Flags a plain `@ivar += ...` (or similar) compound assignment inside a
-        # thread-shared class.
-        #
-        # @param node [RuboCop::AST::OpAsgnNode] the compound-assignment node being visited
-        # @return [void]
         def on_op_asgn(node)
-          # `@x += 1` parses as `(op_asgn (ivasgn :@x) :+ (int 1))` — the
-          # target is an `ivasgn` node carrying just the name (no value
-          # child, unlike a plain `@x = 1`), not an `ivar` node.
+          # The target of `@x += 1` is a value-less `ivasgn` node, not an `ivar`.
           ivar_node = node.children.first
           return unless ivar_node.is_a?(RuboCop::AST::Node) && ivar_node.ivasgn_type?
 
           check(node, ivar_node.children.first)
         end
 
-        # Flags a plain `@ivar ||= ...` assignment inside a thread-shared class.
-        #
-        # @param node [RuboCop::AST::OrAsgnNode] the `||=` assignment node being visited
-        # @return [void]
         def on_or_asgn(node)
           on_op_asgn(node)
         end
 
-        # Flags a plain `@ivar << ...` or `@ivar[k] = v` mutation inside a thread-shared
-        # class.
-        #
-        # @param node [RuboCop::AST::SendNode] the `<<` or `[]=` send node being visited
-        # @return [void]
         def on_send(node)
           return unless RESTRICT_ON_SEND.include?(node.method_name)
 
           receiver = node.receiver
           return unless receiver
 
-          # `@ivar << x` — the receiver is the ivar.
-          # `@ivar[k] = v` — the receiver is a `send(@ivar, :[], k)`, whose
-          # own receiver is the ivar (`node.receiver.receiver`).
+          # `@ivar << x` has the ivar as receiver; `@ivar[k] = v` has it one `send` deeper.
           ivar_node = if receiver.ivar_type?
                         receiver
                       elsif receiver.send_type? && receiver.receiver&.ivar_type?
@@ -149,14 +73,7 @@ module RuboCop
           !!enclosing_class_name(node)&.then { |name| THREAD_SHARED_CLASSES.include?(name) }
         end
 
-        # Walks outward to the nearest enclosing `class` node and returns
-        # its own short name (`Dispatcher`, not the fully-qualified
-        # `Hecks::Runtime::Dispatcher`) — good enough to match this repo's
-        # own one-class-per-file layout without needing full namespace
-        # resolution, and avoids a false negative on `class Dispatcher`
-        # bodies that reopen the class from inside the `Hecks::Runtime`
-        # module (this repo's actual style) as much as one written as
-        # `class Hecks::Runtime::Dispatcher`.
+        # Uses the short class name so both nested and `Hecks::Runtime::Dispatcher` styles match.
         def enclosing_class_name(node)
           klass = node.each_ancestor(:class).first
           return nil unless klass
@@ -165,13 +82,7 @@ module RuboCop
           const_node.const_name.to_s.split("::").last
         end
 
-        # `initialize` is where an ivar is set up for the first time —
-        # before this object has been handed to a caller at all, so no
-        # other thread can hold a reference to mutate concurrently with
-        # it. Also exempts `initialize` methods defined on an object
-        # reopened via `class << self` or nested module — `each_ancestor`
-        # naturally stops at the nearest enclosing `def`, matching Ruby's
-        # own method-scoping.
+        # An ivar set in `initialize` cannot yet be shared with another thread.
         def inside_initialize?(node)
           def_node = node.each_ancestor(:def, :defs).first
           return false unless def_node

data/qa/settings.yml

@@ -0,0 +1,66 @@
+# Dials for the hecks_qa practice; edit values here and review the diff.
+# Meaning and rationale per key live in lib/hecks/quality_control/quality_control.bluebook;
+# loaded by Hecks::Fuzzing::QaSettings, which rejects missing, extra, or mistyped keys.
+#
+# automated_engineer stays a literal in the bluebook: spec/quality_control_spec.rb pins it.
+
+cadence_seconds: 0
+pr_cap_per_day: 0
+
+widening_tiers:
+  - { upto: 4,    seeds: 10, steps: 25 }
+  - { upto: 19,   seeds: 25, steps: 50 }
+  - { upto: .inf, seeds: 50, steps: 100 }
+
+sweep_max_parallel: 4
+liveness_fallback_seconds: 1500
+
+draft_only: false
+auto_merge: true
+branch_prefix: "qa/"
+
+adversarial_fraction: 0.3
+guided_generation: true
+corpus_splice_probability: 0.0
+favor_rare_verbs: 3
+self_consistency_checks: true
+shrink_budget: 200
+
+yield_weight_seconds: 1800
+yield_decay_percent: 50
+rotation_stale_floor_seconds: 21600
+
+persistence_parity_seed_cap: 5
+concurrency_seed_cap: 3
+
+adapter_parity_pairs:
+  persistence_parity:
+    left: memory
+    right: postgres_era
+  adapter_parity_sqlite:
+    left: memory
+    right: sqlite
+
+modes:
+  differential: true
+  ruby_only: true
+  self_consistency: true
+  properties_in_differential: true
+  structural_skip_report: true
+  adapter_parity_sqlite: false
+  persistence_parity: true
+  adapter_parity_postgres: false
+  era_boundary: false
+  concurrency: false
+  wasm_front: false
+
+role_draw_probability: 0.25
+dry_run_fraction: 0.10
+
+generated_domains_per_tick: 2
+generated_domains_rust: true
+generated_domain_seeds: 5
+
+# Construct families a sweep may skip. Shrink-only: spec/fuzzing/rust_gap_manifest_spec.rb fails
+# when a family here is not declared `generated: false` by a committed manifest.
+structural_refusal_boundary: []

data/rust/.cargo/config.toml

@@ -0,0 +1,6 @@
+# Links the main crate (rust/src/generated/, built by most ci.yml jobs) with lld.
+# It has no native C dependencies, so lld has nothing to trip over.
+#
+# Applies only when building for the linux target; a local macOS build never matches.
+[target.x86_64-unknown-linux-gnu]
+rustflags = ["-C", "link-arg=-fuse-ld=lld"]

data/rust/.gitignore

@@ -0,0 +1,2 @@
+/target
+/dist

data/rust/Cargo.lock

@@ -0,0 +1,54 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "memchr"
+version = "2.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
+
+[[package]]
+name = "regex"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
+
+[[package]]
+name = "rust"
+version = "0.1.0"
+dependencies = [
+ "regex",
+]

data/rust/Cargo.toml

@@ -0,0 +1,61 @@
+# Selects which domain's generated module `generated::active` re-exports
+# (rust/src/generated/mod.rs); hecks project_rust adds an entry per generated
+# domain and never removes one, since a domain's own directory is the
+# source of truth for whether it still exists. `default` tracks whichever
+# domain was generated most recently; any other stays reachable via
+# `--no-default-features --features <name>`.
+[features]
+default = ["read_model_on_target_fixture"]
+composite_line_ledger = []
+read_model_on_target_fixture = []
+group_by_collision_fixture = []
+compliance = []
+checkout_fixture = []
+embryonaut_vendoring_demo = []
+generated_route_append = []
+generated_entity_no_identity = []
+generated_revalued_shape = []
+generated_reaction_wording = []
+bug28_existence_fixture = []
+lease_clock = []
+referral_chain = []
+tenant_ledger = []
+corrections = []
+has_many_fixture = []
+ledger_ordering = []
+waybill = []
+nested_pieces = []
+chess = []
+roster = []
+meta = []
+pizzas = []
+banking = []
+
+[package]
+name = "rust"
+version = "0.1.0"
+edition = "2021"
+
+# The one dependency exception to this crate's zero-Cargo-dependency
+# discipline (ADR 0012): `expression_operators/pattern_match.rs`'s `.match?`
+# needs a real, audited regex engine. `default-features = false` keeps out
+# the SIMD-driven `perf` feature; `std`/`unicode` alone cover the Ruby-
+# Regexp-style `\d`/`\w`/case-insensitive matching this grammar's own
+# predicates use.
+[dependencies]
+regex = { version = "1", default-features = false, features = ["std", "unicode"] }
+
+[lib]
+name = "rust"
+path = "src/lib.rs"
+
+[[bin]]
+name = "rust"
+path = "src/main.rs"
+
+# CI runs every binary this crate produces once and throws it away, never
+# attaching a debugger, so the debuginfo a plain `cargo build`/`cargo test`
+# normally embeds is pure build time and disk cost with nothing reading it.
+# Only this dev profile is affected; release builds are unchanged.
+[profile.dev]
+debug = 0

data/rust/build/.cargo/config.toml

@@ -0,0 +1,3 @@
+# Link with lld; this crate has no native C library dependencies.
+[target.x86_64-unknown-linux-gnu]
+rustflags = ["-C", "link-arg=-fuse-ld=lld"]

data/rust/build/.gitignore

@@ -0,0 +1 @@
+/target

data/rust/build/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "hecks_build"
+version = "0.1.0"

data/rust/build/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "hecks_build"
+version = "0.1.0"
+edition = "2021"
+
+# Empty table makes this crate its own workspace root (own target/ and Cargo.lock).
+# Kept out of rust/src/ so this build-time orchestrator does not inflate the shipped artifacts.
+[workspace]
+
+[[bin]]
+name = "hecks-build"
+path = "src/main.rs"
+
+# No dependencies beyond std: this crate only shells out and never ships in a deployed artifact.
+[dependencies]
+
+# Debug info is off: CI binaries are run once and never attached to a debugger.
+[profile.dev]
+debug = 0

data/rust/build/src/build_artifact.rs

@@ -0,0 +1,47 @@
+//! Runs `cargo build` for the generated domain crate, native or WASM.
+
+use std::path::Path;
+
+use crate::subprocess;
+
+/// Runs `cargo build --release` in `rust_dir`, building the `default` feature that
+/// `cargo_sync::run` just set.
+pub fn build_native(rust_dir: &Path) -> Result<(), String> {
+    println!("== cargo build --release (native) ==");
+    subprocess::run_in(rust_dir, "cargo", &["build", "--release"])
+}
+
+/// Cross-compiles to `wasm32-wasip1` and copies the `.wasm` plus its `ir.json` sidecar
+/// into `rust/dist/`.
+///
+/// Builds through `rustup run stable cargo`: a Homebrew `cargo` earlier on the path never
+/// saw `rustup target add` and fails opaquely.
+pub fn build_wasm(root: &Path, rust_dir: &Path, target_mod_name: &str) -> Result<(), String> {
+    let installed = subprocess::run_capture("rustup", &["target", "list", "--installed"])
+        .map_err(|e| format!("checking installed rustup targets: {e}"))?;
+    if !installed.lines().any(|l| l.trim() == "wasm32-wasip1") {
+        return Err(
+            "wasm32-wasip1 isn't installed for this toolchain (environment limitation, not a code bug) — install it once with:\n\n    rustup target add wasm32-wasip1\n\nthen re-run hecks-build --wasm.".to_string(),
+        );
+    }
+
+    println!("== cargo build --release --target wasm32-wasip1 (via rustup run stable) ==");
+    subprocess::run_in(rust_dir, "rustup", &["run", "stable", "cargo", "build", "--release", "--target", "wasm32-wasip1"])?;
+
+    let dist_dir = root.join("rust/dist");
+    std::fs::create_dir_all(&dist_dir).map_err(|e| format!("creating {}: {e}", dist_dir.display()))?;
+
+    let built = rust_dir.join("target/wasm32-wasip1/release/rust.wasm");
+    let out = dist_dir.join(format!("{target_mod_name}.wasm"));
+    std::fs::copy(&built, &out).map_err(|e| format!("copying {} to {}: {e}", built.display(), out.display()))?;
+    println!("wrote {}", out.display());
+
+    let ir_json = root.join("rust/src/generated").join(target_mod_name).join("ir.json");
+    if ir_json.is_file() {
+        let ir_out = dist_dir.join(format!("{target_mod_name}.ir.json"));
+        std::fs::copy(&ir_json, &ir_out).map_err(|e| format!("copying {} to {}: {e}", ir_json.display(), ir_out.display()))?;
+        println!("wrote {}", ir_out.display());
+    }
+
+    Ok(())
+}