Infer element types for array literals and NilClass for nil literals

Array literal chains (`[1, 2, 3]`) previously resolved to a bare
`Array` with no element type. Infer each child's type and attach it
as the Array's generic parameter, falling back to plain `Array` when
empty or undefined.

`simplify_literals` left the `nil` pseudo-type tag as-is instead of
converting it to `NilClass` like other literals are converted to their
class names. This also surfaced two previously-pending specs
(NilClass/nil conformance, and passing a NilClass value to a `nil`
parameter) that now pass.

Author: apiology

lib/solargraph/complex_type/unique_type.rb

@@ -103,6 +103,7 @@ def to_s
       # @return [self]
       def simplify_literals
         transform do |t|
+          next t.recreate(new_name: 'NilClass') if t.nil_type?
           next t unless t.literal?
           t.recreate(new_name: t.non_literal_name)
         end
@@ -309,7 +310,7 @@ def to_rbs
           'untyped'
         elsif name == 'Boolean'
           'bool'
-        elsif name.downcase == 'nil'
+        elsif name.downcase == 'nil' || name == 'NilClass'
           'nil'
         elsif name == GENERIC_TAG_NAME
           all_params.first&.name

lib/solargraph/source/chain/array.rb

@@ -19,7 +19,16 @@ def word
         # @param name_pin [Pin::Base]
         # @param locals [::Array<Pin::Parameter, Pin::LocalVariable>]
         def resolve api_map, name_pin, locals
-          type = ComplexType::UniqueType.new('Array', rooted: true)
+          type = if @children.empty?
+                   ComplexType::UniqueType.new('Array', rooted: true)
+                 else
+                   element_type = ComplexType.new(@children.map { |c| c.infer(api_map, name_pin, locals) })
+                   if element_type.undefined?
+                     ComplexType::UniqueType.new('Array', rooted: true)
+                   else
+                     ComplexType::UniqueType.new('Array', [], [element_type], rooted: true, parameters_type: :list)
+                   end
+                 end
           [Pin::ProxyType.anonymous(type, source: :chain)]
         end
       end

spec/complex_type/conforms_to_spec.rb

@@ -81,7 +81,6 @@ class Sub < Sup; end
   end
 
   it 'handles singleton types compared against their literals' do
-    pending 'side of effect of inference changes'
     exp = Solargraph::ComplexType::UniqueType.new('nil', rooted: true)
     inf = Solargraph::ComplexType::UniqueType.new('NilClass', rooted: true)
     match = inf.conforms_to?(api_map, exp, :method_call)

spec/pin/base_variable_spec.rb

@@ -42,7 +42,7 @@ def bar
     pin = api_map.get_instance_variable_pins('Foo').first
     type = pin.probe(api_map)
     expect(type.tags).to eq('Integer, nil')
-    expect(type.simple_tags).to eq('Integer, nil')
+    expect(type.simple_tags).to eq('Integer, NilClass')
     expect(type.to_rbs).to eq('(::Integer | nil)')
     expect(type.simplify_literals.to_rbs).to eq('(::Integer | nil)')
   end

spec/pin/method_spec.rb

@@ -321,7 +321,7 @@ def bar
     type = pin.probe(api_map)
     expect(type.rooted_tags).to eq('::Integer, nil')
     expect(type.to_rbs).to eq('(::Integer | nil)')
-    expect(type.simple_tags).to eq('Integer, nil')
+    expect(type.simple_tags).to eq('Integer, NilClass')
   end
 
   it 'infers from chains' do

spec/type_checker/levels/strict_spec.rb

@@ -1021,7 +1021,6 @@ def foo(a); end
     end
 
     it 'does not complain when passing NilClass to nil parameter' do
-      pending 'should be feasible'
       checker = type_checker(%(
         # @param a [nil]
         def foo(a); end