private void Wrapping()

in ReSharper.FSharp/src/FSharp/FSharp.Psi/src/CodeFormatter/FSharpCodeFormatterInfoProvider.cs [59:165]
86 lines of code
1 McCabe index (conditional complexity)

    private void Wrapping()
    {
      Describe<WrapRule>()
        .Name($"FieldPatKeepTogether")
        .Where(Node().In(ElementType.FIELD_PAT))
        .Return(WrapType.KeepTogether)
        .Build();

      var pattern = Node().In(ElementType.PAREN_PAT)
        .Satisfies((node, _) => ((IParenPat)node.Node).Pattern is ITuplePat).Or().In(ElementType.PAREN_EXPR)
        .Satisfies((node, _) => ((IParenExpr)node.Node).InnerExpression is ITupleExpr);
      Describe<WrapRule>()
        .Name($"ChopArguments")
        .Where(pattern)
        .Switch(key => key.WrapArguments,
          When(WrapStyleSimple.CHOP_IF_LONG).Return(WrapType.Chop | WrapType.StartAtExternal))
        .Build();

      var blank = pattern.BuildBlank();
      Describe<FormattingRule>()
        .Name($"ChopArguments")
        .Where(
          Parent().Is(blank),
          Left().In(FSharpTokenType.LPAREN))
        .Switch(key => key.PreferLineBreakAfterMultilineLparen,
          When(true)
            .Switch(key => key.WrapArguments,
              When(WrapStyleSimple.CHOP_IF_LONG)
                .Return(IntervalFormatType.InsertNewLineConditionally),
              When(WrapStyleSimple.WRAP_IF_LONG)
                .Return(IntervalFormatType.ExcellentPlaceToWrap)))
        .Build();
      
      Describe<FormattingRule>()
        .Name($"ChopArguments")
        .Where(GrandParent().Is(blank), Left().In(FSharpTokenType.COMMA))
        .Switch(key => key.WrapArguments, When(WrapStyleSimple.CHOP_IF_LONG).Return(IntervalFormatType.InsertNewLineConditionally))
        .Build();
      
      // WrapArguments

      Describe<WrapRule>()
        .Name("MultilineLambdaBody")
        .Where(
          Parent().In(ElementType.LAMBDA_EXPR),
          Node().In(ElementBitsets.F_SHARP_EXPRESSION_BIT_SET)
        )
        .Return(WrapType.KeepTogether | WrapType.LineBreakBeforeIfMultiline)
        .Build();

      // todo: unify with the lambda rule?
      Describe<WrapRule>()
        .Name("BindingBody")
        .Where(
          Parent().In(ElementBitsets.BINDING_BIT_SET.Union(ElementType.DO_STATEMENT, ElementType.DO_EXPR)),
          Node().In(ElementBitsets.F_SHARP_EXPRESSION_BIT_SET.Union(ElementType.CHAMELEON_EXPRESSION))
            .Satisfies((node, _) => ForceInsertLineBreak(node.Node))
        )
        .Return(WrapType.KeepTogether | WrapType.LineBreakBeforeIfMultiline)
        .Build();

      // Describe<FormattingRule>()
      //   .Name("LambdaInBinding")
      //   .StageIdPredicate(FormattingStageAcceptanceType.AdditionalFormatStage)
      //   .Where(
      //     Parent().In(ElementBitsets.BINDING_BIT_SET),
      //     Node().In(ElementType.LAMBDA_EXPR).Satisfies((node, _) => node.ContainsLineBreak()))
      //   .Return(IntervalFormatType.NoLineBreaks)
      //   .Build();

      Describe<WrapRule>()
        .Name("MultilineMatchExpr")
        .Where(
          Node().In(ElementType.MATCH_EXPR, ElementType.MATCH_LAMBDA_EXPR)
        )
        .Return(WrapType.Chop | WrapType.StartAtExternal)
        .Build();
      
      Describe<FormattingRule>()
        .Name("MultilineMatchExpr")
        .Group(WrapRuleGroup)
        .Where(
          Parent().In(ElementType.MATCH_EXPR, ElementType.MATCH_LAMBDA_EXPR),
          Right().In(ElementType.MATCH_CLAUSE)
        )
        .Return(IntervalFormatType.InsertNewLineConditionally)
        .Build();
      return;

      bool ForceInsertLineBreak(ITreeNode treeNode)
      {
        var expr =
          treeNode switch
          {
            IChameleonExpression chameleonExpression => chameleonExpression.Expression,
            IExpression expression => expression,
            _ => null
          };

        return expr switch
        {
          ILambdaExpr => false,
          IPrefixAppExpr { ArgumentExpression: IComputationExpr } => false,
          _ => true
        };
      }
    }