diff --git a/crates/rue-compiler/src/canonical_semantic.rs b/crates/rue-compiler/src/canonical_semantic.rs index 3ad457aed..aa817234c 100644 --- a/crates/rue-compiler/src/canonical_semantic.rs +++ b/crates/rue-compiler/src/canonical_semantic.rs @@ -796,21 +796,6 @@ impl CanonicalSemanticOutput { pub fn body_named_dependencies(&self) -> &[BodyNamedDependencyEvent] { &self.body_named_dependencies } - pub fn named_method_dependencies(&self) -> &[NamedMethodDependencyEvent] { - &self.named_method_dependencies - } - pub fn non_generic_named_method_dependencies_complete(&self) -> bool { - self.non_generic_named_method_dependencies_complete - } - pub fn generic_named_method_dependencies_complete(&self) -> bool { - self.generic_named_method_dependencies_complete - } - pub fn named_destructor_dependencies(&self) -> &[NamedDestructorDependencyEvent] { - &self.named_destructor_dependencies - } - pub fn named_destructor_dependencies_complete(&self) -> bool { - self.named_destructor_dependencies_complete - } pub fn declaration_type_dependencies(&self) -> &[DeclarationTypeDependencyEvent] { &self.declaration_type_dependencies } diff --git a/crates/rue-compiler/src/lib.rs b/crates/rue-compiler/src/lib.rs index 34384e2ea..d50905519 100644 --- a/crates/rue-compiler/src/lib.rs +++ b/crates/rue-compiler/src/lib.rs @@ -183,8 +183,7 @@ pub(crate) use session::{ StableDeclarationTypeCallHeadDependency, StableDeclarationTypeDependency, StableDefinitionFingerprint, StableDefinitionFingerprintPrecision, StableDefinitionInputFingerprint, StableFreeFunctionDependency, StableModuleImportDependency, - StableNamedConstDependency, StableNamedConstDependencyTarget, StableNamedDestructorDependency, - StableNamedMethodDependency, StableNamedMethodDependencyTarget, + StableNamedConstDependency, StableNamedConstDependencyTarget, }; #[cfg(test)] pub(crate) use source_identity::LinkInputDescriptor; diff --git a/crates/rue-compiler/src/session.rs b/crates/rue-compiler/src/session.rs index e69168c30..1e0456563 100644 --- a/crates/rue-compiler/src/session.rs +++ b/crates/rue-compiler/src/session.rs @@ -511,8 +511,6 @@ pub const FRONTEND_INVALIDATION_PLAN_RETENTION_LIMIT: usize = 8; pub struct SemanticDependencyManifestWork { pub definition_records_visited: usize, pub import_records_visited: usize, - pub named_method_events_translated: usize, - pub named_destructor_events_translated: usize, pub declaration_type_events_translated: usize, pub declaration_type_call_head_events_translated: usize, pub builtin_type_call_head_inputs_translated: usize, @@ -531,24 +529,6 @@ pub struct StableFreeFunctionDependency { pub callee: StableDefinitionKey, } -#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub enum StableNamedMethodDependencyTarget { - FreeFunction(StableDefinitionKey), - NamedMethod(StableDefinitionKey), -} - -#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct StableNamedMethodDependency { - pub caller: StableDefinitionKey, - pub target: StableNamedMethodDependencyTarget, -} - -#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct StableNamedDestructorDependency { - pub caller: StableDefinitionKey, - pub target: StableNamedMethodDependencyTarget, -} - #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct StableImplicitNamedDestructorDependency { pub source: StableDefinitionKey, @@ -679,9 +659,7 @@ pub enum StableModuleImportDependency { pub enum SemanticDependencySurface { BodyOwner, FreeFunctionCall, - NonGenericNamedMethodCall, GenericNamedMethodCall, - NamedDestructorCall, ImplicitNamedDestructor, DeclarationType, DeclarationTypeCallHead, @@ -695,7 +673,6 @@ pub enum SemanticDependencyIncompleteReason { AnonymousBodyOwnerUnavailable, CallerEndpointUnavailable, GenericSubstitutionIdentityUnavailable, - DestructorEndpointUnavailable, AnonymousDropOwnerUnavailable, ResolvedTypeIdentityUnavailable, TypeCallHeadIdentityUnavailable, @@ -814,9 +791,7 @@ impl SemanticDependencyGraphState { match blocker.surface { SemanticDependencySurface::BodyOwner | SemanticDependencySurface::FreeFunctionCall - | SemanticDependencySurface::NonGenericNamedMethodCall | SemanticDependencySurface::GenericNamedMethodCall - | SemanticDependencySurface::NamedDestructorCall | SemanticDependencySurface::ImplicitNamedDestructor | SemanticDependencySurface::DeclarationType | SemanticDependencySurface::DeclarationTypeCallHead @@ -865,8 +840,6 @@ pub struct SemanticDependencyInputManifest { definition_fingerprints: Arc<[StableDefinitionInputFingerprint]>, module_imports: Arc<[StableModuleImportDependency]>, free_function_dependencies: Arc<[StableFreeFunctionDependency]>, - named_method_dependencies: Arc<[StableNamedMethodDependency]>, - named_destructor_dependencies: Arc<[StableNamedDestructorDependency]>, implicit_named_destructor_dependencies: Arc<[StableImplicitNamedDestructorDependency]>, declaration_type_dependencies: Arc<[StableDeclarationTypeDependency]>, declaration_type_call_head_dependencies: Arc<[StableDeclarationTypeCallHeadDependency]>, @@ -908,11 +881,6 @@ impl std::fmt::Debug for SemanticDependencyInputManifest { "free_function_dependencies", &self.free_function_dependencies, ) - .field("named_method_dependencies", &self.named_method_dependencies) - .field( - "named_destructor_dependencies", - &self.named_destructor_dependencies, - ) .field( "implicit_named_destructor_dependencies", &self.implicit_named_destructor_dependencies, @@ -965,21 +933,6 @@ impl SemanticDependencyInputManifest { pub fn free_function_caller_dependencies_complete(&self) -> bool { self.surface_complete(SemanticDependencySurface::FreeFunctionCall) } - pub fn named_method_dependencies(&self) -> &[StableNamedMethodDependency] { - &self.named_method_dependencies - } - pub fn non_generic_named_method_dependencies_complete(&self) -> bool { - self.surface_complete(SemanticDependencySurface::NonGenericNamedMethodCall) - } - pub fn generic_named_method_dependencies_complete(&self) -> bool { - self.surface_complete(SemanticDependencySurface::GenericNamedMethodCall) - } - pub fn named_destructor_dependencies(&self) -> &[StableNamedDestructorDependency] { - &self.named_destructor_dependencies - } - pub fn named_destructor_dependencies_complete(&self) -> bool { - self.surface_complete(SemanticDependencySurface::NamedDestructorCall) - } pub fn implicit_named_destructor_dependencies( &self, ) -> &[StableImplicitNamedDestructorDependency] { @@ -7387,23 +7340,16 @@ impl CompilerSession { definition_fingerprints.push(stable_definition_input_fingerprint(&snapshot, record)?); } let ( - mut named_method_dependencies, - mut named_destructor_dependencies, mut declaration_type_dependencies, mut declaration_type_call_head_dependencies, mut builtin_type_call_head_inputs, mut named_const_dependencies, mut implicit_named_destructor_dependencies, - named_method_events_translated, - named_destructor_events_translated, declaration_type_events_translated, declaration_type_call_head_events_translated, builtin_type_call_head_inputs_translated, named_const_events_translated, implicit_named_destructor_events_translated, - named_method_dependencies_complete, - generic_named_method_dependencies_complete, - named_destructor_dependencies_complete, declaration_type_dependencies_complete, declaration_type_call_head_dependencies_complete, supported_type_call_heads_complete, @@ -7421,65 +7367,6 @@ impl CompilerSession { "semantic dependency translation used a stale body-owner issuer revision", )); } - let mut method_edges = Vec::new(); - for event in semantic.named_method_dependencies() { - let provenance = stable_named_method_endpoint( - definitions, - event.caller_file, - &event.caller_owner_name, - &event.caller_method_name, - )?; - let caller = stable_token_endpoint(semantic, event.caller_token, &provenance)?; - let target = match &event.target { - rue_air::NamedMethodDependencyTargetEvent::FreeFunction { file, name } => { - StableNamedMethodDependencyTarget::FreeFunction( - stable_free_function_endpoint(definitions, *file, name)?, - ) - } - rue_air::NamedMethodDependencyTargetEvent::NamedMethod { - file, - owner_name, - method_name, - } => StableNamedMethodDependencyTarget::NamedMethod( - stable_named_method_endpoint( - definitions, - *file, - owner_name, - method_name, - )?, - ), - }; - method_edges.push(StableNamedMethodDependency { caller, target }); - } - let mut destructor_edges = Vec::new(); - for event in semantic.named_destructor_dependencies() { - let provenance = stable_named_destructor_endpoint( - definitions, - event.caller_file, - &event.caller_owner_name, - )?; - let caller = stable_token_endpoint(semantic, event.caller_token, &provenance)?; - let target = match &event.target { - rue_air::NamedMethodDependencyTargetEvent::FreeFunction { file, name } => { - StableNamedMethodDependencyTarget::FreeFunction( - stable_free_function_endpoint(definitions, *file, name)?, - ) - } - rue_air::NamedMethodDependencyTargetEvent::NamedMethod { - file, - owner_name, - method_name, - } => StableNamedMethodDependencyTarget::NamedMethod( - stable_named_method_endpoint( - definitions, - *file, - owner_name, - method_name, - )?, - ), - }; - destructor_edges.push(StableNamedDestructorDependency { caller, target }); - } let mut type_edges = Vec::new(); for event in semantic.declaration_type_dependencies() { let provenance = stable_declaration_source_endpoint(definitions, event)?; @@ -7621,15 +7508,11 @@ impl CompilerSession { }); } ( - method_edges, - destructor_edges, type_edges, type_call_head_edges, builtin_head_inputs, const_edges, implicit_destructor_edges, - semantic.named_method_dependencies().len(), - semantic.named_destructor_dependencies().len(), semantic.declaration_type_dependencies().len(), semantic.declaration_type_call_head_dependencies().len(), semantic @@ -7637,9 +7520,6 @@ impl CompilerSession { .len(), semantic.named_const_dependencies().len(), semantic.implicit_named_destructor_dependencies().len(), - semantic.non_generic_named_method_dependencies_complete(), - semantic.generic_named_method_dependencies_complete(), - semantic.named_destructor_dependencies_complete(), semantic.declaration_type_dependencies_complete(), semantic.declaration_type_call_head_dependencies_complete(), semantic.supported_type_call_heads_complete(), @@ -7653,10 +7533,6 @@ impl CompilerSession { Vec::new(), Vec::new(), Vec::new(), - Vec::new(), - Vec::new(), - 0, - 0, 0, 0, 0, @@ -7667,9 +7543,6 @@ impl CompilerSession { false, false, false, - false, - false, - false, ), }; // RUE-1027: body call edges have one production authority — the @@ -7773,10 +7646,6 @@ impl CompilerSession { body_named_dependencies.dedup(); free_function_dependencies.sort(); free_function_dependencies.dedup(); - named_method_dependencies.sort(); - named_method_dependencies.dedup(); - named_destructor_dependencies.sort(); - named_destructor_dependencies.dedup(); declaration_type_dependencies.sort(); declaration_type_dependencies.dedup(); declaration_type_call_head_dependencies.sort(); @@ -7809,21 +7678,6 @@ impl CompilerSession { SemanticDependencySurface::FreeFunctionCall, SemanticDependencyIncompleteReason::CallerEndpointUnavailable, ); - block_body_surface( - named_method_dependencies_complete, - SemanticDependencySurface::NonGenericNamedMethodCall, - SemanticDependencyIncompleteReason::CallerEndpointUnavailable, - ); - block_body_surface( - generic_named_method_dependencies_complete, - SemanticDependencySurface::GenericNamedMethodCall, - SemanticDependencyIncompleteReason::GenericSubstitutionIdentityUnavailable, - ); - block_body_surface( - named_destructor_dependencies_complete, - SemanticDependencySurface::NamedDestructorCall, - SemanticDependencyIncompleteReason::DestructorEndpointUnavailable, - ); block_body_surface( implicit_named_destructor_dependencies_complete, SemanticDependencySurface::ImplicitNamedDestructor, @@ -7879,24 +7733,6 @@ impl CompilerSession { .filter(|edge| &edge.caller == owner) .map(|edge| edge.callee.clone()), ); - for edge in named_method_dependencies - .iter() - .filter(|edge| &edge.caller == owner) - { - direct_dependencies.push(match &edge.target { - StableNamedMethodDependencyTarget::FreeFunction(target) - | StableNamedMethodDependencyTarget::NamedMethod(target) => target.clone(), - }); - } - for edge in named_destructor_dependencies - .iter() - .filter(|edge| &edge.caller == owner) - { - direct_dependencies.push(match &edge.target { - StableNamedMethodDependencyTarget::FreeFunction(target) - | StableNamedMethodDependencyTarget::NamedMethod(target) => target.clone(), - }); - } direct_dependencies.extend( implicit_named_destructor_dependencies .iter() @@ -8096,8 +7932,6 @@ impl CompilerSession { let work = SemanticDependencyManifestWork { definition_records_visited: partial_work.definition_records_visited, import_records_visited: partial_work.import_records_visited, - named_method_events_translated, - named_destructor_events_translated, declaration_type_events_translated, declaration_type_call_head_events_translated, builtin_type_call_head_inputs_translated, @@ -8155,21 +7989,6 @@ impl CompilerSession { SemanticDependencySurface::FreeFunctionCall, SemanticDependencyIncompleteReason::CallerEndpointUnavailable, ); - block( - named_method_dependencies_complete, - SemanticDependencySurface::NonGenericNamedMethodCall, - SemanticDependencyIncompleteReason::CallerEndpointUnavailable, - ); - block( - generic_named_method_dependencies_complete, - SemanticDependencySurface::GenericNamedMethodCall, - SemanticDependencyIncompleteReason::GenericSubstitutionIdentityUnavailable, - ); - block( - named_destructor_dependencies_complete, - SemanticDependencySurface::NamedDestructorCall, - SemanticDependencyIncompleteReason::DestructorEndpointUnavailable, - ); block( implicit_named_destructor_dependencies_complete, SemanticDependencySurface::ImplicitNamedDestructor, @@ -8202,8 +8021,6 @@ impl CompilerSession { definition_fingerprints: definition_fingerprints.into(), module_imports: module_imports.into(), free_function_dependencies: free_function_dependencies.into(), - named_method_dependencies: named_method_dependencies.into(), - named_destructor_dependencies: named_destructor_dependencies.into(), implicit_named_destructor_dependencies: implicit_named_destructor_dependencies.into(), declaration_type_dependencies: declaration_type_dependencies.into(), declaration_type_call_head_dependencies: declaration_type_call_head_dependencies.into(), @@ -8505,20 +8322,6 @@ fn collect_reverse_dependencies( for edge in manifest.free_function_dependencies.iter() { add(&edge.caller, &edge.callee); } - for edge in manifest.named_method_dependencies.iter() { - let target = match &edge.target { - StableNamedMethodDependencyTarget::FreeFunction(key) - | StableNamedMethodDependencyTarget::NamedMethod(key) => key, - }; - add(&edge.caller, target); - } - for edge in manifest.named_destructor_dependencies.iter() { - let target = match &edge.target { - StableNamedMethodDependencyTarget::FreeFunction(key) - | StableNamedMethodDependencyTarget::NamedMethod(key) => key, - }; - add(&edge.caller, target); - } for edge in manifest.implicit_named_destructor_dependencies.iter() { add(&edge.source, &edge.target); } @@ -14901,18 +14704,10 @@ fn main() -> i32 { SemanticDependencySurface::FreeFunctionCall, SemanticDependencyIncompleteReason::CallerEndpointUnavailable, ), - ( - SemanticDependencySurface::NonGenericNamedMethodCall, - SemanticDependencyIncompleteReason::CallerEndpointUnavailable, - ), ( SemanticDependencySurface::GenericNamedMethodCall, SemanticDependencyIncompleteReason::GenericSubstitutionIdentityUnavailable, ), - ( - SemanticDependencySurface::NamedDestructorCall, - SemanticDependencyIncompleteReason::DestructorEndpointUnavailable, - ), ( SemanticDependencySurface::ImplicitNamedDestructor, SemanticDependencyIncompleteReason::AnonymousDropOwnerUnavailable, @@ -14957,6 +14752,59 @@ fn main() -> i32 { } } + /// RUE-1209: the manifest no longer projects named-method or + /// named-destructor edges, so a method body's calls reach invalidation + /// only through the query-owned body references. Editing a callee must + /// still close over the calling method, the calling destructor, and their + /// own callers. + #[test] + fn incremental_invalidation_closes_across_method_and_destructor_bodies() { + let build = |leaf_value: i32| { + let source = format!( + "fn leaf() -> i32 {{ {leaf_value} }}\n\ + fn sink() {{}}\n\ + struct Value {{ fn run(borrow self) -> i32 {{ leaf() }} }}\n\ + drop fn Value(self) {{ sink(); }}\n\ + fn unaffected() -> i32 {{ 7 }}\n\ + fn main() -> i32 {{ let value = Value {{}}; value.run() }}" + ); + let source = snapshot(&[(1, "/p/main.rue", "main.rue", source.as_str())], 1); + let mut session = CompilerSession::new(); + publish_with_test_imports(&mut session, &source); + session + .canonical_semantic(&CompileOptions::default()) + .unwrap(); + session + .semantic_dependency_inputs(&CompileOptions::default(), None) + .unwrap() + }; + let previous = build(1); + let current = build(2); + let plan = plan_semantic_invalidation(&previous, ¤t); + + assert_eq!(plan.scope(), &SemanticInvalidationScope::Incremental); + assert_eq!( + plan.changed() + .iter() + .map(|key| key.name()) + .collect::>(), + ["leaf"] + ); + // `run` calls `leaf`, and `main` calls `run`. Both close transitively + // even though no named-method edge is projected. + let mut invalidated = plan + .invalidated() + .iter() + .map(|key| key.name()) + .collect::>(); + invalidated.sort_unstable(); + assert_eq!(invalidated, ["leaf", "main", "run"]); + assert!( + plan.reusable().iter().any(|key| key.name() == "unaffected"), + "an unrelated function stays reusable" + ); + } + #[test] fn incremental_invalidation_closes_transitively_across_module_call_edges() { let build = |leaf_value: i32| { @@ -15208,10 +15056,8 @@ fn main() -> i32 { } #[test] - fn stable_named_method_dependency_is_send_and_sync() { + fn stable_named_const_dependency_is_send_and_sync() { fn assert_send_sync() {} - assert_send_sync::(); - assert_send_sync::(); assert_send_sync::(); assert_send_sync::(); assert_send_sync::(); diff --git a/crates/rue-compiler/src/unstable.rs b/crates/rue-compiler/src/unstable.rs index de7bb77b1..c35790f99 100644 --- a/crates/rue-compiler/src/unstable.rs +++ b/crates/rue-compiler/src/unstable.rs @@ -1756,12 +1756,6 @@ impl DependencyBaseline { pub fn free_function_dependencies(&self) -> String { format!("{:?}", self.inner.free_function_dependencies()) } - pub fn named_method_dependencies(&self) -> String { - format!("{:?}", self.inner.named_method_dependencies()) - } - pub fn named_destructor_dependencies(&self) -> String { - format!("{:?}", self.inner.named_destructor_dependencies()) - } pub fn implicit_named_destructor_dependencies(&self) -> String { format!("{:?}", self.inner.implicit_named_destructor_dependencies()) } @@ -1789,15 +1783,6 @@ impl DependencyBaseline { pub fn free_function_caller_dependencies_complete(&self) -> bool { self.inner.free_function_caller_dependencies_complete() } - pub fn non_generic_named_method_dependencies_complete(&self) -> bool { - self.inner.non_generic_named_method_dependencies_complete() - } - pub fn generic_named_method_dependencies_complete(&self) -> bool { - self.inner.generic_named_method_dependencies_complete() - } - pub fn named_destructor_dependencies_complete(&self) -> bool { - self.inner.named_destructor_dependencies_complete() - } pub fn implicit_named_destructor_dependencies_complete(&self) -> bool { self.inner.implicit_named_destructor_dependencies_complete() } @@ -1826,9 +1811,7 @@ impl DependencyBaseline { pub enum DependencySurface { BodyOwner, FreeFunctionCall, - NonGenericNamedMethodCall, GenericNamedMethodCall, - NamedDestructorCall, ImplicitNamedDestructor, DeclarationType, DeclarationTypeCallHead, @@ -1840,7 +1823,6 @@ pub enum DependencyIncompleteReason { AnonymousBodyOwnerUnavailable, CallerEndpointUnavailable, GenericSubstitutionIdentityUnavailable, - DestructorEndpointUnavailable, AnonymousDropOwnerUnavailable, ResolvedTypeIdentityUnavailable, TypeCallHeadIdentityUnavailable, @@ -1904,9 +1886,7 @@ impl InvalidationMetrics { match value { S::BodyOwner => DependencySurface::BodyOwner, S::FreeFunctionCall => DependencySurface::FreeFunctionCall, - S::NonGenericNamedMethodCall => DependencySurface::NonGenericNamedMethodCall, S::GenericNamedMethodCall => DependencySurface::GenericNamedMethodCall, - S::NamedDestructorCall => DependencySurface::NamedDestructorCall, S::ImplicitNamedDestructor => DependencySurface::ImplicitNamedDestructor, S::DeclarationType => DependencySurface::DeclarationType, S::DeclarationTypeCallHead => DependencySurface::DeclarationTypeCallHead, @@ -1926,9 +1906,6 @@ impl InvalidationMetrics { R::GenericSubstitutionIdentityUnavailable => { DependencyIncompleteReason::GenericSubstitutionIdentityUnavailable } - R::DestructorEndpointUnavailable => { - DependencyIncompleteReason::DestructorEndpointUnavailable - } R::AnonymousDropOwnerUnavailable => { DependencyIncompleteReason::AnonymousDropOwnerUnavailable } diff --git a/crates/rue-compiler/tests/differential_oracle.rs b/crates/rue-compiler/tests/differential_oracle.rs index 5c52f1a5d..a876ba1bc 100644 --- a/crates/rue-compiler/tests/differential_oracle.rs +++ b/crates/rue-compiler/tests/differential_oracle.rs @@ -355,15 +355,13 @@ fn observe_with_fault( let diagnostics = normalize_diagnostics(session.latest_diagnostics()); let manifest = match session.unstable_dependency_baseline(&step.options, None) { Ok(manifest) => format!( - "input={:?};imports={:?};definitions={:?};fingerprints={:?};module-imports={:?};free={:?};methods={:?};destructors={:?};implicit={:?};decl-types={:?};call-heads={:?};builtins={:?};consts={:?};bodies={:?};blockers={:?};complete={}", + "input={:?};imports={:?};definitions={:?};fingerprints={:?};module-imports={:?};free={:?};implicit={:?};decl-types={:?};call-heads={:?};builtins={:?};consts={:?};bodies={:?};blockers={:?};complete={}", manifest.input(), manifest.imports(), manifest.definitions(), manifest.definition_fingerprints(), manifest.module_imports(), manifest.free_function_dependencies(), - manifest.named_method_dependencies(), - manifest.named_destructor_dependencies(), manifest.implicit_named_destructor_dependencies(), manifest.declaration_type_dependencies(), manifest.declaration_type_call_head_dependencies(),