tawasuyu/brahman
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(minga-core): cierre del α-hashing de Rust — if let, while let, let-else, or-pattern, let-chains

Browse Source 
Cierra los 5 pendientes documentados en alpha.rs. El hash
alpha-equivalente ahora es estable bajo renombre de TODOS los binders
de Rust, no solo los del MVP (params, let, for, match arms).

Pendientes cerrados:
- if let X = expr { ... }: if_expression detecta let_condition en
  condition, recolecta binders del pattern, los propaga al
  consequence. Alternative (else) no los ve.
- while let X = expr { ... }: simetrico al if-let, propaga al body.
- let-else: ya funcionaba por construccion (alternative procesado en
  scope antes que feed_block extienda con los binders).
- or_pattern: ambos lados introducen los mismos binders (Rust
  enforcement). Emit recorre todos, collect solo el primero para no
  duplicar.
- let-chains (if let X = a && let Y = b): collect_let_condition_binders
  recursa en el arbol del condition capturando todos los let_condition
  vivan donde vivan (binary_expression u otros).

Helper nuevo: feed_let_condition para que el pattern del let_condition
pase por feed_pattern (que distingue binders de constructors). Sin
esto, los identifiers del pattern se hasheaban como variables libres
y Some(x) != Some(y) aun teniendo el mismo significado.

Tests: 6 nuevos en alpha_invariants:
- alpha_if_let_binder_rename_invariant
- alpha_if_let_else_does_not_see_binder
- alpha_while_let_binder_rename_invariant
- alpha_let_else_binder_rename_invariant
- alpha_or_pattern_binder_rename_invariant
- alpha_let_chain_binders_propagate_to_consequence
- alpha_if_let_does_not_collide_with_unrelated_program (negativo)

36 tests alpha verdes. 115 totales en minga-core.

Refactorings del tipo "rename variable" no inflan el storage del
repo. Pendiente futuro: alpha-hashing per-language (Python, TS, JS,
Go) — cada uno requiere conocimiento profundo de su gramatica.
This commit is contained in:
Sergio
2026-05-09 17:21:25 +00:00
parent 4db168253c
commit d1888e0901
3 changed files with 301 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/modules/semantic_dht/minga-core/src/alpha.rs
+126 -2
View File
@@ -30,8 +30,17 @@
//! (`n @ pat`), `range_pattern`, `slice_pattern`, `ref_pattern`,
//! `reference_pattern`, `mut_pattern`.
//!
//! **Pendiente:** `if let`, `while let`, `let-else`, let-chains, `or_pattern`
//! con bindings (Rust requiere mismas variables en cada rama).
//! **Cobertura adicional (este módulo cierra el plan):**
//! - `if_expression` y `while_expression` detectan `let_condition`
//! en su `condition` y propagan los binders al `consequence`/`body`.
//! Cubre `if let`, `while let` y let-chains (`let X && let Y`).
//! - `let_declaration` con `alternative` (let-else): el alternative
//! se procesa en el scope SIN los binders del pattern (Rust no
//! los ve en la rama de fallo). Funciona naturalmente porque
//! `feed_let` no extiende scope; el block padre lo hace después.
//! - `or_pattern`: todos los lados tienen los mismos binders (Rust
//! enforcement); recolectamos sólo del primer alternativo para
//! evitar duplicados, emitimos feed_pattern para cada uno.
use crate::ast::SemanticNode;
use crate::cas::ContentHash;
@@ -57,6 +66,9 @@ fn feed(h: &mut Hasher, node: &SemanticNode, scope: &mut Vec<String>) {
"function_item" | "closure_expression" => feed_callable(h, node, scope),
"block" => feed_block(h, node, scope),
"for_expression" => feed_for(h, node, scope),
"if_expression" => feed_if_expression(h, node, scope),
"while_expression" => feed_while_expression(h, node, scope),
"let_condition" => feed_let_condition(h, node, scope),
"match_arm" => feed_match_arm(h, node, scope),
"identifier" if node.field_name.as_deref() == Some("pattern") => emit_binder_body(h),
"identifier" => emit_identifier_ref(h, node, scope),
@@ -64,6 +76,93 @@ fn feed(h: &mut Hasher, node: &SemanticNode, scope: &mut Vec<String>) {
}
}
/// Dentro de un `let_condition` (`if let X = expr`, `while let X = expr`,
/// let-chains), el `pattern` debe pasar por `feed_pattern` para que los
/// identifiers del pattern se emitan como TAG_BINDER (anónimos), no
/// como referencias libres. El `value` y demás children van por feed
/// normal.
fn feed_let_condition(h: &mut Hasher, node: &SemanticNode, scope: &mut Vec<String>) {
h.update(&[TAG_NO_LEAF]);
h.update(&(node.children.len() as u64).to_le_bytes());
for c in &node.children {
if c.field_name.as_deref() == Some("pattern") {
feed_pattern(h, c);
} else {
feed(h, c, scope);
}
}
}
/// Maneja `if let X = expr { ... }` y let-chains (`if let X = a && let Y = b`).
/// Los binders del/los `let_condition`(s) se acumulan y se propagan
/// SÓLO al `consequence` (no al `alternative`, que es el `else`).
fn feed_if_expression(h: &mut Hasher, node: &SemanticNode, scope: &mut Vec<String>) {
h.update(&[TAG_NO_LEAF]);
let mut binders: Vec<String> = Vec::new();
for c in &node.children {
if c.field_name.as_deref() == Some("condition") {
collect_let_condition_binders(c, &mut binders);
}
}
h.update(&(node.children.len() as u64).to_le_bytes());
for c in &node.children {
match c.field_name.as_deref() {
Some("consequence") => {
let scope_before = scope.len();
scope.extend(binders.iter().cloned());
feed(h, c, scope);
scope.truncate(scope_before);
}
_ => feed(h, c, scope),
}
}
}
/// Maneja `while let X = expr { ... }`. Los binders del `let_condition`
/// se propagan SÓLO al `body` (no al `condition` mismo, que se evalúa
/// con el scope previo).
fn feed_while_expression(h: &mut Hasher, node: &SemanticNode, scope: &mut Vec<String>) {
h.update(&[TAG_NO_LEAF]);
let mut binders: Vec<String> = Vec::new();
for c in &node.children {
if c.field_name.as_deref() == Some("condition") {
collect_let_condition_binders(c, &mut binders);
}
}
h.update(&(node.children.len() as u64).to_le_bytes());
for c in &node.children {
match c.field_name.as_deref() {
Some("body") => {
let scope_before = scope.len();
scope.extend(binders.iter().cloned());
feed(h, c, scope);
scope.truncate(scope_before);
}
_ => feed(h, c, scope),
}
}
}
/// Recolecta binders de patterns dentro de cualquier `let_condition`
/// nested en `node`. Para let-chains (`let X = a && let Y = b`),
/// recursa en el árbol del condition para capturar todos.
fn collect_let_condition_binders(node: &SemanticNode, out: &mut Vec<String>) {
if node.kind == "let_condition" {
for c in &node.children {
if c.field_name.as_deref() == Some("pattern") {
collect_pattern_binders(c, out);
}
}
}
for c in &node.children {
collect_let_condition_binders(c, out);
}
}
fn feed_default(h: &mut Hasher, node: &SemanticNode, scope: &mut Vec<String>) {
emit_leaf_marker(h, node);
h.update(&(node.children.len() as u64).to_le_bytes());
@@ -306,6 +405,17 @@ fn feed_pattern(h: &mut Hasher, node: &SemanticNode) {
feed_pattern(h, c);
}
}
"or_pattern" => {
// Cada lado del or-pattern debe introducir el mismo set
// de binders (Rust enforcement). Emitimos cada rama pero
// sólo recolectaremos binders de la primera —
// la responsabilidad recae en `collect_pattern_binders`.
h.update(&[TAG_NO_LEAF]);
h.update(&(node.children.len() as u64).to_le_bytes());
for c in &node.children {
feed_pattern(h, c);
}
}
"tuple_struct_pattern" => {
h.update(&[TAG_NO_LEAF]);
h.update(&(node.children.len() as u64).to_le_bytes());
@@ -409,6 +519,20 @@ fn collect_pattern_binders(p: &SemanticNode, out: &mut Vec<String>) {
collect_pattern_binders(c, out);
}
}
"or_pattern" => {
// Sólo recolectamos del primer alternativo: Rust exige
// que todos los lados introduzcan exactamente los mismos
// binders, así que el primero es representativo. Iterar
// todos duplicaría los nombres y rompería los índices
// de Bruijn en el cuerpo.
if let Some(first) = p
.children
.iter()
.find(|c| !matches!(c.kind.as_str(), "|" | "or"))
{
collect_pattern_binders(first, out);
}
}
"tuple_struct_pattern" => {
for c in &p.children {
if c.field_name.as_deref() != Some("type") {
crates/modules/semantic_dht/minga-core/tests/alpha_invariants.rs
+115
View File
@@ -250,3 +250,118 @@ fn alpha_match_constructor_vs_binder() {
parse::rust("fn f(v: Option<i32>) -> i32 { match v { x => 0, Some(z) => z } }").unwrap();
assert_ne!(hash_node_alpha(&a), hash_node_alpha(&b));
}
// ====================================================================
// Pendientes documentados — cierre del MVP de α-Rust.
// ====================================================================
#[test]
fn alpha_if_let_binder_rename_invariant() {
// El binder de `if let Some(x) = v` participa sólo del consequence.
// Renombrar x por y no debe afectar el hash.
let a = parse::rust(
"fn f(v: Option<i32>) -> i32 { if let Some(x) = v { x + 1 } else { 0 } }",
)
.unwrap();
let b = parse::rust(
"fn f(v: Option<i32>) -> i32 { if let Some(y) = v { y + 1 } else { 0 } }",
)
.unwrap();
assert_eq!(hash_node_alpha(&a), hash_node_alpha(&b));
}
#[test]
fn alpha_if_let_else_does_not_see_binder() {
// Sanity: el binder NO debe visitar el `else` (alternative). En
// `if let Some(x) = v { ... } else { v }`, el `else` ve `v` libre.
// Si renombramos sólo en el consequence, da el mismo hash.
let a = parse::rust(
"fn f(v: Option<i32>) -> i32 { if let Some(x) = v { x } else { 0 } }",
)
.unwrap();
let b = parse::rust(
"fn f(v: Option<i32>) -> i32 { if let Some(y) = v { y } else { 0 } }",
)
.unwrap();
assert_eq!(hash_node_alpha(&a), hash_node_alpha(&b));
}
#[test]
fn alpha_while_let_binder_rename_invariant() {
// El binder del while-let vive sólo en el body.
let a = parse::rust(
"fn f(mut it: Option<i32>) -> i32 { let mut total = 0; while let Some(x) = it { total += x; it = None; } total }",
)
.unwrap();
let b = parse::rust(
"fn f(mut it: Option<i32>) -> i32 { let mut total = 0; while let Some(y) = it { total += y; it = None; } total }",
)
.unwrap();
assert_eq!(hash_node_alpha(&a), hash_node_alpha(&b));
}
#[test]
fn alpha_let_else_binder_rename_invariant() {
// let-else: el binder vive sólo después del let, no en el else.
let a = parse::rust(
"fn f(v: Option<i32>) -> i32 { let Some(x) = v else { return 0 }; x + 1 }",
)
.unwrap();
let b = parse::rust(
"fn f(v: Option<i32>) -> i32 { let Some(y) = v else { return 0 }; y + 1 }",
)
.unwrap();
assert_eq!(hash_node_alpha(&a), hash_node_alpha(&b));
}
#[test]
fn alpha_or_pattern_binder_rename_invariant() {
// En un or-pattern (`Some(x) | Other(x)`), todos los lados
// introducen el mismo binder. Renombrar afecta a TODOS los lados
// a la vez. El hash se mantiene.
let a = parse::rust(
r#"
enum E { A(i32), B(i32) }
fn f(v: E) -> i32 { match v { E::A(x) | E::B(x) => x } }
"#,
)
.unwrap();
let b = parse::rust(
r#"
enum E { A(i32), B(i32) }
fn f(v: E) -> i32 { match v { E::A(y) | E::B(y) => y } }
"#,
)
.unwrap();
assert_eq!(hash_node_alpha(&a), hash_node_alpha(&b));
}
#[test]
fn alpha_let_chain_binders_propagate_to_consequence() {
// Let-chain: dos let-conditions con &&. Ambos binders viven en
// el consequence. Renombrar ambos da mismo hash.
let a = parse::rust(
"fn f(a: Option<i32>, b: Option<i32>) -> i32 { if let Some(x) = a && let Some(y) = b { x + y } else { 0 } }",
)
.unwrap();
let c = parse::rust(
"fn f(a: Option<i32>, b: Option<i32>) -> i32 { if let Some(p) = a && let Some(q) = b { p + q } else { 0 } }",
)
.unwrap();
assert_eq!(hash_node_alpha(&a), hash_node_alpha(&c));
}
#[test]
fn alpha_if_let_does_not_collide_with_unrelated_program() {
// Sanity negativo: dos programas con `if let` distintos
// (operación distinta) NO deben dar el mismo hash.
let plus = parse::rust(
"fn f(v: Option<i32>) -> i32 { if let Some(x) = v { x + 1 } else { 0 } }",
)
.unwrap();
let minus = parse::rust(
"fn f(v: Option<i32>) -> i32 { if let Some(x) = v { x - 1 } else { 0 } }",
)
.unwrap();
assert_ne!(hash_node_alpha(&plus), hash_node_alpha(&minus));
}