solargraph 0.54.1 → 0.56.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d6619265fc1ba2cab9154e70c5f4a6626999b685d58e26a805ec606d6804f17b
-  data.tar.gz: cfac32a13734ba9b392d27fcb8da7c76b180f0bf64189d17698b2246ce6e3773
+  metadata.gz: 6f8c351394fab745041193e5d33cd582f0131e6d0f2d30f210767bd273376f24
+  data.tar.gz: 9d7a3c46740bd9fa040190d00f0e17cab638bde681da5998337dd41e6a924ff6
 SHA512:
-  metadata.gz: 8d1d40bf5d19b37f6a2ee8cce73e36027140ae402d27326c15e39a961217153e8b269722503ca0a8a3b592bee50cb6227fffcd812f62a1ec8a1bf94219270eea
-  data.tar.gz: 627df7fb0bd23b641f0b1a40434a6384def8f32bf318b4f92d243266ee0c3145059adc29ea487dcdc30c914045e5737bca92bff6bd67fd06527f97c2e4690fb8
+  metadata.gz: 0fefbe369014891f339463c19a198ab0b9c1d918fb70662b496d90f79871e7ab03d3b4e7bf853fee19f7bbd467817690b29e506ca340518156667e986685c92e
+  data.tar.gz: e92af09e57129e47e6c4b685642460c514bc7c26a015f93c7eb81d917b12717cfac0621181fc36dcc481770ce6b3d93a611f5acd5aee64b1730c8dde4b63b949

data/.github/workflows/plugins.yml

@@ -34,6 +34,8 @@ jobs:
         bundle exec solargraph config
         yq -yi '.plugins += ["solargraph-rails"]' .solargraph.yml
         yq -yi '.plugins += ["solargraph-rspec"]' .solargraph.yml
+    - name: Install gem types
+      run: bundle exec rbs collection install
     - name: Ensure typechecking still works
       run: bundle exec solargraph typecheck --level typed
     - name: Ensure specs still run

data/.github/workflows/typecheck.yml

@@ -30,5 +30,7 @@ jobs:
         bundler-cache: false
     - name: Install gems
       run: bundle install
+    - name: Install gem types
+      run: bundle exec rbs collection install
     - name: Typecheck self
-      run: bundle exec solargraph typecheck --level typed
+      run: SOLARGRAPH_ASSERTS=on bundle exec solargraph typecheck --level typed

data/.gitignore

@@ -1,3 +1,5 @@
+/.gem_rbs_collection
+/rbs_collection.lock.yaml
 /Gemfile.lock
 .Gemfile
 .idea

data/CHANGELOG.md

@@ -1,3 +1,73 @@
+## 0.56.0 - July 1, 2025
+-  [regression] Gem caching perf and logging fixes #983 
+
+## 0.55.5 - July 1, 2025
+- Flatten results of DocMap external bundle query (#981)
+- [breaking] Reimplement global conventions (#877)
+- GemPins pin merging improvements (#946)
+- Support class-scoped aliases and attributes from RBS (#952)
+- Restructure ComplexType specs towards YARD doc compliance (#969)
+- Use Prism (#974)
+- Document pages (#977)
+- Enable disabled-but-working specs (#978)
+- Map RBS 'untyped' type (RBS::Types::Bases::Any) to 'undefined' (#979)
+- Re-enable support for .gem_rbs_collection directories (#942)
+- [breaking] Comply with YARD documentation on Hash tag format (#968)
+- Ignore directory paths in Workspace#would_require? (#988)
+
+## 0.55.4 - June 27, 2025
+-  Flatten results of DocMap external bundle query (#981)
+
+## 0.55.3 - June 25, 2025
+-  Nil guards in flow-sensitive typing (patch release) (#980)
+
+## 0.55.2 - June 21, 2025
+- Require external bundle (#972)
+
+## 0.55.1 - June 8, 2025
+- Fix inline Struct definition (#962)
+- Ensure DocMap requires bundler when loading gemspecs (#963)
+- DelegatedMethod improvements (#953)
+
+## 0.55.0 - June 3, 2025
+- Flow-sensitive typing - automatically downcast from is_a? calls (#856)
+- Tuple enabler: infer literal types and use them for signature selection (#836)
+- Signature selection improvements (#907)
+- Add support for Ruby Structs (#939)
+- [regression] Fix interface change breaking solargraph-rails (#940)
+- [regression] Add back bundler/require support for solargraph-rails (#941)
+- Add specs for initialize capabilities (#955)
+- Create MethodAlias pins from YARD (#945)
+- MessageWorker prioritizes synchronization (#956)
+- initialize/new method pin cleanups (#949)
+- Clip rebinds blocks when cursor is not part of receiver (#958)
+
+## 0.54.5 - May 17, 2025
+- Repair unknown encoding errors (#936, #935)
+- Index arbitrary pinsets (#937)
+- Separate YARD cache from doc map cache (#938)
+
+## 0.54.4 - May 14, 2025
+- Delete files from Library hash (#932)
+- Clip#define returns variable pins (#934, #933)
+
+## 0.54.3 - May 13, 2025
+- Improve inspect()/desc()/to_s() methods for better debugging output (#913)
+- Fix generic resolution in Hash types (#906)
+- Stop parsing RBS type parameter constraints as the type name (#918)
+- Fix pin inference stack (#922)
+- Refactor pin equality for performance (#925)
+- Improve ApiMap catalog speed by preserving static pin indexes (#930)
+- Update jaro_winkler dependency (#931)
+
+## 0.54.2 - April 28, 2025
+- Resolve generics correctly on mixin inclusion (#898)
+- Pick correct String#split overload (#905)
+- Fix type sent into YARD method (#912)
+- Early CancelRequest handling (#914)
+- Destructure partial yield types (#915)
+- Dependency versions (#916)
+
 ## 0.54.1 - April 26, 2025
 - Retire more RubyVM-specific code (#797)
 - Add additional docs for key classes, modules and methods (#802)

data/README.md

@@ -63,12 +63,22 @@ The RSpec framework is supported via [solargraph-rspec](https://github.com/lekem
 
 **Note: Before version 0.53.0, it was recommended to run `yard gems` periodically or automate it with `yard config` to ensure that Solargraph had access to gem documentation. These steps are no longer necessary. Solargraph maintains its own gem documentation cache independent of the yardocs in your gem installations.**
 
-Solargraph automatically generates code maps from installed gems. You can also manage your cached gem documentation with the `solargraph gems` command.
-
-When editing code, a `require` call that references a gem will pull the documentation into the code maps and include the gem's API in code completion and intellisense.
+When editing code, a `require` call that references a gem will pull the documentation into the code maps and include the gem's API in code completion and intellisense.  Solargraph automatically generates code maps from installed gems, based on the YARD or RBS type information inside the gem.  You can also eagerly cache gem documentation with the `solargraph gems` command.
 
 If your project automatically requires bundled gems (e.g., `require 'bundler/require'`), Solargraph will add all of the Gemfile's default dependencies to the map.
 
+To ensure you have types for gems which contain neither RBS nor YARD
+information, use
+[gem\_rbs\_collection](https://github.com/ruby/gem_rbs_collection) to
+install a community-supported set of RBS types for various gems:
+
+```sh
+bundle exec rbs collection init
+bundle exec rbs collection install
+```
+
+Once installed, you can also insert your own local overrides and definitions in RBS in a directory configured in the `rbs_collection.yaml` that the above commands create.
+
 ### Type Checking
 
 As of version 0.33.0, Solargraph includes a [type checker](https://github.com/castwide/solargraph/issues/192) that uses a combination of YARD tags and code analysis to report missing type definitions. In strict mode, it performs type inference to determine whether the tags match the types it detects from code.

data/lib/solargraph/api_map/cache.rb

@@ -8,7 +8,7 @@ module Solargraph
         @methods = {}
         # @type [Hash{(String, Array<String>) => Array<Pin::Base>}]
         @constants = {}
-        # @type [Hash{(String, String) => String}]
+        # @type [Hash{String => String}]
         @qualified_namespaces = {}
         # @type [Hash{String => Pin::Method}]
         @receiver_definitions = {}
@@ -16,6 +16,15 @@ module Solargraph
         @clips = {}
       end
 
+      def to_s
+        self.class.to_s
+      end
+
+      # avoid enormous dump
+      def inspect
+        to_s
+      end
+
       # @param fqns [String]
       # @param scope [Symbol]
       # @param visibility [Array<Symbol>]

data/lib/solargraph/api_map/index.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class ApiMap
+    class Index
+      include Logging
+
+      # @param pins [Array<Pin::Base>]
+      def initialize pins = []
+        catalog pins
+      end
+
+      # @return [Array<Pin::Base>]
+      def pins
+        @pins ||= []
+      end
+
+      # @return [Hash{String => Array<Pin::Namespace>}]
+      def namespace_hash
+        @namespace_hash ||= Hash.new { |h, k| h[k] = [] }
+      end
+
+      # @return [Hash{String => Array<Pin::Base>}]
+      def pin_class_hash
+        @pin_class_hash ||= Hash.new { |h, k| h[k] = [] }
+      end
+
+      # @return [Hash{String => Array<Pin::Base>}]
+      def path_pin_hash
+        @path_pin_hash ||= Hash.new { |h, k| h[k] = [] }
+      end
+
+      # @generic T
+      # @param klass [Class<generic<T>>]
+      # @return [Set<generic<T>>]
+      def pins_by_class klass
+        # @type [Set<Solargraph::Pin::Base>]
+        s = Set.new
+        @pin_select_cache[klass] ||= pin_class_hash.each_with_object(s) { |(key, o), n| n.merge(o) if key <= klass }
+      end
+
+      # @return [Hash{String => Array<Pin::Reference::Include>}]
+      def include_references
+        @include_references ||= Hash.new { |h, k| h[k] = [] }
+      end
+
+      # @return [Hash{String => Array<Pin::Reference::Extend>}]
+      def extend_references
+        @extend_references ||= Hash.new { |h, k| h[k] = [] }
+      end
+
+      # @return [Hash{String => Array<Pin::Reference::Prepend>}]
+      def prepend_references
+        @prepend_references ||= Hash.new { |h, k| h[k] = [] }
+      end
+
+      # @return [Hash{String => Array<Pin::Reference::Superclass>}]
+      def superclass_references
+        @superclass_references ||= Hash.new { |h, k| h[k] = [] }
+      end
+
+      # @param pins [Array<Pin::Base>]
+      def merge pins
+        deep_clone.catalog pins
+      end
+
+      protected
+
+      attr_writer :pins, :pin_select_cache, :namespace_hash, :pin_class_hash, :path_pin_hash, :include_references,
+                  :extend_references, :prepend_references, :superclass_references
+
+      def deep_clone
+        Index.allocate.tap do |copy|
+          copy.pin_select_cache = {}
+          copy.pins = pins.clone
+          %i[
+            namespace_hash pin_class_hash path_pin_hash include_references extend_references prepend_references
+            superclass_references
+          ].each do |sym|
+            copy.send("#{sym}=", send(sym).clone)
+            copy.send(sym)&.transform_values!(&:clone)
+          end
+        end
+      end
+
+      # @param new_pins [Array<Pin::Base>]
+      def catalog new_pins
+        @pin_select_cache = {}
+        pins.concat new_pins
+        set = new_pins.to_set
+        set.classify(&:class)
+           .map { |k, v| pin_class_hash[k].concat v.to_a }
+        set.classify(&:namespace)
+           .map { |k, v| namespace_hash[k].concat v.to_a }
+        set.classify(&:path)
+           .map { |k, v| path_pin_hash[k].concat v.to_a }
+        @namespaces = path_pin_hash.keys.compact.to_set
+        map_references Pin::Reference::Include, include_references
+        map_references Pin::Reference::Prepend, prepend_references
+        map_references Pin::Reference::Extend, extend_references
+        map_references Pin::Reference::Superclass, superclass_references
+        map_overrides
+        self
+      end
+
+      # @param klass [Class<Pin::Reference>]
+      # @param hash [Hash{String => Array<Pin::Reference>}]
+      # @return [void]
+      def map_references klass, hash
+        pins_by_class(klass).each do |pin|
+          store_parametric_reference(hash, pin)
+        end
+      end
+
+      # Add references to a map
+      #
+      # @param hash [Hash{String => Array<Pin::Reference>}]
+      # @param reference_pin [Pin::Reference]
+      #
+      # @return [void]
+      def store_parametric_reference(hash, reference_pin)
+        referenced_ns = reference_pin.name
+        referenced_tag_params = reference_pin.generic_values
+        referenced_tag = referenced_ns +
+                         if referenced_tag_params && referenced_tag_params.length > 0
+                           "<" + referenced_tag_params.join(', ') + ">"
+                         else
+                           ''
+                         end
+        referencing_ns = reference_pin.namespace
+        hash[referencing_ns].push referenced_tag
+      end
+
+      # @return [void]
+      def map_overrides
+        pins_by_class(Pin::Reference::Override).each do |ovr|
+          logger.debug { "ApiMap::Index#map_overrides: Looking at override #{ovr} for #{ovr.name}" }
+          pins = path_pin_hash[ovr.name]
+          logger.debug { "ApiMap::Index#map_overrides: pins for path=#{ovr.name}: #{pins}" }
+          pins.each do |pin|
+            new_pin = if pin.path.end_with?('#initialize')
+                        path_pin_hash[pin.path.sub(/#initialize/, '.new')].first
+                      end
+            (ovr.tags.map(&:tag_name) + ovr.delete).uniq.each do |tag|
+              pin.docstring.delete_tags tag
+              new_pin.docstring.delete_tags tag if new_pin
+            end
+            ovr.tags.each do |tag|
+              pin.docstring.add_tag(tag)
+              redefine_return_type pin, tag
+              if new_pin
+                new_pin.docstring.add_tag(tag)
+                redefine_return_type new_pin, tag
+              end
+            end
+          end
+        end
+      end
+
+      # @param pin [Pin::Method]
+      # @param tag [YARD::Tags::Tag]
+      # @return [void]
+      def redefine_return_type pin, tag
+        # @todo can this be made to not mutate existing pins and use
+        #   proxy() / proxy_with_signatures() instead?
+        return unless pin && tag.tag_name == 'return'
+        pin.instance_variable_set(:@return_type, ComplexType.try_parse(tag.type))
+        pin.signatures.each do |sig|
+          sig.instance_variable_set(:@return_type, ComplexType.try_parse(tag.type))
+        end
+        pin.reset_generated!
+      end
+    end
+  end
+end

data/lib/solargraph/api_map/store.rb

@@ -1,19 +1,50 @@
 # frozen_string_literal: true
 
-
 module Solargraph
   class ApiMap
     # Queryable collection of Pins representing a Workspace, gems and the Ruby
     # core.
     #
     class Store
+      # @param pinsets [Array<Enumerable<Pin::Base>>]
+      def initialize *pinsets
+        catalog pinsets
+      end
+
       # @return [Array<Solargraph::Pin::Base>]
-      attr_reader :pins
+      def pins
+        index.pins
+      end
+
+      # @param pinsets [Array<Enumerable<Pin::Base>>]
+      # @return [Boolean] True if the index was updated
+      def update *pinsets
+        return catalog(pinsets) if pinsets.length != @pinsets.length
+
+        changed = pinsets.find_index.with_index { |pinset, idx| @pinsets[idx] != pinset }
+        return false unless changed
 
-      # @param pins [Enumerable<Solargraph::Pin::Base>]
-      def initialize pins = []
-        @pins = pins
-        index
+        # @todo Fix this map
+        @fqns_pins_map = nil
+        return catalog(pinsets) if changed == 0
+
+        pinsets[changed..].each_with_index do |pins, idx|
+          @pinsets[changed + idx] = pins
+          @indexes[changed + idx] = if pins.empty?
+            @indexes[changed + idx - 1]
+          else
+            @indexes[changed + idx - 1].merge(pins)
+          end
+        end
+        true
+      end
+
+      def to_s
+        self.class.to_s
+      end
+
+      def inspect
+        to_s
       end
 
       # @param fqns [String]
@@ -30,18 +61,24 @@ module Solargraph
       # @param visibility [Array<Symbol>]
       # @return [Enumerable<Solargraph::Pin::Method>]
       def get_methods fqns, scope: :instance, visibility: [:public]
-        namespace_children(fqns).select do |pin|
+        all_pins = namespace_children(fqns).select do |pin|
           pin.is_a?(Pin::Method) && pin.scope == scope && visibility.include?(pin.visibility)
         end
+        GemPins.combine_method_pins_by_path(all_pins)
       end
 
-      # @param fqns [String]
+      # @param fq_tag [String]
       # @return [String, nil]
-      def get_superclass fqns
-        raise "Do not prefix fully qualified namespaces with '::' - #{fqns.inspect}" if fqns.start_with?('::')
+      def get_superclass fq_tag
+        raise "Do not prefix fully qualified tags with '::' - #{fq_tag.inspect}" if fq_tag.start_with?('::')
+        sub = ComplexType.parse(fq_tag)
+        fqns = sub.namespace
+        return superclass_references[fq_tag].first if superclass_references.key?(fq_tag)
         return superclass_references[fqns].first if superclass_references.key?(fqns)
         return 'Object' if fqns != 'BasicObject' && namespace_exists?(fqns)
         return 'Object' if fqns == 'Boolean'
+        simplified_literal_name = ComplexType.parse("#{fqns}").simplify_literals.name
+        return simplified_literal_name if simplified_literal_name != fqns
         nil
       end
 
@@ -66,11 +103,7 @@ module Solargraph
       # @param path [String]
       # @return [Array<Solargraph::Pin::Base>]
       def get_path_pins path
-        path_pin_hash[path] || []
-      end
-
-      def cacheable_pins
-        @cacheable_pins ||= pins_by_class(Pin::Namespace) + pins_by_class(Pin::Constant) + pins_by_class(Pin::Method) + pins_by_class(Pin::Reference)
+        index.path_pin_hash[path]
       end
 
       # @param fqns [String]
@@ -85,7 +118,7 @@ module Solargraph
       # @param fqns [String]
       # @return [Enumerable<Solargraph::Pin::Base>]
       def get_class_variables(fqns)
-        namespace_children(fqns).select{|pin| pin.is_a?(Pin::ClassVariable)}
+        namespace_children(fqns).select { |pin| pin.is_a?(Pin::ClassVariable)}
       end
 
       # @return [Enumerable<Solargraph::Pin::Base>]
@@ -101,10 +134,10 @@ module Solargraph
 
       # @return [Set<String>]
       def namespaces
-        @namespaces ||= Set.new
+        index.namespaces
       end
 
-      # @return [Enumerable<Solargraph::Pin::Base>]
+      # @return [Enumerable<Solargraph::Pin::Namespace>]
       def namespace_pins
         pins_by_class(Solargraph::Pin::Namespace)
       end
@@ -143,18 +176,11 @@ module Solargraph
         pins_by_class(Pin::Block)
       end
 
-      def inspect
-        # Avoid insane dumps in specs
-        to_s
-      end
-
       # @generic T
-      # @param klass [Class<T>]
-      # @return [Set<T>]
+      # @param klass [Class<generic<T>>]
+      # @return [Set<generic<T>>]
       def pins_by_class klass
-        # @type [Set<Solargraph::Pin::Base>]
-        s = Set.new
-        @pin_select_cache[klass] ||= @pin_class_hash.each_with_object(s) { |(key, o), n| n.merge(o) if key <= klass }
+        index.pins_by_class klass
       end
 
       # @param fqns [String]
@@ -174,6 +200,23 @@ module Solargraph
 
       private
 
+      def index
+        @indexes.last
+      end
+
+      def catalog pinsets
+        @pinsets = pinsets
+        @indexes = []
+        pinsets.each do |pins|
+          if @indexes.last && pins.empty?
+            @indexes.push @indexes.last
+          else
+            @indexes.push(@indexes.last&.merge(pins) || Solargraph::ApiMap::Index.new(pins))
+          end
+        end
+        true
+      end
+
       # @return [Hash{::Array(String, String) => ::Array<Pin::Namespace>}]
       def fqns_pins_map
         @fqns_pins_map ||= Hash.new do |h, (base, name)|
@@ -184,129 +227,39 @@ module Solargraph
 
       # @return [Enumerable<Solargraph::Pin::Symbol>]
       def symbols
-        pins_by_class(Pin::Symbol)
+        index.pins_by_class(Pin::Symbol)
       end
 
       # @return [Hash{String => Array<String>}]
       def superclass_references
-        @superclass_references ||= {}
+        index.superclass_references
       end
 
       # @return [Hash{String => Array<String>}]
       def include_references
-        @include_references ||= {}
+        index.include_references
       end
 
       # @return [Hash{String => Array<String>}]
       def prepend_references
-        @prepend_references ||= {}
+        index.prepend_references
       end
 
       # @return [Hash{String => Array<String>}]
       def extend_references
-        @extend_references ||= {}
+        index.extend_references
       end
 
       # @param name [String]
       # @return [Enumerable<Solargraph::Pin::Base>]
       def namespace_children name
-        namespace_map[name] || []
-      end
-
-      # @return [Hash{String => Enumerable<Pin::Base>}
-      def namespace_map
-        @namespace_map ||= {}
+        return [] unless index.namespace_hash.key?(name)
+        index.namespace_hash[name]
       end
 
       # @return [Enumerable<Pin::InstanceVariable>]
       def all_instance_variables
-        pins_by_class(Pin::InstanceVariable)
-      end
-
-      # @return [Hash{String => Array<Pin::Base>}]
-      def path_pin_hash
-        @path_pin_hash ||= {}
-      end
-
-      # Add references to a map
-      #
-      # @param h [Hash{String => Pin:Base}]
-      # @param reference_pin [Pin::Reference]
-      #
-      # @return [void]
-      def store_parametric_reference(h, reference_pin)
-        referenced_ns = reference_pin.name
-        referenced_tag_params = reference_pin.generic_values
-        referenced_tag = referenced_ns +
-                         if referenced_tag_params && referenced_tag_params.length > 0
-                           "<" + referenced_tag_params.join(', ') + ">"
-                         else
-                           ''
-                         end
-        referencing_ns = reference_pin.namespace
-        h[referencing_ns] ||= []
-        h[referencing_ns].push referenced_tag
-      end
-
-      # @return [void]
-      def index
-        set = pins.to_set
-        @pin_class_hash = set.classify(&:class).transform_values(&:to_a)
-        # @type [Hash{Class => ::Array<Solargraph::Pin::Base>}]
-        @pin_select_cache = {}
-        @namespace_map = set.classify(&:namespace)
-        @path_pin_hash = set.classify(&:path)
-        @namespaces = @path_pin_hash.keys.compact.to_set
-        pins_by_class(Pin::Reference::Include).each do |pin|
-          store_parametric_reference(include_references, pin)
-        end
-        # @todo move the rest of these reference pins over to use
-        #   generic types, adding rbs_map/conversions.rb code to
-        #   populate type parameters and adding related specs ensuring
-        #   the generics get resolved, along with any api_map.rb
-        #   changes needed in
-        pins_by_class(Pin::Reference::Prepend).each do |pin|
-          prepend_references[pin.namespace] ||= []
-          prepend_references[pin.namespace].push pin.name
-        end
-        pins_by_class(Pin::Reference::Extend).each do |pin|
-          extend_references[pin.namespace] ||= []
-          extend_references[pin.namespace].push pin.name
-        end
-        pins_by_class(Pin::Reference::Superclass).each do |pin|
-          superclass_references[pin.namespace] ||= []
-          superclass_references[pin.namespace].push pin.name
-        end
-        pins_by_class(Pin::Reference::Override).each do |ovr|
-          pin = get_path_pins(ovr.name).first
-          next if pin.nil?
-          new_pin = if pin.path.end_with?('#initialize')
-            get_path_pins(pin.path.sub(/#initialize/, '.new')).first
-          end
-          (ovr.tags.map(&:tag_name) + ovr.delete).uniq.each do |tag|
-            pin.docstring.delete_tags tag.to_sym
-            new_pin.docstring.delete_tags tag.to_sym if new_pin
-          end
-          ovr.tags.each do |tag|
-            pin.docstring.add_tag(tag)
-            redefine_return_type pin, tag
-            if new_pin
-              new_pin.docstring.add_tag(tag)
-              redefine_return_type new_pin, tag
-            end
-          end
-        end
-      end
-
-      # @param pin [Pin::Base]
-      # @param tag [String]
-      # @return [void]
-      def redefine_return_type pin, tag
-        return unless pin && tag.tag_name == 'return'
-        pin.instance_variable_set(:@return_type, ComplexType.try_parse(tag.type))
-        pin.signatures.each do |sig|
-          sig.instance_variable_set(:@return_type, ComplexType.try_parse(tag.type))
-        end
+        index.pins_by_class(Pin::InstanceVariable)
       end
     end
   end