fix(ruby): emit statics only on their defining class

Static stubs were re-emitted on every subclass (allMethods/allProperties
include inherited members) with the *derived* class fqn interpolated into
call_static/get_static — baking the wrong type into the kernel call for
inherited statics.

Ruby singleton methods inherit, which matches the ES6 static-inheritance
semantics the kernel implements (its lookups walk the base chain), so the
fix is to not re-emit at all: a static is generated only where
definingType matches the emitted class. Children that override a static
still get their own stub (allMethods yields the most-derived
declaration), as pinned by the StaticHelloParent/Child fixture.

Generated-code effect on jsii-calc: JSII417Derived no longer re-emits
make_instance (now resolved via inheritance from JSII417PublicBaseOfBase,
through two erased private bases); StaticHelloChild keeps its overriding
stubs with the child fqn.

Tests: both paths covered in classes_spec (pure inheritance via
JSII417Derived, override via StaticHelloChild). Full suite: 235
examples, 0 failures; compliance report unchanged.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: Omar Qureshi

packages/@jsii/ruby-runtime-test/spec/compliance/classes_spec.rb

@@ -219,6 +219,31 @@ def unwrap(gen)
     end
   end
 
+  describe 'static inheritance (extended)' do
+    # jsii's StaticHello fixture documents the design fork: ES6 inherits
+    # statics through the class hierarchy, Java does not.  Ruby naturally
+    # matches ES6 — singleton methods inherit — so the generator emits a
+    # static only on its *defining* class and lets Ruby inheritance (and the
+    # kernel's base-chain lookup) do the rest.
+    it 'resolves inherited statics through singleton-method inheritance' do
+      # makeInstance is defined on JSII417PublicBaseOfBase (two erased
+      # private classes up); JSII417Derived re-emits nothing — the call
+      # resolves to the base stub, carrying the base fqn to the kernel.
+      expect(JsiiCalc::JSII417Derived.make_instance).to be_a(JsiiCalc::JSII417PublicBaseOfBase)
+    end
+
+    it 'lets a child override parent statics (ES6 semantics)' do
+      expect(JsiiCalc::StaticHelloParent.PROPERTY).to eq(1337)
+      expect(JsiiCalc::StaticHelloParent.property).to eq(1337)
+
+      # The child's own stubs shadow the inherited ones and carry the
+      # child's fqn.
+      expect(JsiiCalc::StaticHelloChild.PROPERTY).to eq(42)
+      expect(JsiiCalc::StaticHelloChild.property).to eq(42)
+      expect { JsiiCalc::StaticHelloChild.method() }.not_to raise_error
+    end
+  end
+
   describe 'inheritance (extended)' do
     it 'handles inheritance with no new properties' do
       # DerivedClassHasNoProperties::Derived inherits from Base

packages/jsii-pacmak/lib/targets/ruby.ts

@@ -636,6 +636,16 @@ export class RubyGenerator extends Generator {
     }
     this.code.line('');
 
+    // Static members are emitted only on their *defining* class.  Ruby
+    // inherits singleton methods, which matches the ES6 static-inheritance
+    // semantics the kernel implements (its method/property lookups walk the
+    // base chain, and the base's stub carries the base fqn).  Re-emitting an
+    // inherited static here would bake the *derived* fqn into the kernel
+    // call instead.  A child that overrides a static still gets its own
+    // stub, because allMethods/allProperties yield the most-derived
+    // declaration (see the StaticHelloParent/Child fixture in jsii-calc).
+    const isOwnStatic = (m: any) => m.definingType?.fqn === typeSpec.fqn;
+
     const overridableMethods = resolvedAllMethods.filter((m: any) => !m.static);
     const overridableProps = resolvedAllProperties.filter(
       (p: any) => !p.static,
@@ -663,7 +673,7 @@ export class RubyGenerator extends Generator {
     this.code.line('');
 
     for (const method of resolvedAllMethods) {
-      if (!method.static) continue;
+      if (!method.static || !isOwnStatic(method)) continue;
 
       const sigParams = method.parameters
         .map((p: any) => {
@@ -701,6 +711,8 @@ export class RubyGenerator extends Generator {
     }
 
     for (const prop of resolvedAllProperties) {
+      if (prop.static && !isOwnStatic(prop)) continue;
+
       const rubyName = this.rubyPropertyName(prop);
 
       if (prop.static) {