public void Populate()

in src/StructuredLogger/Search/ProxyNode.cs [47:177]
108 lines of code
36 McCabe index (conditional complexity)

        public void Populate(SearchResult result)
        {
            if (result == null)
            {
                return;
            }

            var node = result.Node;

            if (result.WordsInFields.Count == 0)
            {
                if (result.MatchedByType)
                {
                    Highlights.Add(new HighlightedText { Text = OriginalType });
                }

                Highlights.Add((Highlights.Count > 0 ? " " : "") + TextUtilities.ShortenValue(GetNodeText(node), "..."));

                AddDuration(result);

                return;
            }

            string typePrefix = OriginalType;
            if (typePrefix != Strings.Folder)
            {
                Highlights.Add(typePrefix);
            }

            // NameValueNode is special case: have to show name=value when searched only in one (name or value)
            var nameValueNode = node as NameValueNode;
            var namedNode = node as NamedNode;

            bool nameFound = false;
            bool valueFound = false;
            bool namedNodeNameFound = false;

            foreach (var fieldText in result.WordsInFields)
            {
                if (nameValueNode != null)
                {
                    if (!nameFound && fieldText.field.Equals(nameValueNode.Name))
                    {
                        nameFound = true;
                    }

                    if (!valueFound && fieldText.field.Equals(nameValueNode.Value))
                    {
                        valueFound = true;
                    }
                }
                else if (namedNode != null && !namedNodeNameFound)
                {
                    if (fieldText.field.Equals(namedNode.Name))
                    {
                        namedNodeNameFound = true;
                    }
                }
            }

            if (namedNode != null && !namedNodeNameFound)
            {
                Highlights.Add((Highlights.Count > 0 ? " " : "") + namedNode.Name);
                if (GetNodeDifferentiator(node) is object differentiator)
                {
                    Highlights.Add(differentiator);
                }
            }

            foreach (var wordsInField in result.WordsInFields.GroupBy(t => t.field, t => t.match))
            {
                var fieldText = wordsInField.Key;
                if (fieldText == OriginalType || (node is Task task && task.IsDerivedTask))
                {
                    // OriginalType already added above
                    continue;
                }

                if (Highlights.Count > 0)
                {
                    Highlights.Add(" ");
                }

                if (nameValueNode != null && fieldText.Equals(nameValueNode.Value) && !nameFound)
                {
                    Highlights.Add(nameValueNode.Name + " = ");
                }

                fieldText = TextUtilities.ShortenValue(fieldText, "...");

                var highlightSpans = TextUtilities.GetHighlightedSpansInText(fieldText, wordsInField);
                int index = 0;
                foreach (var span in highlightSpans)
                {
                    if (span.Start > index)
                    {
                        Highlights.Add(fieldText.Substring(index, span.Start - index));
                    }

                    Highlights.Add(new HighlightedText { Text = fieldText.Substring(span.Start, span.Length) });
                    index = span.End;
                }

                if (index < fieldText.Length)
                {
                    Highlights.Add(fieldText.Substring(index, fieldText.Length - index));
                }

                if (nameValueNode != null && wordsInField.Key.Equals(nameValueNode.Name))
                {
                    if (!valueFound)
                    {
                        Highlights.Add(" = " + TextUtilities.ShortenValue(nameValueNode.Value, "..."));
                    }
                    else
                    {
                        Highlights.Add(" = ");
                    }
                }

                if (namedNode != null && namedNode.Name == wordsInField.Key)
                {
                    if (GetNodeDifferentiator(node) is object differentiator)
                    {
                        Highlights.Add(differentiator);
                    }
                }
            }

            AddDuration(result);
        }