WIP, Highlighting: hot methods and invocation of costly methods

resharper/src/resharper-unity/CSharp/Daemon/Errors/CSharpErrors.xml

@@ -446,4 +446,5 @@
     <Range>Expression.GetHighlightingRange()</Range>
     <Behavour overlapResolvePolicy="WARNING" />
   </Warning>
+
 </Errors>

resharper/src/resharper-unity/CSharp/Daemon/Stages/PerformanceCriticalCodeAnalysis/PerformanceCriticalCodeHighlighters.cs

@@ -0,0 +1,76 @@
+using JetBrains.Annotations;
+using JetBrains.DocumentModel;
+using JetBrains.ReSharper.Daemon.BuildScripts.DaemonStage.Highlightings;
+using JetBrains.ReSharper.Feature.Services.Daemon;
+using JetBrains.ReSharper.Plugins.Unity.CSharp.Daemon.Stages.PerformanceCriticalCodeAnalysis;
+using JetBrains.ReSharper.Psi.CSharp;
+using JetBrains.ReSharper.Psi.Resolve;
+[assembly:
+    RegisterConfigurableSeverity(
+        PerformanceCriticalCodeInvocationHighlighting.SEVERITY_ID, 
+        null, 
+        PerformanceCriticalCodeHighlightingAttributeIds.GroupID,
+        "Expensive method call in frequently called method",
+        "Expensive method call in frequently called method", 
+        Severity.INFO
+        ),
+    RegisterConfigurableSeverity(
+        PerformanceCriticalCodeInvocationReachableHighlighting.SEVERITY_ID, 
+        null, 
+        PerformanceCriticalCodeHighlightingAttributeIds.GroupID,
+        "Expensive method is indirectly invoked from the frequently called method",
+        "Expensive method is indirectly invoked from the frequently called method",
+        Severity.INFO
+        ),
+]
+
+namespace JetBrains.ReSharper.Plugins.Unity.CSharp.Daemon.Stages.PerformanceCriticalCodeAnalysis
+{
+    [StaticSeverityHighlighting(
+        Severity.INFO, CSharpLanguage.Name,
+        AttributeId = PerformanceCriticalCodeHighlightingAttributeIds.COSTLY_METHOD_INVOCATION,
+        ShowToolTipInStatusBar = false,
+        ToolTipFormatString = MESSAGE)]
+    public class PerformanceCriticalCodeInvocationHighlighting : PerformanceCriticalCodeHighlightingBase
+    {
+        public const string SEVERITY_ID = "Unity.PerformanceCriticalCodeInvocation";
+        public const string MESSAGE = "Costly method is invoked from performance context";
+
+        public PerformanceCriticalCodeInvocationHighlighting(IReference reference) : 
+            base(PerformanceCriticalCodeHighlightingAttributeIds.COSTLY_METHOD_INVOCATION, reference, MESSAGE) { }
+    }
+
+    [StaticSeverityHighlighting(
+        Severity.INFO, CSharpLanguage.Name,
+        AttributeId = PerformanceCriticalCodeHighlightingAttributeIds.COSTLY_METHOD_REACHABLE,
+        ShowToolTipInStatusBar = false,
+        ToolTipFormatString = MESSAGE)]
+    public class PerformanceCriticalCodeInvocationReachableHighlighting : PerformanceCriticalCodeHighlightingBase
+    {
+        public const string SEVERITY_ID = "Unity.PerformanceCriticalCodeInvocationReachable";
+        public const string MESSAGE = "Invocation of this method indirectly calls costly method";
+
+        public PerformanceCriticalCodeInvocationReachableHighlighting(IReference reference) :
+            base(PerformanceCriticalCodeHighlightingAttributeIds.COSTLY_METHOD_REACHABLE,reference, MESSAGE) { }
+    }
+
+
+    public abstract class PerformanceCriticalCodeHighlightingBase : ICustomAttributeIdHighlighting
+    {
+        private readonly IReference myReference;
+
+        protected PerformanceCriticalCodeHighlightingBase([NotNull] string attributeId, [NotNull] IReference reference, [NotNull] string message)
+        {
+            myReference = reference;
+            ToolTip = message;
+            AttributeId = attributeId;
+        }
+
+        public bool IsValid() => myReference.IsValid();
+        public DocumentRange CalculateRange() => myReference.GetDocumentRange();
+
+        [NotNull] public string ToolTip { get; }
+        [NotNull] public string ErrorStripeToolTip => ToolTip;
+        public string AttributeId { get; }
+    }
+}

resharper/src/resharper-unity/CSharp/Daemon/Stages/PerformanceCriticalCodeAnalysis/PerformanceCriticalCodeHighlightingAttributeIds.cs

@@ -0,0 +1,31 @@
+using JetBrains.ReSharper.Feature.Services.Daemon;
+using JetBrains.ReSharper.Plugins.Unity.CSharp.Daemon.Stages.PerformanceCriticalCodeAnalysis;
+using JetBrains.ReSharper.Plugins.Unity.ShaderLab.Daemon.Stages;
+using JetBrains.TextControl.DocumentMarkup;
+
+[assembly:
+
+    RegisterConfigurableHighlightingsGroup(PerformanceCriticalCodeHighlightingAttributeIds.GroupID, "Unity Costly Highlighters"),
+    RegisterHighlighter(PerformanceCriticalCodeHighlightingAttributeIds.COSTLY_METHOD_REACHABLE,
+        GroupId = PerformanceCriticalCodeHighlightingAttributeIds.GroupID,
+        EffectType = EffectType.SOLID_UNDERLINE,
+        EffectColor = "#ffd070",
+        Layer = HighlighterLayer.SYNTAX + 1),
+    RegisterHighlighter(PerformanceCriticalCodeHighlightingAttributeIds.COSTLY_METHOD_INVOCATION,
+        GroupId = PerformanceCriticalCodeHighlightingAttributeIds.GroupID,
+        EffectType = EffectType.SOLID_UNDERLINE,
+        EffectColor = "#ff7526",
+        Layer = HighlighterLayer.SYNTAX + 1),
+
+]
+namespace JetBrains.ReSharper.Plugins.Unity.CSharp.Daemon.Stages.PerformanceCriticalCodeAnalysis
+{
+
+    public static class PerformanceCriticalCodeHighlightingAttributeIds
+    {
+        public const string GroupID = "ReSharper Unity CostlyHighlighters";
+
+        public const string COSTLY_METHOD_REACHABLE = "Resharper Unity CostlyMethodReachable";
+        public const string COSTLY_METHOD_INVOCATION = "Resharper Unity CostlyMethodInvocation";
+    }
+}

resharper/src/resharper-unity/KnownTypes.cs

@@ -23,6 +23,8 @@ public static class KnownTypes
         public static readonly IClrTypeName SerializeField = new ClrTypeName("UnityEngine.SerializeField");
         public static readonly IClrTypeName Physics = new ClrTypeName("UnityEngine.Physics");
         public static readonly IClrTypeName Physics2D = new ClrTypeName("UnityEngine.Physics2D");
+        public static readonly IClrTypeName Transform = new ClrTypeName("UnityEngine.Transform");
+        public static readonly IClrTypeName Resources = new ClrTypeName("UnityEngine.Resources");
 
         // UnityEngine.Networking
         public static readonly IClrTypeName NetworkBehaviour = new ClrTypeName("UnityEngine.Networking.NetworkBehaviour");

resharper/src/resharper-unity/Rider/UnityOptionsPage.cs

@@ -48,7 +48,11 @@ public UnityOptionsPage(Lifetime lifetime, OptionsSettingsSmartContext settingsS
                     "Parse Cg files for syntax errors. Only works in internal mode.");
                 AddText("Requires solution reopen.");
             }
-
+
+            Header("C# code analysis");
+            CheckBox((UnitySettings s) => s.EnablePerformanceCriticalCodeHighlighting,
+                "Enable highlighting of costly methods and indirect calls for these methods in performance critical code sections");
+
             FinishPage();
         }
 

resharper/src/resharper-unity/Settings/UnitySettings.cs

@@ -21,5 +21,8 @@ public class UnitySettings
 
         [SettingsEntry(false, "Enables syntax error highlighting of CG blocks in ShaderLab files.")]
         public bool EnableCgErrorHighlighting;
+
+        [SettingsEntry(true, "Enables underscore highlighting of costly methods and indirect calls of these methods.")]
+        public bool EnablePerformanceCriticalCodeHighlighting;
     }
 }

resharper/test/data/CSharp/Daemon/Stages/PerformanceCriticalCodeAnalysis/CommonTest.cs

@@ -0,0 +1,40 @@
+using UnityEngine;
+
+namespace DefaultNamespace
+{
+    public class CommonTest : MonoBehaviour
+    {
+        private RigidBody2D myRigidBody2D;
+
+        public void Test()
+        {
+            Update();
+        }
+
+        public void Update()
+        {
+            if (myRigidBody2D == null)
+            {
+                myRigidBody2D = GetComponent<RigidBody2D>();
+            }
+
+            Test();
+            IndirectCostly();
+
+            Test2();
+            Test2();
+            Test2();
+            Test2();
+        }
+
+        private void IndirectCostly()
+        {
+            var temp = gameObject.GetComponent<RigidBody2D>();
+        }
+
+        private void Test2()
+        {
+            IndirectCostly();
+        }
+    }
+}

resharper/test/data/CSharp/Daemon/Stages/PerformanceCriticalCodeAnalysis/CommonTest.cs.gold

@@ -0,0 +1,51 @@
+using UnityEngine;
+
+namespace DefaultNamespace
+{
+    public class CommonTest : MonoBehaviour
+    {
+        private RigidBody2D myRigidBody2D;
+
+        public void Test()
+        {
+            |Update|(0)();
+        }
+
+        public void Update()
+        {
+            if (myRigidBody2D == null)
+            {
+                myRigidBody2D = |GetComponent|(1)<RigidBody2D>();
+            }
+
+            |Test|(2)();
+            |IndirectCostly|(3)();
+
+            |Test2|(4)();
+            |Test2|(5)();
+            |Test2|(6)();
+            |Test2|(7)();
+        }
+
+        private void IndirectCostly()
+        {
+            var temp = gameObject.|GetComponent|(8)<RigidBody2D>();
+        }
+
+        private void Test2()
+        {
+            |IndirectCostly|(9)();
+        }
+    }
+}
+---------------------------------------------------------
+(0): Resharper Unity CostlyMethodReachable: Invocation of this method indirectly calls costly method
+(1): Resharper Unity CostlyMethodInvocation: Costly method is invoked from performance context
+(2): Resharper Unity CostlyMethodReachable: Invocation of this method indirectly calls costly method
+(3): Resharper Unity CostlyMethodReachable: Invocation of this method indirectly calls costly method
+(4): Resharper Unity CostlyMethodReachable: Invocation of this method indirectly calls costly method
+(5): Resharper Unity CostlyMethodReachable: Invocation of this method indirectly calls costly method
+(6): Resharper Unity CostlyMethodReachable: Invocation of this method indirectly calls costly method
+(7): Resharper Unity CostlyMethodReachable: Invocation of this method indirectly calls costly method
+(8): Resharper Unity CostlyMethodInvocation: Costly method is invoked from performance context
+(9): Resharper Unity CostlyMethodReachable: Invocation of this method indirectly calls costly method

resharper/test/data/CSharp/Daemon/Stages/PerformanceCriticalCodeAnalysis/CoroutineTest.cs

@@ -0,0 +1,24 @@
+using UnityEngine;
+using System.Collections;
+
+namespace DefaultNamespace
+{
+    public class CoroutineTest : MonoBehaviour
+    {
+        public void Start()
+        {
+            StartCoroutine("HotMethod");
+            StartCoroutine(HotMethod2());
+        }
+
+        public void HotMethod()
+        {
+            var x = gameObject.GetComponent<Transform>();
+        }
+
+        public IEnumerator HotMethod2()
+        {
+            var x = GetComponent<Transform>();
+        }
+    }
+}

resharper/test/data/CSharp/Daemon/Stages/PerformanceCriticalCodeAnalysis/CoroutineTest.cs.gold

@@ -0,0 +1,27 @@
+using UnityEngine;
+using System.Collections;
+
+namespace DefaultNamespace
+{
+    public class CoroutineTest : MonoBehaviour
+    {
+        public void Start()
+        {
+            StartCoroutine("HotMethod");
+            StartCoroutine(HotMethod2());
+        }
+
+        public void HotMethod()
+        {
+            var x = gameObject.|GetComponent|(0)<Transform>();
+        }
+
+        public IEnumerator HotMethod2()
+        {
+            var x = |GetComponent|(1)<Transform>();
+        }
+    }
+}
+---------------------------------------------------------
+(0): Resharper Unity CostlyMethodInvocation: Costly method is invoked from performance context
+(1): Resharper Unity CostlyMethodInvocation: Costly method is invoked from performance context

resharper/test/data/CSharp/Daemon/Stages/PerformanceCriticalCodeAnalysis/IndirectCostlyTest.cs

@@ -0,0 +1,21 @@
+using UnityEngine;
+
+namespace DefaultNamespace
+{
+    public class IndirectCostlyTest : MonoBehaviour
+    {
+        private Object[] container = null;
+        public void Update()
+        {
+            IndirectCostly();
+        }
+
+        private void IndirectCostly()
+        {
+            if (container == null)
+            {
+                container = Object.FindObjectsOfType<SimpleTest>();
+            }
+        }
+    }
+}

resharper/test/data/CSharp/Daemon/Stages/PerformanceCriticalCodeAnalysis/IndirectCostlyTest.cs.gold

@@ -0,0 +1,24 @@
+using UnityEngine;
+
+namespace DefaultNamespace
+{
+    public class IndirectCostlyTest : MonoBehaviour
+    {
+        private Object[] container = null;
+        public void Update()
+        {
+            |IndirectCostly|(0)();
+        }
+
+        private void IndirectCostly()
+        {
+            if (container == null)
+            {
+                container = Object.|FindObjectsOfType|(1)<SimpleTest>();
+            }
+        }
+    }
+}
+---------------------------------------------------------
+(0): Resharper Unity CostlyMethodReachable: Invocation of this method indirectly calls costly method
+(1): Resharper Unity CostlyMethodInvocation: Costly method is invoked from performance context

resharper/test/data/CSharp/Daemon/Stages/PerformanceCriticalCodeAnalysis/SimpleTest.cs

@@ -0,0 +1,16 @@
+using UnityEngine;
+
+namespace DefaultNamespace
+{
+    public class SimpleTest : MonoBehaviour
+    {
+        private RigidBody2D myRigidBody2D;
+        public void Update()
+        {
+            if (myRigidBody2D == null)
+            {
+                myRigidBody2D = GetComponent<RigidBody2D>();
+            }
+        }
+    }
+}

resharper/test/data/CSharp/Daemon/Stages/PerformanceCriticalCodeAnalysis/SimpleTest.cs.gold

@@ -0,0 +1,18 @@
+using UnityEngine;
+
+namespace DefaultNamespace
+{
+    public class SimpleTest : MonoBehaviour
+    {
+        private RigidBody2D myRigidBody2D;
+        public void Update()
+        {
+            if (myRigidBody2D == null)
+            {
+                myRigidBody2D = |GetComponent|(0)<RigidBody2D>();
+            }
+        }
+    }
+}
+---------------------------------------------------------
+(0): Resharper Unity CostlyMethodInvocation: Costly method is invoked from performance context

resharper/test/data/CSharp/Daemon/Stages/PerformanceCriticalCodeAnalysis/SimpleTest2.cs

@@ -0,0 +1,16 @@
+using UnityEngine;
+
+namespace DefaultNamespace
+{
+    public class SimpleTest : MonoBehaviour
+    {
+        private RigidBody2D myRigidBody2D;
+        public void FixedUpdate()
+        {
+            if (myRigidBody2D == null)
+            {
+                myRigidBody2D = GetComponent<RigidBody2D>();
+            }
+        }
+    }
+}