Initial Commit

2021-08-02 05:44:37 -04:00 · 2021-08-02 05:44:37 -04:00 · 270ab7d11f
commit 270ab7d11f
parent 53eb92e9af
15341 changed files with 700234 additions and 0 deletions
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/Discovery.cs
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/Discovery.cs
@ -0,0 +1,561 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using JetBrains.Annotations;
+using Microsoft.Win32;
+using Packages.Rider.Editor.Util;
+using Unity.CodeEditor;
+using UnityEngine;
+
+namespace Packages.Rider.Editor
+{
+  internal interface IDiscovery
+  {
+    CodeEditor.Installation[] PathCallback();
+  }
+
+  internal class Discovery : IDiscovery
+  {
+    public CodeEditor.Installation[] PathCallback()
+    {
+      return RiderPathLocator.GetAllRiderPaths()
+        .Select(riderInfo => new CodeEditor.Installation
+        {
+          Path = riderInfo.Path,
+          Name = riderInfo.Presentation
+        })
+        .OrderBy(a=>a.Name)
+        .ToArray();
+    }
+  }
+
+  /// <summary>
+  /// This code is a modified version of the JetBrains resharper-unity plugin listed here:
+  /// https://github.com/JetBrains/resharper-unity/blob/master/unity/JetBrains.Rider.Unity.Editor/EditorPlugin/RiderPathLocator.cs
+  /// </summary>
+  internal static class RiderPathLocator
+  {
+#if !(UNITY_4_7 || UNITY_5_5)
+    public static RiderInfo[] GetAllRiderPaths()
+    {
+      try
+      {
+        switch (SystemInfo.operatingSystemFamily)
+        {
+          case OperatingSystemFamily.Windows:
+          {
+            return CollectRiderInfosWindows();
+          }
+
+          case OperatingSystemFamily.MacOSX:
+          {
+            return CollectRiderInfosMac();
+          }
+
+          case OperatingSystemFamily.Linux:
+          {
+            return CollectAllRiderPathsLinux();
+          }
+        }
+      }
+      catch (Exception e)
+      {
+        Debug.LogException(e);
+      }
+
+      return new RiderInfo[0];
+    }
+#endif
+
+#if RIDER_EDITOR_PLUGIN // can't be used in com.unity.ide.rider
+    internal static RiderInfo[] GetAllFoundInfos(OperatingSystemFamilyRider operatingSystemFamily)
+    {
+      try
+      {
+        switch (operatingSystemFamily)
+        {
+          case OperatingSystemFamilyRider.Windows:
+          {
+            return CollectRiderInfosWindows();
+          }
+          case OperatingSystemFamilyRider.MacOSX:
+          {
+            return CollectRiderInfosMac();
+          }
+          case OperatingSystemFamilyRider.Linux:
+          {
+            return CollectAllRiderPathsLinux();
+          }
+        }
+      }
+      catch (Exception e)
+      {
+        Debug.LogException(e);
+      }
+
+      return new RiderInfo[0];
+    }
+
+    internal static string[] GetAllFoundPaths(OperatingSystemFamilyRider operatingSystemFamily)
+    {
+      return GetAllFoundInfos(operatingSystemFamily).Select(a=>a.Path).ToArray();
+    }
+#endif
+
+    private static RiderInfo[] CollectAllRiderPathsLinux()
+    {
+      var installInfos = new List<RiderInfo>();
+      var home = Environment.GetEnvironmentVariable("HOME");
+      if (!string.IsNullOrEmpty(home))
+      {
+        var toolboxRiderRootPath = GetToolboxBaseDir();
+        installInfos.AddRange(CollectPathsFromToolbox(toolboxRiderRootPath, "bin", "rider.sh", false)
+          .Select(a => new RiderInfo(a, true)).ToList());
+
+        //$Home/.local/share/applications/jetbrains-rider.desktop
+        var shortcut = new FileInfo(Path.Combine(home, @".local/share/applications/jetbrains-rider.desktop"));
+
+        if (shortcut.Exists)
+        {
+          var lines = File.ReadAllLines(shortcut.FullName);
+          foreach (var line in lines)
+          {
+            if (!line.StartsWith("Exec=\""))
+              continue;
+            var path = line.Split('"').Where((item, index) => index == 1).SingleOrDefault();
+            if (string.IsNullOrEmpty(path))
+              continue;
+
+            if (installInfos.Any(a => a.Path == path)) // avoid adding similar build as from toolbox
+              continue;
+            installInfos.Add(new RiderInfo(path, false));
+          }
+        }
+      }
+
+      // snap install
+      var snapInstallPath = "/snap/rider/current/bin/rider.sh";
+      if (new FileInfo(snapInstallPath).Exists)
+        installInfos.Add(new RiderInfo(snapInstallPath, false));
+      
+      return installInfos.ToArray();
+    }
+
+    private static RiderInfo[] CollectRiderInfosMac()
+    {
+      var installInfos = new List<RiderInfo>();
+      // "/Applications/*Rider*.app"
+      var folder = new DirectoryInfo("/Applications");
+      if (folder.Exists)
+      {
+        installInfos.AddRange(folder.GetDirectories("*Rider*.app")
+          .Select(a => new RiderInfo(a.FullName, false))
+          .ToList());
+      }
+
+      // /Users/user/Library/Application Support/JetBrains/Toolbox/apps/Rider/ch-1/181.3870.267/Rider EAP.app
+      var toolboxRiderRootPath = GetToolboxBaseDir();
+      var paths = CollectPathsFromToolbox(toolboxRiderRootPath, "", "Rider*.app", true)
+        .Select(a => new RiderInfo(a, true));
+      installInfos.AddRange(paths);
+
+      return installInfos.ToArray();
+    }
+
+    private static RiderInfo[] CollectRiderInfosWindows()
+    {
+      var installInfos = new List<RiderInfo>();
+      var toolboxRiderRootPath = GetToolboxBaseDir();
+      var installPathsToolbox = CollectPathsFromToolbox(toolboxRiderRootPath, "bin", "rider64.exe", false).ToList();
+      installInfos.AddRange(installPathsToolbox.Select(a => new RiderInfo(a, true)).ToList());
+      
+      var installPaths = new List<string>();
+      const string registryKey = @"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall";
+      CollectPathsFromRegistry(registryKey, installPaths);
+      const string wowRegistryKey = @"SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall";
+      CollectPathsFromRegistry(wowRegistryKey, installPaths);
+      
+      installInfos.AddRange(installPaths.Select(a => new RiderInfo(a, false)).ToList());
+
+      return installInfos.ToArray();
+    }
+
+    private static string GetToolboxBaseDir()
+    {
+      switch (SystemInfo.operatingSystemFamily)
+      {
+        case OperatingSystemFamily.Windows:
+        {
+          var localAppData = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
+          return GetToolboxRiderRootPath(localAppData);
+        }
+
+        case OperatingSystemFamily.MacOSX:
+        {
+          var home = Environment.GetEnvironmentVariable("HOME");
+          if (!string.IsNullOrEmpty(home))
+          {
+            var localAppData = Path.Combine(home, @"Library/Application Support");
+            return  GetToolboxRiderRootPath(localAppData);
+          }
+          break;
+        }
+
+        case OperatingSystemFamily.Linux:
+        {
+          var home = Environment.GetEnvironmentVariable("HOME");
+          if (!string.IsNullOrEmpty(home))
+          {
+            var localAppData = Path.Combine(home, @".local/share");
+            return GetToolboxRiderRootPath(localAppData);
+          }
+          break;
+        }
+      }
+      return string.Empty;
+    }
+    
+    
+    private static string GetToolboxRiderRootPath(string localAppData)
+    {
+      var toolboxPath = Path.Combine(localAppData, @"JetBrains/Toolbox");
+      var settingsJson = Path.Combine(toolboxPath, ".settings.json");
+
+      if (File.Exists(settingsJson))
+      {
+        var path = SettingsJson.GetInstallLocationFromJson(File.ReadAllText(settingsJson));
+        if (!string.IsNullOrEmpty(path))
+          toolboxPath = path;
+      }
+
+      var toolboxRiderRootPath = Path.Combine(toolboxPath, @"apps/Rider");
+      return toolboxRiderRootPath;
+    }
+    
+    internal static ProductInfo GetBuildVersion(string path)
+    {
+      var buildTxtFileInfo = new FileInfo(Path.Combine(path, GetRelativePathToBuildTxt()));
+      var dir = buildTxtFileInfo.DirectoryName;
+      if (!Directory.Exists(dir))
+        return null;
+      var buildVersionFile = new FileInfo(Path.Combine(dir, "product-info.json"));
+      if (!buildVersionFile.Exists) 
+        return null;
+      var json = File.ReadAllText(buildVersionFile.FullName);
+      return ProductInfo.GetProductInfo(json);
+    }
+    
+    internal static Version GetBuildNumber(string path)
+    {
+      var file = new FileInfo(Path.Combine(path, GetRelativePathToBuildTxt()));
+      if (!file.Exists) 
+        return null;
+      var text = File.ReadAllText(file.FullName);
+      var index = text.IndexOf("-", StringComparison.Ordinal) + 1; // RD-191.7141.355
+      if (index <= 0) 
+        return null;
+      
+      var versionText = text.Substring(index);
+      return Version.TryParse(versionText, out var v) ? v : null;
+    }
+
+    internal static bool GetIsToolbox(string path)
+    {
+      return Path.GetFullPath(path).StartsWith(Path.GetFullPath(GetToolboxBaseDir()));
+    }
+
+    private static string GetRelativePathToBuildTxt()
+    {
+      switch (SystemInfo.operatingSystemFamily)
+      {
+        case OperatingSystemFamily.Windows: 
+        case OperatingSystemFamily.Linux:
+          return "../../build.txt";
+        case OperatingSystemFamily.MacOSX:
+          return "Contents/Resources/build.txt";
+      }
+      throw new Exception("Unknown OS");
+    }
+    private static void CollectPathsFromRegistry(string registryKey, List<string> installPaths)
+    {
+      using (var key = Registry.CurrentUser.OpenSubKey(registryKey))
+      {
+        CollectPathsFromRegistry(installPaths, key);
+      }
+      using (var key = Registry.LocalMachine.OpenSubKey(registryKey))
+      {
+        CollectPathsFromRegistry(installPaths, key);
+      }
+    }
+
+    private static void CollectPathsFromRegistry(List<string> installPaths, RegistryKey key)
+    {
+      if (key == null) return;
+      foreach (var subkeyName in key.GetSubKeyNames().Where(a => a.Contains("Rider")))
+      {
+        using (var subkey = key.OpenSubKey(subkeyName))
+        {
+          var folderObject = subkey?.GetValue("InstallLocation");
+          if (folderObject == null) continue;
+          var folder = folderObject.ToString();
+          var possiblePath = Path.Combine(folder, @"bin\rider64.exe");
+          if (File.Exists(possiblePath))
+            installPaths.Add(possiblePath);
+        }
+      }
+    }
+
+    private static string[] CollectPathsFromToolbox(string toolboxRiderRootPath, string dirName, string searchPattern,
+      bool isMac)
+    {
+      if (!Directory.Exists(toolboxRiderRootPath))
+        return new string[0];
+
+      var channelDirs = Directory.GetDirectories(toolboxRiderRootPath);
+      var paths = channelDirs.SelectMany(channelDir =>
+        {
+          try
+          {
+            // use history.json - last entry stands for the active build https://jetbrains.slack.com/archives/C07KNP99D/p1547807024066500?thread_ts=1547731708.057700&cid=C07KNP99D
+            var historyFile = Path.Combine(channelDir, ".history.json");
+            if (File.Exists(historyFile))
+            {
+              var json = File.ReadAllText(historyFile);
+              var build = ToolboxHistory.GetLatestBuildFromJson(json);
+              if (build != null)
+              {
+                var buildDir = Path.Combine(channelDir, build);
+                var executablePaths = GetExecutablePaths(dirName, searchPattern, isMac, buildDir);
+                if (executablePaths.Any())
+                  return executablePaths;
+              }
+            }
+
+            var channelFile = Path.Combine(channelDir, ".channel.settings.json");
+            if (File.Exists(channelFile))
+            {
+              var json = File.ReadAllText(channelFile).Replace("active-application", "active_application");
+              var build = ToolboxInstallData.GetLatestBuildFromJson(json);
+              if (build != null)
+              {
+                var buildDir = Path.Combine(channelDir, build);
+                var executablePaths = GetExecutablePaths(dirName, searchPattern, isMac, buildDir);
+                if (executablePaths.Any())
+                  return executablePaths;
+              }
+            }
+
+            // changes in toolbox json files format may brake the logic above, so return all found Rider installations
+            return Directory.GetDirectories(channelDir)
+              .SelectMany(buildDir => GetExecutablePaths(dirName, searchPattern, isMac, buildDir));
+          }
+          catch (Exception e)
+          {
+            // do not write to Debug.Log, just log it.
+            Logger.Warn($"Failed to get RiderPath from {channelDir}", e);
+          }
+
+          return new string[0];
+        })
+        .Where(c => !string.IsNullOrEmpty(c))
+        .ToArray();
+      return paths;
+    }
+
+    private static string[] GetExecutablePaths(string dirName, string searchPattern, bool isMac, string buildDir)
+    {
+      var folder = new DirectoryInfo(Path.Combine(buildDir, dirName));
+      if (!folder.Exists)
+        return new string[0];
+
+      if (!isMac)
+        return new[] {Path.Combine(folder.FullName, searchPattern)}.Where(File.Exists).ToArray();
+      return folder.GetDirectories(searchPattern).Select(f => f.FullName)
+        .Where(Directory.Exists).ToArray();
+    }
+
+    // Disable the "field is never assigned" compiler warning. We never assign it, but Unity does.
+    // Note that Unity disable this warning in the generated C# projects
+#pragma warning disable 0649
+    
+    [Serializable]
+    class SettingsJson
+    {
+      // ReSharper disable once InconsistentNaming
+      public string install_location;
+      
+      [CanBeNull]
+      public static string GetInstallLocationFromJson(string json)
+      {
+        try
+        {
+#if UNITY_4_7 || UNITY_5_5
+          return JsonConvert.DeserializeObject<SettingsJson>(json).install_location;
+#else
+          return JsonUtility.FromJson<SettingsJson>(json).install_location;
+#endif
+        }
+        catch (Exception)
+        {
+          Logger.Warn($"Failed to get install_location from json {json}");
+        }
+
+        return null;
+      }
+    }
+
+    [Serializable]
+    class ToolboxHistory
+    {
+      public List<ItemNode> history;
+
+      [CanBeNull]
+      public static string GetLatestBuildFromJson(string json)
+      {
+        try
+        {
+#if UNITY_4_7 || UNITY_5_5
+          return JsonConvert.DeserializeObject<ToolboxHistory>(json).history.LastOrDefault()?.item.build;
+#else
+          return JsonUtility.FromJson<ToolboxHistory>(json).history.LastOrDefault()?.item.build;
+#endif
+        }
+        catch (Exception)
+        {
+          Logger.Warn($"Failed to get latest build from json {json}");
+        }
+
+        return null;
+      }
+    }
+
+    [Serializable]
+    class ItemNode
+    {
+      public BuildNode item;
+    }
+
+    [Serializable]
+    class BuildNode
+    {
+      public string build;
+    }
+
+    [Serializable]
+    internal class ProductInfo
+    {
+      public string version;
+      public string versionSuffix;
+
+      [CanBeNull]
+      internal static ProductInfo GetProductInfo(string json)
+      {
+        try
+        {
+          var productInfo = JsonUtility.FromJson<ProductInfo>(json);
+          return productInfo;
+        }
+        catch (Exception)
+        {
+          Logger.Warn($"Failed to get version from json {json}");
+        }
+
+        return null;
+      }
+    }
+
+    // ReSharper disable once ClassNeverInstantiated.Global
+    [Serializable]
+    class ToolboxInstallData
+    {
+      // ReSharper disable once InconsistentNaming
+      public ActiveApplication active_application;
+
+      [CanBeNull]
+      public static string GetLatestBuildFromJson(string json)
+      {
+        try
+        {
+#if UNITY_4_7 || UNITY_5_5
+          var toolbox = JsonConvert.DeserializeObject<ToolboxInstallData>(json);
+#else
+          var toolbox = JsonUtility.FromJson<ToolboxInstallData>(json);
+#endif
+          var builds = toolbox.active_application.builds;
+          if (builds != null && builds.Any())
+            return builds.First();
+        }
+        catch (Exception)
+        {
+          Logger.Warn($"Failed to get latest build from json {json}");
+        }
+
+        return null;
+      }
+    }
+
+    [Serializable]
+    class ActiveApplication
+    {
+      // ReSharper disable once InconsistentNaming
+      public List<string> builds;
+    }
+
+#pragma warning restore 0649
+
+    internal struct RiderInfo
+    {
+      public bool IsToolbox;
+      public string Presentation;
+      public Version BuildNumber;
+      public ProductInfo ProductInfo;
+      public string Path;
+
+      public RiderInfo(string path, bool isToolbox)
+      {
+        if (path == RiderScriptEditor.CurrentEditor)
+        {
+          RiderScriptEditorData.instance.Init();
+          BuildNumber = RiderScriptEditorData.instance.editorBuildNumber.ToVersion();
+          ProductInfo = RiderScriptEditorData.instance.productInfo;
+        }
+        else
+        {
+          BuildNumber = GetBuildNumber(path);
+          ProductInfo = GetBuildVersion(path);
+        }
+        Path = new FileInfo(path).FullName; // normalize separators
+        var presentation = $"Rider {BuildNumber}";
+
+        if (ProductInfo != null && !string.IsNullOrEmpty(ProductInfo.version))
+        {
+          var suffix = string.IsNullOrEmpty(ProductInfo.versionSuffix) ? "" : $" {ProductInfo.versionSuffix}";
+          presentation = $"Rider {ProductInfo.version}{suffix}";
+        }
+
+        if (isToolbox)
+          presentation += " (JetBrains Toolbox)";
+
+        Presentation = presentation;
+        IsToolbox = isToolbox;
+      }
+    }
+
+    private static class Logger
+    {
+      internal static void Warn(string message, Exception e = null)
+      {
+#if RIDER_EDITOR_PLUGIN // can't be used in com.unity.ide.rider
+        Log.GetLog(typeof(RiderPathLocator).Name).Warn(message);
+        if (e != null) 
+          Log.GetLog(typeof(RiderPathLocator).Name).Warn(e);
+#else
+        Debug.LogError(message);
+        if (e != null)
+          Debug.LogException(e);
+#endif
+      }
+    }
+  }
+}
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/Discovery.cs.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/Discovery.cs.meta
@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: dab656c79e1985c40b31faebcda44442
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/EditorPluginInterop.cs
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/EditorPluginInterop.cs
@ -0,0 +1,150 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using Debug = UnityEngine.Debug;
+
+namespace Packages.Rider.Editor
+{
+  internal static class EditorPluginInterop
+  {
+    private static string EditorPluginAssemblyNamePrefix = "JetBrains.Rider.Unity.Editor.Plugin.";
+    public static readonly string EditorPluginAssemblyName = $"{EditorPluginAssemblyNamePrefix}Net46.Repacked";
+    public static readonly string EditorPluginAssemblyNameFallback = $"{EditorPluginAssemblyNamePrefix}Full.Repacked";
+    private static string ourEntryPointTypeName = "JetBrains.Rider.Unity.Editor.PluginEntryPoint";
+
+    private static Assembly ourEditorPluginAssembly;
+
+    public static Assembly EditorPluginAssembly
+    {
+      get
+      {
+        if (ourEditorPluginAssembly != null)
+          return ourEditorPluginAssembly;
+        var assemblies = AppDomain.CurrentDomain.GetAssemblies();
+        ourEditorPluginAssembly = assemblies.FirstOrDefault(a =>
+        {
+          try
+          {
+            return a.GetName().Name.StartsWith(EditorPluginAssemblyNamePrefix); // some user assemblies may fail here
+          }
+          catch (Exception)
+          { 
+          }
+
+          return default;
+        });
+        return ourEditorPluginAssembly;
+      }
+    }
+
+    private static void DisableSyncSolutionOnceCallBack()
+    {
+      // RiderScriptableSingleton.Instance.CsprojProcessedOnce = true;
+      // Otherwise EditorPlugin regenerates all on every AppDomain reload
+      var assembly = EditorPluginAssembly;
+      if (assembly == null) return;
+      var type = assembly.GetType("JetBrains.Rider.Unity.Editor.Utils.RiderScriptableSingleton");
+      if (type == null) return;
+      var baseType = type.BaseType;
+      if (baseType == null) return;
+      var instance = baseType.GetProperty("Instance");
+      if (instance == null) return;
+      var instanceVal = instance.GetValue(null);
+      var member = type.GetProperty("CsprojProcessedOnce");
+      if (member==null) return;
+      member.SetValue(instanceVal, true);
+    }
+    
+    public static string LogPath
+    {
+      get
+      {
+        try
+        {
+          var assembly = EditorPluginAssembly;
+          if (assembly == null) return null;
+          var type = assembly.GetType(ourEntryPointTypeName);
+          if (type == null) return null;
+          var field = type.GetField("LogPath", BindingFlags.NonPublic | BindingFlags.Static);
+          if (field == null) return null;
+          return field.GetValue(null) as string;
+        }
+        catch (Exception)
+        {
+          Debug.Log("Unable to do OpenFile to Rider from dll, fallback to com.unity.ide.rider implementation.");
+        }
+
+        return null;
+      }
+    }
+
+    public static bool OpenFileDllImplementation(string path, int line, int column)
+    {
+      var openResult = false;
+      // reflection for fast OpenFileLineCol, when Rider is started and protocol connection is established
+      try
+      {
+        var assembly = EditorPluginAssembly;
+        if (assembly == null) return false;
+        var type = assembly.GetType(ourEntryPointTypeName);
+        if (type == null) return false;
+        var field = type.GetField("OpenAssetHandler", BindingFlags.NonPublic | BindingFlags.Static);
+        if (field == null) return false;
+        var handlerInstance = field.GetValue(null);
+        var method = handlerInstance.GetType()
+          .GetMethod("OnOpenedAsset", new[] {typeof(string), typeof(int), typeof(int)});
+        if (method == null) return false;
+        var assetFilePath = path;
+        if (!string.IsNullOrEmpty(path))
+          assetFilePath = Path.GetFullPath(path);
+        
+        openResult = (bool) method.Invoke(handlerInstance, new object[] {assetFilePath, line, column});
+      }
+      catch (Exception e)
+      {
+        Debug.Log("Unable to do OpenFile to Rider from dll, fallback to com.unity.ide.rider implementation.");
+        Debug.LogException(e);
+      }
+
+      return openResult;
+    }
+
+    public static bool EditorPluginIsLoadedFromAssets(Assembly assembly)
+    {
+      if (assembly == null)
+        return false;
+      var location = assembly.Location;
+      var currentDir = Directory.GetCurrentDirectory();
+      return location.StartsWith(currentDir, StringComparison.InvariantCultureIgnoreCase);
+    }
+
+
+    internal static void InitEntryPoint(Assembly assembly)
+    {
+      try
+      {
+        var version = RiderScriptEditorData.instance.editorBuildNumber;
+        if (version != null)
+        {
+          if (version.Major < 192)
+            DisableSyncSolutionOnceCallBack(); // is require for Rider prior to 2019.2
+        }
+        else
+            DisableSyncSolutionOnceCallBack();
+        
+        var type = assembly.GetType("JetBrains.Rider.Unity.Editor.AfterUnity56.EntryPoint");
+        if (type == null) 
+          type = assembly.GetType("JetBrains.Rider.Unity.Editor.UnitTesting.EntryPoint"); // oldRider
+        RuntimeHelpers.RunClassConstructor(type.TypeHandle);
+      }
+      catch (TypeInitializationException ex)
+      {
+        Debug.LogException(ex);
+        if (ex.InnerException != null) 
+          Debug.LogException(ex.InnerException);
+      }
+    }
+  }
+}
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/EditorPluginInterop.cs.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/EditorPluginInterop.cs.meta
@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f9bd02a3a916be64c9b47b1305149423
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/LoggingLevel.cs
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/LoggingLevel.cs
@ -0,0 +1,22 @@
+namespace Packages.Rider.Editor
+{
+  internal enum LoggingLevel
+  {
+    /// <summary>
+    /// Do not use it in logging. Only in config to disable logging.
+    /// </summary>
+    OFF,
+    /// <summary>For errors that lead to application failure</summary>
+    FATAL,
+    /// <summary>For errors that must be shown in Exception Browser</summary>
+    ERROR,
+    /// <summary>Suspicious situations but not errors</summary>
+    WARN,
+    /// <summary>Regular level for important events</summary>
+    INFO,
+    /// <summary>Additional info for debbuging</summary>
+    VERBOSE,
+    /// <summary>Methods &amp; callstacks tracing, more than verbose</summary>
+    TRACE,
+  }
+}
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/LoggingLevel.cs.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/LoggingLevel.cs.meta
@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 71bb46b59a9a7a346bbab1e185c723df
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/PluginSettings.cs
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/PluginSettings.cs
@ -0,0 +1,118 @@
+using Unity.CodeEditor;
+using UnityEditor;
+using UnityEngine;
+
+namespace Packages.Rider.Editor
+{
+  internal class PluginSettings
+  {
+    public static LoggingLevel SelectedLoggingLevel
+    {
+      get => (LoggingLevel) EditorPrefs.GetInt("Rider_SelectedLoggingLevel", 0);
+      set
+      {
+        EditorPrefs.SetInt("Rider_SelectedLoggingLevel", (int) value);
+      }
+    }
+
+    public static bool LogEventsCollectorEnabled
+    {
+      get { return EditorPrefs.GetBool("Rider_LogEventsCollectorEnabled", true); }
+      private set { EditorPrefs.SetBool("Rider_LogEventsCollectorEnabled", value); }
+    }
+
+    /// <summary>
+    /// Preferences menu layout
+    /// </summary>
+    /// <remarks>
+    /// Contains all 3 toggles: Enable/Disable; Debug On/Off; Writing Launch File On/Off
+    /// </remarks>
+    [SettingsProvider]
+    private static SettingsProvider RiderPreferencesItem()
+    {
+      if (!RiderScriptEditor.IsRiderInstallation(RiderScriptEditor.CurrentEditor))
+        return null;
+      if (!RiderScriptEditorData.instance.shouldLoadEditorPlugin)
+        return null;
+      var provider = new SettingsProvider("Preferences/Rider", SettingsScope.User)
+      {
+        label = "Rider",
+        keywords = new[] { "Rider" },
+        guiHandler = (searchContext) =>
+        {
+          EditorGUIUtility.labelWidth = 200f;
+          EditorGUILayout.BeginVertical();
+
+          GUILayout.BeginVertical();
+          LogEventsCollectorEnabled =
+            EditorGUILayout.Toggle(new GUIContent("Pass Console to Rider:"), LogEventsCollectorEnabled);
+
+          GUILayout.EndVertical();
+          GUILayout.Label("");
+
+          if (!string.IsNullOrEmpty(EditorPluginInterop.LogPath))
+          {
+            EditorGUILayout.BeginHorizontal();
+            EditorGUILayout.PrefixLabel("Log file:");
+            var previous = GUI.enabled;
+            GUI.enabled = previous && SelectedLoggingLevel != LoggingLevel.OFF;
+            var button = GUILayout.Button(new GUIContent("Open log"));
+            if (button)
+            {
+              //UnityEditorInternal.InternalEditorUtility.OpenFileAtLineExternal(PluginEntryPoint.LogPath, 0);
+              // works much faster than the commented code, when Rider is already started
+              CodeEditor.CurrentEditor.OpenProject(EditorPluginInterop.LogPath, 0, 0);
+            }
+
+            GUI.enabled = previous;
+            GUILayout.EndHorizontal();
+          }
+
+          var loggingMsg =
+            @"Sets the amount of Rider Debug output. If you are about to report an issue, please select Verbose logging level and attach Unity console output to the issue.";
+          SelectedLoggingLevel =
+            (LoggingLevel) EditorGUILayout.EnumPopup(new GUIContent("Logging Level:", loggingMsg),
+              SelectedLoggingLevel);
+
+
+          EditorGUILayout.HelpBox(loggingMsg, MessageType.None);
+
+          LinkButton("https://github.com/JetBrains/resharper-unity");
+
+          GUILayout.FlexibleSpace();
+          GUILayout.BeginHorizontal();
+
+          GUILayout.FlexibleSpace();
+          var assembly = EditorPluginInterop.EditorPluginAssembly;
+          if (assembly != null)
+          {
+            var version = assembly.GetName().Version;
+            GUILayout.Label("Plugin version: " + version, new GUIStyle(GUI.skin.label)
+            {
+              margin = new RectOffset(4, 4, 4, 4),
+            });
+          }
+
+          GUILayout.EndHorizontal();
+
+          EditorGUILayout.EndVertical();
+        }
+      };
+      return provider;
+    }
+
+    private static void LinkButton(string url)
+    {
+      var style = EditorStyles.linkLabel;
+
+      var bClicked = GUILayout.Button(url, style);
+
+      var rect = GUILayoutUtility.GetLastRect();
+      rect.width = style.CalcSize(new GUIContent(url)).x;
+      EditorGUIUtility.AddCursorRect(rect, MouseCursor.Link);
+
+      if (bClicked)
+        Application.OpenURL(url);
+    }
+  }
+}
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/PluginSettings.cs.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/PluginSettings.cs.meta
@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1bfe12aa306c0c74db4f4f1a1a0ae5ce
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/PostProcessors.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/PostProcessors.meta
@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: aa290bd9a165a0543a4bf85ac73914bc
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/PostProcessors/RiderAssetPostprocessor.cs
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/PostProcessors/RiderAssetPostprocessor.cs
@ -0,0 +1,16 @@
+using Unity.CodeEditor;
+using UnityEditor;
+
+namespace Packages.Rider.Editor.PostProcessors
+{
+  internal class RiderAssetPostprocessor: AssetPostprocessor
+  {
+    public static bool OnPreGeneratingCSProjectFiles()
+    {
+      var path = RiderScriptEditor.GetEditorRealPath(CodeEditor.CurrentEditorInstallation);
+      if (RiderScriptEditor.IsRiderInstallation(path))
+        return !ProjectGeneration.ProjectGeneration.isRiderProjectGeneration;
+      return false;
+    }
+  }
+}
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/PostProcessors/RiderAssetPostprocessor.cs.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/PostProcessors/RiderAssetPostprocessor.cs.meta
@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 45471ad7b8c1f964da5e3c07d57fbf4f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration.meta
@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 313cbe17019f1934397f91069831062c
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/AssemblyNameProvider.cs
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/AssemblyNameProvider.cs
@ -0,0 +1,155 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEditor.Compilation;
+using UnityEditor.PackageManager;
+
+namespace Packages.Rider.Editor.ProjectGeneration
+{
+  internal class AssemblyNameProvider : IAssemblyNameProvider
+  {
+    ProjectGenerationFlag m_ProjectGenerationFlag = (ProjectGenerationFlag)EditorPrefs.GetInt("unity_project_generation_flag", 3);
+
+    public string[] ProjectSupportedExtensions => EditorSettings.projectGenerationUserExtensions;
+
+    public string ProjectGenerationRootNamespace => EditorSettings.projectGenerationRootNamespace;
+
+    public ProjectGenerationFlag ProjectGenerationFlag
+    {
+      get => m_ProjectGenerationFlag;
+      private set
+      {
+        EditorPrefs.SetInt("unity_project_generation_flag", (int)value);
+        m_ProjectGenerationFlag = value;
+      }
+    }
+
+    public string GetAssemblyNameFromScriptPath(string path)
+    {
+      return CompilationPipeline.GetAssemblyNameFromScriptPath(path);
+    }
+
+    public IEnumerable<Assembly> GetAssemblies(Func<string, bool> shouldFileBePartOfSolution)
+    {
+      var assemblies = GetAssembliesByType(AssembliesType.Editor, shouldFileBePartOfSolution, "Temp\\Bin\\Debug\\");
+
+      if (ProjectGenerationFlag.HasFlag(ProjectGenerationFlag.PlayerAssemblies))
+      {
+        var playerAssemblies = GetAssembliesByType(AssembliesType.Player, shouldFileBePartOfSolution, "Temp\\Bin\\Debug\\Player\\");
+        assemblies = assemblies.Concat(playerAssemblies);
+      }
+
+      return assemblies;
+    }
+
+    private IEnumerable<Assembly> GetAssembliesByType(AssembliesType type, Func<string, bool> shouldFileBePartOfSolution, string outputPath)
+    {
+      foreach (var assembly in CompilationPipeline.GetAssemblies(type))
+      {
+        var options = new ScriptCompilerOptions()
+        {
+          ResponseFiles = assembly.compilerOptions.ResponseFiles,
+          AllowUnsafeCode = assembly.compilerOptions.AllowUnsafeCode,
+          ApiCompatibilityLevel = assembly.compilerOptions.ApiCompatibilityLevel
+        };
+
+        if (assembly.sourceFiles.Any(shouldFileBePartOfSolution))
+        {
+          yield return new Assembly(assembly.name
+            , outputPath, assembly.sourceFiles, assembly.defines
+            , assembly.assemblyReferences, assembly.compiledAssemblyReferences, assembly.flags, options
+#if UNITY_2020_2_OR_NEWER
+            , assembly.rootNamespace
+#endif
+          );
+        }
+      }
+    }
+
+    public string GetProjectName(string assemblyOutputPath, string assemblyName)
+    {
+      return assemblyOutputPath.EndsWith("\\Player\\", StringComparison.Ordinal) ? assemblyName + ".Player" : assemblyName;
+    }
+
+    public IEnumerable<string> GetAllAssetPaths()
+    {
+      return AssetDatabase.GetAllAssetPaths();
+    }
+
+    public UnityEditor.PackageManager.PackageInfo FindForAssetPath(string assetPath)
+    {
+      return UnityEditor.PackageManager.PackageInfo.FindForAssetPath(assetPath);
+    }
+
+    public bool IsInternalizedPackagePath(string path)
+    {
+      if (string.IsNullOrEmpty(path.Trim()))
+      {
+        return false;
+      }
+
+      var packageInfo = FindForAssetPath(path);
+      if (packageInfo == null)
+      {
+        return false;
+      }
+
+      var packageSource = packageInfo.source;
+      switch (packageSource)
+      {
+        case PackageSource.Embedded:
+          return !ProjectGenerationFlag.HasFlag(ProjectGenerationFlag.Embedded);
+        case PackageSource.Registry:
+          return !ProjectGenerationFlag.HasFlag(ProjectGenerationFlag.Registry);
+        case PackageSource.BuiltIn:
+          return !ProjectGenerationFlag.HasFlag(ProjectGenerationFlag.BuiltIn);
+        case PackageSource.Unknown:
+          return !ProjectGenerationFlag.HasFlag(ProjectGenerationFlag.Unknown);
+        case PackageSource.Local:
+          return !ProjectGenerationFlag.HasFlag(ProjectGenerationFlag.Local);
+        case PackageSource.Git:
+          return !ProjectGenerationFlag.HasFlag(ProjectGenerationFlag.Git);
+#if UNITY_2019_3_OR_NEWER
+        case PackageSource.LocalTarball:
+          return !ProjectGenerationFlag.HasFlag(ProjectGenerationFlag.LocalTarBall);
+#endif
+      }
+
+      return false;
+    }
+
+    public ResponseFileData ParseResponseFile(string responseFilePath, string projectDirectory, string[] systemReferenceDirectories)
+    {
+      return CompilationPipeline.ParseResponseFile(
+        responseFilePath,
+        projectDirectory,
+        systemReferenceDirectories
+      );
+    }
+
+    public IEnumerable<string> GetRoslynAnalyzerPaths()
+    {
+      return PluginImporter.GetAllImporters()
+        .Where(i => !i.isNativePlugin && AssetDatabase.GetLabels(i).SingleOrDefault(l => l == "RoslynAnalyzer") != null)
+        .Select(i => i.assetPath);
+    }
+
+    public void ToggleProjectGeneration(ProjectGenerationFlag preference)
+    {
+      if (ProjectGenerationFlag.HasFlag(preference))
+      {
+        ProjectGenerationFlag ^= preference;
+      }
+      else
+      {
+        ProjectGenerationFlag |= preference;
+      }
+    }
+
+    public void ResetProjectGenerationFlag()
+    {
+      ProjectGenerationFlag = ProjectGenerationFlag.None;
+    }
+  }
+}
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/AssemblyNameProvider.cs.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/AssemblyNameProvider.cs.meta
@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 56c8c6e437b14f8e9a91e9832c11bc1a
+timeCreated: 1580717719
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/FileIOProvider.cs
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/FileIOProvider.cs
@ -0,0 +1,22 @@
+using System.IO;
+using System.Text;
+
+namespace Packages.Rider.Editor.ProjectGeneration {
+  class FileIOProvider : IFileIO
+  {
+    public bool Exists(string fileName)
+    {
+      return File.Exists(fileName);
+    }
+
+    public string ReadAllText(string fileName)
+    {
+      return File.ReadAllText(fileName);
+    }
+
+    public void WriteAllText(string fileName, string content)
+    {
+      File.WriteAllText(fileName, content, Encoding.UTF8);
+    }
+  }
+}
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/FileIOProvider.cs.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/FileIOProvider.cs.meta
@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a6ba838b1348d5e46a7eaacd1646c1d3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/GUIDProvider.cs
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/GUIDProvider.cs
@ -0,0 +1,9 @@
+namespace Packages.Rider.Editor.ProjectGeneration {
+  class GUIDProvider : IGUIDGenerator
+  {
+    public string ProjectGuid(string projectName, string assemblyName)
+    {
+      return SolutionGuidGenerator.GuidForProject(projectName + assemblyName);
+    }
+  }
+}
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/GUIDProvider.cs.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/GUIDProvider.cs.meta
@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8cfde1a59fb35574189691a9de1df93b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/IAssemblyNameProvider.cs
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/IAssemblyNameProvider.cs
@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using UnityEditor.Compilation;
+
+namespace Packages.Rider.Editor.ProjectGeneration
+{
+  internal interface IAssemblyNameProvider
+  {
+    string[] ProjectSupportedExtensions { get; }
+    string ProjectGenerationRootNamespace { get; }
+    ProjectGenerationFlag ProjectGenerationFlag { get; }
+
+    string GetAssemblyNameFromScriptPath(string path);
+    string GetProjectName(string assemblyOutputPath, string assemblyName);
+    bool IsInternalizedPackagePath(string path);
+    IEnumerable<Assembly> GetAssemblies(Func<string, bool> shouldFileBePartOfSolution);
+    IEnumerable<string> GetAllAssetPaths();
+    UnityEditor.PackageManager.PackageInfo FindForAssetPath(string assetPath);
+    ResponseFileData ParseResponseFile(string responseFilePath, string projectDirectory, string[] systemReferenceDirectories);
+    IEnumerable<string> GetRoslynAnalyzerPaths();
+    void ToggleProjectGeneration(ProjectGenerationFlag preference);
+  }
+}
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/IAssemblyNameProvider.cs.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/IAssemblyNameProvider.cs.meta
@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 5eea837708474d7e9c1cb4b2eca0213f
+timeCreated: 1580717710
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/IFileIO.cs
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/IFileIO.cs
@ -0,0 +1,10 @@
+namespace Packages.Rider.Editor.ProjectGeneration
+{
+  internal interface IFileIO
+  {
+    bool Exists(string fileName);
+
+    string ReadAllText(string fileName);
+    void WriteAllText(string fileName, string content);
+  }
+}
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/IFileIO.cs.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/IFileIO.cs.meta
@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 1bdab5b8331b4506bf4eae379235c053
+timeCreated: 1580717666
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/IGUIDGenerator.cs
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/IGUIDGenerator.cs
@ -0,0 +1,7 @@
+namespace Packages.Rider.Editor.ProjectGeneration
+{
+  internal interface IGUIDGenerator
+  {
+    string ProjectGuid(string projectName, string assemblyName);
+  }
+}
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/IGUIDGenerator.cs.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/IGUIDGenerator.cs.meta
@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 8c7e8e301f8b4c30bbf9db502d637f0f
+timeCreated: 1580717700
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/IGenerator.cs
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/IGenerator.cs
@ -0,0 +1,13 @@
+using System.Collections.Generic;
+
+namespace Packages.Rider.Editor.ProjectGeneration
+{
+  internal interface IGenerator
+  {
+    bool SyncIfNeeded(IEnumerable<string> affectedFiles, IEnumerable<string> reimportedFiles);
+    void Sync();
+    bool HasSolutionBeenGenerated();
+    string SolutionFile();
+    IAssemblyNameProvider AssemblyNameProvider { get; }
+  }
+}
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/IGenerator.cs.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/IGenerator.cs.meta
@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 39cb9ab8a3b2452cbf58ffbea841d203
+timeCreated: 1580717654
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/ProjectGeneration.cs
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/ProjectGeneration.cs
@ -0,0 +1,872 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Security;
+using System.Text;
+using System.Text.RegularExpressions;
+using Packages.Rider.Editor.Util;
+using UnityEditor;
+using UnityEditor.Compilation;
+using UnityEditorInternal;
+using UnityEngine;
+
+namespace Packages.Rider.Editor.ProjectGeneration
+{
+  internal class ProjectGeneration : IGenerator
+  {
+    private enum ScriptingLanguage
+    {
+      None,
+      CSharp
+    }
+
+    public static readonly string MSBuildNamespaceUri = "http://schemas.microsoft.com/developer/msbuild/2003";
+
+    /// <summary>
+    /// Map source extensions to ScriptingLanguages
+    /// </summary>
+    private static readonly Dictionary<string, ScriptingLanguage> k_BuiltinSupportedExtensions =
+      new Dictionary<string, ScriptingLanguage>
+      {
+        { "cs", ScriptingLanguage.CSharp },
+        { "uxml", ScriptingLanguage.None },
+        { "uss", ScriptingLanguage.None },
+        { "shader", ScriptingLanguage.None },
+        { "compute", ScriptingLanguage.None },
+        { "cginc", ScriptingLanguage.None },
+        { "hlsl", ScriptingLanguage.None },
+        { "glslinc", ScriptingLanguage.None },
+        { "template", ScriptingLanguage.None },
+        { "raytrace", ScriptingLanguage.None }
+      };
+
+    private string m_SolutionProjectEntryTemplate = string.Join(Environment.NewLine,
+      @"Project(""{{{0}}}"") = ""{1}"", ""{2}"", ""{{{3}}}""",
+      @"EndProject").Replace("    ", "\t");
+
+    private string m_SolutionProjectConfigurationTemplate = string.Join(Environment.NewLine,
+      @"        {{{0}}}.Debug|Any CPU.ActiveCfg = Debug|Any CPU",
+      @"        {{{0}}}.Debug|Any CPU.Build.0 = Debug|Any CPU").Replace("    ", "\t");
+
+    private static readonly string[] k_ReimportSyncExtensions = { ".dll", ".asmdef" };
+
+    /// <summary>
+    /// Map ScriptingLanguages to project extensions
+    /// </summary>
+    /*static readonly Dictionary<ScriptingLanguage, string> k_ProjectExtensions = new Dictionary<ScriptingLanguage, string>
+    {
+        { ScriptingLanguage.CSharp, ".csproj" },
+        { ScriptingLanguage.None, ".csproj" },
+    };*/
+    private static readonly Regex k_ScriptReferenceExpression = new Regex(
+      @"^Library.ScriptAssemblies.(?<dllname>(?<project>.*)\.dll$)",
+      RegexOptions.Compiled | RegexOptions.IgnoreCase);
+
+    private string[] m_ProjectSupportedExtensions = new string[0];
+
+    public string ProjectDirectory { get; }
+
+    private readonly string m_ProjectName;
+    private readonly IAssemblyNameProvider m_AssemblyNameProvider;
+    private readonly IFileIO m_FileIOProvider;
+    private readonly IGUIDGenerator m_GUIDGenerator;
+
+    internal static bool isRiderProjectGeneration; // workaround to https://github.cds.internal.unity3d.com/unity/com.unity.ide.rider/issues/28
+
+    private const string k_ToolsVersion = "4.0";
+    private const string k_ProductVersion = "10.0.20506";
+    private const string k_BaseDirectory = ".";
+    private const string k_TargetFrameworkVersion = "v4.7.1";
+    private const string k_TargetLanguageVersion = "latest";
+
+    IAssemblyNameProvider IGenerator.AssemblyNameProvider => m_AssemblyNameProvider;
+
+    public ProjectGeneration()
+      : this(Directory.GetParent(Application.dataPath).FullName) { }
+
+    public ProjectGeneration(string tempDirectory)
+      : this(tempDirectory, new AssemblyNameProvider(), new FileIOProvider(), new GUIDProvider()) { }
+
+    public ProjectGeneration(string tempDirectory, IAssemblyNameProvider assemblyNameProvider, IFileIO fileIoProvider, IGUIDGenerator guidGenerator)
+    {
+      ProjectDirectory = tempDirectory.Replace('\\', '/');
+      m_ProjectName = Path.GetFileName(ProjectDirectory);
+      m_AssemblyNameProvider = assemblyNameProvider;
+      m_FileIOProvider = fileIoProvider;
+      m_GUIDGenerator = guidGenerator;
+    }
+
+    /// <summary>
+    /// Syncs the scripting solution if any affected files are relevant.
+    /// </summary>
+    /// <returns>
+    /// Whether the solution was synced.
+    /// </returns>
+    /// <param name='affectedFiles'>
+    /// A set of files whose status has changed
+    /// </param>
+    /// <param name="reimportedFiles">
+    /// A set of files that got reimported
+    /// </param>
+    public bool SyncIfNeeded(IEnumerable<string> affectedFiles, IEnumerable<string> reimportedFiles)
+    {
+      SetupProjectSupportedExtensions();
+
+      if (HasFilesBeenModified(affectedFiles, reimportedFiles) || RiderScriptEditorData.instance.hasChanges || RiderScriptEditorData.instance.HasChangesInCompilationDefines())
+      {
+        Sync();
+        RiderScriptEditorData.instance.hasChanges = false;
+        RiderScriptEditorData.instance.InvalidateSavedCompilationDefines();
+        return true;
+      }
+
+      return false;
+    }
+
+    private bool HasFilesBeenModified(IEnumerable<string> affectedFiles, IEnumerable<string> reimportedFiles)
+    {
+      return affectedFiles.Any(ShouldFileBePartOfSolution) || reimportedFiles.Any(ShouldSyncOnReimportedAsset);
+    }
+
+    private static bool ShouldSyncOnReimportedAsset(string asset)
+    {
+      return k_ReimportSyncExtensions.Contains(Path.GetExtension(asset)) || Path.GetFileName(asset) == "csc.rsp";
+    }
+
+    public void Sync()
+    {
+      SetupProjectSupportedExtensions();
+      var types = GetAssetPostprocessorTypes();
+      isRiderProjectGeneration = true;
+      var externalCodeAlreadyGeneratedProjects = OnPreGeneratingCSProjectFiles(types);
+      isRiderProjectGeneration = false;
+      if (!externalCodeAlreadyGeneratedProjects)
+      {
+        GenerateAndWriteSolutionAndProjects(types);
+      }
+
+      OnGeneratedCSProjectFiles(types);
+    }
+
+    public bool HasSolutionBeenGenerated()
+    {
+      return m_FileIOProvider.Exists(SolutionFile());
+    }
+
+    private void SetupProjectSupportedExtensions()
+    {
+      m_ProjectSupportedExtensions = m_AssemblyNameProvider.ProjectSupportedExtensions;
+    }
+
+    private bool ShouldFileBePartOfSolution(string file)
+    {
+      // Exclude files coming from packages except if they are internalized.
+      if (m_AssemblyNameProvider.IsInternalizedPackagePath(file))
+      {
+          return false;
+      }
+      return HasValidExtension(file);
+    }
+
+    private bool HasValidExtension(string file)
+    {
+      var extension = Path.GetExtension(file);
+
+      // Dll's are not scripts but still need to be included..
+      if (extension.Equals(".dll", StringComparison.OrdinalIgnoreCase))
+          return true;
+
+      if (extension.Equals(".asmdef", StringComparison.OrdinalIgnoreCase))
+        return true;
+
+      return IsSupportedExtension(extension);
+    }
+
+    private bool IsSupportedExtension(string extension)
+    {
+      extension = extension.TrimStart('.');
+      return k_BuiltinSupportedExtensions.ContainsKey(extension) || m_ProjectSupportedExtensions.Contains(extension);
+    }
+
+    public void GenerateAndWriteSolutionAndProjects(Type[] types)
+    {
+      // Only synchronize islands that have associated source files and ones that we actually want in the project.
+      // This also filters out DLLs coming from .asmdef files in packages.
+      var assemblies = m_AssemblyNameProvider.GetAssemblies(ShouldFileBePartOfSolution).ToArray();
+      var assemblyNames = new HashSet<string>(assemblies.Select(a => a.name));
+      var allAssetProjectParts = GenerateAllAssetProjectParts();
+
+      var projectParts = new List<ProjectPart>();
+      foreach (var assembly in assemblies)
+      {
+        allAssetProjectParts.TryGetValue(assembly.name, out var additionalAssetsForProject);
+        projectParts.Add(new ProjectPart(assembly.name, assembly, additionalAssetsForProject));
+      }
+
+      var projectPartsWithoutAssembly = allAssetProjectParts.Where(a => !assemblyNames.Contains(a.Key));
+      projectParts.AddRange(projectPartsWithoutAssembly.Select(allAssetProjectPart => new ProjectPart(allAssetProjectPart.Key, null, allAssetProjectPart.Value)));
+
+      SyncSolution(projectParts.ToArray(), types);
+      
+      foreach (var projectPart in projectParts)
+      {
+        SyncProject(projectPart, types, GetAllRoslynAnalyzerPaths().ToArray());
+      }
+    }
+
+    private IEnumerable<string> GetAllRoslynAnalyzerPaths()
+    {
+      return m_AssemblyNameProvider.GetRoslynAnalyzerPaths();
+    }
+
+    private Dictionary<string, string> GenerateAllAssetProjectParts()
+    {
+      var stringBuilders = new Dictionary<string, StringBuilder>();
+
+      foreach (var asset in m_AssemblyNameProvider.GetAllAssetPaths())
+      {
+        // Exclude files coming from packages except if they are internalized.
+        if (m_AssemblyNameProvider.IsInternalizedPackagePath(asset))
+        {
+          continue;
+        }
+
+        var extension = Path.GetExtension(asset);
+        if (IsSupportedExtension(extension) && !extension.Equals(".cs", StringComparison.OrdinalIgnoreCase))
+        {
+          // Find assembly the asset belongs to by adding script extension and using compilation pipeline.
+          var assemblyName = m_AssemblyNameProvider.GetAssemblyNameFromScriptPath(asset + ".cs");
+
+          if (string.IsNullOrEmpty(assemblyName))
+          {
+            continue;
+          }
+
+          assemblyName = FileSystemUtil.FileNameWithoutExtension(assemblyName);
+
+          if (!stringBuilders.TryGetValue(assemblyName, out var projectBuilder))
+          {
+            projectBuilder = new StringBuilder();
+            stringBuilders[assemblyName] = projectBuilder;
+          }
+
+          projectBuilder.Append("     <None Include=\"").Append(EscapedRelativePathFor(asset)).Append("\" />")
+            .Append(Environment.NewLine);
+        }
+      }
+
+      var result = new Dictionary<string, string>();
+
+      foreach (var entry in stringBuilders)
+        result[entry.Key] = entry.Value.ToString();
+
+      return result;
+    }
+
+    private void SyncProject(
+      ProjectPart island,
+      Type[] types,
+      string[] roslynAnalyzerDllPaths)
+    {
+      SyncProjectFileIfNotChanged(
+        ProjectFile(island),
+        ProjectText(island, roslynAnalyzerDllPaths),
+        types);
+    }
+
+    private void SyncProjectFileIfNotChanged(string path, string newContents, Type[] types)
+    {
+      if (Path.GetExtension(path) == ".csproj")
+      {
+        newContents = OnGeneratedCSProject(path, newContents, types);
+      }
+
+      SyncFileIfNotChanged(path, newContents);
+    }
+
+    private void SyncSolutionFileIfNotChanged(string path, string newContents, Type[] types)
+    {
+      newContents = OnGeneratedSlnSolution(path, newContents, types);
+
+      SyncFileIfNotChanged(path, newContents);
+    }
+
+    private static void OnGeneratedCSProjectFiles(Type[] types)
+    {
+      foreach (var type in types)
+      {
+        var method = type.GetMethod("OnGeneratedCSProjectFiles",
+          System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic |
+          System.Reflection.BindingFlags.Static);
+        if (method == null)
+        {
+          continue;
+        }
+
+        Debug.LogWarning("OnGeneratedCSProjectFiles is not supported.");
+        // RIDER-51958
+        //method.Invoke(null, args);
+      }
+    }
+
+    public static Type[] GetAssetPostprocessorTypes()
+    {
+      return TypeCache.GetTypesDerivedFrom<AssetPostprocessor>().ToArray(); // doesn't find types from EditorPlugin, which is fine
+    }
+
+    private static bool OnPreGeneratingCSProjectFiles(Type[] types)
+    {
+      var result = false;
+      foreach (var type in types)
+      {
+        var args = new object[0];
+        var method = type.GetMethod("OnPreGeneratingCSProjectFiles",
+          System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic |
+          System.Reflection.BindingFlags.Static);
+        if (method == null)
+        {
+          continue;
+        }
+
+        var returnValue = method.Invoke(null, args);
+        if (method.ReturnType == typeof(bool))
+        {
+          result |= (bool)returnValue;
+        }
+      }
+
+      return result;
+    }
+
+    private static string OnGeneratedCSProject(string path, string content, Type[] types)
+    {
+      foreach (var type in types)
+      {
+        var args = new[] { path, content };
+        var method = type.GetMethod("OnGeneratedCSProject",
+          System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic |
+          System.Reflection.BindingFlags.Static);
+        if (method == null)
+        {
+          continue;
+        }
+
+        var returnValue = method.Invoke(null, args);
+        if (method.ReturnType == typeof(string))
+        {
+          content = (string)returnValue;
+        }
+      }
+
+      return content;
+    }
+
+    private static string OnGeneratedSlnSolution(string path, string content, Type[] types)
+    {
+      foreach (var type in types)
+      {
+        var args = new[] { path, content };
+        var method = type.GetMethod("OnGeneratedSlnSolution",
+          System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic |
+          System.Reflection.BindingFlags.Static);
+        if (method == null)
+        {
+          continue;
+        }
+
+        var returnValue = method.Invoke(null, args);
+        if (method.ReturnType == typeof(string))
+        {
+          content = (string)returnValue;
+        }
+      }
+
+      return content;
+    }
+
+    private void SyncFileIfNotChanged(string filename, string newContents)
+    {
+      try
+      {
+        if (m_FileIOProvider.Exists(filename) && newContents == m_FileIOProvider.ReadAllText(filename))
+        {
+          return;
+        }
+      }
+      catch (Exception exception)
+      {
+        Debug.LogException(exception);
+      }
+
+      m_FileIOProvider.WriteAllText(filename, newContents);
+    }
+
+    private string ProjectText(ProjectPart assembly,
+      string[] roslynAnalyzerDllPaths)
+    {
+      var responseFilesData = assembly.ParseResponseFileData(m_AssemblyNameProvider, ProjectDirectory).ToList();
+      var projectBuilder = new StringBuilder(ProjectHeader(assembly, responseFilesData, roslynAnalyzerDllPaths));
+      
+      foreach (var file in assembly.SourceFiles)
+      {
+        var fullFile = EscapedRelativePathFor(file);
+        projectBuilder.Append("     <Compile Include=\"").Append(fullFile).Append("\" />").Append(Environment.NewLine);
+      }
+
+      projectBuilder.Append(assembly.AssetsProjectPart);
+
+      var responseRefs = responseFilesData.SelectMany(x => x.FullPathReferences.Select(r => r));
+      var internalAssemblyReferences = assembly.AssemblyReferences
+        .Where(reference => !reference.sourceFiles.Any(ShouldFileBePartOfSolution)).Select(i => i.outputPath);
+      var allReferences =
+        assembly.CompiledAssemblyReferences
+          .Union(responseRefs)
+          .Union(internalAssemblyReferences).ToArray();
+
+      foreach (var reference in allReferences)
+      {
+        var fullReference = Path.IsPathRooted(reference) ? reference : Path.Combine(ProjectDirectory, reference);
+        AppendReference(fullReference, projectBuilder);
+      }
+
+      if (0 < assembly.AssemblyReferences.Length)
+      {
+        projectBuilder.Append("  </ItemGroup>").Append(Environment.NewLine);
+        projectBuilder.Append("  <ItemGroup>").Append(Environment.NewLine);
+        foreach (var reference in assembly.AssemblyReferences.Where(i => i.sourceFiles.Any(ShouldFileBePartOfSolution)))
+        {
+          projectBuilder.Append("    <ProjectReference Include=\"").Append(reference.name).Append(GetProjectExtension()).Append("\">").Append(Environment.NewLine);
+          projectBuilder.Append("      <Project>{").Append(ProjectGuid(reference.name, reference.outputPath)).Append("}</Project>").Append(Environment.NewLine);
+          projectBuilder.Append("      <Name>").Append(reference.name).Append("</Name>").Append(Environment.NewLine);
+          projectBuilder.Append("    </ProjectReference>").Append(Environment.NewLine);
+        }
+      }
+
+      projectBuilder.Append(ProjectFooter());
+      return projectBuilder.ToString();
+    }
+
+    private static void AppendReference(string fullReference, StringBuilder projectBuilder)
+    {
+      //replace \ with / and \\ with /
+      var escapedFullPath = SecurityElement.Escape(fullReference);
+      escapedFullPath = escapedFullPath.Replace("\\\\", "/").Replace("\\", "/");
+      projectBuilder.Append("     <Reference Include=\"").Append(FileSystemUtil.FileNameWithoutExtension(escapedFullPath))
+        .Append("\">").Append(Environment.NewLine);
+      projectBuilder.Append("     <HintPath>").Append(escapedFullPath).Append("</HintPath>").Append(Environment.NewLine);
+      projectBuilder.Append("     </Reference>").Append(Environment.NewLine);
+    }
+
+    private string ProjectFile(ProjectPart projectPart)
+    {
+      return Path.Combine(ProjectDirectory, $"{m_AssemblyNameProvider.GetProjectName(projectPart.OutputPath, projectPart.Name)}.csproj");
+    }
+
+    public string SolutionFile()
+    {
+      return Path.Combine(ProjectDirectory, $"{m_ProjectName}.sln");
+    }
+
+    private string ProjectHeader(
+      ProjectPart assembly,
+      List<ResponseFileData> responseFilesData,
+      string[] roslynAnalyzerDllPaths
+    )
+    {
+      var otherResponseFilesData = GetOtherArgumentsFromResponseFilesData(responseFilesData);
+      var arguments = new object[]
+      {
+        k_ToolsVersion,
+        k_ProductVersion,
+        ProjectGuid(assembly.Name, assembly.OutputPath),
+        InternalEditorUtility.GetEngineAssemblyPath(),
+        InternalEditorUtility.GetEditorAssemblyPath(),
+        string.Join(";", assembly.Defines.Concat(responseFilesData.SelectMany(x => x.Defines)).Distinct().ToArray()),
+        MSBuildNamespaceUri,
+        assembly.Name,
+        assembly.OutputPath,
+        assembly.RootNamespace,
+        k_TargetFrameworkVersion,
+        GenerateLangVersion(otherResponseFilesData["langversion"], assembly),
+        k_BaseDirectory,
+        assembly.CompilerOptions.AllowUnsafeCode | responseFilesData.Any(x => x.Unsafe),
+        GenerateNoWarn(otherResponseFilesData["nowarn"].Distinct().ToArray()),
+        GenerateAnalyserItemGroup(
+          otherResponseFilesData["analyzer"].Concat(otherResponseFilesData["a"])
+                                                  .SelectMany(x=>x.Split(';'))
+                                                  .Concat(roslynAnalyzerDllPaths)
+                                                  .Distinct()
+                                                  .ToArray()),
+        GenerateAnalyserAdditionalFiles(otherResponseFilesData["additionalfile"].SelectMany(x=>x.Split(';')).Distinct().ToArray()),
+        #if UNITY_2020_2_OR_NEWER
+        GenerateAnalyserRuleSet(otherResponseFilesData["ruleset"].Append(assembly.CompilerOptions.RoslynAnalyzerRulesetPath).Where(a=>!string.IsNullOrEmpty(a)).Distinct().ToArray()),
+        #else
+        GenerateAnalyserRuleSet(otherResponseFilesData["ruleset"].Distinct().ToArray()),
+        #endif
+        GenerateWarningLevel(otherResponseFilesData["warn"].Concat(otherResponseFilesData["w"]).Distinct()),
+        GenerateWarningAsError(otherResponseFilesData["warnaserror"]),
+        GenerateDocumentationFile(otherResponseFilesData["doc"].ToArray()),
+        GenerateNullable(otherResponseFilesData["nullable"])
+      };
+
+      try
+      {
+        return string.Format(GetProjectHeaderTemplate(), arguments);
+      }
+      catch (Exception)
+      {
+        throw new NotSupportedException(
+          "Failed creating c# project because the c# project header did not have the correct amount of arguments, which is " +
+          arguments.Length);
+      }
+    }
+
+    private string GenerateNullable(IEnumerable<string> enumerable)
+    {
+      if (!enumerable.Any())
+        return string.Empty;
+
+      var returnValue = string.Empty;
+      var val = string.Empty;
+
+      foreach (var s in enumerable)
+      {
+        if (s == "+") val = "enable";
+        else if (s == "-") val = "disable";
+        else val = s;
+      }
+
+      returnValue += $@"    <Nullable>{val}</Nullable>";
+
+      return $"{Environment.NewLine}{returnValue}";
+    }
+
+    private static string GenerateDocumentationFile(string[] paths)
+    {
+      if (!paths.Any())
+        return String.Empty;
+
+      return $"{Environment.NewLine}{string.Join(Environment.NewLine, paths.Select(a => $"  <DocumentationFile>{a}</DocumentationFile>"))}";
+    }
+
+    private static string GenerateWarningAsError(IEnumerable<string> enumerable)
+    {
+      var returnValue = String.Empty;
+      var allWarningsAsErrors = false;
+      var warningIds = new List<string>();
+
+      foreach (var s in enumerable)
+      {
+        if (s == "+") allWarningsAsErrors = true;
+        else if (s == "-") allWarningsAsErrors = false;
+        else
+        {
+          warningIds.Add(s);
+        }
+      }
+
+      returnValue += $@"    <TreatWarningsAsErrors>{allWarningsAsErrors}</TreatWarningsAsErrors>";
+      if (warningIds.Any())
+      {
+        returnValue += $"{Environment.NewLine}    <WarningsAsErrors>{string.Join(";", warningIds)}</WarningsAsErrors>";
+      }
+
+      return $"{Environment.NewLine}{returnValue}";
+    }
+
+    private static string GenerateWarningLevel(IEnumerable<string> warningLevel)
+    {
+      var level = warningLevel.FirstOrDefault();
+      if (!string.IsNullOrWhiteSpace(level))
+        return level;
+
+      return 4.ToString();
+    }
+
+    private static string GetSolutionText()
+    {
+      return string.Join(Environment.NewLine,
+        @"",
+        @"Microsoft Visual Studio Solution File, Format Version {0}",
+        @"# Visual Studio {1}",
+        @"{2}",
+        @"Global",
+        @"    GlobalSection(SolutionConfigurationPlatforms) = preSolution",
+        @"        Debug|Any CPU = Debug|Any CPU",
+        @"    EndGlobalSection",
+        @"    GlobalSection(ProjectConfigurationPlatforms) = postSolution",
+        @"{3}",
+        @"    EndGlobalSection",
+        @"    GlobalSection(SolutionProperties) = preSolution",
+        @"        HideSolutionNode = FALSE",
+        @"    EndGlobalSection",
+        @"EndGlobal",
+        @"").Replace("    ", "\t");
+    }
+
+    private static string GetProjectFooterTemplate()
+    {
+      return string.Join(Environment.NewLine,
+        @"  </ItemGroup>",
+        @"  <Import Project=""$(MSBuildToolsPath)\Microsoft.CSharp.targets"" />",
+        @"  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.",
+        @"       Other similar extension points exist, see Microsoft.Common.targets.",
+        @"  <Target Name=""BeforeBuild"">",
+        @"  </Target>",
+        @"  <Target Name=""AfterBuild"">",
+        @"  </Target>",
+        @"  -->",
+        @"</Project>",
+        @"");
+    }
+
+    private static string GetProjectHeaderTemplate()
+    {
+      var header = new[]
+      {
+        @"<?xml version=""1.0"" encoding=""utf-8""?>",
+        @"<Project ToolsVersion=""{0}"" DefaultTargets=""Build"" xmlns=""{6}"">",
+        @"  <PropertyGroup>",
+        @"    <LangVersion>{11}</LangVersion>",
+        @"    <_TargetFrameworkDirectories>non_empty_path_generated_by_unity.rider.package</_TargetFrameworkDirectories>",
+        @"    <_FullFrameworkReferenceAssemblyPaths>non_empty_path_generated_by_unity.rider.package</_FullFrameworkReferenceAssemblyPaths>",
+        @"    <DisableHandlePackageFileConflicts>true</DisableHandlePackageFileConflicts>{17}",
+        @"  </PropertyGroup>",
+        @"  <PropertyGroup>",
+        @"    <Configuration Condition="" '$(Configuration)' == '' "">Debug</Configuration>",
+        @"    <Platform Condition="" '$(Platform)' == '' "">AnyCPU</Platform>",
+        @"    <ProductVersion>{1}</ProductVersion>",
+        @"    <SchemaVersion>2.0</SchemaVersion>",
+        @"    <RootNamespace>{9}</RootNamespace>",
+        @"    <ProjectGuid>{{{2}}}</ProjectGuid>",
+        @"    <ProjectTypeGuids>{{E097FAD1-6243-4DAD-9C02-E9B9EFC3FFC1}};{{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}}</ProjectTypeGuids>",
+        @"    <OutputType>Library</OutputType>",
+        @"    <AppDesignerFolder>Properties</AppDesignerFolder>",
+        @"    <AssemblyName>{7}</AssemblyName>",
+        @"    <TargetFrameworkVersion>{10}</TargetFrameworkVersion>",
+        @"    <FileAlignment>512</FileAlignment>",
+        @"    <BaseDirectory>{12}</BaseDirectory>",
+        @"  </PropertyGroup>",
+        @"  <PropertyGroup Condition="" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "">",
+        @"    <DebugSymbols>true</DebugSymbols>",
+        @"    <DebugType>full</DebugType>",
+        @"    <Optimize>false</Optimize>",
+        @"    <OutputPath>{8}</OutputPath>",
+        @"    <DefineConstants>{5}</DefineConstants>",
+        @"    <ErrorReport>prompt</ErrorReport>",
+        @"    <WarningLevel>{18}</WarningLevel>",
+        @"    <NoWarn>{14}</NoWarn>",
+        @"    <AllowUnsafeBlocks>{13}</AllowUnsafeBlocks>{19}{20}{21}",
+        @"  </PropertyGroup>"
+      };
+
+      var forceExplicitReferences = new[]
+      {
+        @"  <PropertyGroup>",
+        @"    <NoConfig>true</NoConfig>",
+        @"    <NoStdLib>true</NoStdLib>",
+        @"    <AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>",
+        @"    <ImplicitlyExpandNETStandardFacades>false</ImplicitlyExpandNETStandardFacades>",
+        @"    <ImplicitlyExpandDesignTimeFacades>false</ImplicitlyExpandDesignTimeFacades>",
+        @"  </PropertyGroup>"
+      };
+
+      var footer = new[]
+      {
+        @"{15}{16}  <ItemGroup>",
+        @""
+      };
+
+      var pieces = header.Concat(forceExplicitReferences).Concat(footer).ToArray();
+      return string.Join(Environment.NewLine, pieces);
+    }
+
+    private void SyncSolution(ProjectPart[] islands, Type[] types)
+    {
+      SyncSolutionFileIfNotChanged(SolutionFile(), SolutionText(islands), types);
+    }
+
+    private string SolutionText(ProjectPart[] islands)
+    {
+      var fileversion = "11.00";
+      var vsversion = "2010";
+      
+      var projectEntries = GetProjectEntries(islands);
+      var projectConfigurations = string.Join(Environment.NewLine,
+        islands.Select(i => GetProjectActiveConfigurations(ProjectGuid(i.Name, i.OutputPath))).ToArray());
+      return string.Format(GetSolutionText(), fileversion, vsversion, projectEntries, projectConfigurations);
+    }
+
+    private static string GenerateAnalyserItemGroup(string[] paths)
+    {
+      //   <ItemGroup>
+      //      <Analyzer Include="..\packages\Comments_analyser.1.0.6626.21356\analyzers\dotnet\cs\Comments_analyser.dll" />
+      //      <Analyzer Include="..\packages\UnityEngineAnalyzer.1.0.0.0\analyzers\dotnet\cs\UnityEngineAnalyzer.dll" />
+      //  </ItemGroup>
+      if (!paths.Any())
+        return string.Empty;
+
+      var analyserBuilder = new StringBuilder();
+      analyserBuilder.AppendLine("  <ItemGroup>");
+      foreach (var path in paths)
+      {
+        analyserBuilder.AppendLine($"    <Analyzer Include=\"{path}\" />");
+      }
+
+      analyserBuilder.AppendLine("  </ItemGroup>");
+      return analyserBuilder.ToString();
+    }
+
+    private static ILookup<string, string> GetOtherArgumentsFromResponseFilesData(List<ResponseFileData> responseFilesData)
+    {
+      var paths = responseFilesData.SelectMany(x =>
+        {
+          return x.OtherArguments
+            .Where(a => a.StartsWith("/") || a.StartsWith("-"))
+            .Select(b =>
+            {
+              var index = b.IndexOf(":", StringComparison.Ordinal);
+              if (index > 0 && b.Length > index)
+              {
+                var key = b.Substring(1, index - 1);
+                return new KeyValuePair<string, string>(key, b.Substring(index + 1));
+              }
+
+              const string warnaserror = "warnaserror";
+              if (b.Substring(1).StartsWith(warnaserror))
+              {
+                return new KeyValuePair<string, string>(warnaserror, b.Substring(warnaserror.Length + 1));
+              }
+              const string nullable = "nullable";
+              if (b.Substring(1).Equals(nullable))
+              {
+                return new KeyValuePair<string, string>(nullable, "enable");
+              }
+
+              return default;
+            });
+        })
+        .Distinct()
+        .ToLookup(o => o.Key, pair => pair.Value);
+      return paths;
+    }
+
+    private string GenerateLangVersion(IEnumerable<string> langVersionList, ProjectPart assembly)
+    {
+      var langVersion = langVersionList.FirstOrDefault();
+      if (!string.IsNullOrWhiteSpace(langVersion))
+        return langVersion;
+#if UNITY_2020_2_OR_NEWER
+      return assembly.CompilerOptions.LanguageVersion;
+#else
+      return k_TargetLanguageVersion;
+#endif
+    }
+
+    private static string GenerateAnalyserRuleSet(string[] paths)
+    {
+      //<CodeAnalysisRuleSet>..\path\to\myrules.ruleset</CodeAnalysisRuleSet>
+      if (!paths.Any())
+        return string.Empty;
+
+      return $"{Environment.NewLine}{string.Join(Environment.NewLine, paths.Select(a => $"    <CodeAnalysisRuleSet>{a}</CodeAnalysisRuleSet>"))}";
+    }
+
+    private static string GenerateAnalyserAdditionalFiles(string[] paths)
+    {
+      if (!paths.Any())
+        return string.Empty;
+
+      var analyserBuilder = new StringBuilder();
+      analyserBuilder.AppendLine("  <ItemGroup>");
+      foreach (var path in paths)
+      {
+        analyserBuilder.AppendLine($"    <AdditionalFiles Include=\"{path}\" />");
+      }
+
+      analyserBuilder.AppendLine("  </ItemGroup>");
+      return analyserBuilder.ToString();
+    }
+
+    private static string GenerateNoWarn(string[] codes)
+    {
+      if (!codes.Any())
+        return string.Empty;
+
+      return $",{string.Join(",", codes)}";
+    }
+    
+    private string GetProjectEntries(ProjectPart[] islands)
+    {
+      var projectEntries = islands.Select(i => string.Format(
+        m_SolutionProjectEntryTemplate,
+        SolutionGuidGenerator.GuidForSolution(),
+        i.Name,
+        Path.GetFileName(ProjectFile(i)),
+        ProjectGuid(i.Name, i.OutputPath)
+      ));
+
+      return string.Join(Environment.NewLine, projectEntries.ToArray());
+    }
+
+    /// <summary>
+    /// Generate the active configuration string for a given project guid
+    /// </summary>
+    private string GetProjectActiveConfigurations(string projectGuid)
+    {
+      return string.Format(
+        m_SolutionProjectConfigurationTemplate,
+        projectGuid);
+    }
+
+    private string EscapedRelativePathFor(string file)
+    {
+      var projectDir = ProjectDirectory.Replace('/', '\\');
+      file = file.Replace('/', '\\');
+      var path = SkipPathPrefix(file, projectDir);
+
+      var packageInfo = m_AssemblyNameProvider.FindForAssetPath(path.Replace('\\', '/'));
+      if (packageInfo != null)
+      {
+        // We have to normalize the path, because the PackageManagerRemapper assumes
+        // dir seperators will be os specific.
+        var absolutePath = Path.GetFullPath(NormalizePath(path)).Replace('/', '\\');
+        path = SkipPathPrefix(absolutePath, projectDir);
+      }
+
+      return SecurityElement.Escape(path);
+    }
+
+    private static string SkipPathPrefix(string path, string prefix)
+    {
+      if (path.StartsWith($@"{prefix}\"))
+        return path.Substring(prefix.Length + 1);
+      return path;
+    }
+
+    private static string NormalizePath(string path)
+    {
+      if (Path.DirectorySeparatorChar == '\\')
+        return path.Replace('/', Path.DirectorySeparatorChar);
+      return path.Replace('\\', Path.DirectorySeparatorChar);
+    }
+
+    private static string ProjectFooter()
+    {
+      return GetProjectFooterTemplate();
+    }
+
+    private static string GetProjectExtension()
+    {
+      return ".csproj";
+    }
+
+    private string ProjectGuid(string name, string outputPath)
+    {
+      return m_GUIDGenerator.ProjectGuid(
+        m_ProjectName,
+        m_AssemblyNameProvider.GetProjectName(outputPath, name));
+    }
+  }
+}
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/ProjectGeneration.cs.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/ProjectGeneration.cs.meta
@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7078f19173ceac84fb9e29b9f6175201
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/ProjectGenerationFlag.cs
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/ProjectGenerationFlag.cs
@ -0,0 +1,18 @@
+using System;
+
+namespace Packages.Rider.Editor.ProjectGeneration
+{
+  [Flags]
+  enum ProjectGenerationFlag
+  {
+    None = 0,
+    Embedded = 1,
+    Local = 2,
+    Registry = 4,
+    Git = 8,
+    BuiltIn = 16,
+    Unknown = 32,
+    PlayerAssemblies = 64,
+    LocalTarBall = 128,
+  }
+}
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/ProjectGenerationFlag.cs.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/ProjectGenerationFlag.cs.meta
@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 78af99d0156944f293b020b49a6830c2
+timeCreated: 1580820569
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/ProjectPart.cs
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/ProjectPart.cs
@ -0,0 +1,69 @@
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor.Compilation;
+using UnityEngine;
+
+namespace Packages.Rider.Editor.ProjectGeneration
+{
+  internal class ProjectPart
+  {
+    public string Name { get; }
+    public string OutputPath { get; }
+    public Assembly Assembly { get; }
+    public string AssetsProjectPart { get; }
+    public string[] SourceFiles { get; }
+    public string RootNamespace { get; }
+    public Assembly[] AssemblyReferences { get; }
+    public string[] CompiledAssemblyReferences { get; } 
+    public string[] Defines { get; }      
+    public ScriptCompilerOptions CompilerOptions { get; }
+
+    public ProjectPart(string name, Assembly assembly, string assetsProjectPart)
+    {
+      Name = name;
+      Assembly = assembly;
+      AssetsProjectPart = assetsProjectPart;
+      OutputPath = assembly != null ? assembly.outputPath : "Temp/Bin/Debug";
+      SourceFiles = assembly != null ? assembly.sourceFiles : new string[0];
+#if UNITY_2020_2_OR_NEWER
+      RootNamespace = assembly != null ? assembly.rootNamespace : string.Empty;
+#else
+      RootNamespace = UnityEditor.EditorSettings.projectGenerationRootNamespace;
+#endif
+      AssemblyReferences = assembly != null ? assembly.assemblyReferences : new Assembly[0];
+      CompiledAssemblyReferences = assembly!=null? assembly.compiledAssemblyReferences:new string[0];
+      Defines = assembly != null ? assembly.defines : new string[0];
+      CompilerOptions = assembly != null ? assembly.compilerOptions : new ScriptCompilerOptions();
+    }
+
+    public IEnumerable<ResponseFileData> ParseResponseFileData(IAssemblyNameProvider assemblyNameProvider, string projectDirectory)
+    {
+      if (Assembly == null)
+        return new ResponseFileData[0];
+      
+      var systemReferenceDirectories =
+        CompilationPipeline.GetSystemAssemblyDirectories(Assembly.compilerOptions.ApiCompatibilityLevel);
+
+      var responseFilesData = Assembly.compilerOptions.ResponseFiles.ToDictionary(
+        x => x, x => assemblyNameProvider.ParseResponseFile(
+          x,
+          projectDirectory,
+          systemReferenceDirectories
+        ));
+
+      var responseFilesWithErrors = responseFilesData.Where(x => x.Value.Errors.Any())
+        .ToDictionary(x => x.Key, x => x.Value);
+
+      if (responseFilesWithErrors.Any())
+      {
+        foreach (var error in responseFilesWithErrors)
+        foreach (var valueError in error.Value.Errors)
+        {
+          Debug.LogError($"{error.Key} Parse Error : {valueError}");
+        }
+      }
+
+      return responseFilesData.Select(x => x.Value);
+    }
+  }
+}
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/ProjectPart.cs.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/ProjectPart.cs.meta
@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 0691c2fe40564a64b3a9b7372c5eca2a
+timeCreated: 1604050230
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/SolutionGuidGenerator.cs
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/SolutionGuidGenerator.cs
@ -0,0 +1,29 @@
+using System;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace Packages.Rider.Editor.ProjectGeneration
+{
+  internal static class SolutionGuidGenerator
+  {
+    public static string GuidForProject(string projectName)
+    {
+      return ComputeGuidHashFor(projectName + "salt");
+    }
+
+    public static string GuidForSolution()
+    {
+      // GUID for a C# class library: http://www.codeproject.com/Reference/720512/List-of-Visual-Studio-Project-Type-GUIDs
+      return "FAE04EC0-301F-11D3-BF4B-00C04F79EFBC";
+    }
+
+    static string ComputeGuidHashFor(string input)
+    {
+      using (var md5 = MD5.Create())
+      {
+        var hash = md5.ComputeHash(Encoding.Default.GetBytes(input));
+        return new Guid(hash).ToString();
+      }
+    }
+  }
+}
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/SolutionGuidGenerator.cs.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/ProjectGeneration/SolutionGuidGenerator.cs.meta
@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 3e4e7fdc19414089a0fb43e43b1bdae1
+timeCreated: 1580717740
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/Properties.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/Properties.meta
@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 354fde95fe0643b09509e5fcee350b33
+timeCreated: 1580716670
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/Properties/AssemblyInfo.cs
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/Properties/AssemblyInfo.cs
@ -0,0 +1,10 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+[assembly: AssemblyTitle("Unity.Rider.Editor")]
+[assembly: InternalsVisibleTo("Unity.Rider.EditorTests")]
+[assembly: InternalsVisibleTo("Unity.PackageValidationSuite.Editor")]
+[assembly: InternalsVisibleTo("Assembly-CSharp-Editor")]
+[assembly: InternalsVisibleTo("DynamicProxyGenAssembly2")]
+
+[assembly: AssemblyVersion("3.0.4")]
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/Properties/AssemblyInfo.cs.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/Properties/AssemblyInfo.cs.meta
@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 8472c6472e6d4301873871a9e8fcf952
+timeCreated: 1580716711
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/RiderFileSystemWatcher.cs
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/RiderFileSystemWatcher.cs
@ -0,0 +1,41 @@
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using UnityEngine;
+
+namespace Packages.Rider.Editor
+{
+  internal static class RiderFileSystemWatcher
+  {
+    public static void InitWatcher(string watchDirectory,
+      string filter, FileSystemEventHandler onChanged)
+    {
+      Task.Run(() =>
+      {
+        var watcher = new FileSystemWatcher();
+        watcher.Path = watchDirectory;
+        watcher.NotifyFilter = NotifyFilters.LastWrite; //Watch for changes in LastWrite times
+        watcher.Filter = filter;
+        watcher.Changed += onChanged;
+        watcher.Deleted += onChanged;
+        
+        watcher.EnableRaisingEvents = true;// Begin watching.
+        return watcher;
+      }).ContinueWith(task =>
+      {
+        try
+        {
+          var watcher = task.Result;
+          AppDomain.CurrentDomain.DomainUnload += (EventHandler) ((_, __) =>
+          {
+            watcher.Dispose();
+          });
+        }
+        catch (Exception ex)
+        {
+          Debug.LogError(ex);
+        }
+      }, TaskScheduler.FromCurrentSynchronizationContext());
+    }
+  }
+}
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/RiderFileSystemWatcher.cs.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/RiderFileSystemWatcher.cs.meta
@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f0fa03b1402cfce488be912606bd8de7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/RiderInitializer.cs
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/RiderInitializer.cs
@ -0,0 +1,90 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using Rider.Editor.Util;
+using UnityEngine;
+using Debug = UnityEngine.Debug;
+
+namespace Packages.Rider.Editor
+{
+    internal class RiderInitializer
+    {
+      public void Initialize(string editorPath)
+      {
+        var assembly = EditorPluginInterop.EditorPluginAssembly;
+        if (EditorPluginInterop.EditorPluginIsLoadedFromAssets(assembly))
+        {
+          Debug.LogError($"Please delete {assembly.Location}. Unity 2019.2+ loads it directly from Rider installation. To disable this, open Rider's settings, search and uncheck 'Automatically install and update Rider's Unity editor plugin'.");
+          return;
+        }
+        
+        // for debugging rider editor plugin
+        if (RiderPathUtil.IsRiderDevEditor(editorPath))
+        {
+          LoadEditorPluginForDevEditor(editorPath);
+        }
+        else
+        {
+          var relPath = "../../plugins/rider-unity/EditorPlugin";
+          if (SystemInfo.operatingSystemFamily == OperatingSystemFamily.MacOSX)
+            relPath = "Contents/plugins/rider-unity/EditorPlugin";
+          var baseDir = Path.Combine(editorPath, relPath);
+          var dllFile = new FileInfo(Path.Combine(baseDir, $"{EditorPluginInterop.EditorPluginAssemblyName}.dll"));
+
+          if (!dllFile.Exists)
+            dllFile = new FileInfo(Path.Combine(baseDir,
+              $"{EditorPluginInterop.EditorPluginAssemblyNameFallback}.dll"));
+          
+          if (dllFile.Exists)
+          {
+            var bytes = File.ReadAllBytes(dllFile.FullName); 
+            assembly = AppDomain.CurrentDomain.Load(bytes); // doesn't lock assembly on disk
+            if (PluginSettings.SelectedLoggingLevel >= LoggingLevel.TRACE)
+              Debug.Log($"Rider EditorPlugin loaded from {dllFile.FullName}");
+          
+            EditorPluginInterop.InitEntryPoint(assembly);
+          }
+          else
+          {
+            Debug.Log($"Unable to find Rider EditorPlugin {dllFile.FullName} for Unity ");
+          }
+        }
+      }
+
+      private static void LoadEditorPluginForDevEditor(string editorPath)
+      {
+        var file = new FileInfo(editorPath);
+        if (SystemInfo.operatingSystemFamily == OperatingSystemFamily.MacOSX)
+          file = new FileInfo(Path.Combine(editorPath, "rider-dev.bat"));
+        
+        if (!file.Exists)
+        {
+          Debug.Log($"Unable to determine path to EditorPlugin from {file}");
+          return;
+        }
+        
+        var dllPath = File.ReadLines(file.FullName).FirstOrDefault();
+
+        if (dllPath == null)
+        {
+          Debug.Log($"Unable to determine path to EditorPlugin from {file}");
+          return;
+        }
+
+        var dllFile = new FileInfo(dllPath);
+
+        if (!dllFile.Exists)
+        {
+          Debug.Log($"Unable to find Rider EditorPlugin {dllPath} for Unity ");
+          return;
+        }
+
+        var assembly = AppDomain.CurrentDomain.Load(AssemblyName.GetAssemblyName(dllFile.FullName));
+        if (PluginSettings.SelectedLoggingLevel >= LoggingLevel.TRACE)
+          Debug.Log($"Rider EditorPlugin loaded from {dllFile.FullName}");
+
+        EditorPluginInterop.InitEntryPoint(assembly);
+      }
+    }
+}
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/RiderInitializer.cs.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/RiderInitializer.cs.meta
@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f5a0cc9645f0e2d4fb816156dcf3f4dd
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/RiderScriptEditor.cs
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/RiderScriptEditor.cs
@ -0,0 +1,466 @@
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using JetBrains.Annotations;
+using Packages.Rider.Editor.ProjectGeneration;
+using Packages.Rider.Editor.Util;
+using Unity.CodeEditor;
+using UnityEditor;
+using UnityEngine;
+using Debug = UnityEngine.Debug;
+
+namespace Packages.Rider.Editor
+{
+  [InitializeOnLoad]
+  internal class RiderScriptEditor : IExternalCodeEditor
+  {
+    IDiscovery m_Discoverability;
+    static IGenerator m_ProjectGeneration;
+    RiderInitializer m_Initiliazer = new RiderInitializer();
+
+    static RiderScriptEditor()
+    {
+      try
+      {
+        // todo: make ProjectGeneration lazy
+        var projectGeneration = new ProjectGeneration.ProjectGeneration();
+        var editor = new RiderScriptEditor(new Discovery(), projectGeneration);
+        CodeEditor.Register(editor);
+        var path = GetEditorRealPath(CurrentEditor);
+
+        if (IsRiderInstallation(path))
+        {
+          RiderPathLocator.RiderInfo[] installations = null;
+
+          if (!RiderScriptEditorData.instance.initializedOnce)
+          {
+            installations = RiderPathLocator.GetAllRiderPaths().OrderBy(a => a.BuildNumber).ToArray();
+            // is likely outdated
+            if (installations.Any() && installations.All(a => GetEditorRealPath(a.Path) != path))
+            {
+              if (RiderPathLocator.GetIsToolbox(path)) // is toolbox - update
+              {
+                var toolboxInstallations = installations.Where(a => a.IsToolbox).ToArray();
+                if (toolboxInstallations.Any())
+                {
+                  var newEditor = toolboxInstallations.Last().Path;
+                  CodeEditor.SetExternalScriptEditor(newEditor);
+                  path = newEditor;
+                }
+                else
+                {
+                  var newEditor = installations.Last().Path;
+                  CodeEditor.SetExternalScriptEditor(newEditor);
+                  path = newEditor;
+                }
+              }
+              else // is non toolbox - notify
+              {
+                var newEditorName = installations.Last().Presentation;
+                Debug.LogWarning($"Consider updating External Editor in Unity to {newEditorName}.");
+              }
+            }
+
+            ShowWarningOnUnexpectedScriptEditor(path);
+            RiderScriptEditorData.instance.initializedOnce = true;
+          }
+
+          if (!FileSystemUtil.EditorPathExists(path)) // previously used rider was removed
+          {
+            if (installations == null)
+              installations = RiderPathLocator.GetAllRiderPaths().OrderBy(a => a.BuildNumber).ToArray();
+            if (installations.Any())
+            {
+              var newEditor = installations.Last().Path;
+              CodeEditor.SetExternalScriptEditor(newEditor);
+              path = newEditor;
+            }
+          }
+
+          RiderScriptEditorData.instance.Init();
+
+          editor.CreateSolutionIfDoesntExist();
+          if (RiderScriptEditorData.instance.shouldLoadEditorPlugin)
+          {
+            editor.m_Initiliazer.Initialize(path);
+          }
+
+          RiderFileSystemWatcher.InitWatcher(
+            Directory.GetCurrentDirectory(), "*.csproj", (sender, args) =>
+            {
+              RiderScriptEditorData.instance.hasChanges = true;
+            });
+
+          RiderFileSystemWatcher.InitWatcher(
+            Directory.GetCurrentDirectory(), "*.sln", (sender, args) =>
+            {
+              RiderScriptEditorData.instance.hasChanges = true;
+            });
+          
+          RiderFileSystemWatcher.InitWatcher(
+            Path.Combine(Directory.GetCurrentDirectory(), "Packages"),
+            "manifest.json", (sender, args) => { RiderScriptEditorData.instance.hasChanges = true; });
+
+          // can't switch to non-deprecated api, because UnityEditor.Build.BuildPipelineInterfaces.processors is internal
+#pragma warning disable 618
+          EditorUserBuildSettings.activeBuildTargetChanged += () =>
+#pragma warning restore 618
+          {
+            RiderScriptEditorData.instance.hasChanges = true;
+          };
+        }
+      }
+      catch (Exception e)
+      {
+        Debug.LogException(e);
+      }
+    }
+
+    private static void ShowWarningOnUnexpectedScriptEditor(string path)
+    {
+      // Show warning, when Unity was started from Rider, but external editor is different https://github.com/JetBrains/resharper-unity/issues/1127
+      try
+      {
+        var args = Environment.GetCommandLineArgs();
+        var commandlineParser = new CommandLineParser(args);
+        if (commandlineParser.Options.ContainsKey("-riderPath"))
+        {
+          var originRiderPath = commandlineParser.Options["-riderPath"];
+          var originRealPath = GetEditorRealPath(originRiderPath);
+          var originVersion = RiderPathLocator.GetBuildNumber(originRealPath);
+          var version = RiderPathLocator.GetBuildNumber(path);
+          if (originVersion != null && originVersion != version)
+          {
+            Debug.LogWarning("Unity was started by a version of Rider that is not the current default external editor. Advanced integration features cannot be enabled.");
+            Debug.Log($"Unity was started by Rider {originVersion}, but external editor is set to: {path}");
+          }
+        }
+      }
+      catch (Exception e)
+      {
+        Debug.LogException(e);
+      }
+    }
+
+    internal static string GetEditorRealPath(string path)
+    {
+      if (string.IsNullOrEmpty(path))
+      {
+        return path;
+      }
+
+      if (!FileSystemUtil.EditorPathExists(path))
+        return path;
+
+      if (SystemInfo.operatingSystemFamily != OperatingSystemFamily.Windows)
+      {
+        var realPath = FileSystemUtil.GetFinalPathName(path);
+
+        // case of snap installation
+        if (SystemInfo.operatingSystemFamily == OperatingSystemFamily.Linux)
+        {
+          if (new FileInfo(path).Name.ToLowerInvariant() == "rider" &&
+              new FileInfo(realPath).Name.ToLowerInvariant() == "snap")
+          {
+            var snapInstallPath = "/snap/rider/current/bin/rider.sh";
+            if (new FileInfo(snapInstallPath).Exists)
+              return snapInstallPath;
+          }
+        }
+
+        // in case of symlink
+        return realPath;
+      }
+
+      return path;
+    }
+
+    public RiderScriptEditor(IDiscovery discovery, IGenerator projectGeneration)
+    {
+      m_Discoverability = discovery;
+      m_ProjectGeneration = projectGeneration;
+    }
+
+    private static string[] defaultExtensions
+    {
+      get
+      {
+        var customExtensions = new[] {"json", "asmdef", "log", "xaml"};
+        return EditorSettings.projectGenerationBuiltinExtensions.Concat(EditorSettings.projectGenerationUserExtensions)
+          .Concat(customExtensions).Distinct().ToArray();
+      }
+    }
+
+    private static string[] HandledExtensions
+    {
+      get
+      {
+        return HandledExtensionsString.Split(new[] {';'}, StringSplitOptions.RemoveEmptyEntries).Select(s => s.TrimStart('.', '*'))
+          .ToArray();
+      } 
+    }
+
+    private static string HandledExtensionsString
+    {
+      get { return EditorPrefs.GetString("Rider_UserExtensions", string.Join(";", defaultExtensions));}
+      set { EditorPrefs.SetString("Rider_UserExtensions", value); }
+    }
+
+    private static bool SupportsExtension(string path)
+    {
+      var extension = Path.GetExtension(path);
+      if (string.IsNullOrEmpty(extension))
+        return false;
+      // cs is a default extension, which should always be handled
+      return extension == ".cs" || HandledExtensions.Contains(extension.TrimStart('.'));
+    }
+
+    public void OnGUI()
+    {
+      if (RiderScriptEditorData.instance.shouldLoadEditorPlugin)
+      {
+        HandledExtensionsString = EditorGUILayout.TextField(new GUIContent("Extensions handled: "), HandledExtensionsString);
+      }
+
+      EditorGUILayout.LabelField("Generate .csproj files for:");
+      EditorGUI.indentLevel++;
+      SettingsButton(ProjectGenerationFlag.Embedded, "Embedded packages", "");
+      SettingsButton(ProjectGenerationFlag.Local, "Local packages", "");
+      SettingsButton(ProjectGenerationFlag.Registry, "Registry packages", "");
+      SettingsButton(ProjectGenerationFlag.Git, "Git packages", "");
+      SettingsButton(ProjectGenerationFlag.BuiltIn, "Built-in packages", "");
+#if UNITY_2019_3_OR_NEWER
+      SettingsButton(ProjectGenerationFlag.LocalTarBall, "Local tarball", "");
+#endif
+      SettingsButton(ProjectGenerationFlag.Unknown, "Packages from unknown sources", "");
+      SettingsButton(ProjectGenerationFlag.PlayerAssemblies, "Player projects", "For each player project generate an additional csproj with the name 'project-player.csproj'");
+      RegenerateProjectFiles();
+      EditorGUI.indentLevel--;
+    }
+
+    void RegenerateProjectFiles()
+    {
+      var rect = EditorGUI.IndentedRect(EditorGUILayout.GetControlRect(new GUILayoutOption[] {}));
+      rect.width = 252;
+      if (GUI.Button(rect, "Regenerate project files"))
+      {
+        m_ProjectGeneration.Sync();
+      }
+    }
+
+    void SettingsButton(ProjectGenerationFlag preference, string guiMessage, string toolTip)
+    {
+      var prevValue = m_ProjectGeneration.AssemblyNameProvider.ProjectGenerationFlag.HasFlag(preference);
+      var newValue = EditorGUILayout.Toggle(new GUIContent(guiMessage, toolTip), prevValue);
+      if (newValue != prevValue)
+      {
+        m_ProjectGeneration.AssemblyNameProvider.ToggleProjectGeneration(preference);
+      }
+    }
+
+    public void SyncIfNeeded(string[] addedFiles, string[] deletedFiles, string[] movedFiles, string[] movedFromFiles,
+      string[] importedFiles)
+    {
+      m_ProjectGeneration.SyncIfNeeded(addedFiles.Union(deletedFiles).Union(movedFiles).Union(movedFromFiles),
+        importedFiles);
+    }
+
+    public void SyncAll()
+    {
+      AssetDatabase.Refresh();
+      m_ProjectGeneration.SyncIfNeeded(new string[] { }, new string[] { });
+    }
+    
+    [UsedImplicitly]
+    public static void SyncSolution() // generate-the-sln-file-via-script-or-command-line
+    {
+      m_ProjectGeneration.Sync();
+    }
+    
+    [UsedImplicitly]
+    public static void SyncSolutionAndOpenExternalEditor()
+    {
+      m_ProjectGeneration.Sync();
+      CodeEditor.CurrentEditor.OpenProject();
+    }
+
+    public void Initialize(string editorInstallationPath) // is called each time ExternalEditor is changed
+    {
+      var oldBuildNumber = RiderScriptEditorData.instance.editorBuildNumber;
+      
+      RiderScriptEditorData.instance.Invalidate(editorInstallationPath);
+      if (oldBuildNumber.ToVersion() != RiderScriptEditorData.instance.editorBuildNumber.ToVersion()) // in Unity 2019.3 any change in preference causes `Initialize` call
+      {
+        m_ProjectGeneration.Sync(); // regenerate csproj and sln for new editor
+#if UNITY_2019_3_OR_NEWER
+        EditorUtility.RequestScriptReload(); // EditorPlugin would get loaded
+#else 
+        UnityEditorInternal.InternalEditorUtility.RequestScriptReload();
+#endif
+        
+      }
+    }
+
+    public bool OpenProject(string path, int line, int column)
+    {
+      if (path != "" && !SupportsExtension(path)) // Assets - Open C# Project passes empty path here
+      {
+        return false;
+      }
+      
+      if (!IsUnityScript(path))
+      {
+        m_ProjectGeneration.SyncIfNeeded(affectedFiles: new string[] { }, new string[] { });
+        var fastOpenResult = EditorPluginInterop.OpenFileDllImplementation(path, line, column);
+        if (fastOpenResult)
+          return true;
+      }
+
+      if (SystemInfo.operatingSystemFamily == OperatingSystemFamily.MacOSX)
+      {
+        return OpenOSXApp(path, line, column);
+      }
+
+      var solution = GetSolutionFile(path); // TODO: If solution file doesn't exist resync.
+      solution = solution == "" ? "" : $"\"{solution}\"";
+      var process = new Process
+      {
+        StartInfo = new ProcessStartInfo
+        {
+          FileName = CodeEditor.CurrentEditorInstallation,
+          Arguments = $"{solution} -l {line} \"{path}\"",
+          UseShellExecute = true,
+        }
+      };
+
+      process.Start();
+
+      return true;
+    }
+
+    private bool OpenOSXApp(string path, int line, int column)
+    {
+      var solution = GetSolutionFile(path);
+      solution = solution == "" ? "" : $"\"{solution}\"";
+      var pathArguments = path == "" ? "" : $"-l {line} \"{path}\"";
+      var process = new Process
+      {
+        StartInfo = new ProcessStartInfo
+        {
+          FileName = "open",
+          Arguments = $"-n -j \"{CodeEditor.CurrentEditorInstallation}\" --args {solution} {pathArguments}",
+          CreateNoWindow = true,
+          UseShellExecute = true,
+        }
+      };
+
+      process.Start();
+
+      return true;
+    }
+
+    private string GetSolutionFile(string path)
+    {
+      if (IsUnityScript(path))
+      {
+        return Path.Combine(GetBaseUnityDeveloperFolder(), "Projects/CSharp/Unity.CSharpProjects.gen.sln");
+      }
+
+      var solutionFile = m_ProjectGeneration.SolutionFile();
+      if (File.Exists(solutionFile))
+      {
+        return solutionFile;
+      }
+
+      return "";
+    }
+
+    static bool IsUnityScript(string path)
+    {
+      if (UnityEditor.Unsupported.IsDeveloperBuild())
+      {
+        var baseFolder = GetBaseUnityDeveloperFolder().Replace("\\", "/");
+        var lowerPath = path.ToLowerInvariant().Replace("\\", "/");
+
+        if (lowerPath.Contains((baseFolder + "/Runtime").ToLowerInvariant())
+          || lowerPath.Contains((baseFolder + "/Editor").ToLowerInvariant()))
+        {
+          return true;
+        }
+      }
+
+      return false;
+    }
+
+    static string GetBaseUnityDeveloperFolder()
+    {
+      return Directory.GetParent(EditorApplication.applicationPath).Parent.Parent.FullName;
+    }
+
+    public bool TryGetInstallationForPath(string editorPath, out CodeEditor.Installation installation)
+    {
+      if (FileSystemUtil.EditorPathExists(editorPath) && IsRiderInstallation(editorPath))
+      {
+        var info = new RiderPathLocator.RiderInfo(editorPath, false);
+        installation = new CodeEditor.Installation
+        {
+          Name = info.Presentation,
+          Path = info.Path
+        };
+        return true;
+      }
+
+      installation = default;
+      return false;
+    }
+
+    public static bool IsRiderInstallation(string path)
+    {
+      if (IsAssetImportWorkerProcess())
+        return false;
+
+#if UNITY_2021_1_OR_NEWER
+      if (UnityEditor.MPE.ProcessService.level == UnityEditor.MPE.ProcessLevel.Secondary)
+        return false;
+#elif UNITY_2020_2_OR_NEWER
+      if (UnityEditor.MPE.ProcessService.level == UnityEditor.MPE.ProcessLevel.Slave)
+        return false;
+#elif UNITY_2020_1_OR_NEWER
+      if (Unity.MPE.ProcessService.level == Unity.MPE.ProcessLevel.UMP_SLAVE)
+        return false;
+#endif
+      
+      if (string.IsNullOrEmpty(path))
+        return false;
+
+      var fileInfo = new FileInfo(path);
+      var filename = fileInfo.Name.ToLowerInvariant();
+      return filename.StartsWith("rider", StringComparison.Ordinal);
+    }
+
+    private static bool IsAssetImportWorkerProcess()
+    {
+#if UNITY_2020_2_OR_NEWER
+      return UnityEditor.AssetDatabase.IsAssetImportWorkerProcess();
+#elif UNITY_2019_3_OR_NEWER
+      return UnityEditor.Experimental.AssetDatabaseExperimental.IsAssetImportWorkerProcess();
+#else
+      return false;
+#endif
+    }
+
+    public static string CurrentEditor // works fast, doesn't validate if executable really exists
+      => EditorPrefs.GetString("kScriptsDefaultApp");
+
+    public CodeEditor.Installation[] Installations => m_Discoverability.PathCallback();
+
+    private void CreateSolutionIfDoesntExist()
+    {
+      if (!m_ProjectGeneration.HasSolutionBeenGenerated())
+      {
+        m_ProjectGeneration.Sync();
+      }
+    }
+  }
+}
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/RiderScriptEditor.cs.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/RiderScriptEditor.cs.meta
@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c4095d72f77fbb64ea39b8b3ca246622
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/RiderScriptEditorData.cs
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/RiderScriptEditorData.cs
@ -0,0 +1,57 @@
+using System;
+using System.Linq;
+using Packages.Rider.Editor.Util;
+using Rider.Editor.Util;
+using UnityEditor;
+using UnityEngine;
+
+namespace Packages.Rider.Editor
+{
+  internal class RiderScriptEditorData : ScriptableSingleton<RiderScriptEditorData>
+  {
+    [SerializeField] internal bool hasChanges = true; // sln/csproj files were changed 
+    [SerializeField] internal bool shouldLoadEditorPlugin;
+    [SerializeField] internal bool initializedOnce;
+    [SerializeField] internal SerializableVersion editorBuildNumber;
+    [SerializeField] internal RiderPathLocator.ProductInfo productInfo;
+    [SerializeField] internal string[] activeScriptCompilationDefines;
+
+    public void Init()
+    {
+      if (editorBuildNumber == null)
+      {
+        Invalidate(RiderScriptEditor.CurrentEditor);
+      }
+    }
+
+    public void InvalidateSavedCompilationDefines()
+    {
+      activeScriptCompilationDefines = EditorUserBuildSettings.activeScriptCompilationDefines;
+    }
+    
+    public bool HasChangesInCompilationDefines()
+    {
+      if (activeScriptCompilationDefines == null)
+        return false;
+      
+      return !EditorUserBuildSettings.activeScriptCompilationDefines.SequenceEqual(activeScriptCompilationDefines);
+    }
+
+    public void Invalidate(string editorInstallationPath)
+    {
+      var riderBuildNumber = RiderPathLocator.GetBuildNumber(editorInstallationPath);
+      editorBuildNumber = riderBuildNumber.ToSerializableVersion();
+      productInfo = RiderPathLocator.GetBuildVersion(editorInstallationPath);
+      if (riderBuildNumber == null) // if we fail to parse for some reason
+        shouldLoadEditorPlugin = true;
+
+      shouldLoadEditorPlugin = riderBuildNumber >= new Version("191.7141.156");
+
+      if (RiderPathUtil.IsRiderDevEditor(editorInstallationPath))
+      {
+        shouldLoadEditorPlugin = true;
+        editorBuildNumber = new SerializableVersion(new Version("999.999.999.999"));
+      }
+    }
+  }
+}
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/RiderScriptEditorData.cs.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/RiderScriptEditorData.cs.meta
@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f079e3afd077fb94fa2bda74d6409499
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/UnitTesting.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/UnitTesting.meta
@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: a52391bc44c477f40a547ed4ef3b9560
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/UnitTesting/CallbackData.cs
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/UnitTesting/CallbackData.cs
@ -0,0 +1,36 @@
+#if TEST_FRAMEWORK
+using System;
+using System.Collections.Generic;
+using JetBrains.Annotations;
+using UnityEditor;
+
+namespace Packages.Rider.Editor.UnitTesting
+{
+  /// <summary>
+  /// Is used by Rider Unity plugin by reflection
+  /// </summary>
+  [UsedImplicitly] // from Rider Unity plugin
+  public class CallbackData : ScriptableSingleton<CallbackData>
+  {
+    public bool isRider;
+
+    [UsedImplicitly] public static event EventHandler Changed = (sender, args) => { }; 
+
+    internal void RaiseChangedEvent()
+    {
+      Changed(null, EventArgs.Empty);
+    }
+
+    public List<TestEvent> events = new List<TestEvent>();
+
+    /// <summary>
+    /// Is used by Rider Unity plugin by reflection
+    /// </summary>
+    [UsedImplicitly]
+    public void Clear()
+    {
+      events.Clear();
+    }
+  }
+}
+#endif
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/UnitTesting/CallbackData.cs.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/UnitTesting/CallbackData.cs.meta
@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 010246a07de7cb34185a2a7b1c1fad59
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/UnitTesting/CallbackInitializer.cs
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/UnitTesting/CallbackInitializer.cs
@ -0,0 +1,18 @@
+#if TEST_FRAMEWORK
+using UnityEditor;
+using UnityEditor.TestTools.TestRunner.Api;
+using UnityEngine;
+
+namespace Packages.Rider.Editor.UnitTesting
+{
+  [InitializeOnLoad]
+  internal static class CallbackInitializer
+  {
+    static CallbackInitializer()
+    {
+      if (CallbackData.instance.isRider)
+        ScriptableObject.CreateInstance<TestRunnerApi>().RegisterCallbacks(ScriptableObject.CreateInstance<TestsCallback>(), 0);
+    }
+  }
+}
+#endif
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/UnitTesting/CallbackInitializer.cs.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/UnitTesting/CallbackInitializer.cs.meta
@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: aa1c6b1a353ab464782fc1e7c051eb02
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/UnitTesting/RiderTestRunner.cs
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/UnitTesting/RiderTestRunner.cs
@ -0,0 +1,91 @@
+using JetBrains.Annotations;
+using UnityEngine;
+#if TEST_FRAMEWORK
+using UnityEditor;
+using UnityEditor.TestTools.TestRunner.Api;
+#else
+using System;
+#endif
+
+namespace Packages.Rider.Editor.UnitTesting
+{
+  /// <summary>
+  /// Is called by Rider Unity plugin via reflections
+  /// </summary>
+  [UsedImplicitly]
+  public static class RiderTestRunner
+  {
+#if TEST_FRAMEWORK
+    private static readonly TestsCallback Callback = ScriptableObject.CreateInstance<TestsCallback>();
+#endif
+    
+    /// <summary>
+    /// Is called by Rider Unity plugin via reflections
+    /// </summary>
+    /// <param name="sessionId"></param>
+    /// <param name="testMode"></param>
+    /// <param name="assemblyNames"></param>
+    /// <param name="testNames"></param>
+    /// <param name="categoryNames"></param>
+    /// <param name="groupNames"></param>
+    /// <param name="buildTarget"></param>
+    /// <param name="callbacksHandlerCodeBase"></param>
+    /// <param name="callbacksHandlerTypeName"></param>
+    /// <param name="callbacksHandlerDependencies"></param>
+    [UsedImplicitly]
+    public static void RunTestsWithSyncCallbacks(string sessionId, int testMode, string[] assemblyNames, 
+      string[] testNames, string[] categoryNames, string[] groupNames, int? buildTarget,  
+      string callbacksHandlerCodeBase, string callbacksHandlerTypeName, string[] callbacksHandlerDependencies)
+    {
+#if !TEST_FRAMEWORK
+      Debug.LogError("Update Test Framework package to v.1.1.1+ to run tests from Rider.");
+      throw new NotSupportedException("Incompatible `Test Framework` package in Unity. Update to v.1.1.1+");
+#else
+      SyncTestRunEventsHandler.instance.InitRun(sessionId, callbacksHandlerCodeBase, callbacksHandlerTypeName, callbacksHandlerDependencies);
+      RunTests(testMode, assemblyNames, testNames, categoryNames, groupNames, buildTarget);
+#endif      
+    }
+    
+    /// <summary>
+    /// Is called by Rider Unity plugin via reflections
+    /// </summary>
+    /// <param name="testMode"></param>
+    /// <param name="assemblyNames"></param>
+    /// <param name="testNames"></param>
+    /// <param name="categoryNames"></param>
+    /// <param name="groupNames"></param>
+    /// <param name="buildTarget"></param>
+    [UsedImplicitly]
+    public static void RunTests(int testMode, string[] assemblyNames, string[] testNames, string[] categoryNames, string[] groupNames, int? buildTarget)
+    {
+#if !TEST_FRAMEWORK
+      Debug.LogError("Update Test Framework package to v.1.1.1+ to run tests from Rider.");
+      throw new NotSupportedException("Incompatible `Test Framework` package in Unity. Update to v.1.1.1+");
+#else
+      CallbackData.instance.isRider = true;
+            
+      var api = ScriptableObject.CreateInstance<TestRunnerApi>();
+      var settings = new ExecutionSettings();
+      var filter = new Filter
+      {
+        assemblyNames = assemblyNames,
+        testNames = testNames,
+        categoryNames = categoryNames,
+        groupNames = groupNames,
+        targetPlatform = (BuildTarget?) buildTarget
+      };
+      
+      if (testMode > 0) // for future use - test-framework would allow running both Edit and Play test at once
+        filter.testMode = (TestMode) testMode;
+      
+      settings.filters = new []{
+        filter
+      };
+      api.Execute(settings);
+      
+      api.UnregisterCallbacks(Callback); // avoid multiple registrations
+      api.RegisterCallbacks(Callback); // This can be used to receive information about when the test suite and individual tests starts and stops. Provide this with a scriptable object implementing ICallbacks
+#endif
+    }
+  }
+}
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/UnitTesting/RiderTestRunner.cs.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/UnitTesting/RiderTestRunner.cs.meta
@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5c3b27069cb3ddf42ba1260eeefcdd1c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/UnitTesting/SyncTestRunCallback.cs
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/UnitTesting/SyncTestRunCallback.cs
@ -0,0 +1,49 @@
+#if TEST_FRAMEWORK
+using NUnit.Framework.Interfaces;
+using Packages.Rider.Editor.UnitTesting;
+using UnityEngine.TestRunner;
+
+[assembly: TestRunCallback(typeof(SyncTestRunCallback))]
+
+namespace Packages.Rider.Editor.UnitTesting
+{
+  public class SyncTestRunCallback : ITestRunCallback
+  {
+    public void RunStarted(ITest testsToRun)
+    {
+    }
+
+    public void RunFinished(ITestResult testResults)
+    {
+      SyncTestRunEventsHandler.instance.OnRunFinished();
+    }
+
+    public void TestStarted(ITest test)
+    {
+      if (!test.IsSuite)
+        SyncTestRunEventsHandler.instance.OnTestStarted(GenerateId(test));
+    }
+
+    public void TestFinished(ITestResult result)
+    {
+      if (!result.Test.IsSuite)
+        SyncTestRunEventsHandler.instance.OnTestFinished();
+    }
+    
+    // https://jetbrains.team/p/net/code/dotnet-libs/files/f04cde7d1dd70ee13bf5532e30f929b9b5ed08a4/ReSharperTestRunner/src/Adapters/TestRunner.Adapters.NUnit3/RemoteTaskDepot.cs?tab=source&line=129
+    private static string GenerateId(ITest node)
+    {
+      // ES: Parameterized tests defined in a parametrized test fixture, though 
+      // constructed for a particular test fixture with the given parameter, have identical fullname that does
+      // not include parameters of parent testfixture (name of the without parameters is used instead).
+      // This leads to 'Test with {id} id is already running' message.
+      var typeName = node.GetType().Name;
+      if (typeName == "ParameterizedMethod" ||
+          typeName == "GenericMethod") 
+        return $"{node.Parent.FullName}.{node.Name}";
+      
+      return node.FullName;
+    }
+  }
+}
+#endif 
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/UnitTesting/SyncTestRunCallback.cs.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/UnitTesting/SyncTestRunCallback.cs.meta
@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 58ab3828fb407c742a48b82bc5983a87
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/UnitTesting/SyncTestRunEventsHandler.cs
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/UnitTesting/SyncTestRunEventsHandler.cs
@ -0,0 +1,148 @@
+#if TEST_FRAMEWORK
+using System;
+using System.Reflection;
+using UnityEditor;
+using UnityEngine;
+
+namespace Packages.Rider.Editor.UnitTesting
+{
+  internal class SyncTestRunEventsHandler : ScriptableSingleton<SyncTestRunEventsHandler>
+  {
+    [SerializeField] private string m_SessionId;
+    [SerializeField] private string m_HandlerCodeBase;
+    [SerializeField] private string m_HandlerTypeName;
+    [SerializeField] private string[] m_HandlerDependencies;
+    [SerializeField] private bool m_RunInitialized;
+    
+    private object m_Handler;
+    private MethodInfo m_OnSessionStartedMethodInfo;
+    private MethodInfo m_OnTestStartedMethodInfo;
+    private MethodInfo m_OnTestFinishedMethodInfo;
+    private MethodInfo m_OnSessionFinishedMethodInfo;
+    
+    internal void InitRun(string sessionId, string handlerCodeBase, string handlerTypeName, string[] handlerDependencies)
+    {
+      if (PluginSettings.SelectedLoggingLevel >= LoggingLevel.TRACE)
+        Debug.Log("Rider Test Runner: initializing sync callbacks handler: " + 
+                  $"sessionId={sessionId}, " + 
+                  $"codeBase={handlerCodeBase}, " + 
+                  $"typeName={handlerTypeName}, " + 
+                  $"dependencies={(handlerDependencies == null ? "" : string.Join("; ", handlerDependencies))}");
+    
+      m_SessionId = sessionId;
+      m_HandlerCodeBase = handlerCodeBase;
+      m_HandlerTypeName = handlerTypeName;
+      m_HandlerDependencies = handlerDependencies;
+      m_RunInitialized = true;
+      
+      CreateHandlerInstance();
+      SafeInvokeHandlerMethod(m_OnSessionStartedMethodInfo, Array.Empty<object>());
+    }
+
+    private void OnEnable()
+    {
+      if (m_RunInitialized)
+        CreateHandlerInstance();
+    }
+
+    internal void OnTestStarted(string testId)
+    {
+      if (m_RunInitialized)
+        SafeInvokeHandlerMethod(m_OnTestStartedMethodInfo, new object[] {testId});
+    }
+
+    internal void OnTestFinished()
+    {
+      if (m_RunInitialized)
+        SafeInvokeHandlerMethod(m_OnTestFinishedMethodInfo, Array.Empty<object>());
+    }
+
+    internal void OnRunFinished()
+    {
+      if (!m_RunInitialized)
+        return;
+      
+      SafeInvokeHandlerMethod(m_OnSessionFinishedMethodInfo, Array.Empty<object>());
+      CleanUp();
+      m_RunInitialized = false;
+    }
+
+    private void SafeInvokeHandlerMethod(MethodInfo methodInfo, object[] args)
+    {
+      try
+      {
+        methodInfo?.Invoke(m_Handler, args);
+      }
+      catch (Exception e)
+      {
+        Debug.LogException(e);
+      }
+    }
+    
+    private void CreateHandlerInstance()
+    {
+      try
+      {
+        if (m_HandlerDependencies != null)
+          foreach (var dependency in m_HandlerDependencies)
+          {
+            if (PluginSettings.SelectedLoggingLevel >= LoggingLevel.TRACE) 
+              Debug.Log($"Rider Test Runner: loading assembly from {dependency}");
+            Assembly.LoadFrom(dependency);
+          }
+        if (PluginSettings.SelectedLoggingLevel >= LoggingLevel.TRACE)
+          Debug.Log($"Rider Test Runner: loading assembly from {m_HandlerCodeBase}");
+        var assembly = Assembly.LoadFrom(m_HandlerCodeBase);
+        var type = assembly.GetType(m_HandlerTypeName);
+        if (type == null)
+        {
+          Debug.LogError($"Rider Test Runner: type '{m_HandlerTypeName}' not found in assembly '{assembly.FullName}'");
+          return;
+        }
+        
+        if (PluginSettings.SelectedLoggingLevel >= LoggingLevel.TRACE) 
+          Debug.Log($"Rider Test Runner: creating instance of type '{type.AssemblyQualifiedName}'");
+        m_Handler = Activator.CreateInstance(type, m_SessionId);
+
+        m_OnSessionStartedMethodInfo = type.GetMethod("OnSessionStarted", BindingFlags.Instance | BindingFlags.Public);
+        if (m_OnSessionStartedMethodInfo == null)
+        {
+          Debug.LogError($"Rider Test Runner: OnSessionStarted method not found in type='{type.AssemblyQualifiedName}'");
+          return;
+        }
+
+        m_OnTestStartedMethodInfo = type.GetMethod("OnTestStarted", BindingFlags.Instance | BindingFlags.Public);
+        if (m_OnTestStartedMethodInfo == null)
+        {
+          Debug.LogError($"Rider Test Runner: OnTestStarted method not found in type='{type.AssemblyQualifiedName}'");
+          return;
+        }
+
+        m_OnTestFinishedMethodInfo = type.GetMethod("OnTestFinished", BindingFlags.Instance | BindingFlags.Public);
+        if (m_OnTestFinishedMethodInfo == null)
+        {
+          Debug.LogError($"Rider Test Runner: OnTestFinished method not found in type='{type.AssemblyQualifiedName}'");
+          return;
+        }
+
+        m_OnSessionFinishedMethodInfo = type.GetMethod("OnSessionFinished", BindingFlags.Instance | BindingFlags.Public);
+        if (m_OnSessionFinishedMethodInfo == null)
+          Debug.LogError($"Rider Test Runner: OnSessionFinished method not found in type='{type.AssemblyQualifiedName}'");
+      }
+      catch (Exception e)
+      {
+        Debug.LogException(e);
+      }
+    }
+
+    private void CleanUp()
+    {
+      m_Handler = null;
+      m_OnSessionStartedMethodInfo = null;
+      m_OnSessionFinishedMethodInfo = null;
+      m_OnTestStartedMethodInfo = null;
+      m_OnTestFinishedMethodInfo = null;
+    }
+  }
+}
+#endif
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/UnitTesting/SyncTestRunEventsHandler.cs.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/UnitTesting/SyncTestRunEventsHandler.cs.meta
@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 48483563a64de3a4e8690122762055f1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/UnitTesting/TestEvent.cs
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/UnitTesting/TestEvent.cs
@ -0,0 +1,39 @@
+#if TEST_FRAMEWORK
+using System;
+using NUnit.Framework.Interfaces;
+
+namespace Packages.Rider.Editor.UnitTesting
+{
+  /// <summary>
+  /// Is used by Rider Unity plugin by reflection
+  /// </summary>
+  [Serializable]
+  public enum EventType { TestStarted, TestFinished, RunFinished, RunStarted } // do not reorder
+
+  /// <summary>
+  /// Is used by Rider Unity plugin by reflection
+  /// </summary>
+  [Serializable]
+  public class TestEvent
+  {
+    public EventType type;
+    public string id;
+    public string assemblyName;
+    public string output;
+    public TestStatus testStatus;
+    public double duration;
+    public string parentId;
+    
+    public TestEvent(EventType type, string id, string assemblyName, string output, double duration, TestStatus testStatus, string parentID)
+    {
+      this.type = type;
+      this.id = id;
+      this.assemblyName = assemblyName;
+      this.output = output;
+      this.testStatus = testStatus;
+      this.duration = duration;
+      parentId = parentID;
+    }
+  }
+}
+#endif
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/UnitTesting/TestEvent.cs.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/UnitTesting/TestEvent.cs.meta
@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f9413c47b3a14a64e8810ce76d1a6032
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/UnitTesting/TestsCallback.cs
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/UnitTesting/TestsCallback.cs
@ -0,0 +1,101 @@
+#if TEST_FRAMEWORK
+using System;
+using System.Text;
+using UnityEditor.TestTools.TestRunner.Api;
+using UnityEngine;
+
+namespace Packages.Rider.Editor.UnitTesting
+{
+  public class TestsCallback : ScriptableObject, IErrorCallbacks
+    {
+        public void RunFinished(ITestResultAdaptor result)
+        {
+          CallbackData.instance.isRider = false;
+          
+          CallbackData.instance.events.Add(
+            new TestEvent(EventType.RunFinished, "", "","", 0, ParseTestStatus(result.TestStatus), ""));
+          CallbackData.instance.RaiseChangedEvent();
+        }
+        
+        public void RunStarted(ITestAdaptor testsToRun)
+        {
+          CallbackData.instance.events.Add(
+            new TestEvent(EventType.RunStarted, "", "","", 0, NUnit.Framework.Interfaces.TestStatus.Passed, ""));
+          CallbackData.instance.RaiseChangedEvent();
+        }
+
+        public void TestStarted(ITestAdaptor result)
+        {
+          if (result.Method == null) return;
+          
+          CallbackData.instance.events.Add(
+           new TestEvent(EventType.TestStarted, GenerateId(result), result.Method.TypeInfo.Assembly.GetName().Name, "", 0, NUnit.Framework.Interfaces.TestStatus.Passed, GenerateId(result.Parent)));
+          CallbackData.instance.RaiseChangedEvent();
+        }
+
+        public void TestFinished(ITestResultAdaptor result)
+        {
+          if (result.Test.Method == null) return;
+          
+          CallbackData.instance.events.Add(
+            new TestEvent(EventType.TestFinished, GenerateId(result.Test), result.Test.Method.TypeInfo.Assembly.GetName().Name, ExtractOutput(result), (result.EndTime-result.StartTime).Milliseconds, ParseTestStatus(result.TestStatus), GenerateId(result.Test.Parent)));
+          CallbackData.instance.RaiseChangedEvent();
+        }
+
+        public void OnError(string message)
+        {
+          CallbackData.instance.isRider = false;
+          
+          CallbackData.instance.events.Add(
+            new TestEvent(EventType.RunFinished, "", "",message, 0, NUnit.Framework.Interfaces.TestStatus.Failed, ""));
+          CallbackData.instance.RaiseChangedEvent();
+        }
+
+        // see explanation in https://jetbrains.team/p/net/code/dotnet-libs/files/f04cde7d1dd70ee13bf5532e30f929b9b5ed08a4/ReSharperTestRunner/src/Adapters/TestRunner.Adapters.NUnit3/RemoteTaskDepot.cs?tab=source&line=129
+        private static string GenerateId(ITestAdaptor node)
+        {
+          // ES: Parameterized tests defined in a parametrized test fixture, though 
+          // constructed for a particular test fixture with the given parameter, have identical fullname that does
+          // not include parameters of parent testfixture (name of the without parameters is used instead).
+          // This leads to 'Test with {id} id is already running' message.
+          if (node.TypeInfo == null) 
+            return $"{node.Parent.FullName}.{node.Name}";
+
+          return node.FullName;
+        }
+
+        private static NUnit.Framework.Interfaces.TestStatus ParseTestStatus(TestStatus testStatus)
+        {
+          return (NUnit.Framework.Interfaces.TestStatus)Enum.Parse(typeof(NUnit.Framework.Interfaces.TestStatus), testStatus.ToString());
+        }
+        
+        private static string ExtractOutput(ITestResultAdaptor testResult)
+        {
+          var stringBuilder = new StringBuilder();
+          if (testResult.Message != null)
+          {
+            stringBuilder.AppendLine("Message: ");
+            stringBuilder.AppendLine(testResult.Message);
+          }
+
+          if (!string.IsNullOrEmpty(testResult.Output))
+          {
+            stringBuilder.AppendLine("Output: ");
+            stringBuilder.AppendLine(testResult.Output);
+          }
+
+          if (!string.IsNullOrEmpty(testResult.StackTrace))
+          {
+            stringBuilder.AppendLine("Stacktrace: ");
+            stringBuilder.AppendLine(testResult.StackTrace);
+          }
+      
+          var result = stringBuilder.ToString();
+          if (result.Length > 0)
+            return result;
+
+          return testResult.Output ?? string.Empty;
+        }
+    }
+}
+#endif
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/UnitTesting/TestsCallback.cs.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/UnitTesting/TestsCallback.cs.meta
@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 58aa570dbe0761f43b25ff6c2265bbe2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/Util.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/Util.meta
@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 5e726086cd652f82087d59d67d2c24cd
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/Util/CommandLineParser.cs
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/Util/CommandLineParser.cs
@ -0,0 +1,36 @@
+using System.Collections.Generic;
+
+namespace Packages.Rider.Editor.Util
+{
+  internal class CommandLineParser
+  {
+    public Dictionary<string, string> Options = new Dictionary<string, string>();
+    
+    public CommandLineParser(string[] args)
+    {
+      var i = 0;
+      while (i < args.Length)
+      {
+        var arg = args[i];
+        if (!arg.StartsWith("-"))
+        {
+          i++;
+          continue;
+        }
+
+        string value = null;
+        if (i + 1 < args.Length && !args[i + 1].StartsWith("-"))
+        {
+          value = args[i + 1];
+          i++;
+        }
+
+        if (!(Options.ContainsKey(arg)))
+        {
+          Options.Add(arg, value);
+        }
+        i++;
+      }
+    }
+  }
+}
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/Util/CommandLineParser.cs.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/Util/CommandLineParser.cs.meta
@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 154ace4bd16de9f4e84052ac257786d6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/Util/FileSystemUtil.cs
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/Util/FileSystemUtil.cs
@ -0,0 +1,66 @@
+using System;
+using System.ComponentModel;
+using System.IO;
+using System.Text;
+using JetBrains.Annotations;
+using UnityEngine;
+
+namespace Packages.Rider.Editor.Util
+{
+  internal static class FileSystemUtil
+  {
+    [NotNull]
+    public static string GetFinalPathName([NotNull] string path)
+    {
+      if (path == null) throw new ArgumentNullException("path");
+
+      // up to MAX_PATH. MAX_PATH on Linux currently 4096, on Mac OS X 1024
+      // doc: http://man7.org/linux/man-pages/man3/realpath.3.html
+      var sb = new StringBuilder(8192);
+      var result = LibcNativeInterop.realpath(path, sb);
+      if (result == IntPtr.Zero)
+      {
+        throw new Win32Exception($"{path} was not resolved.");
+      }
+
+      return new FileInfo(sb.ToString()).FullName;
+    }
+
+    public static string FileNameWithoutExtension(string path)
+    {
+      if (string.IsNullOrEmpty(path))
+      {
+        return "";
+      }
+
+      var indexOfDot = -1;
+      var indexOfSlash = 0;
+      for (var i = path.Length - 1; i >= 0; i--)
+      {
+        if (indexOfDot == -1 && path[i] == '.')
+        {
+          indexOfDot = i;
+        }
+
+        if (indexOfSlash == 0 && path[i] == '/' || path[i] == '\\')
+        {
+          indexOfSlash = i + 1;
+          break;
+        }
+      }
+
+      if (indexOfDot == -1)
+      {
+        indexOfDot = path.Length;
+      }
+
+      return path.Substring(indexOfSlash, indexOfDot - indexOfSlash);
+    }
+    
+    public static bool EditorPathExists(string editorPath)
+    {
+      return SystemInfo.operatingSystemFamily == OperatingSystemFamily.MacOSX && new DirectoryInfo(editorPath).Exists 
+             || SystemInfo.operatingSystemFamily != OperatingSystemFamily.MacOSX && new FileInfo(editorPath).Exists;
+    }
+  }
+}
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/Util/FileSystemUtil.cs.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/Util/FileSystemUtil.cs.meta
@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: bdbd564a9fdad0b738e76d030cad1204
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/Util/LibcNativeInterop.cs
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/Util/LibcNativeInterop.cs
@ -0,0 +1,12 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace Packages.Rider.Editor.Util
+{
+  internal static class LibcNativeInterop
+  {
+    [DllImport("libc", SetLastError = true)] 
+    public static extern IntPtr realpath(string path, StringBuilder resolved_path);
+  }
+}
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/Util/LibcNativeInterop.cs.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/Util/LibcNativeInterop.cs.meta
@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 071c17858dc6c47ada7b2a1f1ded5402
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/Util/RiderMenu.cs
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/Util/RiderMenu.cs
@ -0,0 +1,30 @@
+using JetBrains.Annotations;
+using Packages.Rider.Editor;
+using Unity.CodeEditor;
+
+// ReSharper disable once CheckNamespace 
+namespace JetBrains.Rider.Unity.Editor
+{
+  /// <summary>
+  /// Is called via commandline from Rider Notification after checking out from source control.
+  /// </summary>
+  [UsedImplicitly]
+  public static class RiderMenu
+  {
+    /// <summary>
+    /// Is called via commandline from Rider Notification after checking out from source control.
+    /// </summary>
+    [UsedImplicitly]
+    public static void MenuOpenProject()
+    {
+      if (RiderScriptEditor.IsRiderInstallation(RiderScriptEditor.CurrentEditor))
+      {
+        // Force the project files to be sync
+        CodeEditor.CurrentEditor.SyncAll();
+
+        // Load Project
+        CodeEditor.CurrentEditor.OpenProject();
+      }
+    }
+  }
+}
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/Util/RiderMenu.cs.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/Util/RiderMenu.cs.meta
@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a8860c53ca4073d4f92c403e709c12ba
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/Util/RiderPathUtil.cs
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/Util/RiderPathUtil.cs
@ -0,0 +1,14 @@
+using System.IO;
+
+namespace Rider.Editor.Util
+{
+  internal static class RiderPathUtil
+  {
+    public static bool IsRiderDevEditor(string editorPath)
+    {
+      if (editorPath == null)
+        return false;
+      return "rider-dev".Equals(Path.GetFileNameWithoutExtension(editorPath));
+    }
+  }
+}
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/Util/RiderPathUtil.cs.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/Util/RiderPathUtil.cs.meta
@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4d34a9510a5b9d21381c93e73867a193
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/Util/SerializableVersion.cs
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/Util/SerializableVersion.cs
@ -0,0 +1,51 @@
+using System;
+
+namespace Packages.Rider.Editor.Util
+{
+  [Serializable]
+  internal class SerializableVersion
+  {
+    public SerializableVersion(Version version)
+    {
+
+      Major = version.Major;
+      Minor = version.Minor;
+      if (version.Build >= 0)
+        Build = version.Build;
+      if (version.Revision >= 0)
+        Revision = version.Revision;
+    }
+
+    public int Build;
+    public int Major;
+    public int Minor;
+    public int Revision;
+  }
+
+  internal static class VersionExtension
+  {
+    public static SerializableVersion ToSerializableVersion(this Version version)
+    {
+      if (version == null)
+        return null;
+        
+      return new SerializableVersion(version);
+    }
+
+    public static Version ToVersion(this SerializableVersion serializableVersion)
+    {
+      if (serializableVersion == null)
+        return null;
+
+      var build = serializableVersion.Build;
+      if (build < 0)
+          build = 0;
+      var revision = serializableVersion.Revision;
+      if (revision < 0)
+          revision = 0;
+      
+      return new Version(serializableVersion.Major, serializableVersion.Minor, build,
+          revision);
+    }
+  }
+}
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/Util/SerializableVersion.cs.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/Util/SerializableVersion.cs.meta
@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8e1f00a9be2eb66438e2835fdf1ea11b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/com.unity.ide.rider.asmdef
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/com.unity.ide.rider.asmdef
@ -0,0 +1,27 @@
+{
+    "name": "Unity.Rider.Editor",
+    "rootNamespace": "Packages",
+    "references": [
+        "GUID:0acc523941302664db1f4e527237feb3",
+        "GUID:27619889b8ba8c24980f49ee34dbb44a"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": true,
+    "precompiledReferences": [
+        "nunit.framework.dll"
+    ],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [
+        {
+            "name": "com.unity.test-framework",
+            "expression": "1.1.1",
+            "define": "TEST_FRAMEWORK"
+        }
+    ],
+    "noEngineReferences": false
+}
--- a/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/com.unity.ide.rider.asmdef.meta
+++ b/Library/PackageCache/com.unity.ide.rider@3.0.5/Rider/Editor/com.unity.ide.rider.asmdef.meta
@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: d528c8c98d269ca44a06cd9624a03945
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: