Add specialized #first and #last type for tuples

lib/steep/ast/types/factory.rb

@@ -468,6 +468,36 @@ def interface(type, private:, self_type: type)
                     incompatible: false
                   )
                 end
+
+                array_interface.methods[:first] = array_interface.methods[:first].yield_self do |first|
+                  Interface::Interface::Combination.overload(
+                    [
+                      Interface::MethodType.new(
+                        type_params: [],
+                        params: Interface::Params.empty,
+                        block: nil,
+                        return_type: type.types[0] || AST::Builtin.nil_type,
+                        location: nil
+                      )
+                    ],
+                    incompatible: false
+                  )
+                end
+
+                array_interface.methods[:last] = array_interface.methods[:last].yield_self do |last|
+                  Interface::Interface::Combination.overload(
+                    [
+                      Interface::MethodType.new(
+                        type_params: [],
+                        params: Interface::Params.empty,
+                        block: nil,
+                        return_type: type.types.last || AST::Builtin.nil_type,
+                        location: nil
+                      )
+                    ],
+                    incompatible: false
+                  )
+                end
               end
             end
 

test/test_helper.rb

@@ -287,6 +287,9 @@ def each: { (A) -> untyped } -> self
   def zip: [B] (Array[B]) -> Array[A | B]
   def each_with_object: [B] (B) { (A, B) -> untyped } -> B
   def map: [X] { (A) -> X } -> Array[X]
+
+  def first: () -> A?
+  def last: () -> A?
 end
 
 class Hash[A, B]

test/type_construction_test.rb

@@ -3741,6 +3741,27 @@ def test_tuple5_subtyping
     end
   end
 
+  def test_tuple_first_last
+    with_checker do |checker|
+      source = parse_ruby(<<EOF)
+# @type var x: [Integer, String]
+x = (_=[])
+
+a = x.first
+b = x.last
+EOF
+
+      with_standard_construction(checker, source) do |construction, typing|
+        _, _, context = construction.synthesize(source.node)
+
+        assert_no_error typing
+
+        assert_equal parse_type('::Integer'), context.lvar_env[:a]
+        assert_equal parse_type('::String'), context.lvar_env[:b]
+      end
+    end
+  end
+
   def test_hash_tuple
     with_checker do |checker|
       source = parse_ruby(<<EOF)