solargraph 0.59.0.dev.1 → 0.59.0.dev.2

data/lib/solargraph/rbs_map/core_fills.rb

@@ -1,84 +1,91 @@
-# frozen_string_literal: true
-
-module Solargraph
-  class RbsMap
-    # Override pins to fill gaps in RbsMap::CoreMap coverage
-    #
-    module CoreFills
-      Override = Pin::Reference::Override
-
-      KEYWORDS = [
-        '__ENCODING__', '__LINE__', '__FILE__', 'BEGIN', 'END', 'alias', 'and',
-        'begin', 'break', 'case', 'class', 'def', 'defined?', 'do', 'else',
-        'elsif', 'end', 'ensure', 'false', 'for', 'if', 'in', 'module', 'next',
-        'nil', 'not', 'or', 'redo', 'rescue', 'retry', 'return', 'self', 'super',
-        'then', 'true', 'undef', 'unless', 'until', 'when', 'while', 'yield'
-      ].map { |k| Pin::Keyword.new(k, source: :core_fill) }
-
-      MISSING = [
-        Solargraph::Pin::Method.new(name: 'class', scope: :instance,
-                                    closure: Solargraph::Pin::Namespace.new(name: 'Object', source: :core_fill), comments: '@return [::Class<self>]',
-                                    source: :core_fill)
-      ]
-
-      OVERRIDES = [
-        Override.from_comment('BasicObject#instance_eval', '@yieldreceiver [self]',
-                              source: :core_fill),
-        Override.from_comment('BasicObject#instance_exec', '@yieldreceiver [self]',
-                              source: :core_fill),
-        Override.from_comment('Module#define_method', '@yieldreceiver [::Object<self>]',
-                              source: :core_fill),
-        Override.from_comment('Module#class_eval', '@yieldreceiver [::Class<self>]',
-                              source: :core_fill),
-        Override.from_comment('Module#class_exec', '@yieldreceiver [::Class<self>]',
-                              source: :core_fill),
-        Override.from_comment('Module#module_eval', '@yieldreceiver [::Module<self>]',
-                              source: :core_fill),
-        Override.from_comment('Module#module_exec', '@yieldreceiver [::Module<self>]',
-                              source: :core_fill),
-        # RBS does not define Class with a generic, so all calls to
-        # generic() return an 'untyped'.  We can do better:
-        Override.method_return('Class#allocate', 'self', source: :core_fill),
-      ]
-
-      # @todo I don't see any direct link in RBS to build this from -
-      #   presumably RBS is using duck typing to match interfaces
-      #   against concrete classes
-      INCLUDES = [
-        Solargraph::Pin::Reference::Include.new(name: '_ToAry',
-                                                closure: Solargraph::Pin::Namespace.new(name: 'Array', source: :core_fill),
-                                                generic_values: ['generic<Elem>'],
-                                                source: :core_fill),
-        Solargraph::Pin::Reference::Include.new(name: '_ToAry',
-                                                closure: Solargraph::Pin::Namespace.new(name: 'Set', source: :core_fill),
-                                                generic_values: ['generic<Elem>'],
-                                                source: :core_fill),
-        Solargraph::Pin::Reference::Include.new(name: '_Each',
-                                                closure: Solargraph::Pin::Namespace.new(name: 'Array', source: :core_fill),
-                                                generic_values: ['generic<Elem>'],
-                                                source: :core_fill),
-        Solargraph::Pin::Reference::Include.new(name: '_Each',
-                                                closure: Solargraph::Pin::Namespace.new(name: 'Set', source: :core_fill),
-                                                generic_values: ['generic<Elem>'],
-                                                source: :core_fill),
-        Solargraph::Pin::Reference::Include.new(name: '_ToS',
-                                                closure: Solargraph::Pin::Namespace.new(name: 'Object', source: :core_fill),
-                                                source: :core_fill),
-        Solargraph::Pin::Reference::Include.new(name: '_ToS',
-                                                closure: Solargraph::Pin::Namespace.new(name: 'String', source: :core_fill),
-                                                source: :core_fill)
-      ]
-
-      # HACK: Add Errno exception classes
-      errno = Solargraph::Pin::Namespace.new(name: 'Errno', source: :core_fill)
-      errnos = []
-      Errno.constants.each do |const|
-        errnos.push Solargraph::Pin::Namespace.new(type: :class, name: const.to_s, closure: errno, source: :core_fill)
-        errnos.push Solargraph::Pin::Reference::Superclass.new(closure: errnos.last, name: 'SystemCallError', source: :core_fill)
-      end
-      ERRNOS = errnos
-
-      ALL = KEYWORDS + MISSING + OVERRIDES + ERRNOS + INCLUDES
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  class RbsMap
+    # Override pins to fill gaps in RbsMap::CoreMap coverage
+    #
+    module CoreFills
+      Override = Pin::Reference::Override
+
+      KEYWORDS = [
+        '__ENCODING__', '__LINE__', '__FILE__', 'BEGIN', 'END', 'alias', 'and',
+        'begin', 'break', 'case', 'class', 'def', 'defined?', 'do', 'else',
+        'elsif', 'end', 'ensure', 'false', 'for', 'if', 'in', 'module', 'next',
+        'nil', 'not', 'or', 'redo', 'rescue', 'retry', 'return', 'self', 'super',
+        'then', 'true', 'undef', 'unless', 'until', 'when', 'while', 'yield'
+      ].map { |k| Pin::Keyword.new(k, source: :core_fill) }
+
+      MISSING = [
+        Solargraph::Pin::Method.new(name: 'class', scope: :instance,
+                                    closure: Solargraph::Pin::Namespace.new(name: 'Object', source: :core_fill), comments: '@return [::Class<self>]',
+                                    source: :core_fill)
+      ].freeze
+
+      OVERRIDES = [
+        Override.from_comment('BasicObject#instance_eval', '@yieldreceiver [self]',
+                              source: :core_fill),
+        Override.from_comment('BasicObject#instance_exec', '@yieldreceiver [self]',
+                              source: :core_fill),
+        Override.from_comment('Module#define_method', '@yieldreceiver [::Object<self>]',
+                              source: :core_fill),
+        Override.from_comment('Module#class_eval', '@yieldreceiver [::Class<self>]',
+                              source: :core_fill),
+        Override.from_comment('Module#class_exec', '@yieldreceiver [::Class<self>]',
+                              source: :core_fill),
+        Override.from_comment('Module#module_eval', '@yieldreceiver [::Module<self>]',
+                              source: :core_fill),
+        Override.from_comment('Module#module_exec', '@yieldreceiver [::Module<self>]',
+                              source: :core_fill),
+        # RBS does not define Class with a generic, so all calls to
+        # generic() return an 'untyped'.  We can do better:
+        Override.method_return('Class#allocate', 'self', source: :core_fill)
+      ].freeze
+
+      # @todo I don't see any direct link in RBS to build this from -
+      #   presumably RBS is using duck typing to match interfaces
+      #   against concrete classes
+      INCLUDES = [
+        Solargraph::Pin::Reference::Include.new(name: '_ToAry',
+                                                closure: Solargraph::Pin::Namespace.new(name: 'Array',
+                                                                                        source: :core_fill),
+                                                generic_values: ['generic<Elem>'],
+                                                source: :core_fill),
+        Solargraph::Pin::Reference::Include.new(name: '_ToAry',
+                                                closure: Solargraph::Pin::Namespace.new(name: 'Set',
+                                                                                        source: :core_fill),
+                                                generic_values: ['generic<Elem>'],
+                                                source: :core_fill),
+        Solargraph::Pin::Reference::Include.new(name: '_Each',
+                                                closure: Solargraph::Pin::Namespace.new(name: 'Array',
+                                                                                        source: :core_fill),
+                                                generic_values: ['generic<Elem>'],
+                                                source: :core_fill),
+        Solargraph::Pin::Reference::Include.new(name: '_Each',
+                                                closure: Solargraph::Pin::Namespace.new(name: 'Set',
+                                                                                        source: :core_fill),
+                                                generic_values: ['generic<Elem>'],
+                                                source: :core_fill),
+        Solargraph::Pin::Reference::Include.new(name: '_ToS',
+                                                closure: Solargraph::Pin::Namespace.new(name: 'Object',
+                                                                                        source: :core_fill),
+                                                source: :core_fill),
+        Solargraph::Pin::Reference::Include.new(name: '_ToS',
+                                                closure: Solargraph::Pin::Namespace.new(name: 'String',
+                                                                                        source: :core_fill),
+                                                source: :core_fill)
+      ].freeze
+
+      # HACK: Add Errno exception classes
+      errno = Solargraph::Pin::Namespace.new(name: 'Errno', source: :core_fill)
+      errnos = []
+      Errno.constants.each do |const|
+        errnos.push Solargraph::Pin::Namespace.new(type: :class, name: const.to_s, closure: errno, source: :core_fill)
+        errnos.push Solargraph::Pin::Reference::Superclass.new(closure: errnos.last, name: 'SystemCallError',
+                                                               source: :core_fill)
+      end
+      ERRNOS = errnos
+
+      ALL = KEYWORDS + MISSING + OVERRIDES + ERRNOS + INCLUDES
+    end
+  end
+end

data/lib/solargraph/rbs_map/stdlib_map.rb

@@ -12,7 +12,6 @@ module Solargraph
       # @type [Hash{String => RbsMap}]
       @stdlib_maps_hash = {}
 
-
       # @param rebuild [Boolean] build pins regardless of whether we
       #   have cached them already
       # @param library [String]

data/lib/solargraph/rbs_map.rb

@@ -16,11 +16,7 @@ module Solargraph
     # @type [Hash{String => RbsMap}]
     @@rbs_maps_hash = {}
 
-    attr_reader :library
-
-    attr_reader :rbs_collection_paths
-
-    attr_reader :rbs_collection_config_path
+    attr_reader :library, :rbs_collection_paths, :rbs_collection_config_path
 
     # @param library [String]
     # @param version [String, nil]
@@ -72,7 +68,7 @@ module Solargraph
     def cache_key
       return CACHE_KEY_UNRESOLVED unless resolved?
 
-      @hextdigest ||= begin
+      @cache_key ||= begin
         # @type [String, nil]
         data = nil
         # @type gem_config [nil, Hash{String => Hash{String => String}}]
@@ -145,7 +141,7 @@ module Solargraph
     # @return [generic<T>, nil]
     def path_pin path, klass = Pin::Base
       pin = pins.find { |p| p.path == path }
-      pin if pin&.is_a?(klass)
+      pin if pin.is_a?(klass)
     end
 
     # @param path [String]
@@ -176,11 +172,6 @@ module Solargraph
 
     private
 
-    # @return [RBS::EnvironmentLoader]
-    def loader
-      @loader ||= RBS::EnvironmentLoader.new(core_root: nil, repository: repository)
-    end
-
     # @return [Conversions]
     def conversions
       @conversions ||= Conversions.new(loader: loader)

data/lib/solargraph/server_methods.rb

@@ -1,16 +1,16 @@
-# frozen_string_literal: true
-
-require 'socket'
-
-module Solargraph
-  module ServerMethods
-    # @return [Integer]
-    def available_port
-      socket = Socket.new(:INET, :STREAM, 0)
-      socket.bind(Addrinfo.tcp("127.0.0.1", 0))
-      port = socket.local_address.ip_port
-      socket.close
-      port
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'socket'
+
+module Solargraph
+  module ServerMethods
+    # @return [Integer]
+    def available_port
+      socket = Socket.new(:INET, :STREAM, 0)
+      socket.bind(Addrinfo.tcp('127.0.0.1', 0))
+      port = socket.local_address.ip_port
+      socket.close
+      port
+    end
+  end
+end

data/lib/solargraph/shell.rb

@@ -16,7 +16,7 @@ module Solargraph
 
     map %w[--version -v] => :version
 
-    desc "--version, -v", "Print the version"
+    desc '--version, -v', 'Print the version'
     # @return [void]
     def version
       puts Solargraph::VERSION
@@ -31,15 +31,15 @@ module Solargraph
       port = options[:port]
       port = available_port if port.zero?
       Backport.run do
-        Signal.trap("INT") do
+        Signal.trap('INT') do
           Backport.stop
         end
-        Signal.trap("TERM") do
+        Signal.trap('TERM') do
           Backport.stop
         end
         # @sg-ignore Wrong argument type for Backport.prepare_tcp_server: adapter expected Backport::Adapter, received Module<Solargraph::LanguageServer::Transport::Adapter>
         Backport.prepare_tcp_server host: options[:host], port: port, adapter: Solargraph::LanguageServer::Transport::Adapter
-        STDERR.puts "Solargraph is listening PORT=#{port} PID=#{Process.pid}"
+        warn "Solargraph is listening PORT=#{port} PID=#{Process.pid}"
       end
     end
 
@@ -48,15 +48,15 @@ module Solargraph
     def stdio
       require 'backport'
       Backport.run do
-        Signal.trap("INT") do
+        Signal.trap('INT') do
           Backport.stop
         end
-        Signal.trap("TERM") do
+        Signal.trap('TERM') do
           Backport.stop
         end
         # @sg-ignore Wrong argument type for Backport.prepare_stdio_server: adapter expected Backport::Adapter, received Module<Solargraph::LanguageServer::Transport::Adapter>
         Backport.prepare_stdio_server adapter: Solargraph::LanguageServer::Transport::Adapter
-        STDERR.puts "Solargraph is listening on stdio PID=#{Process.pid}"
+        warn "Solargraph is listening on stdio PID=#{Process.pid}"
       end
     end
 
@@ -64,11 +64,11 @@ module Solargraph
     option :extensions, type: :boolean, aliases: :e, desc: 'Add installed extensions', default: true
     # @param directory [String]
     # @return [void]
-    def config(directory = '.')
+    def config directory = '.'
       matches = []
       if options[:extensions]
         Gem::Specification.each do |g|
-          if g.name.match(/^solargraph\-[A-Za-z0-9_\-]*?\-ext/)
+          if g.name.match(/^solargraph-[A-Za-z0-9_-]*?-ext/)
             require g.name
             matches.push g.name
           end
@@ -84,7 +84,7 @@ module Solargraph
       File.open(File.join(directory, '.solargraph.yml'), 'w') do |file|
         file.puts conf.to_yaml
       end
-      STDOUT.puts "Configuration file initialized."
+      $stdout.puts 'Configuration file initialized.'
     end
 
     desc 'clear', 'Delete all cached documentation'
@@ -93,7 +93,7 @@ module Solargraph
     )
     # @return [void]
     def clear
-      puts "Deleting all cached documentation (gems, core and stdlib)"
+      puts 'Deleting all cached documentation (gems, core and stdlib)'
       Solargraph::PinCache.clear
     end
     map 'clear-cache' => :clear
@@ -109,7 +109,7 @@ module Solargraph
       # '
     end
 
-    desc 'uncache GEM [...GEM]', "Delete specific cached gem documentation"
+    desc 'uncache GEM [...GEM]', 'Delete specific cached gem documentation'
     long_desc %(
       Specify one or more gem names to clear. 'core' or 'stdlib' may
       also be specified to clear cached system documentation.
@@ -174,7 +174,7 @@ module Solargraph
       if names.empty?
         workspace.cache_all_for_workspace!($stdout, rebuild: options[:rebuild])
       else
-        $stderr.puts("Caching these gems: #{names}")
+        warn("Caching these gems: #{names}")
         names.each do |name|
           if name == 'core'
             PinCache.cache_core(out: $stdout) if !PinCache.core? || options[:rebuild]
@@ -195,7 +195,7 @@ module Solargraph
           # @sg-ignore Need to add nil check here
           warn e.backtrace.join("\n")
         end
-        $stderr.puts "Documentation cached for #{names.count} gems."
+        warn "Documentation cached for #{names.count} gems."
       end
     end
 
@@ -212,7 +212,7 @@ module Solargraph
 
       Type checking levels are normal, typed, strict, and strong.
     )
-    option :level, type: :string, aliases: [:mode, :m, :l], desc: 'Type checking level', default: 'normal'
+    option :level, type: :string, aliases: %i[mode m l], desc: 'Type checking level', default: 'normal'
     option :directory, type: :string, aliases: :d, desc: 'The workspace directory', default: '.'
     # @return [void]
     def typecheck *files
@@ -231,21 +231,28 @@ module Solargraph
         files.map! { |file| File.realpath(file) }
       end
       filecount = 0
-      time = Benchmark.measure {
+      time = Benchmark.measure do
         files.each do |file|
-          checker = TypeChecker.new(file, api_map: api_map, rules: rules, level: options[:level].to_sym, workspace: workspace)
+          checker = TypeChecker.new(file, api_map: api_map, rules: rules, level: options[:level].to_sym,
+                                          workspace: workspace)
           problems = checker.problems
           next if problems.empty?
           problems.sort! { |a, b| a.location.range.start.line <=> b.location.range.start.line }
-          puts problems.map { |prob| "#{prob.location.filename}:#{prob.location.range.start.line + 1} - #{prob.message}" }.join("\n")
+          puts problems.map { |prob|
+            "#{prob.location.filename}:#{prob.location.range.start.line + 1} - #{prob.message}"
+          }.join("\n")
           filecount += 1
           probcount += problems.length
         end
-      }
+      end
       puts "Typecheck finished in #{time.real} seconds."
-      puts "#{probcount} problem#{probcount != 1 ? 's' : ''} found#{files.length != 1 ? " in #{filecount} of #{files.length} files" : ''}."
+      puts "#{probcount} problem#{if probcount != 1
+                                    's'
+                                  end} found#{if files.length != 1
+                                                                  " in #{filecount} of #{files.length} files"
+                                                                end}."
       # "
-      exit 1 if probcount > 0
+      exit 1 if probcount.positive?
     end
 
     desc 'scan', 'Test the workspace for problems'
@@ -262,26 +269,26 @@ module Solargraph
       directory = File.realpath(options[:directory])
       # @type [Solargraph::ApiMap, nil]
       api_map = nil
-      time = Benchmark.measure {
+      time = Benchmark.measure do
         api_map = Solargraph::ApiMap.load_with_cache(directory, $stdout)
         # @sg-ignore flow sensitive typing should be able to handle redefinition
         api_map.pins.each do |pin|
-          begin
-            puts pin_description(pin) if options[:verbose]
-            pin.typify api_map
-            pin.probe api_map
-          rescue StandardError => e
-            # @todo to add nil check here
-            # @todo should warn on nil dereference below
-            STDERR.puts "Error testing #{pin_description(pin)} #{pin.location ? "at #{pin.location.filename}:#{pin.location.range.start.line + 1}" : ''}"
-            STDERR.puts "[#{e.class}]: #{e.message}"
-            # @todo Need to add nil check here
-            # @todo flow sensitive typing should be able to handle redefinition
-            STDERR.puts e.backtrace.join("\n")
-            exit 1
-          end
+          puts pin_description(pin) if options[:verbose]
+          pin.typify api_map
+          pin.probe api_map
+        rescue StandardError => e
+          # @todo to add nil check here
+          # @todo should warn on nil dereference below
+          warn "Error testing #{pin_description(pin)} #{if pin.location
+                                                          "at #{pin.location.filename}:#{pin.location.range.start.line + 1}"
+                                                        end}"
+          warn "[#{e.class}]: #{e.message}"
+          # @todo Need to add nil check here
+          # @todo flow sensitive typing should be able to handle redefinition
+          warn e.backtrace.join("\n")
+          exit 1
         end
-      }
+      end
       # @sg-ignore Need to add nil check here
       puts "Scanned #{directory} (#{api_map.pins.length} pins) in #{time.real} seconds."
     end
@@ -296,12 +303,15 @@ module Solargraph
       puts "#{workspace.filenames.length} files total."
     end
 
-    desc 'pin [PATH]', 'Describe a pin', hide: true
+    desc 'pin [PATH]', 'Describe a pin'
     option :rbs, type: :boolean, desc: 'Output the pin as RBS', default: false
-    option :typify, type: :boolean, desc: 'Output the calculated return type of the pin from annotations', default: false
+    option :typify, type: :boolean, desc: 'Output the calculated return type of the pin from annotations',
+                    default: false
     option :references, type: :boolean, desc: 'Show references', default: false
-    option :probe, type: :boolean, desc: 'Output the calculated return type of the pin from annotations and inference', default: false
-    option :stack, type: :boolean, desc: 'Show entire stack of a method pin by including definitions in superclasses', default: false
+    option :probe, type: :boolean, desc: 'Output the calculated return type of the pin from annotations and inference',
+                   default: false
+    option :stack, type: :boolean, desc: 'Show entire stack of a method pin by including definitions in superclasses',
+                   default: false
     # @param path [String] The path to the method pin, e.g. 'Class#method' or 'Class.method'
     # @return [void]
     def pin path
@@ -326,7 +336,7 @@ module Solargraph
       pin = pins.first
       case pin
       when nil
-        $stderr.puts "Pin not found for path '#{path}'"
+        warn "Pin not found for path '#{path}'"
         exit 1
       when Pin::Namespace
         if options[:references]
@@ -360,15 +370,15 @@ module Solargraph
     # @return [String]
     def pin_description pin
       desc = if pin.path.nil? || pin.path.empty?
-        if pin.closure
-          # @sg-ignore Need to add nil check here
-          "#{pin.closure.path} | #{pin.name}"
-        else
-          "#{pin.context.namespace} | #{pin.name}"
-        end
-      else
-        pin.path
-      end
+               if pin.closure
+                 # @sg-ignore Need to add nil check here
+                 "#{pin.closure.path} | #{pin.name}"
+               else
+                 "#{pin.context.namespace} | #{pin.name}"
+               end
+             else
+               pin.path
+             end
       # @sg-ignore Need to add nil check here
       desc += " (#{pin.location.filename} #{pin.location.range.start.line})" if pin.location
       desc
@@ -376,7 +386,7 @@ module Solargraph
 
     # @param type [ComplexType, ComplexType::UniqueType]
     # @return [void]
-    def print_type(type)
+    def print_type type
       if options[:rbs]
         puts type.to_rbs
       else
@@ -386,7 +396,7 @@ module Solargraph
 
     # @param pin [Solargraph::Pin::Base]
     # @return [void]
-    def print_pin(pin)
+    def print_pin pin
       if options[:rbs]
         puts pin.to_rbs
       else

data/lib/solargraph/source/chain/array.rb

@@ -1,37 +1,39 @@
-module Solargraph
-  class Source
-    class Chain
-      class Array < Literal
-        # @param children [::Array<Chain>]
-        # @param node [Parser::AST::Node]
-        def initialize children, node
-          super('::Array', node)
-          @children = children
-        end
-
-        def word
-          @word ||= "<#{@type}>"
-        end
-
-        # @param api_map [ApiMap]
-        # @param name_pin [Pin::Base]
-        # @param locals [::Array<Pin::Parameter, Pin::LocalVariable>]
-        def resolve api_map, name_pin, locals
-          child_types = @children.map do |child|
-            child.infer(api_map, name_pin, locals).simplify_literals
-          end
-          type = if child_types.length == 0 || child_types.any?(&:undefined?)
-                   ComplexType::UniqueType.new('Array', rooted: true)
-                 elsif child_types.uniq.length == 1 && child_types.first.defined?
-                   ComplexType::UniqueType.new('Array', [], child_types.uniq, rooted: true, parameters_type: :list)
-                 elsif child_types.length == 0
-                   ComplexType::UniqueType.new('Array', rooted: true, parameters_type: :list)
-                 else
-                   ComplexType::UniqueType.new('Array', [], child_types, rooted: true, parameters_type: :fixed)
-                 end
-          [Pin::ProxyType.anonymous(type, source: :chain)]
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      class Array < Literal
+        # @param children [::Array<Chain>]
+        # @param node [Parser::AST::Node]
+        def initialize children, node
+          super('::Array', node)
+          @children = children
+        end
+
+        def word
+          @word ||= "<#{@type}>"
+        end
+
+        # @param api_map [ApiMap]
+        # @param name_pin [Pin::Base]
+        # @param locals [::Array<Pin::Parameter, Pin::LocalVariable>]
+        def resolve api_map, name_pin, locals
+          child_types = @children.map do |child|
+            child.infer(api_map, name_pin, locals).simplify_literals
+          end
+          type = if child_types.empty? || child_types.any?(&:undefined?)
+                   ComplexType::UniqueType.new('Array', rooted: true)
+                 elsif child_types.uniq.length == 1 && child_types.first.defined?
+                   ComplexType::UniqueType.new('Array', [], child_types.uniq, rooted: true, parameters_type: :list)
+                 elsif child_types.empty?
+                   ComplexType::UniqueType.new('Array', rooted: true, parameters_type: :list)
+                 else
+                   ComplexType::UniqueType.new('Array', [], child_types, rooted: true, parameters_type: :fixed)
+                 end
+          [Pin::ProxyType.anonymous(type, source: :chain)]
+        end
+      end
+    end
+  end
+end