Add serveral new analysis

.gitignore

@@ -257,3 +257,4 @@ $RECYCLE.BIN/
 
 # Windows shortcuts
 *.lnk
+.DS_Store

UnityEngineAnalyzer.CLI/SolutionAnalyzer.cs

@@ -6,7 +6,7 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.MSBuild;
-using UnityEngineAnalyzer.ForEachInUpdate;
+using UnityEngineAnalyzer.IL2CPP;
 
 namespace UnityEngineAnalyzer.CLI
 {
@@ -27,7 +27,7 @@ private ImmutableArray<DiagnosticAnalyzer> GetAnalyzers()
         {
             var listBuilder = ImmutableArray.CreateBuilder<DiagnosticAnalyzer>();
 
-            var assembly = typeof(DoNotUseForEachInUpdate).Assembly;
+            var assembly = typeof(UnsealedDerivedClassAnalyzer).Assembly;
             var allTypes = assembly.DefinedTypes;
 
             foreach (var type in allTypes)

UnityEngineAnalyzer/UnityEngineAnalyzer.Test/Camera/DoNotUseCameraMainInUpdateAnalyzerTests.cs

@@ -0,0 +1,86 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Text;
+using NUnit.Framework;
+using RoslynNUnitLight;
+using UnityEngineAnalyzer.FindMethodsInUpdate;
+
+
+//using Microsoft.CodeAnalysis.Workspaces;
+
+namespace UnityEngineAnalyzer.Test.FindMethodsInUpdate
+{
+    [TestFixture]
+    sealed class DoNotUseCameraMainInUpdateAnalyzerTests : AnalyzerTestFixture
+    {
+
+        protected override string LanguageName => LanguageNames.CSharp;
+        protected override DiagnosticAnalyzer CreateAnalyzer() => new DoNotUseCameraMainInUpdateAnalyzer();
+
+        [Test]
+        public void CameraMainInUpdate()
+        {
+            var code = @"
+using UnityEngine;
+
+class C : MonoBehaviour
+{
+    void Update()
+    {
+        Camera main = [|Camera.main|];
+
+        //var result = GameObject.Find(""param"");
+    }
+}";
+
+            Document document;
+            TextSpan span;
+
+            if (TestHelpers.TryGetDocumentAndSpanFromMarkup(code, LanguageName, MetadataReferenceHelper.UsingUnityEngine,
+                out document, out span))
+            {
+                HasDiagnostic(document, span, DiagnosticIDs.DoNotUseCameraMainInUpdate);
+            }
+            else
+            {
+                Assert.Fail("Could not load unit test code");
+            }
+        }
+
+
+        [Test]
+        public void CameraMainInUpdateRecursive()
+        {
+            var code = @"
+using UnityEngine;
+
+class C : MonoBehaviour
+{
+    void Update()
+    {
+        [|MyMethod()|];
+        //var result = GameObject.Find(""param"");
+    }
+
+    void MyMethod()
+    {
+        Camera main = Camera.main;
+    }
+}";
+
+            Document document;
+            TextSpan span;
+
+            if (TestHelpers.TryGetDocumentAndSpanFromMarkup(code, LanguageName, MetadataReferenceHelper.UsingUnityEngine,
+                out document, out span))
+            {
+                HasDiagnostic(document, span, DiagnosticIDs.DoNotUseCameraMainInUpdate);
+            }
+            else
+            {
+                Assert.Fail("Could not load unit test code");
+            }
+        }
+
+    }
+}

UnityEngineAnalyzer/UnityEngineAnalyzer.Test/Delegates/ShouldCacheDelegateAnalyzerTests.cs

@@ -0,0 +1,222 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Text;
+using NUnit.Framework;
+using RoslynNUnitLight;
+using UnityEngineAnalyzer.Delegates;
+
+
+//using Microsoft.CodeAnalysis.Workspaces;
+
+namespace UnityEngineAnalyzer.Test.Delegates
+{
+    [TestFixture]
+    sealed class ShouldCacheDelegatesAnalyzerTests : AnalyzerTestFixture
+    {
+
+        protected override string LanguageName => LanguageNames.CSharp;
+        protected override DiagnosticAnalyzer CreateAnalyzer() => new ShouldCacheDelegateAnalyzer();
+
+        [Test]
+        public void EventDidNotCacheDelegate()
+        {
+            var code = @"
+
+using System;
+
+class C
+{
+    public event EventHandler e;
+    void Update()
+    {
+        e += [|OnCallBack|];
+    }
+
+    private void OnCallBack(object sender, EventArgs e)
+    {
+        throw new NotImplementedException();
+    }
+}";
+
+            Document document;
+            TextSpan span;
+
+            if (TestHelpers.TryGetDocumentAndSpanFromMarkup(code, LanguageName, MetadataReferenceHelper.UsingUnityEngine,
+                out document, out span))
+            {
+                HasDiagnostic(document, span, DiagnosticIDs.ShouldCacheDelegate);
+            }
+            else
+            {
+                Assert.Fail("Could not load unit test code");
+            }
+        }
+
+        [Test]
+        public void EventDidNotCacheDelegate2()
+        {
+            var code = @"
+
+using System;
+
+class C
+{
+    public event EventHandler e;
+    void Update()
+    {
+        e -= [|OnCallBack|];
+    }
+
+    private void OnCallBack(object sender, EventArgs e)
+    {
+        throw new NotImplementedException();
+    }
+}";
+
+            Document document;
+            TextSpan span;
+
+            if (TestHelpers.TryGetDocumentAndSpanFromMarkup(code, LanguageName, MetadataReferenceHelper.UsingUnityEngine,
+                out document, out span))
+            {
+                HasDiagnostic(document, span, DiagnosticIDs.ShouldCacheDelegate);
+            }
+            else
+            {
+                Assert.Fail("Could not load unit test code");
+            }
+        }
+
+        [Test]
+        public void EventDidCacheDelegate()
+        {
+            var code = @"
+
+using System;
+
+class C
+{
+    public event EventHandler e;
+    private EventHandler m_cachedDelegate = OnCallBack;
+
+    void Intialize()
+    {
+        m_cachedDelegate = OnCallBack;
+    }
+
+    void Update()
+    {
+        e += [|m_cachedDelegate|];
+    }
+
+    private void OnCallBack(object sender, EventArgs e)
+    {
+        throw new NotImplementedException();
+    }
+}";
+
+            Document document;
+            TextSpan span;
+
+            if (TestHelpers.TryGetDocumentAndSpanFromMarkup(code, LanguageName, MetadataReferenceHelper.UsingUnityEngine,
+                out document, out span))
+            {
+                NoDiagnostic(document, DiagnosticIDs.ShouldCacheDelegate);
+            }
+            else
+            {
+                Assert.Fail("Could not load unit test code");
+            }
+        }
+
+
+        [Test]
+        public void FunctionDidNotCacheDelegate()
+        {
+            var code = @"
+
+using System;
+
+class C
+{
+    public event EventHandler e;
+    void Update()
+    {
+        CallDelegate([|OnCallBack|]);
+    }
+
+    private void CallDelegate(EventHandler handler)
+    {
+
+    }    
+
+    private void OnCallBack(object sender, EventArgs e)
+    {
+        throw new NotImplementedException();
+    }
+}";
+
+            Document document;
+            TextSpan span;
+
+            if (TestHelpers.TryGetDocumentAndSpanFromMarkup(code, LanguageName, MetadataReferenceHelper.UsingUnityEngine,
+                out document, out span))
+            {
+                HasDiagnostic(document, span, DiagnosticIDs.ShouldCacheDelegate);
+            }
+            else
+            {
+                Assert.Fail("Could not load unit test code");
+            }
+        }
+
+
+        [Test]
+        public void FunctionDidCacheDelegate()
+        {
+            var code = @"
+
+using System;
+
+class C
+{
+    public event EventHandler e;
+    private EventHandler m_cachedDelegate;
+
+    void Intialize()
+    {
+        m_cachedDelegate = OnCallBack;
+    }
+
+    void Update()
+    {
+        CallDelegate([|m_cachedDelegate|]);
+    }
+
+    private void CallDelegate(EventHandler handler)
+    {
+
+    }    
+
+    private void OnCallBack(object sender, EventArgs e)
+    {
+        throw new NotImplementedException();
+    }
+}";
+
+            Document document;
+            TextSpan span;
+
+            if (TestHelpers.TryGetDocumentAndSpanFromMarkup(code, LanguageName, MetadataReferenceHelper.UsingUnityEngine,
+                out document, out span))
+            {
+                NoDiagnostic(document, DiagnosticIDs.ShouldCacheDelegate);
+            }
+            else
+            {
+                Assert.Fail("Could not load unit test code");
+            }
+        }
+
+    }
+}

UnityEngineAnalyzer/UnityEngineAnalyzer.Test/FindMethodsInUpdate/DoNotUseFindMethodsInUpdateAnalyzerTests.cs

@@ -47,6 +47,42 @@ void Update()
             }
         }
 
+
+        [Test]
+        public void GameObjectFindInUpdateRecursive()
+        {
+            var code = @"
+using UnityEngine;
+
+class C : MonoBehaviour
+{
+    void Update()
+    {
+        [|MyMethod()|];
+        //var result = GameObject.Find(""param"");
+    }
+
+    void MyMethod()
+    {
+        GameObject.Find(""param"");
+    }
+}";
+
+            Document document;
+            TextSpan span;
+
+            if (TestHelpers.TryGetDocumentAndSpanFromMarkup(code, LanguageName, MetadataReferenceHelper.UsingUnityEngine,
+                out document, out span))
+            {
+                HasDiagnostic(document, span, DiagnosticIDs.DoNotUseFindMethodsInUpdate);
+            }
+            else
+            {
+                Assert.Fail("Could not load unit test code");
+            }
+        }
+
+
         [Test]
         public void GameObjectFindInStart()
         {