Pattern Matching edge cases

[belav]

MethodInfo needs a space after it

                target = member switch
                {
                    PropertyInfo property => Expression.Property(target, property),
                    MethodInfo{ IsStatic: true } getter => Expression.Call(getter, target),
                    FieldInfo field => Field(target, field),
                    MethodInfo getter => Expression.Call(target, getter),
                    _
                      => throw new ArgumentOutOfRangeException(
                          nameof(member),
                          member,
                          "Unexpected member."
                      )
                };

[belav]

The { IsAbstract: true } doesn't need to be break

        public static Expression GenerateConstructorExpression(Type type) =>
            type switch
            {
                { IsValueType: true } => Default(type),
                Type stringType when stringType == typeof(string) => Constant(string.Empty),
                { IsInterface: true } => CreateInterfaceExpression(type),
                {
                    IsAbstract: true
                }
                  => InvalidType(type, $"Cannot create an instance of abstract type {type}."),
                _ => CallConstructor(type)
            };

// also
                {
                    ConstructorMap: { CanResolve: true } constructorMap
                }
                  => ConstructorMapping(constructorMap),

[belav]

The second case probably shouldn't break

                switch (expressionToCheck)
                {
                    case MemberExpression
                    {
                        Member: var member,
                        Expression: { NodeType: ExpressionType.Parameter or ExpressionType.Convert }
                    }:
                        return member;
                    case UnaryExpression
                    {
                        Operand: var operand
                    }:
                        expressionToCheck = operand;
                        break;
                    default:
                        break;

[belav]

Random extra space

        var location = declaringSyntax.GetSyntax() switch
        {
            CSharpSyntax.ClassDeclarationSyntax s => s.Identifier.GetLocation(),
             { } otherSyntax => otherSyntax.GetLocation()
        };

[belav]

This looks a little jank

                if (
                    !(
                        symbol
                        is
                        {
                            Kind: SymbolKind.Local,
                            DeclaringSyntaxReferences: { Length: 1 } syntaxRefs
                        }
                    )
                ) {
                    return null;
                }

[belav]

What about this?

                if (
                    blockParent
                    is MemberDeclarationSyntax
                    or AccessorDeclarationSyntax
                    or AnonymousFunctionExpressionSyntax
                ) {

[belav]

See also

            else if (
                constantValue
                is (sbyte)-1
                or (short)-1
                or (int)-1
                or (long)-1
                or -1.0
                or -1.0f
                or -1.0m
            ) {

[belav]

                typeNode = objectCreation.Parent.Parent switch
                {
                    LocalFunctionStatementSyntax localFunction => localFunction.ReturnType,
                    MethodDeclarationSyntax method => method.ReturnType,
                    ConversionOperatorDeclarationSyntax conversion => conversion.Type,
                    OperatorDeclarationSyntax op => op.ReturnType,
                    BasePropertyDeclarationSyntax property => property.Type,
                    AccessorDeclarationSyntax{
                        RawKind: (int)SyntaxKind.GetAccessorDeclaration,
                        Parent: AccessorListSyntax
                        {
                            Parent: BasePropertyDeclarationSyntax baseProperty
                        }
                    } accessor
                      => baseProperty.Type,
                    _ => null,
                };

[belav]

            switch (operation)
            {
                case IBinaryOperation
                {
                    OperatorKind: BinaryOperatorKind.Equals
                } op:
                    return ParseConstantPattern(op);

[belav]

The is shouldn't need to break

            if (
                suppressMessageAttributeType.Equals(attribute.AttributeClass)
                && attribute.AttributeConstructor?.Parameters.Length >= 2
                && attribute.AttributeConstructor.Parameters[1].Name == "checkId"
                && attribute.AttributeConstructor.Parameters[1].Type.SpecialType
                    == SpecialType.System_String
                && attribute.ConstructorArguments.Length >= 2
                && attribute.ConstructorArguments[1]
                    is
                    {
                        Kind: TypedConstantKind.Primitive,
                        Value: string checkId
                    }
            ) {

[belav]

The first arm shouldn't need to break

            return operation.Syntax switch
            {
                TConditionalExpressionSyntax{
                    Parent: TParenthesizedExpressionSyntax parent
                }
                  => parent,
                var syntax => syntax,
            };

[belav]

Double space

            if (!(statements[0] is IReturnOperation { ReturnedValue:  { } returnedValue }))
            {

[belav]

Probably already covered

            var (originalGroup, isAddressOf) = source switch
            {
                BoundMethodGroup m => (m, false),
                BoundUnconvertedAddressOfOperator{ Operand:  { } m } => (m, true),

[belav]

Shouldn't need to break

                    Debug.Assert(
                        scriptClassBinder.ContainingMemberOrLambda
                            is NamedTypeSymbol
                            {
                                IsScriptClass: true
                            }
                    );

[belav]

Shouldn't need to break

            switch (left.Kind, right.Kind)
            {
                case
                (BoundKind.DefaultLiteral, _) when !isEquality:
                case
                (_, BoundKind.DefaultLiteral) when !isEquality:
                    // other than == and !=, binary operators are disallowed on `default` literal
                    Error(
                        diagnostics,
                        ErrorCode.ERR_BadOpOnNullOrDefaultOrNew,
                        node,
                        operatorToken.Text,
                        "default"
                    );
                    return;

[belav]

This comes in right at 100 but breaks. If even breaks below 100 (the is .... line)

class ClassName
{
    void MethodName()
    {
        if (true)
        {
            while (
                expressionType
                    is ArrayTypeSymbol { ElementType: var e1, IsSZArray: var sz1, Rank: var r1 }
            ) { }
        }
    }
}