Fix variables assigned inside && conditions with method calls incorrectly got Nil added to their type (#16512)

Variables assigned on the right-hand side of a `&&` operator were missing `TruthyFilters`.
Because they were not present within `@type_filters`, `Nil` was being added to its type since the compiler thought they actually were nilable.

Author: Blacksmoke16

spec/compiler/semantic/if_spec.cr

@@ -448,6 +448,47 @@ describe "Semantic: if" do
       CRYSTAL
   end
 
+  it "doesn't add Nil to var assigned in && condition with method call (#15739)" do
+    assert_type(<<-CRYSTAL, inject_primitives: true) { int32 }
+      def foo
+        if true && (x = 1) == 1
+          x
+        else
+          0
+        end
+      end
+      foo
+      CRYSTAL
+  end
+
+  it "types var assigned in && condition correctly when used after (#15739)" do
+    assert_type(<<-CRYSTAL, inject_primitives: true) { int32 }
+      def bar : Int32
+        1
+      end
+
+      def foo
+        if true && (x = bar) > 0
+          x
+        else
+          0
+        end
+      end
+      foo
+      CRYSTAL
+  end
+
+  it "allows chained comparisons of 4+ expressions (#16361)" do
+    assert_type(<<-CRYSTAL, inject_primitives: true) { bool }
+      def a; 1; end
+      def b; 2; end
+      def c; 3; end
+      def d; 4; end
+
+      a < b < c < d
+      CRYSTAL
+  end
+
   it "includes pointer types in falsey branch" do
     assert_type(<<-CRYSTAL) { nilable union_of bool, pointer_of(int32), int32 }
       def foo

src/compiler/crystal/semantic/filters.cr

@@ -287,6 +287,14 @@ module Crystal
       new node, TruthyFilter.instance
     end
 
+    def self.truthy_var(name : String)
+      new_filters = new
+      filter = TruthyFilter.instance
+      new_filters.pos[name] = filter
+      new_filters.neg[name] = filter.not
+      new_filters
+    end
+
     def self.and(filters1, filters2)
       return nil if filters1.nil? && filters2.nil?
 

src/compiler/crystal/semantic/main_visitor.cr

@@ -2017,7 +2017,15 @@ module Crystal
           # `a && b` is expanded to `a ? b : a`
           # We don't use `else_type_filters` because if `a` is a temp var
           # assignment then `cond_type_filters` would contain more information
-          @type_filters = TypeFilters.and(cond_type_filters, then_type_filters)
+          and_filters = TypeFilters.and(cond_type_filters, then_type_filters)
+          # For variables assigned in the then branch but not in the condition,
+          # add truthy filters so they're properly narrowed when the && result
+          # is used as a condition (#15739)
+          then_vars.each do |name, _|
+            next if cond_vars.has_key?(name)
+            and_filters = TypeFilters.and(and_filters, TypeFilters.truthy_var(name))
+          end
+          @type_filters = and_filters
         when .or?
           # `a || b` is expanded to `a ? a : b`
           @type_filters = TypeFilters.or(cond_type_filters, else_type_filters)