private IEnumerable GetRelatedExpressionsInner()

in resharper/resharper-unity/src/Unity/Utils/UnityComponentRelatedExpressionFinder.cs [46:142]
87 lines of code
30 McCabe index (conditional complexity)

            private IEnumerable<IReferenceExpression> GetRelatedExpressionsInner([NotNull] ITreeNode scope, [CanBeNull] ITreeNode from = null)
            {
                var descendants = scope.ThisAndDescendants();
                while (descendants.MoveNext())
                {
                    var current = descendants.Current;
                    if (current == from)
                        isFound = true;

                    switch (current)
                    {
                        case ICSharpClosure _:
                            descendants.SkipThisNode();
                            break;
                        case IInvocationExpression invocationExpression:
                            descendants.SkipThisNode();
                            var argumentList = invocationExpression.ArgumentList;
                            if (argumentList != null)
                            {
                                foreach (var re in GetRelatedExpressionsInner(argumentList, from))
                                {
                                    if (isFound)
                                        yield return re;
                                }
                            }

                            var invokedExpression = invocationExpression.InvokedExpression;
                            foreach (var re in GetRelatedExpressionsInner(invokedExpression, from))
                            {
                                if (isFound)
                                    yield return re;
                            }

                            continue;
                        case IAssignmentExpression assignmentExpression:
                            descendants.SkipThisNode();
                            var source = assignmentExpression.Source;
                            if (source != null)
                            {
                                foreach (var re in GetRelatedExpressionsInner(source, from))
                                {
                                    if (isFound)
                                        yield return re;
                                }
                            }

                            var dest = assignmentExpression.Dest;
                            if (dest != null)
                            {
                                foreach (var re in GetRelatedExpressionsInner(dest, from))
                                {
                                    if (isFound)
                                        yield return re;
                                }
                            }

                            continue;
                        case IReferenceExpression referenceExpression:
                            var currentNodeDeclaredElement = referenceExpression.Reference.Resolve().DeclaredElement as IClrDeclaredElement;
                            var currentNodeContainingType = currentNodeDeclaredElement?.GetContainingType();
                            switch (currentNodeDeclaredElement)
                            {
                                case IField _:
                                case IProperty _:
                                    var qualifier = referenceExpression.QualifierExpression as IReferenceExpression;
                                    if (!ReComparer.Equals(ComponentReferenceExpression, qualifier))
                                        continue;

                                    if (currentNodeContainingType == null)
                                        continue;

                                    if (!ContainingType.Equals(currentNodeContainingType))
                                        continue;

                                    break;
                                case IMethod method:
                                    if (currentNodeContainingType == null ||
                                        !ContainingType.Equals(currentNodeContainingType))
                                    {
                                        if (!myIgnoreNotComponentInvocations && isFound)
                                        {
                                            yield return referenceExpression;
                                        }
                                        continue;
                                    }
                                    break;
                                default:
                                    continue;
                            }

                            if (isFound && !IsReferenceExpressionNotRelated(referenceExpression, currentNodeDeclaredElement, currentNodeContainingType) )
                                yield return referenceExpression;

                            break;
                    }
                }
            }