sorbet_typed-props 1.5.2 → 1.5.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38708cf1f39a8cef314d4843c4fed453f4faf8f2fc35db4e47e1c659dcd581d7
-  data.tar.gz: 94b1bf4f088610d3e3e3bb1eb1ea7f09da8428f9849176d214f4f0a9d2760ff7
+  metadata.gz: e7206c19cf06589c26a6d00a673273645270a37d4957304902ee0a3eb5e5cfe9
+  data.tar.gz: 44091faa0e3dbf390cb383dbed54044230cb1416eaee7a4501003d1209622183
 SHA512:
-  metadata.gz: d37eeeaea430f1950b0a9bc80e50e5c98945458082ee037989c213151a593e67ecf9e52816b05c371636b8110b01d161ba53418f601ec514d654c5ea4abfa374
-  data.tar.gz: e54af5f419e3cea6b5aaacc4379db254d17c3cc6da84be35c8ab715149194466a1c5cec687896dc2cf93027541f1a5af88246ac4fd83d99fa92d3d54801e973e
+  metadata.gz: d196157b6961f084f2ef8b60e77348d17b2a7d72f6a75a990bdaff20747ff80807a3ca5d091dab0a1f7e072dc36a9f44fdd510e9e88205d968cee1d9359907b6
+  data.tar.gz: ce46d5dc413eb1da669a9c98a24051c56c2cbf741952a4445e55ff237a70900ea0372f7456e59caab3f4c10746babdf57e1c0b93ff5c504ffa10b76c3fa10192

data/.cz.yaml

@@ -15,7 +15,7 @@ commitizen:
     - mise run format
   tag_format: v$version
   update_changelog_on_bump: true
-  version: 1.5.2
+  version: 1.5.5
   version_files:
     - lib/sorbet_typed/props/version.rb
   version_scheme: semver2

data/CHANGELOG.md

@@ -1,3 +1,23 @@
+## v1.5.5 (2026-07-17)
+
+### Fix
+
+- **phlex**: validate Phlex ::new calls statically like #initialize
+
+## v1.5.4 (2026-07-05)
+
+### Fix
+
+- **ci**: allow Behaviour in cspell dictionary globally
+
+## v1.5.3 (2026-07-04)
+
+### Fix
+
+- **ci**: silence spellchecker false-positive on minimumReleaseAgeBehaviour
+- **ci**: skip patch versions still within minimumReleaseAge in matrix generator
+- **ci**: install mise tools strictly from lockfile to avoid GitHub API rate limiting
+
 ## v1.5.2 (2026-07-03)
 
 ### Fix

data/CLAUDE.md

@@ -0,0 +1,25 @@
+# Claude Instructions
+
+## Conventional Commits
+
+This project uses [Conventional Commits](https://www.conventionalcommits.org/) with `commitizen`
+(`cz_conventional_commits`). Semver bumps are driven by commit type:
+
+- `fix:` → patch bump
+- `feat:` → minor bump
+- `feat!:` / `BREAKING CHANGE:` → major bump
+- All other types (`chore`, `ci`, `refactor`, `test`, `docs`, `style`, `perf`) → **no version bump**
+
+**Rule:** Only use `fix` or `feat` (or their breaking variants) when the change affects the **published gem** — its
+public API, runtime behavior, or bug fixes visible to gem consumers.
+
+Changes that must **not** use `fix` or `feat`:
+
+- CI pipeline configuration (`.gitlab-ci.yml`, `ci/`)
+- Ruby version matrix or Renovate configuration
+- Test suite changes that don't fix a gem bug
+- Dev tooling, scripts, linting rules
+- Dependency updates (Renovate handles these as `chore`)
+- Documentation that describes internal/dev processes
+
+When in doubt: if removing the change would not affect consumers of the installed gem, it is not a `fix` or `feat`.

data/README.md

@@ -37,6 +37,7 @@ This gem is tested against all combinations of the following dependency versions
 | Ruby           | 3.3, 3.4, 4.0        |
 | sorbet-runtime | 0.6.12997, 0.6.13321 |
 | tapioca        | 0.17, 0.18, 0.19     |
+| phlex          | 1.11, 2.4            |
 | sorbet         | 0.6.12997, 0.6.13321 |
 
 ### Excluded combinations
@@ -172,10 +173,6 @@ class Components::HelloWorld < Phlex::HTML
 end
 ```
 
-> **Known limitation:** Phlex overrides `::new` rather than `#initialize` in `Phlex::SGML`, so Sorbet cannot statically
-> validate props on Phlex components. Calling `HelloWorld.new` without required props will not raise a Sorbet error. See
-> issue [#23](https://gitlab.com/sorbet_typed/props/-/work_items/23).
-
 → [Full documentation](docs/phlex.md)
 
 ### Extending initializer logic

data/docs/phlex.md

@@ -1,9 +1,5 @@
 # Phlex integration
 
-> [!warning]
->
-> [Known static typing limitation](#known-static-typing-limitation)
-
 ## Table of Contents
 
 - [Table of Contents](#table-of-contents)
@@ -11,8 +7,10 @@
 - [When to use](#when-to-use)
 - [Examples](#examples)
   - [Phlex component with props](#phlex-component-with-props)
-  - [Known static typing limitation](#known-static-typing-limitation)
 - [Behavior notes](#behavior-notes)
+- [Automatic `::new` typing](#automatic-new-typing)
+- [Phlex version compatibility](#phlex-version-compatibility)
+- [Element-name collisions](#element-name-collisions)
 
 ## What it does
 
@@ -63,36 +61,40 @@ class Components::UserCard < Phlex::HTML
 end
 ```
 
-### Known static typing limitation
+## Behavior notes
 
-> [!warning] Known limitation
->
-> Phlex overrides `::new` rather than `#initialize` in `Phlex::SGML`, so Sorbet cannot statically validate props on
-> Phlex components. Calling `HelloWorld.new` without required props will not raise a Sorbet error. See issue
-> [#23](https://gitlab.com/sorbet_typed/props/-/work_items/23).
+- Props are validated at runtime.
+- The generated `initialize` RBI is correct — Sorbet validates calls to `#initialize` where it can reach them.
+- Phlex `::new` calls are statically typed (see "Automatic `::new` typing" below).
 
-```ruby
-# Sorbet does NOT catch this at static analysis time — only raises at runtime:
-Components::UserCard.new
-# => ArgumentError: Missing required prop `name` for class `Components::UserCard`
-```
+## Automatic `::new` typing
 
-A possible workaround is to add a manual RBI shim for `::new` on the component:
+Phlex overrides `::new` (not `#initialize`) in `Phlex::SGML`. The Tapioca compiler shipped with this gem detects that
+override and generates a matching `self.new` signature directly on your component class, so Sorbet validates `.new`
+calls exactly like it validates `#initialize` calls on non-Phlex classes — no manual shim needed.
 
 ```ruby
-# sorbet/rbi/shims/components/user_card.rbi
-class Components::UserCard
-  sig { params(name: String, email: String).returns(T.attached_class) }
-  def self.new(name:, email:); end
-end
+# Sorbet catches this at static analysis time:
+Components::UserCard.new # error: Missing required keyword argument `name`
 ```
 
-This requires a shim per component. See issue [#23](https://gitlab.com/sorbet_typed/props/-/work_items/23) for the
-upstream discussion.
+## Phlex version compatibility
 
-## Behavior notes
+`SorbetTyped::Props` requires Phlex `>= 1.0.0` when included in a Phlex component. Versions before 1.0 predate the
+`Phlex::SGML`-based architecture this integration targets entirely. Including `SorbetTyped::Props` in an older Phlex
+component raises `ArgumentError` immediately.
 
-- Props are validated at runtime even though Sorbet cannot check `::new` call sites statically on Phlex components.
-- The generated `initialize` RBI is correct — Sorbet validates calls to `#initialize` where it can reach them.
-- The limitation applies only to `Phlex::SGML` subclasses (i.e. `Phlex::HTML` and `Phlex::SVG`). Non-Phlex classes work
-  fully with static analysis.
+## Element-name collisions
+
+Phlex registers an instance method for every HTML tag (`title`, `label`, `header`, `time`, `data`, and dozens more). A
+prop with the same name as one of these silently shadowed the tag-rendering method before — `title { ... }` in
+`view_template` would stop working with no error. This is now caught: defining a prop whose name collides with a
+Phlex-registered element method raises `ArgumentError` immediately.
+
+```ruby
+class Components::Article < Phlex::HTML
+  include SorbetTyped::Props
+
+  prop :title, String # ArgumentError: collides with a Phlex element method of the same name
+end
+```

data/lib/sorbet_typed/props/version.rb

@@ -5,7 +5,7 @@
 
 module SorbetTyped
   module Props
-    VERSION = '1.5.2'
+    VERSION = '1.5.5'
   end
 end
 

data/lib/sorbet_typed/props/without_init_param_and_no_default_plugin.rb

@@ -31,10 +31,13 @@ module SorbetTyped
         private
 
         sig { params(value: T.untyped, rules: T::Props::Decorator::Rules).returns(T::Boolean) }
+        # :reek:FeatureEnvy -- a pure predicate over its arguments, no `self`
+        # state to operate on instead; that's the whole point of the method.
         def prop_read_before_set?(value, rules)
-          !!(rules.dig(:extra, :initializer) == false &&
-            !rules[:type_object].valid?(value) &&
-            !rspec_double_valid_for_type?(value, rules[:type_object]))
+          return false unless rules.dig(:extra, :initializer) == false
+
+          type_object = rules[:type_object]
+          !!(!type_object.valid?(value) && !rspec_double_valid_for_type?(value, type_object))
         end
 
         # NOTE: allows RSpec verifying doubles (e.g. instance_double) to be used
@@ -42,6 +45,8 @@ module SorbetTyped
         # triggering the "read before being set" error. This mirrors the approach
         # taken by the rspec-sorbet gem for T.let/T.cast type checks.
         sig { params(value: T.untyped, type_object: T::Types::Base).returns(T::Boolean) }
+        # :reek:FeatureEnvy -- a pure predicate over its arguments, no `self`
+        # state to operate on instead; that's the whole point of the method.
         def rspec_double_valid_for_type?(value, type_object)
           # :nocov: -- entry guard not testable without loading a non-RSpec
           # environment
@@ -53,7 +58,7 @@ module SorbetTyped
           # :nocov: -- nil cases not really testable without constructing
           # pathological doubles from scratch
           target = value.instance_variable_get(:@doubled_module)&.target
-          return false if target.nil?
+          return false unless target
           # :nocov:
 
           rspec_double_target_matches_type?(target, type_object)
@@ -61,11 +66,13 @@ module SorbetTyped
 
         sig { params(target: T::Module[T.anything], type_object: T::Types::Base).returns(T::Boolean) }
         def rspec_double_target_matches_type?(target, type_object)
+          target_ancestors = target.ancestors
+
           case type_object
           when T::Types::Simple
-            target.ancestors.include?(type_object.raw_type)
+            target_ancestors.include?(type_object.raw_type)
           when T::Types::Union
-            type_object.types.any? { |t| t.is_a?(T::Types::Simple) && target.ancestors.include?(t.raw_type) }
+            type_object.types.any? { |candidate_type| candidate_type.is_a?(T::Types::Simple) && target_ancestors.include?(candidate_type.raw_type) }
           # :nocov: -- else false not reachable with standard Sorbet type objects (always Simple or Union)
           else
             false

data/lib/sorbet_typed/props.rb

@@ -23,6 +23,196 @@ module SorbetTyped
 
     include Kernel
 
+    # Phlex predates its current Phlex::SGML-based architecture entirely
+    # before 1.0 (confirmed by inspecting phlex 0.5.3's source: no
+    # Phlex::SGML class, different Rails-view-coupled design) - this is the
+    # only place this version literal is written; tested_gem_versions.yml
+    # references it by name via `min_constant`, never duplicates it.
+    MINIMUM_SUPPORTED_PHLEX_VERSION = '1.0.0'
+
+    sig { params(base: T::Module[T.anything]).void }
+    def self.included(base)
+      super
+      check_phlex_compatibility!(base)
+      patch_phlex_method_added!(base)
+    end
+
+    sig { params(base: T::Module[T.anything]).void }
+    # NOTE: reflection (`const_defined?`/`const_get`), not a bare `Phlex::VERSION`
+    # reference, on purpose - a literal `Phlex::VERSION`/`Phlex::SGML` constant
+    # reference is statically resolved by Sorbet regardless of `defined?`
+    # guarding, and fails `srb tc` with "Unable to resolve constant" since this
+    # gem never depends on Phlex (no RBI shim for it exists in this project).
+    # This must stay resolvable whether or not Phlex is ever bundled.
+    #
+    # :reek:TooManyStatements -- a sequence of independent early-return guard
+    # clauses; splitting further would hurt readability more than it helps.
+    def self.check_phlex_compatibility!(base)
+      return unless base.ancestors.any? { |mod| mod.name&.start_with?('Phlex::') }
+      # :nocov: -- if an ancestor's name starts with 'Phlex::', the top-level
+      # Phlex constant must already be defined; this guard only matters if
+      # that invariant is ever violated (e.g. a hand-rolled ancestor faking
+      # the namespace), which isn't reproducible without doing exactly that
+      return unless Object.const_defined?(:Phlex)
+      # :nocov:
+
+      phlex = T.unsafe(Object).const_get(:Phlex) # rubocop:disable Sorbet/ConstantsFromStrings -- Phlex is a soft, optional dependency, never statically resolvable
+      # :nocov: -- every supported Phlex release defines Phlex::VERSION; this
+      # guards only a hypothetical broken/partial install
+      return unless phlex.const_defined?(:VERSION)
+      # :nocov:
+
+      phlex_version = phlex.const_get(:VERSION) # rubocop:disable Sorbet/ConstantsFromStrings -- see above
+      return if Gem::Version.new(phlex_version) >= Gem::Version.new(MINIMUM_SUPPORTED_PHLEX_VERSION)
+
+      raise ArgumentError,
+            'SorbetTyped::Props does not support Phlex < ' \
+              "#{MINIMUM_SUPPORTED_PHLEX_VERSION} " \
+              "(found #{phlex_version}). See docs/phlex.md."
+    end
+    private_class_method :check_phlex_compatibility!
+
+    sig { params(base: T::Module[T.anything]).void }
+    # MONKEYPATCH (Phlex::SGML.method_added), applied at runtime below via
+    # `install_phlex_method_added_super!`, only when actually needed. Not
+    # filed upstream against Phlex - this is only a problem for the narrow
+    # combination of Phlex + sorbet-runtime `sig` + running under Tapioca's
+    # RBS-comment rewriter, so it's not established that Phlex's behavior is
+    # wrong in general.
+    #
+    # What we observed: some Phlex versions' `method_added` don't forward via
+    # `super` for the `view_template` method specifically (confirmed in
+    # 1.11.1; still true in 2.3.1's `view_template`-specific branch; fixed by
+    # 2.4.1, which forwards unconditionally). On its own this is harmless - a
+    # plain `extend T::Sig` on a Phlex subclass puts sorbet-runtime's
+    # method_added hook ahead of Phlex::SGML's in the singleton ancestor
+    # chain, so it fires first regardless. But Tapioca's RBS-comment rewriter
+    # (loaded by any `tapioca dsl` run, whether or not RBS comments are used)
+    # does a *global* `Module.include(T::Sig)` so bare RBS-comment files get
+    # `sig` without their own `extend T::Sig`. Since `include`/`extend` of
+    # the same module is a no-op the second time, that global include makes
+    # our per-class `extend T::Sig` a no-op for ancestor *positioning* too -
+    # the hook ends up reachable only via `Module`, which sits *below*
+    # Phlex::SGML in a Phlex subclass's chain. method_added dispatch then
+    # never reaches sorbet-runtime's hook, leaving its pending `sig`
+    # declaration dangling until some unrelated class's next method
+    # definition wrongly consumes it, raising a confusing error that blames
+    # that unrelated class.
+    #
+    # There's no clean Phlex version-number boundary for this (the fix landed
+    # somewhere between 2.3.1 and 2.4.1, and earlier point releases aren't
+    # all verified), so this is gated on detected behavior
+    # (`phlex_method_added_forwards_view_template?`), not `Phlex::VERSION` -
+    # patch only the versions that actually need it.
+    # :reek:TooManyStatements -- a sequence of independent early-return guard
+    # clauses, same shape as check_phlex_compatibility! above; splitting
+    # further would hurt readability more than it helps.
+    # :reek:NilCheck -- phlex_sgml_constant legitimately returns nil when
+    # Phlex/Phlex::SGML aren't defined; this is the guard for that.
+    # :reek:ManualDispatch -- respond_to? here is the actual idempotency
+    # marker check (has this specific `sgml` already been patched?), not
+    # duck-typing standing in for a missing interface.
+    def self.patch_phlex_method_added!(base)
+      return unless base.ancestors.any? { |mod| mod.name&.start_with?('Phlex::') }
+
+      sgml = phlex_sgml_constant
+      return if sgml.nil? || sgml.respond_to?(:__sorbet_typed_props_method_added_checked__)
+
+      sgml.define_singleton_method(:__sorbet_typed_props_method_added_checked__) { true }
+      install_phlex_method_added_super!(sgml) unless phlex_method_added_forwards_view_template?(sgml)
+    end
+    private_class_method :patch_phlex_method_added!
+
+    sig { returns(T.untyped) }
+    def self.phlex_sgml_constant
+      # :nocov: -- callers only reach this once `check_phlex_compatibility!`
+      # has already confirmed Phlex and Phlex::VERSION are defined; these
+      # guards duplicate that invariant defensively and aren't independently
+      # reachable
+      return unless Object.const_defined?(:Phlex)
+
+      phlex = T.unsafe(Object).const_get(:Phlex) # rubocop:disable Sorbet/ConstantsFromStrings -- see check_phlex_compatibility!
+      return unless phlex.const_defined?(:SGML)
+      # :nocov:
+
+      phlex.const_get(:SGML) # rubocop:disable Sorbet/ConstantsFromStrings -- see check_phlex_compatibility!
+    end
+    private_class_method :phlex_sgml_constant
+
+    sig { params(sgml: T.untyped).returns(T::Boolean) }
+    # Detects whether `sgml`'s own `method_added` forwards via `super` for
+    # `view_template` specifically (the one method name Phlex special-cases -
+    # see the NOTE above `patch_phlex_method_added!` on why testing a generic
+    # method name would wrongly pass against Phlex 2.3.1).
+    #
+    # Deliberately does NOT test this via a throwaway subclass that does its
+    # own `extend T::Sig` - a fresh class's `extend T::Sig` would normally
+    # win the ancestor-chain race regardless of Phlex's own behavior (that's
+    # the "harmless on its own" case described above), so a probe built that
+    # way would never actually exercise the failure condition and would
+    # always report `true`. Instead, a canary module is included directly
+    # into `sgml.singleton_class` - `include` inserts right after the
+    # includer, exactly where a `super` call from within `sgml`'s own
+    # `method_added` would look - and the hook is invoked directly on `sgml`
+    # itself. This tests Phlex's forwarding behavior in isolation, decoupled
+    # from any ancestor-chain positioning question.
+    #
+    # NOTE: the canary itself forwards via `super` (`if defined?(super)`,
+    # since it may sit directly below `Module`/`Kernel`, which don't
+    # implement `method_added` themselves). Ruby has no way to remove an
+    # included module afterward, so this canary is permanent once installed
+    # - it must stay transparent. That's safe either way: if `sgml` doesn't
+    # forward on its own, this canary is simply never reached (`sgml`'s own
+    # body returns before calling `super`), so it's inert dead code sitting
+    # below whatever `install_phlex_method_added_super!` separately patches
+    # onto `sgml` itself; if `sgml` does forward, the canary passes the call
+    # straight through, same as if it weren't there.
+    #
+    # :reek:TooManyStatements -- building the canary, installing it, and
+    # invoking the probed hook are each one line; splitting this into
+    # smaller methods would just spread a single cohesive check across
+    # several call sites for no readability gain.
+    def self.phlex_method_added_forwards_view_template?(sgml)
+      forwarded = T.let(false, T::Boolean)
+      canary = Module.new
+      canary.define_method(:method_added) do |name|
+        forwarded = true if name == :view_template
+        # :nocov: -- `defined?(super)` is always true here: Module itself
+        # provides a default `method_added`, so the canary (included into
+        # sgml's singleton class) always has one further up the chain to
+        # forward to
+        super(name) if defined?(super)
+        # :nocov:
+      end
+      sgml.singleton_class.include(canary)
+
+      sgml.send(:method_added, :view_template)
+      forwarded
+    end
+    private_class_method :phlex_method_added_forwards_view_template?
+
+    sig { params(sgml: T.untyped).void }
+    # NOTE: `alias_method`, not a captured `sgml.method(:method_added)` - a
+    # `Method` object is permanently bound to the receiver it was captured
+    # from (`sgml` itself). Calling it later from inside our wrapper (which
+    # runs with `self` set to whatever class is actually being defined, e.g.
+    # a Phlex::HTML subclass) would still execute with `self` == `sgml`,
+    # breaking Phlex 2.x's own method_added body (which already calls
+    # `super` and inspects `self`) - confirmed by this exact regression
+    # against Phlex 2.4.1 while adding the second Phlex fixture spec. An
+    # aliased method, by contrast, dispatches with the correct dynamic
+    # `self` when invoked via `send`, same as a normal method call.
+    def self.install_phlex_method_added_super!(sgml)
+      original_method_added_name = :__sorbet_typed_props_original_method_added__
+      sgml.singleton_class.send(:alias_method, original_method_added_name, :method_added)
+
+      sgml.define_singleton_method(:method_added) do |name|
+        send(original_method_added_name, name)
+        super(name)
+      end
+    end
+    private_class_method :install_phlex_method_added_super!
+
     plugin(WithoutInitParamAndNoDefaultPlugin)
 
     # Methods injected into the including class singleton
@@ -36,6 +226,53 @@ module SorbetTyped
           prop_parameters.dig(:extra, :initializer) == false
         end
       end
+
+      sig { params(name: Symbol, cls: T.untyped, rules: T.untyped).void }
+      def prop(name, cls, **rules)
+        check_element_method_collision!(name)
+        super
+      end
+
+      private
+
+      # Phlex::HTML::StandardElements registers an instance method per HTML
+      # tag (title, label, header, ...). A same-named prop silently shadows
+      # it - the prop reader wins method resolution, no error today. Duck
+      # -typed against Phlex's own element registry accessor rather than a
+      # blanket "any ancestor method collision" check, which would
+      # false-positive constantly on ordinary Ruby method names (type, name,
+      # format, hash, ...) for any non-Phlex consumer. The accessor's name
+      # changed across majors - registered_elements (1.x, on
+      # Phlex::Elements) vs __registered_elements__ (2.x, on
+      # Phlex::SGML::Elements) - check both defensively. If a future Phlex
+      # major renames it again, this degrades silently (stops detecting new
+      # collisions) rather than raising false positives.
+      PHLEX_REGISTERED_ELEMENTS_READERS = T.let(
+        %i[__registered_elements__ registered_elements].freeze,
+        T::Array[Symbol]
+      )
+      private_constant :PHLEX_REGISTERED_ELEMENTS_READERS
+
+      sig { params(name: Symbol).void }
+      def check_element_method_collision!(name)
+        return unless T.unsafe(self).method_defined?(name)
+
+        owner = T.unsafe(self).instance_method(name).owner
+        return unless phlex_element_owner?(owner, name)
+
+        Kernel.raise ArgumentError,
+                     "#{self}: prop `#{name}` collides with a Phlex element method of the same " \
+                       "name defined by `#{owner}` - rendering `#{name} { ... }` in " \
+                       "'view_template' would no longer work."
+      end
+
+      sig { params(owner: T.untyped, name: Symbol).returns(T::Boolean) }
+      # :reek:ManualDispatch -- intentional duck-typing against Phlex modules via reflect
+      def phlex_element_owner?(owner, name)
+        PHLEX_REGISTERED_ELEMENTS_READERS.any? do |reader|
+          T.unsafe(owner).respond_to?(reader) && T.unsafe(owner).public_send(reader).key?(name)
+        end
+      end
     end
 
     mixes_in_class_methods(ClassMethods)

data/lib/tapioca/dsl/compilers/sorbet_typed_props_constructor.rb

@@ -80,7 +80,7 @@ module Tapioca
         end
 
         sig { void }
-        def define_initializer_sig
+        def define_initializer_sig # rubocop:disable Metrics/MethodLength
           superclass = constant.superclass
           superclass_name = superclass == Object ? nil : superclass.to_s
 
@@ -91,9 +91,29 @@ module Tapioca
               return_type: 'void',
               comments: [RBI::Comment.new('Generated from sorbet SorbetTyped::Props')]
             )
+
+            next unless self_new_overridden?
+
+            klass.create_method(
+              'new',
+              parameters: params_with_optional_last,
+              return_type: 'T.attached_class',
+              class_method: true,
+              comments: [RBI::Comment.new('Generated from sorbet SorbetTyped::Props')]
+            )
           end
         end
 
+        sig { returns(T::Boolean) }
+        # NOTE: Phlex::SGML overrides `self.new` (untyped), so Sorbet resolves
+        # `.new` calls against that instead of synthesizing a signature from
+        # `#initialize`. Defining our own `self.new` directly on the leaf class
+        # wins ancestor-chain resolution over any such override. Gated so plain
+        # classes (the common case) get no extra RBI output.
+        def self_new_overridden?
+          constant.method(:new).owner != Class
+        end
+
         sig { returns(T::Array[RBI::TypedParam]) }
         def params_with_optional_last
           required_params, optional_params = params.partition do |param|

data/tested_gem_versions.yml

@@ -24,6 +24,12 @@ sorbet-runtime:
   patch_sample_step: 500
 tapioca: '0.19.2'
 
+test_dependencies:
+  phlex:
+    max: '2.4.1'
+    min_constant: 'SorbetTyped::Props::MINIMUM_SUPPORTED_PHLEX_VERSION'
+    granularity: major
+
 incompatible_combinations:
   - tapioca: '< 0.19.0'
     sorbet-runtime: '>= 0.6.13149'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sorbet_typed-props
 version: !ruby/object:Gem::Version
-  version: 1.5.2
+  version: 1.5.5
 platform: ruby
 authors:
 - Richard Kramer
@@ -54,6 +54,7 @@ files:
 - ".shellcheckrc"
 - ".specstory/.gitignore"
 - CHANGELOG.md
+- CLAUDE.md
 - COPYING
 - README.md
 - docs/defaults.md