fix(ruby): distinguish parameterless and private constructors in codegen

The initializer fallback emitted a single catch-all `initialize(*args)`
passthrough for two very different cases:

- Parameterless constructors (initializer entry with no parameters):
  stray arguments were silently forwarded to the kernel. Now emitted
  with exact zero arity, matching how parameterized signatures are
  enforced.

- No initializer entry at all: jsii emits this for classes whose
  constructor is private — instances only come from factory methods,
  hydrated via allocate (which never calls #initialize). The
  passthrough also silently skipped any base-class coercion/checks,
  relying on the unstated invariant that the jsii compiler propagates
  initializer entries onto instantiable subclasses (verified: all 27
  such classes in jsii-calc have private ctors). Constructing one from
  Ruby is now an eager NoMethodError naming the class and pointing at
  the factories, instead of a less helpful kernel rejection.

Verified no spec instantiates any of the 27 private-ctor fixture
classes. Tests pin zero-arity enforcement, the raising stub, and the
unaffected factory path. Full suite: 240 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/unit/type_validation_spec.rb

@@ -107,5 +107,24 @@
       expect { JsiiCalc::Calculator.new('not props') }
         .to raise_error(TypeError, /Expected props to be of type/)
     end
+
+    it 'enforces zero arity for parameterless constructors' do
+      # Previously a catch-all (*args) silently forwarded stray arguments
+      # to the kernel.
+      expect { JsiiCalc::AllTypes.new(123) }.to raise_error(ArgumentError)
+      expect { JsiiCalc::AllTypes.new }.not_to raise_error
+    end
+
+    it 'raises a helpful error when constructing a private-constructor class' do
+      # Classes without an initializer entry in the assembly have private
+      # constructors: instances only come from factories (hydrated via
+      # allocate, which never calls #initialize).
+      expect { JsiiCalc::ClassWithPrivateConstructorAndAutomaticProperties.new('a', 'b') }
+        .to raise_error(NoMethodError, /does not have a visible constructor/)
+
+      # The factory path is unaffected.
+      obj = JsiiCalc::ClassWithPrivateConstructorAndAutomaticProperties.create('Hello', 'Bye')
+      expect(obj.read_only_string).to eq('Hello')
+    end
   end
 end

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

@@ -624,10 +624,26 @@ export class RubyGenerator extends Generator {
         `Jsii::Object.instance_method(:initialize).bind(self).call(${superArgs})`,
       );
       this.code.close('end');
+    } else if (initializer) {
+      // Parameterless constructor (the jsii compiler propagates initializer
+      // entries onto instantiable subclasses, so a missing parameter list
+      // here really means "takes no arguments" — enforce that arity rather
+      // than silently forwarding stray args to the kernel).
+      this.code.open('def initialize');
+      this.code.line(
+        'Jsii::Object.instance_method(:initialize).bind(self).call',
+      );
+      this.code.close('end');
     } else {
+      // No initializer entry at all: jsii emits this for classes whose
+      // constructor is not visible (private).  Instances only ever come
+      // from factory methods and are hydrated via `allocate`, which never
+      // calls #initialize — so constructing one from Ruby is always a bug.
+      // Raise eagerly with a pointer to the factories instead of letting
+      // the kernel reject the create call with a less helpful error.
       this.code.open('def initialize(*args)');
       this.code.line(
-        'Jsii::Object.instance_method(:initialize).bind(self).call(*args)',
+        `raise NoMethodError, "${rubyDq(typeSpec.fqn)} does not have a visible constructor; use the provided factory methods"`,
       );
       this.code.close('end');
     }