Properly multiline user-multilined call chains

fixtures/large/rspec_mocks_proxy_expected.rb

@@ -305,7 +305,10 @@ def reset
     class PartialDoubleProxy < Proxy
       def original_method_handle_for(message)
         if any_instance_class_recorder_observing_method?(@object.class, message)
-          message = ::RSpec::Mocks.space.any_instance_recorder_for(@object.class).build_alias_method_name(message)
+          message = ::RSpec::Mocks
+            .space
+            .any_instance_recorder_for(@object.class)
+            .build_alias_method_name(message)
         end
 
         ::RSpec::Support.method_handle_for(@object, message)

fixtures/small/comments_at_indentation_changes_expected.rb

@@ -1,6 +1,9 @@
 it "" do
-  # Should only download the patches twice
-  Test::Mock.expects(Util, :download_file).twice.returns(true)
+  Test::Mock
+    .expects(Util, :download_file)
+    # Should only download the patches twice
+    .twice
+    .returns(true)
 end
 
 # Make some fake thing

fixtures/small/method_annotation_expected.rb

@@ -3,7 +3,9 @@ def empty_example
 end
 
 sig do
-  params(a: T::Array[String], b: T::Hash[Symbol, String]).returns(T::Set[Symbol]).checked(:tests)
+  params(a: T::Array[String], b: T::Hash[Symbol, String])
+    .returns(T::Set[Symbol])
+    .checked(:tests)
 end
 def do_the_thing(a, b)
   puts(a)

fixtures/small/method_chains_actual.rb

@@ -13,6 +13,28 @@
   b: ""
 )
 
+foo.bar.baz
+
+foo.bar
+.baz
+
+# If they're all on the same line but different from
+# the first receiver, consider that "on one line"
+foo
+.bar.baz
+
+foo::bar
+&.nil?
+
+foo::bar
+&.nil?::klass
+.true?
+
+Class
+&.new
+.call!
+
+
 def example
   things
     .map do |thing|

fixtures/small/method_chains_expected.rb

@@ -15,6 +15,26 @@
     b: ""
   )
 
+foo.bar.baz
+
+foo
+  .bar
+  .baz
+
+# If they're all on the same line but different from
+# the first receiver, consider that "on one line"
+foo.bar.baz
+
+foo::bar&.nil?
+
+foo::bar
+  &.nil?::klass
+  .true?
+
+Class
+  &.new
+  .call!
+
 def example
   things
     .map do |thing|

librubyfmt/rubyfmt_lib.rb

@@ -169,6 +169,10 @@ def escape_percent_array_paren_content(part, pattern)
     end
   end
 
+  def on_op(*_args)
+    super + [[lineno, lineno]]
+  end
+
   def on_next(*_args)
     super + [start_end_for_keyword('next')]
   end

librubyfmt/src/format.rs

@@ -2789,7 +2789,16 @@ fn format_call_chain_elements(
                     ps.start_indent();
                     has_indented = true;
                 }
-                if render_multiline_chain {
+                let is_double_colon = match &d {
+                    DotTypeOrOp::ColonColon(_) => true,
+                    DotTypeOrOp::StringDot(val) => val == "::",
+                    _ => false,
+                };
+                if render_multiline_chain
+                    // Separating `::` calls with a newline
+                    // isn't valid syntax
+                    && !is_double_colon
+                {
                     ps.emit_newline();
                     ps.emit_indent();
                 }
@@ -2844,9 +2853,10 @@ fn is_heredoc_call_chain_with_breakables(cc_elements: &[CallChainElement]) -> bo
 ///
 /// ## High-level rules
 ///
-/// The two main rules that govern whether or not to multiline a method chain is to split across multiple lines if
-/// (1) the whole chain exceeds the maximum line length or
-/// (2) the chain contains blocks that are split across multiple lines
+/// The three main rules that govern whether or not to multiline a method chain is to split across multiple lines if
+/// (1) the user multilined the chain,
+/// (2) the whole chain exceeds the maximum line length, or
+/// (3) the chain contains blocks that are split across multiple lines
 ///
 /// That said, both of these have some *very large* asterisks, since there are a lot of contexts in which these
 /// have special cases for various reasons (see below).
@@ -2884,6 +2894,38 @@ fn should_multiline_call_chain(ps: &mut dyn ConcreteParserState, method_call: &M
         CallChainElement::ArgsAddStarOrExpressionListOrArgsForward(args, start_end),
     ]);
 
+    let all_op_locations = call_chain_to_check
+        .iter()
+        .filter_map(|cc_elem| match cc_elem {
+            CallChainElement::DotTypeOrOp(dot_type_or_op) => {
+                match dot_type_or_op {
+                    // ColonColon is specially represented in the parser, and
+                    // it can't be properly multilined anyways, so we ignore it here
+                    DotTypeOrOp::ColonColon(..) => None,
+                    DotTypeOrOp::StringDot(..) => None,
+                    DotTypeOrOp::Op(Op(.., start_end))
+                    | DotTypeOrOp::DotType(
+                        DotType::LonelyOperator(LonelyOperator(_, start_end))
+                        | DotType::Dot(Dot(_, start_end)),
+                    ) => Some(start_end.clone()),
+                    DotTypeOrOp::Period(Period(.., linecol)) => {
+                        Some(StartEnd(linecol.0, linecol.0))
+                    }
+                }
+            }
+            _ => None,
+        })
+        .collect::<Vec<StartEnd>>();
+    // Multiline the chain if all the operators (dots, double colons, etc.) are not on the same line
+    if let Some(first_op_start_end) = all_op_locations.first() {
+        let chain_is_user_multilined = !all_op_locations
+            .iter()
+            .all(|op_start_end| op_start_end == first_op_start_end);
+        if chain_is_user_multilined {
+            return true;
+        }
+    }
+
     // Ignore chains that are basically only method calls, e.g.
     // ````ruby
     // Thing.foo(args)

librubyfmt/src/ripper_tree_types.rs

@@ -994,7 +994,7 @@ pub struct BlockArg(pub blockarg_tag, pub Ident);
 #[derive(Deserialize, Debug, Clone)]
 pub struct LineCol(pub LineNumber, pub u64);
 
-#[derive(Deserialize, Debug, Clone)]
+#[derive(Deserialize, Debug, Clone, Eq, PartialEq)]
 pub struct StartEnd(pub LineNumber, pub LineNumber);
 
 impl StartEnd {
@@ -1527,19 +1527,19 @@ pub struct Equals(pub equals_tag);
 
 def_tag!(dot_tag, ".");
 #[derive(Deserialize, Debug, Clone)]
-pub struct Dot(pub dot_tag);
+pub struct Dot(pub dot_tag, pub StartEnd);
 
 def_tag!(colon_colon_tag, "::");
 #[derive(Deserialize, Debug, Clone)]
 pub struct ColonColon(pub colon_colon_tag);
 
 def_tag!(lonely_operator_tag, "&.");
 #[derive(Deserialize, Debug, Clone)]
-pub struct LonelyOperator(pub lonely_operator_tag);
+pub struct LonelyOperator(pub lonely_operator_tag, pub StartEnd);
 
 def_tag!(op_tag, "@op");
 #[derive(Deserialize, Debug, Clone)]
-pub struct Op(pub op_tag, pub Operator, pub LineCol);
+pub struct Op(pub op_tag, pub Operator, pub LineCol, pub StartEnd);
 
 #[derive(RipperDeserialize, Debug, Clone)]
 pub enum Operator {