Inheritance: CodeLocationObject
Ejemplo n.º 1
0
        internal void IntelligentExpand()
        {
            if (Location?.Importance == CodeFlowLocationImportance.Essential)
            {
                CallTreeNode current = this;

                while (current != null)
                {
                    current.IsExpanded = true;
                    current            = current.Parent;
                }
            }
            else
            {
                IsExpanded = false;
            }

            if (Children != null)
            {
                foreach (CallTreeNode child in Children)
                {
                    child.IntelligentExpand();
                }
            }
        }
Ejemplo n.º 2
0
        public void CallTreeNode_SelectedHighlightColor()
        {
            var callTreeNode = new CallTreeNode
            {
                Location = new AnnotatedCodeLocation(),
            };

            callTreeNode.Location.Importance = AnnotatedCodeLocationImportance.Essential;
            callTreeNode.SelectedSourceHighlightColor.Should().Be("CodeAnalysisCurrentStatementSelection");
        }
Ejemplo n.º 3
0
        internal void IntelligentExpand()
        {
            foreach (CallTree callTree in this)
            {
                CallTreeNode selectedItem = callTree.SelectedItem;

                callTree.IntelligentExpand();

                callTree.SelectedItem = selectedItem;
            }
        }
        internal CallTreeNode FindNext()
        {
            CallTreeNode next = FindNext(this.SelectedItem, true);

            if (next == null)
            {
                // no next exists, current remains selected
                return(this.SelectedItem);
            }
            else
            {
                return(next);
            }
        }
        // go to parent, find self, find previous/next, make sure not to roll off
        internal CallTreeNode FindPrevious()
        {
            CallTreeNode previous = FindPrevious(this.SelectedItem, true);

            if (previous == null)
            {
                // no previous exists, current remains selected
                return(this.SelectedItem);
            }
            else
            {
                return(previous);
            }
        }
Ejemplo n.º 6
0
        internal void SetVerbosity(CodeFlowLocationImportance importance)
        {
            Visibility visibility = Visibility.Visible;
            CodeFlowLocationImportance myImportance = (Location?.Importance).GetValueOrDefault(CodeFlowLocationImportance.Unimportant);

            switch (importance)
            {
            case CodeFlowLocationImportance.Essential:
                if (myImportance != CodeFlowLocationImportance.Essential)
                {
                    visibility = Visibility.Collapsed;
                }
                break;

            case CodeFlowLocationImportance.Important:
                if (myImportance == CodeFlowLocationImportance.Unimportant)
                {
                    visibility = Visibility.Collapsed;
                }
                break;

            default:
                visibility = Visibility.Visible;
                break;
            }

            if (visibility == Visibility.Visible)
            {
                CallTreeNode current = this;

                while (current != null)
                {
                    current.Visibility = Visibility.Visible;
                    current            = current.Parent;
                }
            }
            else
            {
                Visibility = Visibility.Collapsed;
            }

            if (Children != null)
            {
                foreach (CallTreeNode child in Children)
                {
                    child.SetVerbosity(importance);
                }
            }
        }
Ejemplo n.º 7
0
        public void CallTreeNode_DefaultHighlightColor()
        {
            var callTreeNode = new CallTreeNode
            {
                Location = new AnnotatedCodeLocation(),
            };

            callTreeNode.Location.Importance = AnnotatedCodeLocationImportance.Essential;
            callTreeNode.DefaultSourceHighlightColor.Should().Be("CodeAnalysisKeyEventSelection");

            callTreeNode.Location.Importance = AnnotatedCodeLocationImportance.Important;
            callTreeNode.DefaultSourceHighlightColor.Should().Be("CodeAnalysisLineTraceSelection");

            callTreeNode.Location.Importance = AnnotatedCodeLocationImportance.Unimportant;
            callTreeNode.DefaultSourceHighlightColor.Should().Be("CodeAnalysisLineTraceSelection");
        }
        private static string MakeDisplayString(CallTreeNode node)
        {
            // Use the following preferences for the CallTreeNode text.
            // 1. AnnotatedCodeLocation.Message
            // 2. AnnotatedCodeLocation.Snippet
            // 3. Callee for calls
            // 4. "Return" for returns
            // 5. AnnotatedCodeLocation.Kind
            string text = string.Empty;

            AnnotatedCodeLocation annotatedLocation = node.Location;
            if (annotatedLocation != null)
            {
                if (!String.IsNullOrEmpty(annotatedLocation.Message))
                {
                    text = annotatedLocation.Message;
                }
                else if (!String.IsNullOrEmpty(annotatedLocation.Snippet))
                {
                    text = annotatedLocation.Snippet.Trim();
                }
                else
                {
                    switch (annotatedLocation.Kind)
                    {
                        case AnnotatedCodeLocationKind.Call:
                            string callee = annotatedLocation.Target;
                            text = !string.IsNullOrEmpty(callee) ? callee : Resources.UnknownCalleMessage;
                            break;

                        case AnnotatedCodeLocationKind.CallReturn:
                            text = Resources.ReturnMessage;
                            break;

                        default:
                            if (annotatedLocation.Kind != default(AnnotatedCodeLocationKind))
                            {
                                text = annotatedLocation.Kind.ToString();
                            }
                            break;
                    }
                }
            }

            return text;
        }
Ejemplo n.º 9
0
        internal void IntelligentExpand()
        {
            if (!SarifViewerPackage.IsUnitTesting)
            {
#pragma warning disable VSTHRD108 // Assert thread affinity unconditionally
                ThreadHelper.ThrowIfNotOnUIThread();
#pragma warning restore VSTHRD108 // Assert thread affinity unconditionally
            }
            foreach (CallTree callTree in this)
            {
                CallTreeNode selectedItem = callTree.SelectedItem;

                callTree.IntelligentExpand();

                callTree.SelectedItem = selectedItem;
            }
        }
        internal static bool TryGetFirstItem(IList <CallTreeNode> items, out CallTreeNode firstItem)
        {
            firstItem = null;

            if (items != null)
            {
                for (int i = 0; i < items.Count; i++)
                {
                    CallTreeNode nextNode = items[i];
                    if (nextNode.Visibility == System.Windows.Visibility.Visible)
                    {
                        firstItem = nextNode;
                        break;
                    }
                }
            }
            return(firstItem != null);
        }
Ejemplo n.º 11
0
        private static List<CallTreeNode> GetChildren(CodeFlow codeFlow, ref int currentCodeFlowIndex, CallTreeNode parent)
        {
            currentCodeFlowIndex++;
            List<CallTreeNode> children = new List<CallTreeNode>();
            bool foundCallReturn = false;

            while (currentCodeFlowIndex < codeFlow.Locations.Count && !foundCallReturn)
            {
                switch (codeFlow.Locations[currentCodeFlowIndex].Kind)
                {
                    case AnnotatedCodeLocationKind.Call:
                        var newNode = new CallTreeNode
                        {
                            Location = codeFlow.Locations[currentCodeFlowIndex],
                            Parent = parent
                        };
                        newNode.Children = GetChildren(codeFlow, ref currentCodeFlowIndex, newNode);
                        children.Add(newNode);
                        break;

                    case AnnotatedCodeLocationKind.CallReturn:
                        children.Add(new CallTreeNode
                        {
                            Location = codeFlow.Locations[currentCodeFlowIndex],
                            Children = new List<CallTreeNode>(),
                            Parent = parent
                        });
                        foundCallReturn = true;
                        break;

                    default:
                        children.Add(new CallTreeNode
                        {
                            Location = codeFlow.Locations[currentCodeFlowIndex],
                            Children = new List<CallTreeNode>(),
                            Parent = parent
                        });
                        currentCodeFlowIndex++;
                        break;
                }
            }
            currentCodeFlowIndex++;
            return children;
        }
        public void CallTreeNodeToTextConverter_HandlesCallWithNoCallee()
        {
            var callTreeNode = new CallTreeNode
            {
                Location = new AnnotatedCodeLocation
                {
                    Kind = AnnotatedCodeLocationKind.Call,
                    PhysicalLocation = new PhysicalLocation
                    {
                        Region = new Region
                        {
                            StartLine = 42
                        }
                    }
                }
            };

            VerifyConversion(callTreeNode, "<unknown callee>");
        }
        internal static bool TryGetLastItem(IList <CallTreeNode> items, out CallTreeNode lastItem)
        {
            lastItem = null;

            if (items != null)
            {
                for (int i = items.Count - 1; i >= 0; i--)
                {
                    CallTreeNode nextNode = items[i];
                    if (nextNode.Visibility == System.Windows.Visibility.Visible)
                    {
                        lastItem = nextNode;
                        break;
                    }
                }
            }

            return(lastItem != null);
        }
        internal static bool TryGetIndexInCallTreeNodeList(IList <CallTreeNode> list, CallTreeNode givenNode, out int index)
        {
            index = -1;

            if (list != null)
            {
                for (int i = 0; i < list.Count; i++)
                {
                    CallTreeNode listNode = list[i];
                    if (listNode == givenNode)
                    {
                        index = i;
                        break;
                    }
                }
            }

            return(index != -1);
        }
        internal CallTreeNode FindPrevious(CallTreeNode currentNode, bool includeChildren)
        {
            if (currentNode == null)
            {
                return(null);
            }

            CallTreeNode previousNode;

            // Find the next visible sibling.
            CallTreeNode         currentParent = currentNode.Parent;
            IList <CallTreeNode> nodeList;

            if (currentParent == null)
            {
                nodeList = this.TopLevelNodes;
            }
            else
            {
                nodeList = currentParent.Children;
            }

            if (TryGetPreviousSibling(nodeList, currentNode, out previousNode))
            {
                CallTreeNode previousNodeChild;
                if (includeChildren && TryGetLastItem(previousNode.Children, out previousNodeChild))
                {
                    return(previousNodeChild);
                }
                else
                {
                    return(previousNode);
                }
            }
            else if (currentParent != null && currentParent.Visibility == System.Windows.Visibility.Visible)
            {
                return(currentParent);
            }

            // Walk up the tree trying to find the previous node.
            return(FindPrevious(currentParent, false));
        }
        public void CallTreeNodeToTextConverter_HandlesCall()
        {
            var callTreeNode = new CallTreeNode
            {
                Location = new AnnotatedCodeLocation
                {
                    Kind = AnnotatedCodeLocationKind.Call,
                    Target = "my_function",
                    PhysicalLocation = new PhysicalLocation
                    {
                        Region = new Region
                        {
                            StartLine = 42
                        }
                    }
                }
            };

            VerifyConversion(callTreeNode, "my_function");
        }
        internal static bool TryGetNextSibling(IList <CallTreeNode> items, CallTreeNode currentItem, out CallTreeNode nextSibling)
        {
            nextSibling = null;

            int currentIndex;

            if (TryGetIndexInCallTreeNodeList(items, currentItem, out currentIndex))
            {
                for (int i = currentIndex + 1; i < items.Count; i++)
                {
                    CallTreeNode nextNode = items[i];
                    if (nextNode.Visibility == System.Windows.Visibility.Visible)
                    {
                        nextSibling = nextNode;
                        break;
                    }
                }
            }

            return(nextSibling != null);
        }
        internal static bool TryGetPreviousSibling(IList <CallTreeNode> items, CallTreeNode currentItem, out CallTreeNode previousSibling)
        {
            previousSibling = null;

            int currentIndex;

            if (TryGetIndexInCallTreeNodeList(items, currentItem, out currentIndex))
            {
                for (int i = currentIndex - 1; i >= 0; i--)
                {
                    CallTreeNode previousNode = items[i];
                    if (previousNode.Visibility == System.Windows.Visibility.Visible)
                    {
                        previousSibling = previousNode;
                        break;
                    }
                }
            }

            return(previousSibling != null);
        }
        internal CallTreeNode FindNext(CallTreeNode currentNode, bool includeChildren)
        {
            if (currentNode == null)
            {
                return(null);
            }

            // For Call nodes, find the first visible child.
            CallTreeNode nextNode;

            if (includeChildren && TryGetFirstItem(currentNode.Children, out nextNode))
            {
                return(nextNode);
            }

            // For all other nodes or Call nodes without a visible child, find the next visible sibling.
            CallTreeNode         currentParent = currentNode.Parent;
            IList <CallTreeNode> nodeList;

            if (currentParent == null)
            {
                nodeList = this.TopLevelNodes;
            }
            else
            {
                nodeList = currentParent.Children;
            }

            if (TryGetNextSibling(nodeList, currentNode, out nextNode))
            {
                return(nextNode);
            }

            // Walk up the tree trying to find the next node.
            return(FindNext(currentParent, false));
        }
Ejemplo n.º 20
0
        public void CallTree_TryGetIndexInCallTreeNodeList_NullList()
        {
            List<CallTreeNode> list = null;

            CallTreeNode node = new CallTreeNode();

            int index;
            bool result = CallTree.TryGetIndexInCallTreeNodeList(list, node, out index);

            result.Should().BeFalse();
        }
Ejemplo n.º 21
0
        public void CallTree_TryGetIndexInCallTreeNodeList_MiddleNode()
        {
            List<CallTreeNode> list = new List<CallTreeNode>();
            CallTreeNode target = new CallTreeNode();
            list.Add(new CallTreeNode());
            list.Add(target);
            list.Add(new CallTreeNode());

            int index;
            bool result = CallTree.TryGetIndexInCallTreeNodeList(list, target, out index);

            result.Should().BeTrue();
            index.Should().Be(1);
        }
Ejemplo n.º 22
0
        internal static bool TryGetPreviousSibling(IList<CallTreeNode> items, CallTreeNode currentItem, out CallTreeNode previousSibling)
        {
            previousSibling = null;

            int currentIndex;
            if (TryGetIndexInCallTreeNodeList(items, currentItem, out currentIndex))
            {
                for (int i = currentIndex - 1; i >= 0; i--)
                {
                    CallTreeNode previousNode = items[i];
                    if (previousNode.Visibility == System.Windows.Visibility.Visible)
                    {
                        previousSibling = previousNode;
                        break;
                    }
                }
            }

            return previousSibling != null;
        }
Ejemplo n.º 23
0
        internal static bool TryGetNextSibling(IList<CallTreeNode> items, CallTreeNode currentItem, out CallTreeNode nextSibling)
        {
            nextSibling = null;

            int currentIndex;
            if (TryGetIndexInCallTreeNodeList(items, currentItem, out currentIndex))
            {
                for (int i = currentIndex + 1; i < items.Count; i++)
                {
                    CallTreeNode nextNode = items[i];
                    if (nextNode.Visibility == System.Windows.Visibility.Visible)
                    {
                        nextSibling = nextNode;
                        break;
                    }
                }
            }

            return nextSibling != null;
        }
Ejemplo n.º 24
0
        internal static bool TryGetFirstItem(IList<CallTreeNode> items, out CallTreeNode firstItem)
        {
            firstItem = null;

            if (items != null)
            {
                for (int i = 0; i < items.Count; i++)
                {
                    CallTreeNode nextNode = items[i];
                    if (nextNode.Visibility == System.Windows.Visibility.Visible)
                    {
                        firstItem = nextNode;
                        break;
                    }
                }
            }
            return firstItem != null;
        }
        public void CallTreeNodeToTextConverter_HandlesMessage()
        {
            string snippet = "    contentStores[0] = contentStores[index];";
            string message = "The error happened here.";
            string sourceFile = @"file:///c:/dir1/dir%202\source%20file.cpp";

            var callTreeNode = new CallTreeNode
            {
                Location = new AnnotatedCodeLocation
                {
                    Kind = AnnotatedCodeLocationKind.Call,
                    Snippet = snippet,
                    Message = message,
                    Target = "my_function",
                    PhysicalLocation = new PhysicalLocation
                    {
                        Uri = new System.Uri(sourceFile),
                        Region = new Region
                        {
                            StartLine = 42
                        }
                    }
                }
            };

            VerifyConversion(callTreeNode, message);
        }
Ejemplo n.º 26
0
        public void CallTree_TryGetPreviousSibling_NoVisibleNodes()
        {
            List<CallTreeNode> list = new List<CallTreeNode>();
            CallTreeNode target = new CallTreeNode();
            list.Add(new CallTreeNode() { Visibility = Visibility.Collapsed });
            list.Add(new CallTreeNode() { Visibility = Visibility.Hidden });
            list.Add(target);
            list.Add(new CallTreeNode());

            CallTreeNode resultNode;
            bool result = CallTree.TryGetPreviousSibling(list, target, out resultNode);

            result.Should().BeFalse();
        }
        public void CallTreeNodeToTextConverter_HandlesNullSnippet()
        {
            string snippet = null;
            string sourceFile = @"file:///c:/dir1/dir%202\source%20file.cpp";

            var callTreeNode = new CallTreeNode
            {
                Location = new AnnotatedCodeLocation
                {
                    Kind = AnnotatedCodeLocationKind.Call,
                    Snippet = snippet,
                    Target = "my_function",
                    PhysicalLocation = new PhysicalLocation
                    {
                        Uri = new System.Uri(sourceFile),
                        Region = new Region
                        {
                            StartLine = 42
                        }
                    }
                }
            };

            VerifyConversion(callTreeNode, "my_function");
        }
Ejemplo n.º 28
0
        internal CallTreeNode FindPrevious(CallTreeNode currentNode, bool includeChildren)
        {
            if (currentNode == null)
            {
                return null;
            }

            CallTreeNode previousNode;

            // Find the next visible sibling.
            CallTreeNode currentParent = currentNode.Parent;
            IList<CallTreeNode> nodeList;

            if (currentParent == null)
            {
                nodeList = this.TopLevelNodes;
            }
            else
            {
                nodeList = currentParent.Children;
            }

            if (TryGetPreviousSibling(nodeList, currentNode, out previousNode))
            {
                CallTreeNode previousNodeChild;
                if (includeChildren && previousNode.Location.Kind == AnnotatedCodeLocationKind.Call && TryGetLastItem(previousNode.Children, out previousNodeChild))
                {
                    return previousNodeChild;

                }
                else
                {
                    return previousNode;
                }
            }
            else if (currentParent != null && currentParent.Visibility == System.Windows.Visibility.Visible)
            {
                return currentParent;
            }

            // Walk up the tree trying to find the previous node.
            return FindPrevious(currentParent, false);
        }
Ejemplo n.º 29
0
        public void CallTree_TryGetPreviousSibling_SkipNonVisibleNodes()
        {
            List<CallTreeNode> list = new List<CallTreeNode>();
            CallTreeNode target = new CallTreeNode();
            list.Add(new CallTreeNode() { FilePath = Expected });
            list.Add(new CallTreeNode() { Visibility = Visibility.Collapsed });
            list.Add(new CallTreeNode() { Visibility = Visibility.Hidden });
            list.Add(target);
            list.Add(new CallTreeNode());

            CallTreeNode resultNode;
            bool result = CallTree.TryGetPreviousSibling(list, target, out resultNode);

            result.Should().BeTrue();
            resultNode.FilePath.Should().Be(Expected);
        }
Ejemplo n.º 30
0
        internal static bool TryGetLastItem(IList<CallTreeNode> items, out CallTreeNode lastItem)
        {
            lastItem = null;

            if (items != null)
            {
                for (int i = items.Count - 1; i >= 0; i--)
                {
                    CallTreeNode nextNode = items[i];
                    if (nextNode.Visibility == System.Windows.Visibility.Visible)
                    {
                        lastItem = nextNode;
                        break;
                    }
                }
            }

            return lastItem != null;
        }
Ejemplo n.º 31
0
        public void CallTree_TryGetNextSibling_LastNode()
        {
            List<CallTreeNode> list = new List<CallTreeNode>();
            CallTreeNode target = new CallTreeNode();
            list.Add(new CallTreeNode());
            list.Add(new CallTreeNode());
            list.Add(target);

            CallTreeNode resultNode;
            bool result = CallTree.TryGetNextSibling(list, target, out resultNode);

            result.Should().BeFalse();
        }
        public void CallTreeNodeToTextConverter_HandlesNonCallOrReturnNodes()
        {
            var callTreeNode = new CallTreeNode
            {
                Location = new AnnotatedCodeLocation
                {
                    Kind = AnnotatedCodeLocationKind.Continuation,
                    PhysicalLocation = new PhysicalLocation
                    {
                        Region = new Region
                        {
                            StartLine = 42
                        }
                    }
                }
            };

            VerifyConversion(callTreeNode, "Continuation");
        }
Ejemplo n.º 33
0
        public void CallTree_TryGetPreviousSibling_MiddleNode()
        {
            List<CallTreeNode> list = new List<CallTreeNode>();
            CallTreeNode target = new CallTreeNode();
            list.Add(new CallTreeNode() { FilePath = Expected });
            list.Add(target);
            list.Add(new CallTreeNode());

            CallTreeNode resultNode;
            bool result = CallTree.TryGetPreviousSibling(list, target, out resultNode);

            result.Should().BeTrue();
            resultNode.FilePath.Should().Be(Expected);
        }
Ejemplo n.º 34
0
        internal static bool TryGetIndexInCallTreeNodeList(IList<CallTreeNode> list, CallTreeNode givenNode, out int index)
        {
            index = -1;

            if (list != null)
            {
                for (int i = 0; i < list.Count; i++)
                {
                    CallTreeNode listNode = list[i];
                    if (listNode == givenNode)
                    {
                        index = i;
                        break;
                    }
                }
            }

            return index != -1;
        }
Ejemplo n.º 35
0
        public void CallTree_TryGetPreviousSibling_NullList()
        {
            List<CallTreeNode> list = null;

            CallTreeNode node = new CallTreeNode();

            CallTreeNode resultNode;
            bool result = CallTree.TryGetPreviousSibling(list, node, out resultNode);

            result.Should().BeFalse();
        }
        private static void VerifyConversion(CallTreeNode callTreeNode, string expectedText)
        {
            var converter = new CallTreeNodeToTextConverter();

            string text = (string)converter.Convert(callTreeNode, typeof(string), null, CultureInfo.CurrentCulture);

            text.Should().Be(expectedText);
        }
        public void CallTreeNodeToTextConverter_HandlesMissingRegion()
        {
            var callTreeNode = new CallTreeNode
            {
                Location = new AnnotatedCodeLocation
                {
                    Kind = AnnotatedCodeLocationKind.CallReturn,
                    PhysicalLocation = new PhysicalLocation()
                }
            };

            VerifyConversion(callTreeNode, "Return");
        }
Ejemplo n.º 38
0
        internal CallTreeNode FindNext(CallTreeNode currentNode, bool includeChildren)
        {
            if (currentNode == null)
            {
                return null;
            }

            // For Call nodes, find the first visible child.
            CallTreeNode nextNode;
            if (includeChildren && currentNode.Location.Kind == AnnotatedCodeLocationKind.Call && TryGetFirstItem(currentNode.Children, out nextNode))
            {
                return nextNode;
            }

            // For all other nodes or Call nodes without a visible child, find the next visible sibling.
            CallTreeNode currentParent = currentNode.Parent;
            IList<CallTreeNode> nodeList;

            if (currentParent == null)
            {
                nodeList = this.TopLevelNodes;
            }
            else
            {
                nodeList = currentParent.Children;
            }

            if (TryGetNextSibling(nodeList, currentNode, out nextNode))
            {
                return nextNode;
            }

            // Walk up the tree trying to find the next node.
            return FindNext(currentParent, false);
        }