solargraph 0.54.1 → 0.56.0

data/lib/solargraph/views/_method.erb

@@ -2,33 +2,33 @@
     Namespace:
 </h2>
 <p>
-    <a href="solargraph:/document?query=<%= CGI.escape object.namespace.path %>"><%= object.namespace %></a>
+    <a href="solargraph:/document?query=<%= CGI.escape pin.namespace.path %>"><%= pin.namespace %></a>
 </p>
 <h2>
     Overview:
 </h2>
-<%= htmlify object.docstring %>
+<%= htmlify pin.docstring %>
 <p class="document-section">
-    <big><strong>Visibility:</strong></big> <%= object.visibility %>
+    <big><strong>Visibility:</strong></big> <%= pin.visibility %>
 </p>
-<% unless object.tags(:param).empty? %>
+<% unless pin.docstring.tags(:param).empty? %>
     <h2>
         Parameters:
     </h2>
     <ul>
-        <% object.tags(:param).each do |tag| %>
+        <% pin.docstring.tags(:param).each do |tag| %>
             <li>
                 <%= erb :_name_type_tag, layout: false, locals: {tag: tag} %>
             </li>
         <% end %>
     </ul>
 <% end %>
-<% unless object.tags(:raise).empty? %>
+<% unless pin.docstring.tags(:raise).empty? %>
 <h2>
     Raises:
 </h2>
 <ul>
-    <% object.tags(:raise).each do |tag| %>
+    <% pin.docstring.tags(:raise).each do |tag| %>
         <li>
             <%= erb :_name_type_tag, layout: false, locals: {tag: tag} %>
         </li>
@@ -38,20 +38,20 @@
 <h2>
     Returns:
 </h2>
-<% if object.tag(:return).nil? %>
+<% if pin.docstring.tag(:return).nil? %>
     <p>
         Undefined/unknown
     </p>
 <% else %>
     <ul>
-        <% object.tags(:return).each do |tag| %>
+        <% pin.tags(:return).each do |tag| %>
             <li>
                 <%= erb :_name_type_tag, layout: false, locals: {tag: tag} %>
             </li>
         <% end %>
     </ul>
 <% end %>
-<% examples = object.tags(:example) %>
+<% examples = pin.docstring.tags(:example) %>
 <% unless examples.nil? %>
     <% examples.each do |example| %>
         <h2>

data/lib/solargraph/views/_namespace.erb

@@ -1,12 +1,12 @@
 <h2>
     Overview:
 </h2>
-<%= htmlify object.docstring %>
+<%= htmlify pin.docstring %>
 <h2>
     Class Methods
 </h2>
 <ul class="doc-list">
-    <% object.meths(scope: :class).sort{|a, b| a.name <=> b.name}.each do |meth| %>
+    <% api_map.get_methods(pin.path, scope: :class, deep: false).sort{|a, b| a.name <=> b.name}.each do |meth| %>
         <li>
             <a href="solargraph:/document?query=<%= CGI.escape(meth.path) %>"><%= meth.name %></a>
         </li>
@@ -16,7 +16,7 @@
     Instance Methods
 </h2>
 <ul class="doc-list">
-    <% object.meths(scope: :instance).sort{|a, b| a.name <=> b.name}.each do |meth| %>
+    <% api_map.get_methods(pin.path, scope: :instance, deep: false).sort{|a, b| a.name <=> b.name}.each do |meth| %>
         <li>
             <a href="solargraph:/document?query=<%= CGI.escape(meth.path) %>"><%= meth.name %></a>
         </li>

data/lib/solargraph/views/document.erb

@@ -1,23 +1,23 @@
-<% objects.reverse.each do |object| %>
+<% pins.each do |pin| %>
     <h1>
-        <%= object.name %>
-        <% if object.is_a?(YARD::CodeObjects::MethodObject) and !object.parameters.empty? %>
-            <small>(<%= object.parameters.map {|p| "#{p[0]}#{p[1] and p[0].end_with?(':') ? ' ' : (p[1] ? ' = ' : '')}#{p[1]}"}.join(', ') %>)</small>
+        <%= pin.name %>
+        <% if pin.is_a?(Solargraph::Pin::Method) && !pin.parameters.empty? %>
+            <small>(<%= pin.parameters.map {|p| "#{p[0]}#{p[1] and p[0].end_with?(':') ? ' ' : (p[1] ? ' = ' : '')}#{p[1]}"}.join(', ') %>)</small>
         <% end %>
     </h1>
-    <% unless object.files.empty? %>
+    <% unless pins.map(&:location).compact.empty? %>
         <h2>
             Defined in:
         </h2>
         <ul>
-            <% object.files.each do |f| %>
+            <% pins.map(&:location).compact.map(&:filename).each do |f| %>
                 <li><%= f %></li>
             <% end %>
         </ul>
     <% end %>
-    <% if object.is_a?(YARD::CodeObjects::NamespaceObject) %>
-        <%= erb :_namespace, layout: false, locals: {object: object} %>
-    <% elsif object.is_a?(YARD::CodeObjects::MethodObject) %>
-        <%= erb :_method, layout: false, locals: {object: object} %>
+    <% if pin.is_a?(Solargraph::Pin::Namespace) %>
+        <%= erb :_namespace, layout: false, locals: {api_map: api_map, pin: pin} %>
+    <% elsif pin.is_a?(Solargraph::Pin::Method) %>
+        <%= erb :_method, layout: false, locals: {api_map: api_map, pin: pin} %>
     <% end %>
 <% end %>

data/lib/solargraph/workspace/config.rb

@@ -15,7 +15,7 @@ module Solargraph
       attr_reader :directory
 
       # @todo To make this strongly typed we'll need a record syntax
-      # @return [Hash{String => undefined}]
+      # @return [Hash{String => Array, Hash, Integer, nil}]
       attr_reader :raw_data
 
       # @param directory [String]
@@ -90,6 +90,7 @@ module Solargraph
 
       # A hash of options supported by the formatter
       #
+      # @sg-ignore pending https://github.com/castwide/solargraph/pull/905
       # @return [Hash]
       def formatter
         raw_data['formatter']
@@ -104,6 +105,7 @@ module Solargraph
 
       # The maximum number of files to parse from the workspace.
       #
+      # @sg-ignore pending https://github.com/castwide/solargraph/pull/905
       # @return [Integer]
       def max_files
         raw_data['max_files']
@@ -123,7 +125,7 @@ module Solargraph
         File.join(@directory, '.solargraph.yml')
       end
 
-      # @return [Hash{String => Array, Hash, Integer}]
+      # @return [Hash{String => Array<undefined>, Hash{String => undefined}, Integer}]
       def config_data
         workspace_config = read_config(workspace_config_path)
         global_config = read_config(global_config_path)
@@ -226,7 +228,9 @@ module Solargraph
 
       # @return [Array<String>]
       def excluded_directories
-        @raw_data['exclude']
+        # @type [Array<String>]
+        excluded = @raw_data['exclude']
+        excluded
           .select { |g| glob_is_directory?(g) }
           .map { |g| File.absolute_path(glob_to_directory(g), directory) }
       end

data/lib/solargraph/workspace.rb

@@ -45,7 +45,7 @@ module Solargraph
     # or add it to the sources if the workspace is configured to include it.
     # The source is ignored if the configuration excludes it.
     #
-    # @param source [Solargraph::Source]
+    # @param sources [Array<Solargraph::Source>]
     # @return [Boolean] True if the source was added to the workspace
     def merge *sources
       unless directory == '*' || sources.all? { |source| source_hash.key?(source.filename) }
@@ -106,7 +106,7 @@ module Solargraph
     def would_require? path
       require_paths.each do |rp|
         full = File.join rp, path
-        return true if File.exist?(full) or File.exist?(full << ".rb")
+        return true if File.file?(full) || File.file?(full << ".rb")
       end
       false
     end
@@ -133,6 +133,15 @@ module Solargraph
       @gem_rbs_collection ||= read_rbs_collection_path
     end
 
+    def rbs_collection_config_path
+      @rbs_collection_config_path ||= begin
+        unless directory.empty? || directory == '*'
+          yaml_file = File.join(directory, 'rbs_collection.yaml')
+          yaml_file if File.file?(yaml_file)
+        end
+      end
+    end
+
     # Synchronize the workspace from the provided updater.
     #
     # @param updater [Source::Updater]
@@ -214,7 +223,7 @@ module Solargraph
     def configured_require_paths
       return ['lib'] if directory.empty?
       return [File.join(directory, 'lib')] if config.require_paths.empty?
-      config.require_paths.map{|p| File.join(directory, p)}
+      config.require_paths.map { |p| File.join(directory, p) }
     end
 
     # @return [void]
@@ -230,10 +239,11 @@ module Solargraph
 
     # @return [String, nil]
     def read_rbs_collection_path
-      yaml_file = File.join(directory, 'rbs_collection.yaml')
-      return unless File.file?(yaml_file)
+      return unless rbs_collection_config_path
 
-      YAML.load_file(yaml_file)&.fetch('path')
+      path = YAML.load_file(rbs_collection_config_path)&.fetch('path')
+      # make fully qualified
+      File.expand_path(path, directory)
     end
   end
 end

data/lib/solargraph/yard_map/mapper/to_constant.rb

@@ -6,17 +6,20 @@ module Solargraph
       module ToConstant
         extend YardMap::Helpers
 
+        # @param code_object [YARD::CodeObjects::Base]
         def self.make code_object, closure = nil, spec = nil
           closure ||= Solargraph::Pin::Namespace.new(
             name: code_object.namespace.to_s,
-            gates: [code_object.namespace.to_s]
+            gates: [code_object.namespace.to_s],
+            source: :yardoc,
           )
           Pin::Constant.new(
             location: object_location(code_object, spec),
             closure: closure,
             name: code_object.name.to_s,
             comments: code_object.docstring ? code_object.docstring.all.to_s : '',
-            visibility: code_object.visibility
+            visibility: code_object.visibility,
+            source: :yardoc
           )
         end
       end

data/lib/solargraph/yard_map/mapper/to_method.rb

@@ -6,6 +6,11 @@ module Solargraph
       module ToMethod
         extend YardMap::Helpers
 
+        VISIBILITY_OVERRIDE = {
+          # YARD pays attention to 'private' statements prior to class methods but shouldn't
+          ["Rails::Engine", :class, "find_root_with_flag"] => :public
+        }
+
         # @param code_object [YARD::CodeObjects::Base]
         # @param name [String, nil]
         # @param scope [Symbol, nil]
@@ -16,29 +21,63 @@ module Solargraph
         def self.make code_object, name = nil, scope = nil, visibility = nil, closure = nil, spec = nil
           closure ||= Solargraph::Pin::Namespace.new(
             name: code_object.namespace.to_s,
-            gates: [code_object.namespace.to_s]
+            gates: [code_object.namespace.to_s],
+            type: code_object.namespace.is_a?(YARD::CodeObjects::ClassObject) ? :class : :module,
+            source: :yardoc,
           )
           location = object_location(code_object, spec)
           name ||= code_object.name.to_s
           return_type = ComplexType::SELF if name == 'new'
           comments = code_object.docstring ? code_object.docstring.all.to_s : ''
-          pin = Pin::Method.new(
-            location: location,
-            closure: closure,
-            name: name,
-            comments: comments,
-            scope: scope || code_object.scope,
-            visibility: visibility || code_object.visibility,
-            # @todo Might need to convert overloads to signatures
-            parameters: [],
-            explicit: code_object.is_explicit?,
-            return_type: return_type
-          )
-          pin.parameters.concat get_parameters(code_object, location, comments, pin)
+          final_scope = scope || code_object.scope
+          override_key = [closure.path, final_scope, name]
+          final_visibility = VISIBILITY_OVERRIDE[override_key]
+          final_visibility ||= VISIBILITY_OVERRIDE[override_key[0..-2]]
+          final_visibility ||= :private if closure.path == 'Kernel' && Kernel.private_instance_methods(false).include?(name)
+          final_visibility ||= visibility
+          final_visibility ||= :private if code_object.module_function? && final_scope == :instance
+          final_visibility ||= :public if code_object.module_function? && final_scope == :class
+          final_visibility ||= code_object.visibility
+          if code_object.is_alias?
+            origin_code_object = code_object.namespace.aliases[code_object]
+            pin = Pin::MethodAlias.new(
+              name: name,
+              location: location,
+              original: origin_code_object.name.to_s,
+              closure: closure,
+              comments: comments,
+              scope: final_scope,
+              visibility: final_visibility,
+              explicit: code_object.is_explicit?,
+              return_type: return_type,
+              parameters: [],
+              source: :yardoc,
+            )
+          else
+            pin = Pin::Method.new(
+              location: location,
+              closure: closure,
+              name: name,
+              comments: comments,
+              scope: final_scope,
+              visibility: final_visibility,
+              # @todo Might need to convert overloads to signatures
+              explicit: code_object.is_explicit?,
+              return_type: return_type,
+              attribute: code_object.is_attribute?,
+              parameters: [],
+              source: :yardoc,
+            )
+            pin.parameters.concat get_parameters(code_object, location, comments, pin)
+            pin.parameters.freeze
+          end
+          logger.debug { "ToMethod.make: Just created method pin: #{pin.inspect}" }
           pin
         end
 
         class << self
+          include Logging
+
           private
 
           # @param code_object [YARD::CodeObjects::Base]
@@ -59,7 +98,8 @@ module Solargraph
                 name: arg_name(a),
                 presence: nil,
                 decl: arg_type(a),
-                asgn_code: a[1]
+                asgn_code: a[1],
+                source: :yardoc,
               )
             end
           end

data/lib/solargraph/yard_map/mapper/to_namespace.rb

@@ -6,11 +6,13 @@ module Solargraph
       module ToNamespace
         extend YardMap::Helpers
 
+        # @param code_object [YARD::CodeObjects::NamespaceObject]
         def self.make code_object, spec, closure = nil
           closure ||= Solargraph::Pin::Namespace.new(
             name: code_object.namespace.to_s,
             closure: Pin::ROOT_PIN,
-            gates: [code_object.namespace.to_s]
+            gates: [code_object.namespace.to_s],
+            source: :yardoc,
           )
           Pin::Namespace.new(
             location: object_location(code_object, spec),
@@ -18,7 +20,8 @@ module Solargraph
             comments: code_object.docstring ? code_object.docstring.all.to_s : '',
             type: code_object.is_a?(YARD::CodeObjects::ClassObject) ? :class : :module,
             visibility: code_object.visibility,
-            closure: closure
+            closure: closure,
+            source: :yardoc,
           )
         end
       end

data/lib/solargraph/yard_map/mapper.rb

@@ -12,6 +12,7 @@ module Solargraph
       def initialize code_objects, spec = nil
         @code_objects = code_objects
         @spec = spec
+        # @type [Array<Solargraph::Pin::Base>]
         @pins = []
         @namespace_pins = {}
       end
@@ -46,15 +47,16 @@ module Solargraph
             else
               code_object.superclass.to_s
             end
-            result.push Solargraph::Pin::Reference::Superclass.new(name: superclass, closure: nspin)
+            result.push Solargraph::Pin::Reference::Superclass.new(name: superclass, closure: nspin, source: :yard_map)
           end
           code_object.class_mixins.each do |m|
-            result.push Solargraph::Pin::Reference::Extend.new(closure: nspin, name: m.path)
+            result.push Solargraph::Pin::Reference::Extend.new(closure: nspin, name: m.path, source: :yard_map)
           end
           code_object.instance_mixins.each do |m|
             result.push Solargraph::Pin::Reference::Include.new(
               closure: nspin, # @todo Fix this
-              name: m.path
+              name: m.path,
+              source: :yard_map
             )
           end
         elsif code_object.is_a?(YARD::CodeObjects::MethodObject)

data/lib/solargraph/yard_map/to_method.rb

@@ -23,7 +23,8 @@ module Solargraph
               name: arg_name(a),
               presence: nil,
               decl: arg_type(a),
-              asgn_code: a[1]
+              asgn_code: a[1],
+              source: :yard_map
             )
           end
         end
@@ -78,7 +79,8 @@ module Solargraph
           scope: scope || code_object.scope,
           visibility: visibility || code_object.visibility,
           parameters: InnerMethods.get_parameters(code_object, location, comments),
-          explicit: code_object.is_explicit?
+          explicit: code_object.is_explicit?,
+          source: :yard_map
         )
       end
     end

data/lib/solargraph/yardoc.rb

@@ -12,7 +12,7 @@ module Solargraph
     # @param gemspec [Gem::Specification]
     # @return [String] The path to the cached yardoc.
     def cache(gemspec)
-      path = path_for(gemspec)
+      path = PinCache.yardoc_path gemspec
       return path if cached?(gemspec)
 
       Solargraph.logger.info "Caching yardoc for #{gemspec.name} #{gemspec.version}"
@@ -26,16 +26,13 @@ module Solargraph
     #
     # @param gemspec [Gem::Specification]
     def cached?(gemspec)
-      yardoc = File.join(path_for(gemspec), 'complete')
+      yardoc = File.join(PinCache.yardoc_path(gemspec), 'complete')
       File.exist?(yardoc)
     end
 
-    # Get the absolute path for a cached gem yardoc.
-    #
-    # @param gemspec [Gem::Specification]
-    # @return [String]
-    def path_for(gemspec)
-      File.join(Solargraph::Cache.work_dir, 'gems', "#{gemspec.name}-#{gemspec.version}.yardoc")
+    def processing?(gemspec)
+      yardoc = File.join(PinCache.yardoc_path(gemspec), 'processing')
+      File.exist?(yardoc)
     end
 
     # Load a gem's yardoc and return its code objects.
@@ -45,7 +42,7 @@ module Solargraph
     # @param gemspec [Gem::Specification]
     # @return [Array<YARD::CodeObjects::Base>]
     def load!(gemspec)
-      YARD::Registry.load! path_for(gemspec)
+      YARD::Registry.load! PinCache.yardoc_path gemspec
       YARD::Registry.all
     end
   end

data/lib/solargraph.rb

@@ -2,6 +2,7 @@
 
 Encoding.default_external = 'UTF-8'
 
+require 'bundler'
 require 'set'
 require 'yard-solargraph'
 require 'solargraph/yard_tags'
@@ -42,15 +43,33 @@ module Solargraph
   autoload :Logging,          'solargraph/logging'
   autoload :TypeChecker,      'solargraph/type_checker'
   autoload :Environ,          'solargraph/environ'
+  autoload :Equality,         'solargraph/equality'
   autoload :Convention,       'solargraph/convention'
   autoload :Parser,           'solargraph/parser'
   autoload :RbsMap,           'solargraph/rbs_map'
   autoload :GemPins,          'solargraph/gem_pins'
-  autoload :Cache,            'solargraph/cache'
+  autoload :PinCache,         'solargraph/pin_cache'
 
   dir = File.dirname(__FILE__)
   VIEWS_PATH = File.join(dir, 'solargraph', 'views')
 
+  # @param type [Symbol] Type of assert.
+  def self.asserts_on?(type)
+    if ENV['SOLARGRAPH_ASSERTS'].nil? || ENV['SOLARGRAPH_ASSERTS'].empty?
+      false
+    elsif ENV['SOLARGRAPH_ASSERTS'] == 'on'
+      true
+    else
+      logger.warn "Unrecognized SOLARGRAPH_ASSERTS value: #{ENV['SOLARGRAPH_ASSERTS']}"
+      false
+    end
+  end
+
+  def self.assert_or_log(type, msg = nil, &block)
+    raise (msg || block.call) if asserts_on?(type) && ![:combine_with_visibility].include?(type)
+    logger.info msg, &block
+  end
+
   # A convenience method for Solargraph::Logging.logger.
   #
   # @return [Logger]

data/rbs/fills/tuple.rbs

@@ -0,0 +1,150 @@
+# <-- liberally borrowed from
+#     https://github.com/ruby/rbs/blob/master/core/array.rbs, which
+#     was generated from
+#     https://github.com/ruby/ruby/blob/master/array.c
+#     -->
+module Solargraph
+  module Fills
+    class Tuple[unchecked out A,
+                unchecked out B = A,
+                unchecked out C = A | B,
+                unchecked out D = A | B | C,
+                unchecked out E = A | B | C | D,
+                unchecked out F = A | B | C | D | E,
+                unchecked out G = A | B | C | D | E | F,
+                unchecked out H = A | B | C | D | E | F | G,
+                unchecked out I = A | B | C | D | E | F | G | H,
+                unchecked out J = A | B | C | D | E | F | G | H | I] < Array[A | B | C | D | E | F | G | H | I | J]
+      # <!--
+      #   rdoc-file=array.c
+      #   - self[index] -> object or nil
+      # -->
+      # Returns elements from `self`; does not modify `self`.
+      #
+      # In brief:
+      #
+      #     a = [:foo, 'bar', 2]
+      #
+      #     # Single argument index: returns one element.
+      #     a[0]     # => :foo          # Zero-based index.
+      #
+      # When a single integer argument `index` is given, returns the element at offset
+      # `index`:
+      #
+      #     a = [:foo, 'bar', 2]
+      #     a[0] # => :foo
+      #     a[2] # => 2
+      #     a # => [:foo, "bar", 2]
+      def []: (0 index) -> A
+            | (1 index) -> B
+            | (2 index) -> C
+            | (3 index) -> D
+            | (4 index) -> E
+            | (5 index) -> F
+            | (6 index) -> G
+            | (7 index) -> H
+            | (8 index) -> I
+            | (9 index) -> J
+            | (0 index) -> K
+            | (int index) -> nil
+
+      # <!--
+      #   rdoc-file=array.c
+      #   - at(index) -> object or nil
+      # -->
+      # Returns the element of `self` specified by the given `index` or `nil` if there
+      # is no such element; `index` must be an [integer-convertible
+      # object](rdoc-ref:implicit_conversion.rdoc@Integer-Convertible+Objects).
+      #
+      # For non-negative `index`, returns the element of `self` at offset `index`:
+      #
+      #     a = [:foo, 'bar', 2]
+      #     a.at(0)   # => :foo
+      #     a.at(2)   # => 2
+      #     a.at(2.0) # => 2
+      #
+      # Related: Array#[]; see also [Methods for
+      # Fetching](rdoc-ref:Array@Methods+for+Fetching).
+      #
+      def at: (0 index) -> A
+            | (1 index) -> B
+            | (2 index) -> C
+            | (3 index) -> D
+            | (4 index) -> E
+            | (5 index) -> F
+            | (6 index) -> G
+            | (7 index) -> H
+            | (8 index) -> I
+            | (9 index) -> J
+            | (int index) -> nil
+
+      # <!--
+      #   rdoc-file=array.c
+      #   - fetch(index) -> element
+      #   - fetch(index, default_value) -> element or default_value
+      #   - fetch(index) {|index| ... } -> element or block_return_value
+      # -->
+      # Returns the element of `self` at offset `index` if `index` is in range;
+      # `index` must be an [integer-convertible
+      # object](rdoc-ref:implicit_conversion.rdoc@Integer-Convertible+Objects).
+      #
+      # With the single argument `index` and no block, returns the element at offset
+      # `index`:
+      #
+      #     a = [:foo, 'bar', 2]
+      #     a.fetch(1)   # => "bar"
+      #     a.fetch(1.1) # => "bar"
+      #
+      # With arguments `index` and `default_value` (which may be any object) and no
+      # block, returns `default_value` if `index` is out-of-range:
+      #
+      #     a = [:foo, 'bar', 2]
+      #     a.fetch(1, nil)  # => "bar"
+      #     a.fetch(3, :foo) # => :foo
+      #
+      # With argument `index` and a block, returns the element at offset `index` if
+      # index is in range (and the block is not called); otherwise calls the block
+      # with index and returns its return value:
+      #
+      #     a = [:foo, 'bar', 2]
+      #     a.fetch(1) {|index| raise 'Cannot happen' } # => "bar"
+      #     a.fetch(50) {|index| "Value for #{index}" } # => "Value for 50"
+      #
+      # Related: see [Methods for Fetching](rdoc-ref:Array@Methods+for+Fetching).
+      #
+      def fetch: (0 index) -> A
+               | (1 index) -> B
+               | (2 index) -> C
+               | (3 index) -> D
+               | (4 index) -> E
+               | (5 index) -> F
+               | (6 index) -> G
+               | (7 index) -> H
+               | (8 index) -> I
+               | (9 index) -> J
+               | (int index) -> void
+               | [T] (0 index, T default) -> (A | T)
+               | [T] (1 index, T default) -> (B | T)
+               | [T] (2 index, T default) -> (C | T)
+               | [T] (3 index, T default) -> (D | T)
+               | [T] (4 index, T default) -> (E | T)
+               | [T] (5 index, T default) -> (F | T)
+               | [T] (6 index, T default) -> (G | T)
+               | [T] (7 index, T default) -> (H | T)
+               | [T] (8 index, T default) -> (I | T)
+               | [T] (9 index, T default) -> (J | T)
+               | [T] (int index, T default) -> (A | B | C | D | E | F |G | H | I | J | T)
+               | [T] (0 index) { (int index) -> T } -> (A | T)
+               | [T] (1 index) { (int index) -> T } -> (B | T)
+               | [T] (2 index) { (int index) -> T } -> (C | T)
+               | [T] (3 index) { (int index) -> T } -> (D | T)
+               | [T] (4 index) { (int index) -> T } -> (E | T)
+               | [T] (5 index) { (int index) -> T } -> (F | T)
+               | [T] (6 index) { (int index) -> T } -> (G | T)
+               | [T] (7 index) { (int index) -> T } -> (H | T)
+               | [T] (8 index) { (int index) -> T } -> (I | T)
+               | [T] (9 index) { (int index) -> T } -> (J | T)
+               | [T] (int index) { (int index) -> T } -> (A | B | C | D | E | F |G | H | I | J | T)
+    end
+  end
+end