type-guessr 0.0.3 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8ff8e62640844d1f305406b2ecf2c67d139e20aa1710e245b9650ce89f051c2d
-  data.tar.gz: ce2659a63614befd227cd54e2755dcda8a32dfd88640665b09101d97cc211071
+  metadata.gz: 7783e3a53037ee36f81b86f0d78518ad46cdbf84ba63e3de3262114d82773873
+  data.tar.gz: 00d1c370e84981d176b78d39a10aeb0b7371ff8e8f4f046bb1cc9e7d7aad0031
 SHA512:
-  metadata.gz: b075460f82c3d9a9046e5b2e6ca87173fe84dd62244f240654bea83a7afbb4f1de785d53b2907030b37d6bdd4004a68fda4ca38a2ce4ea1e2720ed5534d30a32
-  data.tar.gz: 80468b024537670450a638f51cfae739ef1efe68227b89c675f095d9ecf1e57dbf648d65f15526f8cce8b5a9d2b9e74313c5f9dc7da9191e5221a2c4f9f6517b
+  metadata.gz: 1a0f3223ed5c77a2601e9649181aea9b2db9d9e977374ccbda3a832cadf61b123b046f040ccd654c49ea1516a928d565543b1b8e80bf5d6ca630e90c29346e66
+  data.tar.gz: 749c0256b9402d1885a00dcf3b52f662e77bae6bccdd1d797920af0930bd875605248eb00d9e8a43a47b8626164c28ec161bd3bd72e4fda6392ceb19f58a3c38

data/lib/ruby_lsp/type_guessr/code_index_adapter.rb

@@ -119,7 +119,7 @@ module RubyLsp
                        entries = if @member_index
                                    @member_index[pivot.name.to_s] || []
                                  else
-                                   @index.fuzzy_search(pivot.name.to_s) do |entry|
+                                   @index.fuzzy_search(pivot.name.to_s).select do |entry|
                                      entry.is_a?(RubyIndexer::Entry::Member) && entry.name == pivot.name.to_s
                                    end
                                  end

data/lib/type_guessr/core/converter/definition_converter.rb

@@ -202,6 +202,12 @@ module TypeGuessr
           nested_classes = []
           if prism_node.body.is_a?(Prism::StatementsNode)
             prism_node.body.body.each do |stmt|
+              if attr_accessor_call?(stmt)
+                # attr_reader/attr_accessor/attr_writer DSL → 合成DefNodeを生成
+                methods.concat(synthesize_attr_defs(stmt, class_context))
+                next
+              end
+
               node = convert(stmt, class_context)
               if node.is_a?(IR::DefNode)
                 methods << node
@@ -217,6 +223,66 @@ module TypeGuessr
           IR::ClassModuleNode.new(name, methods, [], convert_loc(prism_node.constant_path&.location || prism_node.location))
         end
 
+        ATTR_DSL_NAMES = %i[attr_reader attr_writer attr_accessor].freeze
+        private_constant :ATTR_DSL_NAMES
+
+        private def attr_accessor_call?(prism_node)
+          return false unless prism_node.is_a?(Prism::CallNode)
+          return false unless prism_node.receiver.nil?
+
+          ATTR_DSL_NAMES.include?(prism_node.name)
+        end
+
+        # attr_reader/attr_writer/attr_accessor呼び出しから合成DefNodeを生成する
+        # @return [Array<IR::DefNode>]
+        private def synthesize_attr_defs(prism_node, context)
+          dsl_name = prism_node.name
+          args = prism_node.arguments&.arguments || []
+
+          args.flat_map do |arg|
+            attr_name = extract_attr_name(arg)
+            next [] unless attr_name
+
+            loc = convert_loc(arg.location)
+            case dsl_name
+            when :attr_reader
+              [build_reader_def(attr_name, context.current_class_name, loc)]
+            when :attr_writer
+              [build_writer_def(attr_name, context.current_class_name, loc)]
+            when :attr_accessor
+              [
+                build_reader_def(attr_name, context.current_class_name, loc),
+                build_writer_def(attr_name, context.current_class_name, loc),
+              ]
+            end
+          end
+        end
+
+        # 記号/文字列リテラル引数から属性名を取り出す
+        # @return [Symbol, nil] シンボルで返す。リテラルでない場合はnil
+        private def extract_attr_name(arg)
+          case arg
+          when Prism::SymbolNode
+            arg.value&.to_sym
+          when Prism::StringNode
+            arg.unescaped.to_sym
+          end
+        end
+
+        # attr_readerに対応する合成DefNode (引数なし、@ivarを返す)
+        private def build_reader_def(attr_name, class_name, loc)
+          ivar_name = :"@#{attr_name}"
+          ivar_read = IR::InstanceVariableReadNode.new(ivar_name, class_name, nil, [], loc)
+          IR::DefNode.new(attr_name, class_name, [], ivar_read, [ivar_read], [], loc, false)
+        end
+
+        # attr_writerに対応する合成DefNode (name= :引数を返す)
+        private def build_writer_def(attr_name, class_name, loc)
+          setter_name = :"#{attr_name}="
+          param = IR::ParamNode.new(:value, :required, nil, [], loc)
+          IR::DefNode.new(setter_name, class_name, [param], param, [param], [], loc, false)
+        end
+
         private def convert_singleton_class(prism_node, context)
           # Create a new context for singleton class scope
           singleton_context = context.fork(:class)

data/lib/type_guessr/core/inference/resolver.rb

@@ -669,12 +669,25 @@ module TypeGuessr
             )
           end
 
-          # Try project class methods first (includes extended module methods)
-          # Use code_index adapter to find method owner
-          owner_name = @code_index&.class_method_owner(class_name, node.method.to_s)
+          # ConstantName.method is always a class method or module function, so the
+          # method's owner must be the receiver's singleton class. Look up the registry
+          # directly to avoid depending on ruby-lsp's indexer state for methods we
+          # ourselves registered.
+          singleton_scope = "#{class_name}::<Class:#{IR.extract_last_name(class_name)}>"
+          def_node = @method_registry.lookup(singleton_scope, node.method.to_s)
+          if def_node
+            return_result = infer(def_node)
+            return Result.new(
+              return_result.type,
+              "#{class_name}.#{node.method} (project)",
+              :project
+            )
+          end
 
-          # Early return: project class method found
-          if owner_name
+          # Fall back to code_index for inherited class methods (the method is defined
+          # on an ancestor, so its singleton scope differs from the receiver's).
+          owner_name = @code_index&.class_method_owner(class_name, node.method.to_s)
+          if owner_name && owner_name != singleton_scope
             def_node = @method_registry.lookup(owner_name, node.method.to_s)
             if def_node
               return_result = infer(def_node)

data/lib/type_guessr/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TypeGuessr
-  VERSION = "0.0.3"
+  VERSION = "0.0.5"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: type-guessr
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.5
 platform: ruby
 authors:
 - riseshia
@@ -124,7 +124,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 3.6.9
 specification_version: 4
 summary: A heuristic type inference tool for Ruby
 test_files: []