Essentials + extra crap

Loadings Startups Movement Camera
2026-01-12 18:43:51 +03:00
1 parent 662f4a1d05
commit 5f5ace1b52
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: bdecd2714d8a463fa3bdae705d942796
+timeCreated: 1672992950
@@ -0,0 +1,36 @@
+using System.Linq;
+using ImmersiveVrToolsCommon.Runtime.Logging;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace FastScriptReload.Editor.Compilation.CodeRewriting
+{
+    class BuilderPatternFunctionsRewriter : FastScriptReloadCodeRewriterBase
+    {
+        public BuilderPatternFunctionsRewriter(bool writeRewriteReasonAsComment, bool visitIntoStructuredTrivia = false) 
+            : base(writeRewriteReasonAsComment, visitIntoStructuredTrivia)
+        {
+        }
+
+        public override SyntaxNode VisitMethodDeclaration(MethodDeclarationSyntax node)
+        {
+            var ancestorName = node.Ancestors().OfType<TypeDeclarationSyntax>().FirstOrDefault()?.Identifier.ValueText;
+            if (string.IsNullOrEmpty(ancestorName)) //TODO: that happens too often for some methods, odd. Why? At very least don't spam user
+            {
+                LoggerScoped.LogWarning($"Unable to find ancestor for node '{node.ToFullString()}'");
+            }
+            else
+            {
+                var ancestorNameWithoutPatchedPostfix = ancestorName.Replace(FastScriptReload.Runtime.AssemblyChangesLoader.ClassnamePatchedPostfix, "");
+
+                if (node.ReturnType is IdentifierNameSyntax name && name.Identifier.ValueText == ancestorNameWithoutPatchedPostfix)
+                {
+                    return node.WithReturnType(SyntaxFactory.IdentifierName(ancestorName + " "));
+                }
+            }
+            
+            return base.VisitMethodDeclaration(node);
+        }
+    }
+}
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: ad3d5960a86c431cbea11b8962fa361e
+timeCreated: 1678960928
+AssetOrigin:
+  serializedVersion: 1
+  productId: 239351
+  packageName: Fast Script Reload
+  packageVersion: 1.6.1
+  assetPath: Assets/FastScriptReload/Scripts/Editor/Compilation/CodeRewriting/BuilderPatternFunctionsRewriter.cs
+  uploadId: 710802
@@ -0,0 +1,84 @@
+using System.Linq;
+using FastScriptReload.Runtime;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace FastScriptReload.Editor.Compilation.CodeRewriting
+{
+	class ConstructorRewriter : FastScriptReloadCodeRewriterBase
+        {
+	        private readonly bool _adjustCtorOnlyForNonNestedTypes;
+	        
+	        public ConstructorRewriter(bool adjustCtorOnlyForNonNestedTypes, bool writeRewriteReasonAsComment)
+				: base(writeRewriteReasonAsComment)
+	        {
+		        _adjustCtorOnlyForNonNestedTypes = adjustCtorOnlyForNonNestedTypes;
+	        }
+	        
+	        public override SyntaxNode VisitConstructorDeclaration(ConstructorDeclarationSyntax node)
+	        {
+		        if (_adjustCtorOnlyForNonNestedTypes)
+		        {
+			        var typeNestedLevel = node.Ancestors().Count(a => a is TypeDeclarationSyntax);
+			        if (typeNestedLevel == 1)
+			        {
+				        return AdjustCtorOrDestructorNameForTypeAdjustment(node, node.Identifier);
+			        }
+		        }
+		        else
+		        {
+			        return AdjustCtorOrDestructorNameForTypeAdjustment(node, node.Identifier);
+		        }
+
+		        return base.VisitConstructorDeclaration(node);
+	        }
+
+	        public override SyntaxNode VisitDestructorDeclaration(DestructorDeclarationSyntax node)
+	        {
+		        if (_adjustCtorOnlyForNonNestedTypes)
+		        {
+			        var typeNestedLevel = node.Ancestors().Count(a => a is TypeDeclarationSyntax);
+			        if (typeNestedLevel == 1)
+			        {
+				        return AdjustCtorOrDestructorNameForTypeAdjustment(node, node.Identifier);
+			        }
+		        }
+		        else
+		        {
+			        return AdjustCtorOrDestructorNameForTypeAdjustment(node, node.Identifier);
+		        }
+		        
+		        return base.VisitDestructorDeclaration(node);
+	        }
+
+	        private SyntaxNode AdjustCtorOrDestructorNameForTypeAdjustment(BaseMethodDeclarationSyntax node, SyntaxToken nodeIdentifier)
+	        {
+		        var typeName = (node.Ancestors().First(n => n is TypeDeclarationSyntax) as TypeDeclarationSyntax).Identifier.ToString();
+		        if (!nodeIdentifier.ToFullString().Contains(typeName))
+		        {
+			        //Used Roslyn version bug, some static methods are also interpreted as ctors, eg
+			        // public static void Method()
+			        // {
+			        //    Bar(); //treated as Ctor declaration...
+			        // }
+			        //
+			        // private static void Bar() 
+			        // {
+			        //  
+			        // }
+			        return node;
+		        }
+		        
+		        if (!typeName.EndsWith(AssemblyChangesLoader.ClassnamePatchedPostfix))
+		        {
+			        typeName += AssemblyChangesLoader.ClassnamePatchedPostfix;
+		        }
+
+		        return AddRewriteCommentIfNeeded(
+			        node.ReplaceToken(nodeIdentifier, SyntaxFactory.Identifier(typeName)), 
+			        $"{nameof(ConstructorRewriter)}:{nameof(AdjustCtorOrDestructorNameForTypeAdjustment)}"
+			    );
+	        }
+        }
+}
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 1d2a76467ecd40529f59bc68be8d7289
+timeCreated: 1672992987
+AssetOrigin:
+  serializedVersion: 1
+  productId: 239351
+  packageName: Fast Script Reload
+  packageVersion: 1.6.1
+  assetPath: Assets/FastScriptReload/Scripts/Editor/Compilation/CodeRewriting/ConstructorRewriter.cs
+  uploadId: 710802
@@ -0,0 +1,153 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using ImmersiveVrToolsCommon.Runtime.Logging;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace FastScriptReload.Editor.Compilation.CodeRewriting
+{
+	class CreateNewFieldInitMethodRewriter: FastScriptReloadCodeRewriterBase {
+		private readonly Dictionary<string, List<string>> _typeToNewFieldDeclarations;
+		private static readonly string NewFieldsToCreateValueFnDictionaryFieldName = "__Patched_NewFieldNameToInitialValueFn";
+		private static readonly string NewFieldsToGetTypeFnDictionaryFieldName = "__Patched_NewFieldsToGetTypeFnDictionaryFieldName";
+		private static readonly string DictionaryFullNamespaceTypeName = "global::System.Collections.Generic.Dictionary";
+
+		public static Dictionary<string, Func<object>> ResolveNewFieldsToCreateValueFn(Type forType)
+		{
+			return (Dictionary<string, Func<object>>) forType.GetField(NewFieldsToCreateValueFnDictionaryFieldName, BindingFlags.NonPublic | BindingFlags.Static).GetValue(null);
+		}
+		
+		public static Dictionary<string, Func<object>> ResolveNewFieldsToTypeFn(Type forType)
+		{
+			return (Dictionary<string, Func<object>>) forType.GetField(NewFieldsToGetTypeFnDictionaryFieldName, BindingFlags.NonPublic | BindingFlags.Static).GetValue(null);
+		}
+
+		public CreateNewFieldInitMethodRewriter(Dictionary<string, List<string>> typeToNewFieldDeclarations, bool writeRewriteReasonAsComment)
+			:base(writeRewriteReasonAsComment)
+		{
+			_typeToNewFieldDeclarations = typeToNewFieldDeclarations;
+		}
+
+		public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node)
+		{
+			var fullClassName = RoslynUtils.GetMemberFQDN(node, node.Identifier.ToString());
+			if (!_typeToNewFieldDeclarations.TryGetValue(fullClassName, out var newClassFields))
+			{
+				LoggerScoped.LogWarning($"Unable to find new-fields for type: {fullClassName}, this is not an issue if there are no new fields for that type.");
+			}
+
+			Func<FieldDeclarationSyntax, ExpressionSyntax> getObjectFnSyntax = fieldDeclarationNode => fieldDeclarationNode.Declaration.Variables[0].Initializer?.Value //value captured from initializer
+			                                            ?? SyntaxFactory.DefaultExpression(SyntaxFactory.IdentifierName(fieldDeclarationNode.Declaration.Type.ToString()));
+			var withDictionaryFieldNameToInitFieldValue = CreateNewFieldNameToGetObjectFnDictionary(node, newClassFields, getObjectFnSyntax, NewFieldsToCreateValueFnDictionaryFieldName);
+
+			//TODO: slightly odd scenario 'When explicit #nullable enable is used, reference types should be rewritten to typeof(type) for initialization and value types should remain typeof(type?)'
+			// Func<FieldDeclarationSyntax, ExpressionSyntax> getObjectTypeFnSyntax = fieldDeclarationNode => SyntaxFactory.TypeOfExpression(
+			// 	SyntaxFactory.ParseTypeName(fieldDeclarationNode.Declaration.Type.ToFullString().Replace("?", ""))
+			// );
+			Func<FieldDeclarationSyntax, ExpressionSyntax> getObjectTypeFnSyntax = fieldDeclarationNode => SyntaxFactory.TypeOfExpression(fieldDeclarationNode.Declaration.Type);
+			return CreateNewFieldNameToGetObjectFnDictionary(withDictionaryFieldNameToInitFieldValue, newClassFields, getObjectTypeFnSyntax, NewFieldsToGetTypeFnDictionaryFieldName);
+		}
+
+		private ClassDeclarationSyntax CreateNewFieldNameToGetObjectFnDictionary(ClassDeclarationSyntax node,
+			List<string> newClassFields, Func<FieldDeclarationSyntax, ExpressionSyntax> getObjectFnSyntax, string dictionaryFieldName)
+		{
+			var dictionaryKeyToInitValueNodes = newClassFields.SelectMany(fieldName =>
+			{
+				var fieldDeclarationNode = node.ChildNodes().OfType<FieldDeclarationSyntax>()
+					.Single(f => f.Declaration.Variables.First().Identifier.ToString() == fieldName);
+
+				return new[]
+				{
+					(SyntaxNodeOrToken)SyntaxFactory.AssignmentExpression(
+						SyntaxKind.SimpleAssignmentExpression,
+						SyntaxFactory.ImplicitElementAccess()
+							.WithArgumentList(
+								SyntaxFactory.BracketedArgumentList(
+									SyntaxFactory.SingletonSeparatedList<ArgumentSyntax>(
+										SyntaxFactory.Argument(
+											SyntaxFactory.LiteralExpression(
+												SyntaxKind.StringLiteralExpression,
+												SyntaxFactory.Literal(fieldDeclarationNode.Declaration.Variables.First()
+													.Identifier.ToString())))))), //variable name
+						SyntaxFactory.ParenthesizedLambdaExpression(getObjectFnSyntax(fieldDeclarationNode))),
+					SyntaxFactory.Token(SyntaxKind.CommaToken) //comma, add for all
+				};
+			}).ToArray();
+
+
+			var dictionaryInitializer =
+				SyntaxFactory.InitializerExpression(
+					SyntaxKind.ObjectInitializerExpression,
+					SyntaxFactory.SeparatedList<ExpressionSyntax>(
+						dictionaryKeyToInitValueNodes.ToArray()
+					));
+
+			var withDictionaryFieldNameToInitFieldValue = node.AddMembers(
+				SyntaxFactory.FieldDeclaration(
+						SyntaxFactory.VariableDeclaration(
+								SyntaxFactory.GenericName(
+										SyntaxFactory.Identifier(DictionaryFullNamespaceTypeName))
+									.WithTypeArgumentList(
+										SyntaxFactory.TypeArgumentList(
+											SyntaxFactory.SeparatedList<TypeSyntax>(
+												new SyntaxNodeOrToken[]
+												{
+													SyntaxFactory.PredefinedType(
+														SyntaxFactory.Token(SyntaxKind.StringKeyword)),
+													SyntaxFactory.Token(SyntaxKind.CommaToken),
+													SyntaxFactory.GenericName(
+															SyntaxFactory.Identifier("global::System.Func"))
+														.WithTypeArgumentList(
+															SyntaxFactory.TypeArgumentList(
+																SyntaxFactory.SingletonSeparatedList<TypeSyntax>(
+																	SyntaxFactory.PredefinedType(
+																		SyntaxFactory.Token(SyntaxKind.ObjectKeyword)))))
+												}))))
+							.WithVariables(
+								SyntaxFactory.SingletonSeparatedList<VariableDeclaratorSyntax>(
+									SyntaxFactory.VariableDeclarator(
+											SyntaxFactory.Identifier(dictionaryFieldName))
+										.WithInitializer(
+											SyntaxFactory.EqualsValueClause(
+												SyntaxFactory.ObjectCreationExpression(
+														SyntaxFactory.GenericName(
+																SyntaxFactory.Identifier(DictionaryFullNamespaceTypeName))
+															.WithTypeArgumentList(
+																SyntaxFactory.TypeArgumentList(
+																	SyntaxFactory.SeparatedList<TypeSyntax>(
+																		new SyntaxNodeOrToken[]
+																		{
+																			SyntaxFactory.PredefinedType(
+																				SyntaxFactory.Token(SyntaxKind.StringKeyword)),
+																			SyntaxFactory.Token(SyntaxKind.CommaToken),
+																			SyntaxFactory.QualifiedName(
+																				SyntaxFactory.IdentifierName("global::System"),
+																				SyntaxFactory.GenericName(
+																						SyntaxFactory.Identifier("Func"))
+																					.WithTypeArgumentList(
+																						SyntaxFactory.TypeArgumentList(
+																							SyntaxFactory
+																								.SingletonSeparatedList<
+																									TypeSyntax>(
+																									SyntaxFactory
+																										.PredefinedType(
+																											SyntaxFactory.Token(
+																												SyntaxKind
+																													.ObjectKeyword))))))
+																		}))))
+													.WithInitializer(dictionaryInitializer))))))
+					.WithModifiers(
+						SyntaxFactory.TokenList(
+							SyntaxFactory.Token(SyntaxKind.PrivateKeyword),
+							SyntaxFactory.Token(SyntaxKind.StaticKeyword)))
+					.NormalizeWhitespace()
+					.WithLeadingTrivia(SyntaxFactory.TriviaList(SyntaxFactory.ElasticCarriageReturnLineFeed))
+					.WithTrailingTrivia(SyntaxFactory.TriviaList(SyntaxFactory.ElasticCarriageReturnLineFeed, SyntaxFactory.ElasticCarriageReturnLineFeed))
+			);
+			return AddRewriteCommentIfNeeded(withDictionaryFieldNameToInitFieldValue, $"{nameof(CreateNewFieldInitMethodRewriter)}", true);
+		}
+	}
+}
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 6bbeaafe1bf54bda9b46e237bec3ccc0
+timeCreated: 1674215064
+AssetOrigin:
+  serializedVersion: 1
+  productId: 239351
+  packageName: Fast Script Reload
+  packageVersion: 1.6.1
+  assetPath: Assets/FastScriptReload/Scripts/Editor/Compilation/CodeRewriting/CreateNewFieldInitMethodRewriter.cs
+  uploadId: 710802
@@ -0,0 +1,74 @@
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace FastScriptReload.Editor.Compilation.CodeRewriting
+{
+    // When calling other extension methods from same file compilation would fail with 'The call is ambiguous between the following methods or properties' 
+    class ExtensionMethodsCallingOtherExtensionMethodsInSameFileRewriter : FastScriptReloadCodeRewriterBase
+    {
+        private Dictionary<string, Dictionary<string, string>>  _typeNameToDeclaredMethodNameToThisArgName = new Dictionary<string, Dictionary<string, string>>();
+        
+        public ExtensionMethodsCallingOtherExtensionMethodsInSameFileRewriter(bool writeRewriteReasonAsComment)
+            : base(writeRewriteReasonAsComment)
+        {
+	        
+        }
+
+        public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node)
+        {
+            var classDeclaredMethodNameToThisArgName = new Dictionary<string, string>();
+            _typeNameToDeclaredMethodNameToThisArgName[node.Identifier.Text] = classDeclaredMethodNameToThisArgName;
+            
+            foreach (var methodDeclaration in node.Members
+                         .Where(n => n.Kind() == SyntaxKind.MethodDeclaration)
+                         .Select(n => (MethodDeclarationSyntax)n))
+            {
+                var parameters = methodDeclaration.ParameterList.Parameters;
+                if (parameters.Count > 0 && parameters[0].Modifiers.Any(SyntaxKind.ThisKeyword))
+                {
+                    var thisArgumentName = parameters[0].Identifier.Text;
+                    classDeclaredMethodNameToThisArgName.TryAdd(methodDeclaration.Identifier.Text, thisArgumentName);
+                }
+            }
+            
+            return base.VisitClassDeclaration(node);
+        }
+        
+        public override SyntaxNode VisitInvocationExpression(InvocationExpressionSyntax node)
+        {
+            // Check if the invocation is an instance method with a member access (e.g., selfName.CallingOtherTest())
+            if (node.Expression is MemberAccessExpressionSyntax memberAccess)
+            {
+                var methodName = memberAccess.Name.Identifier.Text;
+                var instanceArgName = memberAccess.Expression;
+                var className = node.Ancestors().OfType<ClassDeclarationSyntax>().First().Identifier.Text;
+                if (_typeNameToDeclaredMethodNameToThisArgName.TryGetValue(className, out var declaredMethodNameToThisArgName)
+                    && declaredMethodNameToThisArgName.TryGetValue(methodName, out var definedInstanceArgName))
+                {
+                    if (instanceArgName.ToString() == definedInstanceArgName)
+                    {
+                        // Rewrite the invocation to a static method call
+                        var newInvocation = SyntaxFactory.InvocationExpression(SyntaxFactory.IdentifierName(methodName))
+                            .WithArgumentList(
+                                SyntaxFactory.ArgumentList(
+                                    SyntaxFactory.SeparatedList(
+                                        node.ArgumentList.Arguments.Insert(0, SyntaxFactory.Argument(instanceArgName)) // Add instance as first argument
+                                    )
+                                )
+                            ).NormalizeWhitespace();
+                        
+                        return AddRewriteCommentIfNeeded(
+                            newInvocation, 
+                            $"{nameof(ExtensionMethodsCallingOtherExtensionMethodsInSameFileRewriter)}:Replaced extension method call with static call"
+                        );
+                    }
+                }
+            }
+
+            return base.VisitInvocationExpression(node);
+        }
+    }
+}
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 9f739c197f9040efabf7f64461882d7b
+timeCreated: 1727194643
+AssetOrigin:
+  serializedVersion: 1
+  productId: 239351
+  packageName: Fast Script Reload
+  packageVersion: 1.6.1
+  assetPath: Assets/FastScriptReload/Scripts/Editor/Compilation/CodeRewriting/ExtensionMethodsCallingOtherExtensionMethodsInSameFileRewriter.cs
+  uploadId: 710802
@@ -0,0 +1,64 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+
+namespace FastScriptReload.Editor.Compilation.CodeRewriting
+{
+    public abstract class FastScriptReloadCodeRewriterBase : CSharpSyntaxRewriter
+    {
+        protected readonly bool _writeRewriteReasonAsComment;
+
+        protected FastScriptReloadCodeRewriterBase(bool writeRewriteReasonAsComment, bool visitIntoStructuredTrivia = false) : base(visitIntoStructuredTrivia)
+        {
+            _writeRewriteReasonAsComment = writeRewriteReasonAsComment;
+        }
+        
+        protected SyntaxToken AddRewriteCommentIfNeeded(SyntaxToken syntaxToken, string commentText, bool append = false)
+        {
+            return AddRewriteCommentIfNeeded(syntaxToken, commentText, _writeRewriteReasonAsComment, append);
+        }
+
+        public static SyntaxToken AddRewriteCommentIfNeeded(SyntaxToken syntaxToken, string commentText, bool writeRewriteReasonAsComment, bool append)
+        {
+            if (writeRewriteReasonAsComment)
+            {
+                if (append)
+                {
+                    return syntaxToken.WithLeadingTrivia(
+                        syntaxToken.LeadingTrivia.Add(SyntaxFactory.Comment($"/*FSR:{commentText}*/")));
+                }
+                else
+                {
+                    return syntaxToken.WithTrailingTrivia(
+                        syntaxToken.TrailingTrivia.Add(SyntaxFactory.Comment($"/*FSR:{commentText}*/")));
+                }
+            }
+
+            return syntaxToken;
+        }
+
+        protected T AddRewriteCommentIfNeeded<T>(T syntaxNode, string commentText, bool append = false)
+            where T : SyntaxNode
+        {
+            return AddRewriteCommentIfNeeded(syntaxNode, commentText, _writeRewriteReasonAsComment, append);
+        }
+
+        public static T AddRewriteCommentIfNeeded<T>(T syntaxNode, string commentText, bool writeRewriteReasonAsComment, bool append) where T : SyntaxNode
+        {
+            if (writeRewriteReasonAsComment)
+            {
+                if (append)
+                {
+                    return syntaxNode.WithLeadingTrivia(syntaxNode.GetLeadingTrivia()
+                        .Add(SyntaxFactory.Comment($"/*FSR:{commentText}*/")));
+                }
+                else
+                {
+                    return syntaxNode.WithTrailingTrivia(syntaxNode.GetTrailingTrivia()
+                        .Add(SyntaxFactory.Comment($"/*FSR:{commentText}*/")));
+                }
+            }
+
+            return syntaxNode;
+        }
+    }
+}
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: bcc848f0140d41cdbf1003b0f594694e
+timeCreated: 1677233811
+AssetOrigin:
+  serializedVersion: 1
+  productId: 239351
+  packageName: Fast Script Reload
+  packageVersion: 1.6.1
+  assetPath: Assets/FastScriptReload/Scripts/Editor/Compilation/CodeRewriting/FastScriptReloadCodeRewriterBase.cs
+  uploadId: 710802
@@ -0,0 +1,43 @@
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace FastScriptReload.Editor.Compilation.CodeRewriting
+{
+    class FieldsWalker : CSharpSyntaxWalker {
+        private readonly Dictionary<string, List<NewFieldDeclaration>> _typeNameToFieldDeclarations = new Dictionary<string, List<NewFieldDeclaration>>();
+
+        public override void VisitClassDeclaration(ClassDeclarationSyntax node)
+        {
+            var className = node.Identifier;
+            var fullClassName = RoslynUtils.GetMemberFQDN(node, className.ToString());
+            if(!_typeNameToFieldDeclarations.ContainsKey(fullClassName)) {
+                _typeNameToFieldDeclarations[fullClassName] = new List<NewFieldDeclaration>();
+            }
+
+            base.VisitClassDeclaration(node);
+        }
+
+        public override void VisitFieldDeclaration(FieldDeclarationSyntax node)
+        {
+            var fieldName = node.Declaration.Variables.First().Identifier.ToString();
+            var fullClassName = RoslynUtils.GetMemberFQDNWithoutMemberName(node);
+            if(!_typeNameToFieldDeclarations.ContainsKey(fullClassName)) {
+                _typeNameToFieldDeclarations[fullClassName] = new List<NewFieldDeclaration>();
+            }
+		
+            _typeNameToFieldDeclarations[fullClassName].Add(new NewFieldDeclaration(fieldName, node.Declaration.Type.ToString(), node));
+		
+            base.VisitFieldDeclaration(node);
+        }
+
+        public Dictionary<string, List<NewFieldDeclaration>> GetTypeToFieldDeclarations() {
+            return _typeNameToFieldDeclarations;
+        }
+        
+        public List<string> GetTypeNames() {
+            return _typeNameToFieldDeclarations.Select(kv => kv.Key).ToList();
+        }
+    }
+}
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: e4a18d5133af410bab07d9c1a973fe7a
+timeCreated: 1672993042
+AssetOrigin:
+  serializedVersion: 1
+  productId: 239351
+  packageName: Fast Script Reload
+  packageVersion: 1.6.1
+  assetPath: Assets/FastScriptReload/Scripts/Editor/Compilation/CodeRewriting/FieldsWalker.cs
+  uploadId: 710802
@@ -0,0 +1,71 @@
+using System.Collections.Generic;
+using FastScriptReload.Runtime;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace FastScriptReload.Editor.Compilation.CodeRewriting
+{
+    class HotReloadCompliantRewriter : FastScriptReloadCodeRewriterBase
+    {
+        public List<string> StrippedUsingDirectives = new List<string>();
+        public List<string> OriginalIdentifiersRenamedToContainPatchedPostfix = new List<string>();
+        
+        public HotReloadCompliantRewriter(bool writeRewriteReasonAsComment, bool visitIntoStructuredTrivia = false) 
+            : base(writeRewriteReasonAsComment, visitIntoStructuredTrivia)
+        {
+        }
+
+        public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node)
+        {
+            return AddPatchedPostfixToTopLevelDeclarations(node, node.Identifier);
+            //if subclasses need to be adjusted, it's done via recursion.
+            // foreach (var childNode in node.ChildNodes().OfType<ClassDeclarationSyntax>())
+            // {
+            //     var changed = Visit(childNode);
+            //     node = node.ReplaceNode(childNode, changed);
+            // }
+        }
+
+        public override SyntaxNode VisitStructDeclaration(StructDeclarationSyntax node)
+        {
+            return AddPatchedPostfixToTopLevelDeclarations(node, node.Identifier);
+        }
+
+        public override SyntaxNode VisitEnumDeclaration(EnumDeclarationSyntax node)
+        {
+            return AddPatchedPostfixToTopLevelDeclarations(node, node.Identifier);
+        }
+
+        public override SyntaxNode VisitDelegateDeclaration(DelegateDeclarationSyntax node)
+        {
+            return AddPatchedPostfixToTopLevelDeclarations(node, node.Identifier);
+        }
+
+        public override SyntaxNode VisitInterfaceDeclaration(InterfaceDeclarationSyntax node)
+        {
+            return AddPatchedPostfixToTopLevelDeclarations(node, node.Identifier);
+        }
+
+        public override SyntaxNode VisitUsingDirective(UsingDirectiveSyntax node)
+        {
+            if (node.Parent is CompilationUnitSyntax)
+            {
+                StrippedUsingDirectives.Add(node.ToFullString());
+                return null;
+            }
+
+            return base.VisitUsingDirective(node);
+        }
+
+        private SyntaxNode AddPatchedPostfixToTopLevelDeclarations(CSharpSyntaxNode node, SyntaxToken identifier)
+        {
+            OriginalIdentifiersRenamedToContainPatchedPostfix.Add(identifier.ValueText);
+            
+            var newIdentifier = SyntaxFactory.Identifier(identifier + AssemblyChangesLoader.ClassnamePatchedPostfix);
+            newIdentifier = AddRewriteCommentIfNeeded(newIdentifier, $"{nameof(HotReloadCompliantRewriter)}:{nameof(AddPatchedPostfixToTopLevelDeclarations)}");
+            node = node.ReplaceToken(identifier, newIdentifier);
+            return node;
+        }
+    }
+}
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: f75e3e02acfa4397a558a923f7fa4f8e
+timeCreated: 1672993042
+AssetOrigin:
+  serializedVersion: 1
+  productId: 239351
+  packageName: Fast Script Reload
+  packageVersion: 1.6.1
+  assetPath: Assets/FastScriptReload/Scripts/Editor/Compilation/CodeRewriting/HotReloadCompliantRewriter.cs
+  uploadId: 710802
@@ -0,0 +1,127 @@
+using System;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace FastScriptReload.Editor.Compilation.CodeRewriting
+{
+    public class ManualUserDefinedScriptOverridesRewriter : FastScriptReloadCodeRewriterBase
+    {
+        private readonly SyntaxNode _userDefinedOverridesRoot;
+
+        public ManualUserDefinedScriptOverridesRewriter(SyntaxNode userDefinedOverridesRoot, bool writeRewriteReasonAsComment, bool visitIntoStructuredTrivia = false)
+            : base(writeRewriteReasonAsComment, visitIntoStructuredTrivia)
+        {
+            _userDefinedOverridesRoot = userDefinedOverridesRoot;
+        }
+        
+        //TODO: refactor to use OverrideDeclarationWithMatchingUserDefinedIfExists
+        public override SyntaxNode VisitConversionOperatorDeclaration(ConversionOperatorDeclarationSyntax node)
+        {
+            var methodFQDN = RoslynUtils.GetMemberFQDN(node, "operator");
+            var matchingInOverride = _userDefinedOverridesRoot.DescendantNodes()
+                //implicit conversion operators do not have name, just parameter list
+                .OfType<BaseMethodDeclarationSyntax>()
+                .FirstOrDefault(m => m.ParameterList.ToString() == node.ParameterList.ToString() //parameter lists is type / order / names, all good for targetting if there's a proper match
+                                      && methodFQDN == RoslynUtils.GetMemberFQDN(m, "operator") //make sure same FQDN, even though there's no name there could be more implicit operators in file
+                );
+
+            if (matchingInOverride != null)
+            {
+                return AddRewriteCommentIfNeeded(matchingInOverride.WithTriviaFrom(node), $"User defined custom conversion override", true);
+            }
+            else {
+                return base.VisitConversionOperatorDeclaration(node);
+            }
+        }
+
+        //TODO: refactor to use OverrideDeclarationWithMatchingUserDefinedIfExists
+        public override SyntaxNode VisitMethodDeclaration(MethodDeclarationSyntax node)
+        {
+            var methodName = node.Identifier.ValueText;
+            var methodFQDN = RoslynUtils.GetMemberFQDN(node, node.Identifier.ToString());
+            var matchingInOverride = _userDefinedOverridesRoot.DescendantNodes()
+                .OfType<MethodDeclarationSyntax>()
+                .FirstOrDefault(m => m.Identifier.ValueText == methodName
+                                     && m.ParameterList.Parameters.Count == node.ParameterList.Parameters.Count
+                                     && m.ParameterList.ToString() == node.ParameterList.ToString() //parameter lists is type / order / names, all good for targetting if there's a proper match
+                                     && m.TypeParameterList?.ToString() == node.TypeParameterList?.ToString() //typed paratemets are for generics, also check
+                                     && methodFQDN == RoslynUtils.GetMemberFQDN(m, m.Identifier.ToString()) //last check for mathod FQDN (potentially slower than others)
+                );
+
+            if (matchingInOverride != null)
+            {
+                return AddRewriteCommentIfNeeded(matchingInOverride.WithTriviaFrom(node), $"User defined custom method override", true);
+            }
+            else {
+                return base.VisitMethodDeclaration(node);
+            }
+        }
+        
+        
+        public override SyntaxNode VisitConstructorDeclaration(ConstructorDeclarationSyntax node)
+        {
+            return OverrideDeclarationWithMatchingUserDefinedIfExists(
+                node, 
+                (d) => d.Identifier.ValueText, 
+                (d) => HasSameParametersPredicate(node.ParameterList)(d.ParameterList), 
+                (d) => base.VisitConstructorDeclaration(d)
+            );
+        }
+        
+        public override SyntaxNode VisitDestructorDeclaration(DestructorDeclarationSyntax node)
+        {
+            return OverrideDeclarationWithMatchingUserDefinedIfExists(
+                node, 
+                (d) => d.Identifier.ValueText, 
+                (d) => HasSameParametersPredicate(node.ParameterList)(d.ParameterList), 
+                (d) => base.VisitDestructorDeclaration(d)
+            );
+        }
+        
+        public override SyntaxNode VisitPropertyDeclaration(PropertyDeclarationSyntax node)
+        {
+            return OverrideDeclarationWithMatchingUserDefinedIfExists(
+                node, 
+                (d) => d.Identifier.ValueText, 
+                (d) => true, 
+                (d) => base.VisitPropertyDeclaration(d)
+            );
+        }
+
+        private SyntaxNode OverrideDeclarationWithMatchingUserDefinedIfExists<T>(T node, Func<T, string> getName, 
+            Func<T, bool> customFindMatchInOverridePredicate, Func<T, SyntaxNode> visitDefault)
+            where T: MemberDeclarationSyntax
+        {
+            var name = getName(node);
+            var fqdn = RoslynUtils.GetMemberFQDN(node, name);
+            var matchingInOverride = _userDefinedOverridesRoot.DescendantNodes()
+                .OfType<T>()
+                .FirstOrDefault(d =>
+                    {
+                        var declarationName = getName(d);
+                        return declarationName == name
+                               && customFindMatchInOverridePredicate(d)
+                               && fqdn == RoslynUtils.GetMemberFQDN(d, declarationName);                     //last check for mathod FQDN (potentially slower than others)
+                    }
+
+                );
+
+            if (matchingInOverride != null)
+            {
+                return AddRewriteCommentIfNeeded(matchingInOverride.WithTriviaFrom(node),
+                    $"User defined custom {typeof(T)} override", true);
+            }
+            else
+            {
+                return visitDefault(node);
+            }
+        }
+        
+        private Func<ParameterListSyntax, bool> HasSameParametersPredicate(ParameterListSyntax parameters)
+        {
+            return (resolvedParams) => resolvedParams.Parameters.Count == parameters.Parameters.Count
+                                       && resolvedParams.ToString() == parameters.ToString();
+        }
+    }
+}
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 7d61f64c891c45b68a7db1ea67854127
+timeCreated: 1678101034
+AssetOrigin:
+  serializedVersion: 1
+  productId: 239351
+  packageName: Fast Script Reload
+  packageVersion: 1.6.1
+  assetPath: Assets/FastScriptReload/Scripts/Editor/Compilation/CodeRewriting/ManualUserDefinedScriptOverridesRewriter.cs
+  uploadId: 710802
@@ -0,0 +1,18 @@
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace FastScriptReload.Editor.Compilation.CodeRewriting
+{
+    public class NewFieldDeclaration
+    {
+        public string FieldName { get; }
+        public string TypeName { get; }
+        public FieldDeclarationSyntax FieldDeclarationSyntax { get; } //TODO: PERF: will that block whole tree from being garbage collected
+
+        public NewFieldDeclaration(string fieldName, string typeName, FieldDeclarationSyntax fieldDeclarationSyntax)
+        {
+            FieldName = fieldName;
+            TypeName = typeName;
+            FieldDeclarationSyntax = fieldDeclarationSyntax;
+        }
+    }
+}
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: ad6e49db99ff4065b14a3fc416af560b
+timeCreated: 1673019285
+AssetOrigin:
+  serializedVersion: 1
+  productId: 239351
+  packageName: Fast Script Reload
+  packageVersion: 1.6.1
+  assetPath: Assets/FastScriptReload/Scripts/Editor/Compilation/CodeRewriting/NewFieldDeclaration.cs
+  uploadId: 710802
@@ -0,0 +1,144 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using FastScriptReload.Runtime;
+using FastScriptReload.Scripts.Runtime;
+using ImmersiveVrToolsCommon.Runtime.Logging;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace FastScriptReload.Editor.Compilation.CodeRewriting
+{
+	class NewFieldsRewriter : FastScriptReloadCodeRewriterBase
+	{
+		private readonly Dictionary<string, List<string>> _typeToNewFieldDeclarations;
+
+		public NewFieldsRewriter(Dictionary<string, List<string>> typeToNewFieldDeclarations, bool writeRewriteReasonAsComment) 
+			:base(writeRewriteReasonAsComment)
+		{
+			_typeToNewFieldDeclarations = typeToNewFieldDeclarations;
+		}
+
+		public static List<MemberInfo> GetReplaceableMembers(Type type)
+		{ //TODO: later other might need to be included? props?
+			return type.GetFields(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).Cast<MemberInfo>().ToList();
+		}
+
+
+		public override SyntaxNode VisitInvocationExpression(InvocationExpressionSyntax node)
+		{
+			if (node.Expression.ToString() == "nameof")
+			{
+				var classNode = node.Ancestors().OfType<ClassDeclarationSyntax>().FirstOrDefault();
+				if (classNode != null)
+				{
+					var fullClassName = RoslynUtils.GetMemberFQDN(classNode, classNode.Identifier.ToString());
+					if (!string.IsNullOrEmpty(fullClassName))
+					{
+						var nameofExpressionParts = node.ArgumentList.Arguments.First().ToFullString().Split('.'); //nameof could have multiple . like NewFieldCustomClass.FieldInThatClass
+						var fieldName = nameofExpressionParts.First();  // should take first part only to determine if new field eg. 'NewFieldCustomClass'
+						if (_typeToNewFieldDeclarations.TryGetValue(fullClassName, out var allNewFieldNamesForClass))
+						{
+							if (allNewFieldNamesForClass.Contains(fieldName))
+							{
+								return AddRewriteCommentIfNeeded(
+									SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(nameofExpressionParts.Last())), // should take last part only to for actual string eg. 'FieldInThatClass'
+									$"{nameof(NewFieldsRewriter)}:{nameof(VisitInvocationExpression)}");
+							}
+							
+						}
+					}
+				}
+			}
+
+			return base.VisitInvocationExpression(node);
+		}
+
+		public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node)
+		{
+			var classNode = node.Ancestors().OfType<ClassDeclarationSyntax>().FirstOrDefault();
+			if (classNode != null)
+			{
+				var fullClassName = RoslynUtils.GetMemberFQDN(classNode, classNode.Identifier.ToString());
+				if (!string.IsNullOrEmpty(fullClassName))
+				{
+					var fieldName = node.Identifier.ToString();
+					if (_typeToNewFieldDeclarations.TryGetValue(fullClassName, out var allNewFieldNamesForClass))
+					{
+						if (allNewFieldNamesForClass.Contains(fieldName))
+						{
+							if(node.Parent is MemberAccessExpressionSyntax memberAccessExpressionSyntax)
+							{
+								//for member access expressions only rewrite if used with .this, eg this.NewField, that prevents rewriting of static class fields with same name
+								if (!memberAccessExpressionSyntax.ToString().StartsWith("this."))
+								{
+									return base.VisitIdentifierName(node);
+								}
+							}
+							
+							var isNameOfExpression = node.Ancestors().OfType<InvocationExpressionSyntax>().Any(e => e.Expression.ToString() == "nameof");
+							if (!isNameOfExpression) //nameof expression will be rewritten via VisitInvocationExpression
+							{
+								return
+								AddRewriteCommentIfNeeded(
+									SyntaxFactory.MemberAccessExpression(
+											SyntaxKind.SimpleMemberAccessExpression,
+											SyntaxFactory.InvocationExpression(
+													SyntaxFactory.MemberAccessExpression(
+														SyntaxKind.SimpleMemberAccessExpression,
+														SyntaxFactory.IdentifierName(typeof(TemporaryNewFieldValues).FullName),
+														SyntaxFactory.GenericName(
+																SyntaxFactory.Identifier(nameof(TemporaryNewFieldValues.ResolvePatchedObject)))
+															.WithTypeArgumentList(
+																SyntaxFactory.TypeArgumentList(
+																	SyntaxFactory.SingletonSeparatedList<TypeSyntax>(
+																		SyntaxFactory.IdentifierName(fullClassName + AssemblyChangesLoader.ClassnamePatchedPostfix))))))
+												.WithArgumentList(
+													SyntaxFactory.ArgumentList(
+														SyntaxFactory.SingletonSeparatedList<ArgumentSyntax>(
+															SyntaxFactory.Argument(
+																SyntaxFactory.ThisExpression())))),
+											SyntaxFactory.IdentifierName(fieldName))
+										.WithTriviaFrom(node),
+									$"{nameof(NewFieldsRewriter)}:{nameof(VisitIdentifierName)}"
+								);
+							}
+						}
+					}
+					else
+					{
+						LoggerScoped.LogWarning($"Unable to find type: {fullClassName}");
+					}
+				}
+			}
+
+			return base.VisitIdentifierName(node);
+		}
+
+		public override SyntaxNode VisitFieldDeclaration(FieldDeclarationSyntax node)
+		{
+			var fieldName = node.Declaration.Variables.First().Identifier.ToString();
+			var fullClassName = RoslynUtils.GetMemberFQDNWithoutMemberName(node);
+
+			if (_typeToNewFieldDeclarations.TryGetValue(fullClassName, out var newFields))
+			{
+				if (newFields.Contains(fieldName))
+				{
+					var existingLeading = node.GetLeadingTrivia();
+					var existingTrailing = node.GetTrailingTrivia();
+
+					return AddRewriteCommentIfNeeded(
+						node
+							.WithLeadingTrivia(existingLeading.Add(SyntaxFactory.Comment("/* ")))
+							.WithTrailingTrivia(existingTrailing.Insert(0, SyntaxFactory.Comment(" */ //Auto-excluded to prevent exceptions - see docs"))),
+						$"{nameof(NewFieldsRewriter)}:{nameof(VisitFieldDeclaration)}"
+					);
+				}
+			}
+
+			return base.VisitFieldDeclaration(node);
+		}
+	}
+}
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 0e9e687bdfc0444395deab1e7c68ed3f
+timeCreated: 1672993042
+AssetOrigin:
+  serializedVersion: 1
+  productId: 239351
+  packageName: Fast Script Reload
+  packageVersion: 1.6.1
+  assetPath: Assets/FastScriptReload/Scripts/Editor/Compilation/CodeRewriting/NewFieldsRewriter.cs
+  uploadId: 710802
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 919d4ff85d4d4156bddf5c48bcc99da1
+timeCreated: 1719699288
@@ -0,0 +1,87 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using UnityEngine;
+
+public static class PartialClassFinder
+{
+    //TODO: optimize lookup, currently this loads all files in directory and checks if they have 'partial' string in them. For directories with many files this will not be sufficient
+    public static IEnumerable<string> FindPartialClassFilesInDirectory(string filePath, int maxDepth = int.MaxValue)
+    {
+        if (string.IsNullOrEmpty(filePath) || !File.Exists(filePath))
+            return Enumerable.Empty<string>();
+
+        string directory = Path.GetDirectoryName(filePath);
+        string fileContent = File.ReadAllText(filePath);
+
+        string partialClassName = ExtractPartialClassName(fileContent);
+        if (string.IsNullOrEmpty(partialClassName))
+        {
+            Debug.LogWarning($"No partial class/struct found in file: {filePath}");
+            return Enumerable.Empty<string>();
+        }
+
+        return FindPartialClassFilesRecursively(directory, partialClassName, maxDepth, currentDepth: 0);
+    }
+
+    private static IEnumerable<string> FindPartialClassFilesRecursively(string directory, string partialClassName, int maxDepth, int currentDepth)
+    {
+        var files = new List<string>();
+
+        try
+        {
+            // Search in current directory
+            files.AddRange(Directory.GetFiles(directory, "*.cs")
+                .Where(file => IsPartialClassFile(file, partialClassName)));
+
+            // If we haven't reached max depth, search in subdirectories
+            if (currentDepth < maxDepth)
+            {
+                foreach (var subDir in Directory.GetDirectories(directory))
+                {
+                    files.AddRange(FindPartialClassFilesRecursively(subDir, partialClassName, maxDepth, currentDepth + 1));
+                }
+            }
+        }
+        catch (UnauthorizedAccessException ex)
+        {
+            Debug.LogWarning($"Access denied to directory: {directory}. Error: {ex.Message}");
+        }
+        catch (Exception ex)
+        {
+            Debug.LogError($"Error searching directory: {directory}. Error: {ex.Message}");
+        }
+
+        return files;
+    }
+
+    private static bool IsPartialClassFile(string filePath, string className)
+    {
+        try
+        {
+            string content = File.ReadAllText(filePath);
+            return content.Contains($"partial class {className}")
+                || content.Contains($"partial struct {className}");
+        }
+        catch (Exception ex)
+        {
+            Debug.LogError($"Error reading file: {filePath}. Error: {ex.Message}");
+            return false;
+        }
+    }
+
+    private static string ExtractPartialClassName(string fileContent)
+    {
+        // This is a simple implementation and might need to be more robust
+        // depending on your specific needs
+        var partialClassDeclaration = fileContent.Split(new[] { "partial class", "partial struct" }, StringSplitOptions.RemoveEmptyEntries)
+            .Skip(1)
+            .FirstOrDefault();
+
+        if (partialClassDeclaration == null)
+            return string.Empty;
+
+        return partialClassDeclaration.TrimStart().Split(new[] { ' ', '{', ':' }, StringSplitOptions.RemoveEmptyEntries).FirstOrDefault().Trim();
+    }
+}
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 6f182f9db524441e80f367f8f99d8a5f
+timeCreated: 1719778688
+AssetOrigin:
+  serializedVersion: 1
+  productId: 239351
+  packageName: Fast Script Reload
+  packageVersion: 1.6.1
+  assetPath: Assets/FastScriptReload/Scripts/Editor/Compilation/CodeRewriting/Partials/PartialClassFinder.cs
+  uploadId: 710802
@@ -0,0 +1,92 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace FastScriptReload.Editor.Compilation.CodeRewriting
+{
+    internal static class PartialTreeProcessor
+    {
+        /// <summary>
+        /// Processes a syntax tree containing partial type definitions, merging it with other partial definitions found in the same directory.
+        /// </summary>
+        /// <param name="tree">The original syntax tree to process.</param>
+        /// <param name="definedPreprocessorSymbols">A collection of defined preprocessor symbols.</param>
+        /// <returns>A new SyntaxTree with merged partial types and added InternalsVisibleTo attribute.</returns>
+        /// <remarks>
+        /// This method performs the following steps:
+        /// 1. Checks if the tree contains partial types.
+        /// 2. If it does, processes the current tree and other partial files in the same directory.
+        /// 3. Combines all partial type declarations.
+        /// 4. Creates a new compilation unit with merged types and using directives.
+        /// 5. Adds the InternalsVisibleTo attribute to the resulting tree.
+        /// </remarks>
+        internal static SyntaxTree ProcessPartialTree(SyntaxTree tree, IEnumerable<string> definedPreprocessorSymbols)
+        {
+            if (!HasPartialTypes(tree))
+            {
+                return tree;
+            }
+
+            var combinedTypes = new Dictionary<string, List<TypeDeclarationSyntax>>();
+            var combinedUsingDirectives = new HashSet<UsingDirectiveSyntax>();
+            var combinedTypesDefined = new HashSet<string>();
+
+            ProcessTree(tree, combinedTypes, combinedUsingDirectives, combinedTypesDefined);
+
+            const int fileSearchMaxDepth = 5;
+            var otherPartialFiles = PartialClassFinder.FindPartialClassFilesInDirectory(tree.FilePath, fileSearchMaxDepth)
+                    .Where(file => file != tree.FilePath);
+
+            foreach (var file in otherPartialFiles)
+            {
+                var partialTree = CSharpSyntaxTree.ParseText(File.ReadAllText(file), path: file);
+                ProcessTree(partialTree, combinedTypes, combinedUsingDirectives, combinedTypesDefined);
+            }
+
+            var combinedTypeDeclarations = combinedTypes
+                    .Select(kvp => PartialTypeCombiner.CombinePartialType(kvp.Value))
+                    .ToList<MemberDeclarationSyntax>();
+
+            var newRoot = SyntaxFactory.CompilationUnit()
+                    .WithUsings(SyntaxFactory.List(combinedUsingDirectives))
+                    .WithMembers(SyntaxFactory.List(combinedTypeDeclarations))
+                    .WithAdditionalAnnotations(new SyntaxAnnotation("PreprocessorSymbols", string.Join(",", definedPreprocessorSymbols)));
+
+            return CSharpSyntaxTree.Create(newRoot, null, tree.FilePath)
+                    .AddInternalsVisibleToAttribute();
+        }
+
+        private static bool HasPartialTypes(SyntaxTree tree)
+        {
+            var root = tree.GetCompilationUnitRoot();
+            return root.DescendantNodes().OfType<TypeDeclarationSyntax>().Any(type => type.Modifiers.Any(SyntaxKind.PartialKeyword));
+        }
+
+        private static void ProcessTree(
+                SyntaxTree tree,
+                Dictionary<string, List<TypeDeclarationSyntax>> combinedTypes,
+                HashSet<UsingDirectiveSyntax> combinedUsingDirectives,
+                HashSet<string> combinedTypesDefined)
+        {
+            var root = tree.GetCompilationUnitRoot();
+
+            combinedUsingDirectives.UnionWith(root.Usings);
+
+            foreach (var typeDecl in root.DescendantNodes().OfType<TypeDeclarationSyntax>())
+            {
+                var fullName = NamespaceHelper.GetFullyQualifiedName(typeDecl);
+                combinedTypesDefined.Add(fullName);
+
+                if (!combinedTypes.TryGetValue(fullName, out var declarations))
+                {
+                    declarations = new List<TypeDeclarationSyntax>();
+                    combinedTypes[fullName] = declarations;
+                }
+                declarations.Add(typeDecl);
+            }
+        }
+    }
+}
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 4aafad9b85b44ebe902ba3cee7bda205
+timeCreated: 1719954990
+AssetOrigin:
+  serializedVersion: 1
+  productId: 239351
+  packageName: Fast Script Reload
+  packageVersion: 1.6.1
+  assetPath: Assets/FastScriptReload/Scripts/Editor/Compilation/CodeRewriting/Partials/PartialTreeProcessor.cs
+  uploadId: 710802
@@ -0,0 +1,45 @@
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace FastScriptReload.Editor.Compilation.CodeRewriting
+{
+    internal static class PartialTypeCombiner
+    {
+        internal static TypeDeclarationSyntax CombinePartialType(List<TypeDeclarationSyntax> declarations)
+        {
+            if (declarations.Count == 1)
+                return declarations[0];
+
+            var firstDeclaration = declarations[0];
+            var combinedMembers = declarations.SelectMany(d => d.Members).ToList();
+
+            var combinedModifiers = declarations
+                    .SelectMany(d => d.Modifiers)
+                    .Where(m => !m.IsKind(SyntaxKind.PartialKeyword))
+                    .GroupBy(m => m.ValueText)
+                    .Select(g => g.First().WithTrailingTrivia(SyntaxFactory.Space))
+                    .ToList();
+
+            if (!combinedModifiers.Any(m => m.IsKind(SyntaxKind.PartialKeyword)))
+                combinedModifiers.Add(SyntaxFactory.Token(SyntaxKind.PartialKeyword).WithTrailingTrivia(SyntaxFactory.Space));
+
+            var combinedBaseList = declarations
+                    .Where(d => d.BaseList != null)
+                    .SelectMany(d => d.BaseList.Types)
+                    .GroupBy(t => t.ToString())
+                    .Select(g => g.First())
+                    .ToList();
+
+            return firstDeclaration
+                    .WithMembers(SyntaxFactory.List(combinedMembers))
+                    .WithModifiers(SyntaxFactory.TokenList(combinedModifiers))
+                    .WithKeyword(firstDeclaration.Keyword.WithLeadingTrivia(SyntaxFactory.Space))
+                    .WithBaseList(combinedBaseList.Any()
+                            ? SyntaxFactory.BaseList(SyntaxFactory.SeparatedList(combinedBaseList))
+                            : null);
+        }
+    }
+}
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: cc8170320f3a463590d434f7e0570ea0
+timeCreated: 1719955225
+AssetOrigin:
+  serializedVersion: 1
+  productId: 239351
+  packageName: Fast Script Reload
+  packageVersion: 1.6.1
+  assetPath: Assets/FastScriptReload/Scripts/Editor/Compilation/CodeRewriting/Partials/PartialTypeCombiner.cs
+  uploadId: 710802
@@ -0,0 +1,52 @@
+using System.Collections.Generic;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace FastScriptReload.Editor.Compilation.CodeRewriting
+{
+    internal static class NamespaceHelper
+    {
+        internal static string GetFullyQualifiedName(TypeDeclarationSyntax typeDeclaration)
+        {
+            var namespaces = new List<string>();
+            var currentNode = typeDeclaration.Parent;
+            while (currentNode != null)
+            {
+                if (currentNode is NamespaceDeclarationSyntax namespaceDeclaration)
+                {
+                    namespaces.Add(namespaceDeclaration.Name.ToString());
+                }
+                currentNode = currentNode.Parent;
+            }
+            namespaces.Reverse();
+            var namespaceName = string.Join(".", namespaces);
+            return string.IsNullOrEmpty(namespaceName)
+                    ? typeDeclaration.Identifier.Text
+                    : $"{namespaceName}.{typeDeclaration.Identifier.Text}";
+        }
+    }
+
+    internal static class SyntaxTreeExtensions
+    {
+        internal static SyntaxTree AddInternalsVisibleToAttribute(this SyntaxTree tree)
+        {
+            var root = tree.GetCompilationUnitRoot();
+
+            var attributeArgument = SyntaxFactory.AttributeArgument(
+                    SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal("Assembly-CSharp"))
+            );
+            var attribute = SyntaxFactory.Attribute(
+                    SyntaxFactory.ParseName("System.Runtime.CompilerServices.InternalsVisibleTo"),
+                    SyntaxFactory.AttributeArgumentList(SyntaxFactory.SeparatedList(new[] { attributeArgument }))
+            );
+
+            var attributeList = SyntaxFactory.AttributeList(SyntaxFactory.SingletonSeparatedList(attribute))
+                    .WithTarget(SyntaxFactory.AttributeTargetSpecifier(SyntaxFactory.Token(SyntaxKind.AssemblyKeyword)));
+
+            var newRoot = root.AddAttributeLists(attributeList);
+
+            return tree.WithRootAndOptions(newRoot, tree.Options);
+        }
+    }
+}
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 1c2f0e22f1a24fcda6d0c0516b428420
+timeCreated: 1719954970
+AssetOrigin:
+  serializedVersion: 1
+  productId: 239351
+  packageName: Fast Script Reload
+  packageVersion: 1.6.1
+  assetPath: Assets/FastScriptReload/Scripts/Editor/Compilation/CodeRewriting/Partials/SyntaxTreeHelpers.cs
+  uploadId: 710802
@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+
+namespace FastScriptReload.Editor.Compilation.CodeRewriting
+{
+    public static class SyntaxTreeMergePartialsExtensions
+    {
+        public static IEnumerable<SyntaxTree> MergePartials(
+                this IEnumerable<SyntaxTree> trees,
+                IEnumerable<string> definedPreprocessorSymbols)
+        {
+            return trees
+                    .Select(tree => PartialTreeProcessor.ProcessPartialTree(tree, definedPreprocessorSymbols))
+                    .ToList();
+        }
+    }
+}
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 550c942c025f4fd5a1062891f3623c60
+timeCreated: 1719174342
+AssetOrigin:
+  serializedVersion: 1
+  productId: 239351
+  packageName: Fast Script Reload
+  packageVersion: 1.6.1
+  assetPath: Assets/FastScriptReload/Scripts/Editor/Compilation/CodeRewriting/Partials/SyntaxTreeMergePartialsExtensions.cs
+  uploadId: 710802
@@ -0,0 +1,36 @@
+using FastScriptReload.Runtime;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace FastScriptReload.Editor.Compilation.CodeRewriting
+{
+	class RecordeRewriter : FastScriptReloadCodeRewriterBase
+    {
+        public RecordeRewriter(bool writeRewriteReasonAsComment)
+	        : base(writeRewriteReasonAsComment)
+        {
+	        
+        }
+        
+        public override SyntaxNode VisitRecordDeclaration(RecordDeclarationSyntax node)
+        {
+	        return AdjustRecordName(node, node.Identifier);
+        }
+
+        private SyntaxNode AdjustRecordName(RecordDeclarationSyntax node, SyntaxToken nodeIdentifier)
+        {
+	        var typeName = nodeIdentifier.ToString(); //Not ToFullString() as it may include spaces and break.
+	        
+	        if (!typeName.EndsWith(AssemblyChangesLoader.ClassnamePatchedPostfix))
+	        {
+		        typeName += AssemblyChangesLoader.ClassnamePatchedPostfix;
+	        }
+
+	        return AddRewriteCommentIfNeeded(
+		        node.ReplaceToken(nodeIdentifier, SyntaxFactory.Identifier(typeName)), 
+		        $"{nameof(RecordeRewriter)}:{nameof(AdjustRecordName)}"
+		    );
+        }
+    }
+}
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: bb801c55172044ed9294ef722937f12f
+timeCreated: 1705523787
+AssetOrigin:
+  serializedVersion: 1
+  productId: 239351
+  packageName: Fast Script Reload
+  packageVersion: 1.6.1
+  assetPath: Assets/FastScriptReload/Scripts/Editor/Compilation/CodeRewriting/RecordRewriter.cs
+  uploadId: 710802
@@ -0,0 +1,41 @@
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace FastScriptReload.Editor.Compilation.CodeRewriting
+{
+    //ideally we'd use Simplifier but FSR doesn't have access to semantic model on which simplifier works
+    
+    //Removes redundant type name qualifiers, eg: RootClass.NestedEnum.Value -> NestedEnum.Value, root class component is rewritten to have
+    //__Patched_ postfix and if original remains it'll cause type mismatch
+    class RedundantTypeNameQualifierRewriter : FastScriptReloadCodeRewriterBase
+    {
+        public RedundantTypeNameQualifierRewriter(bool writeRewriteReasonAsComment, bool visitIntoStructuredTrivia = false) 
+            : base(writeRewriteReasonAsComment, visitIntoStructuredTrivia)
+        {
+        }
+
+        public override SyntaxNode VisitMemberAccessExpression(MemberAccessExpressionSyntax node)
+        {
+            if(node.Parent is MemberAccessExpressionSyntax)
+                return base.VisitMemberAccessExpression(node); //only target outermost member access for full rewrite
+            
+            var firstNode = node.DescendantNodes().OfType<IdentifierNameSyntax>().FirstOrDefault();
+            if(firstNode is IdentifierNameSyntax idNode && node.DescendantNodes().Count() > 1)
+            {
+                //enclosing type name same as first id node
+                if((idNode.Ancestors().First(n => n is TypeDeclarationSyntax) as TypeDeclarationSyntax)?.Identifier.ToString() == idNode.Identifier.ToString())
+                {
+                    return AddRewriteCommentIfNeeded(
+                        SyntaxFactory.ParseExpression(node.ToString().Replace($"{firstNode.Identifier.ToString()}.", string.Empty)),
+                        $"{nameof(RedundantTypeNameQualifierRewriter)}"
+                    );
+                }
+            }
+
+            
+            return base.VisitMemberAccessExpression(node);
+        }
+    }
+}
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 80a540048e524157a41df1241bd5c168
+timeCreated: 1679325667
+AssetOrigin:
+  serializedVersion: 1
+  productId: 239351
+  packageName: Fast Script Reload
+  packageVersion: 1.6.1
+  assetPath: Assets/FastScriptReload/Scripts/Editor/Compilation/CodeRewriting/RedundantTypeNameQualifierRewriter.cs
+  uploadId: 710802
@@ -0,0 +1,29 @@
+using System;
+using System.Linq;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace FastScriptReload.Editor.Compilation.CodeRewriting
+{
+    public class RoslynUtils
+    {
+        public static string GetMemberFQDN(MemberDeclarationSyntax memberNode, string memberName) //TODO: try get rid of member name (needs to cast to whatever member it could be to get identifier)
+        {
+            var outer = GetMemberFQDNWithoutMemberName(memberNode);
+            return !string.IsNullOrEmpty(outer)
+                ? $"{outer}.{memberName}"
+                : memberName;
+        }
+
+        public static string GetMemberFQDNWithoutMemberName(MemberDeclarationSyntax memberNode) //TODO: move out to helper class
+        {
+            var fullTypeContibutingAncestorNames = memberNode.Ancestors().OfType<MemberDeclarationSyntax>().Select(da =>
+            {
+                if (da is TypeDeclarationSyntax t) return t.Identifier.ToString();
+                else if (da is NamespaceDeclarationSyntax n) return n.Name.ToString();
+                else throw new Exception("Unable to resolve full field name");
+            }).Reverse().ToList();
+
+            return string.Join(".", fullTypeContibutingAncestorNames);
+        }
+    }
+}
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 29bd7fad38034046a8dd4c7eea68907c
+timeCreated: 1673017013
+AssetOrigin:
+  serializedVersion: 1
+  productId: 239351
+  packageName: Fast Script Reload
+  packageVersion: 1.6.1
+  assetPath: Assets/FastScriptReload/Scripts/Editor/Compilation/CodeRewriting/RoslynUtils.cs
+  uploadId: 710802
@@ -0,0 +1,21 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace FastScriptReload.Editor.Compilation.CodeRewriting
+{
+    class ThisAssignmentRewriter: ThisRewriterBase {
+        public ThisAssignmentRewriter(bool writeRewriteReasonAsComment, bool visitIntoStructuredTrivia = false) 
+            : base(writeRewriteReasonAsComment, visitIntoStructuredTrivia)
+        {
+        }
+        
+        public override SyntaxNode VisitThisExpression(ThisExpressionSyntax node)
+        {
+            if (node.Parent is AssignmentExpressionSyntax) {
+                return CreateCastedThisExpression(node);
+            }
+
+            return base.VisitThisExpression(node);
+        }
+    }
+}
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: c5a960528b2b44edbf644e0ac0950d35
+timeCreated: 1672993042
+AssetOrigin:
+  serializedVersion: 1
+  productId: 239351
+  packageName: Fast Script Reload
+  packageVersion: 1.6.1
+  assetPath: Assets/FastScriptReload/Scripts/Editor/Compilation/CodeRewriting/ThisAssignmentRewriter.cs
+  uploadId: 710802
@@ -0,0 +1,22 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace FastScriptReload.Editor.Compilation.CodeRewriting
+{
+    class ThisCallRewriter : ThisRewriterBase
+    {
+        public ThisCallRewriter(bool writeRewriteReasonAsComment, bool visitIntoStructuredTrivia = false) 
+            : base(writeRewriteReasonAsComment, visitIntoStructuredTrivia)
+        {
+        }
+        
+        public override SyntaxNode VisitThisExpression(ThisExpressionSyntax node)
+        {
+            if (node.Parent is ArgumentSyntax)
+            {
+                return CreateCastedThisExpression(node);
+            }
+            return base.VisitThisExpression(node);
+        }
+    }
+}
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: f7e7aad39cec445db504fe5a117beae5
+timeCreated: 1672993042
+AssetOrigin:
+  serializedVersion: 1
+  productId: 239351
+  packageName: Fast Script Reload
+  packageVersion: 1.6.1
+  assetPath: Assets/FastScriptReload/Scripts/Editor/Compilation/CodeRewriting/ThisCallRewriter.cs
+  uploadId: 710802
@@ -0,0 +1,51 @@
+using System.Linq;
+using ImmersiveVrToolsCommon.Runtime.Logging;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace FastScriptReload.Editor.Compilation.CodeRewriting
+{
+    abstract class ThisRewriterBase : FastScriptReloadCodeRewriterBase
+    {
+        protected ThisRewriterBase(bool writeRewriteReasonAsComment, bool visitIntoStructuredTrivia = false) 
+            : base(writeRewriteReasonAsComment, visitIntoStructuredTrivia)
+        {
+        }
+        
+        protected SyntaxNode CreateCastedThisExpression(ThisExpressionSyntax node)
+        {
+            var ancestors = node.Ancestors().Where(n => n is TypeDeclarationSyntax).Cast<TypeDeclarationSyntax>().ToList();
+            if (ancestors.Count() > 1)
+            {
+                LoggerScoped.LogWarning($"ThisRewriter: for class: '{ancestors.First().Identifier}' - 'this' call/assignment in nested class / struct. Dynamic cast will be used but this could cause issues in some cases:" +
+                                 $"\r\n\r\n1) - If called method has multiple overrides, using dynamic will cause compiler issue as it'll no longer be able to pick correct one" +
+                                 $"\r\n\r\n If you see any issues with that message, please look at 'Limitation' section in documentation as this outlines how to deal with it.");
+
+                //TODO: casting to dynamic seems to be best option (and one that doesn't fail for nested classes), what's the performance overhead?
+                return SyntaxFactory.CastExpression(
+                    SyntaxFactory.ParseTypeName("dynamic"),
+                    node
+                );
+            }
+            
+            var firstAncestor = ancestors.FirstOrDefault();
+            if (firstAncestor == null)
+            {
+                LoggerScoped.LogWarning($"Unable to find first ancestor for node: {node.ToFullString()}, this rewrite will not be applied");
+                return node;
+            }
+
+            var methodInType = firstAncestor.Identifier.ToString();
+            var resultNode = SyntaxFactory.CastExpression(
+                SyntaxFactory.ParseTypeName(methodInType),
+                SyntaxFactory.CastExpression(
+                    SyntaxFactory.ParseTypeName(typeof(object).FullName),
+                    node
+                )
+            );
+
+            return AddRewriteCommentIfNeeded(resultNode, $"{nameof(ThisRewriterBase)}:{nameof(CreateCastedThisExpression)}");
+        }
+    }
+}
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 0fd0b779590247168b3873c939c42d71
+timeCreated: 1672993042
+AssetOrigin:
+  serializedVersion: 1
+  productId: 239351
+  packageName: Fast Script Reload
+  packageVersion: 1.6.1
+  assetPath: Assets/FastScriptReload/Scripts/Editor/Compilation/CodeRewriting/ThisRewriterBase.cs
+  uploadId: 710802
@@ -0,0 +1,349 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading;
+using FastScriptReload.Editor.AssemblyPostProcess;
+using HarmonyLib;
+using ImmersiveVRTools.Editor.Common.Cache;
+using ImmersiveVRTools.Editor.Common.Utilities;
+using ImmersiveVRTools.Runtime.Common;
+using ImmersiveVrToolsCommon.Runtime.Logging;
+using UnityEditor;
+
+namespace FastScriptReload.Editor.Compilation
+{
+    [InitializeOnLoad]
+    public class DotnetExeDynamicCompilation: DynamicCompilationBase
+    {
+        private static string _dotnetExePath;
+        private static string _cscDll;
+        private static string _tempFolder;
+
+        private static string ApplicationContentsPath = EditorApplication.applicationContentsPath;
+        private static readonly List<string> _createdFilesToCleanUp = new List<string>();
+        private static readonly Dictionary<string, Assembly> _typeNameAssemblyCache = new Dictionary<string, Assembly>(16);
+
+        static DotnetExeDynamicCompilation()
+        {
+#if UNITY_EDITOR_WIN
+            const string dotnetExecutablePath = "dotnet.exe";
+#else
+            const string dotnetExecutablePath = "dotnet"; //mac and linux, no extension
+#endif
+                
+            _dotnetExePath = FindFileOrThrow(dotnetExecutablePath);
+            _cscDll = FindFileOrThrow("csc.dll"); //even on mac/linux need to find dll and use, not no extension one
+            _tempFolder = Path.GetTempPath();
+            
+            EditorApplication.playModeStateChanged += obj =>
+            {
+                if (obj == PlayModeStateChange.ExitingPlayMode && _createdFilesToCleanUp.Any())
+                {
+                    LoggerScoped.LogDebug($"Removing temporary files: [{string.Join(",", _createdFilesToCleanUp)}]");
+                    
+                    foreach (var fileToCleanup in _createdFilesToCleanUp)
+                    {
+                        new FileInfo(fileToCleanup).IsReadOnly = false;
+                        File.Delete(fileToCleanup);
+                    }
+                    _createdFilesToCleanUp.Clear();
+                }
+            };
+        }
+
+        private static string FindFileOrThrow(string fileName)
+        {
+            return SessionStateCache.GetOrCreateString($"FSR:FilePath_{fileName}", () =>
+            {
+                var foundFile = Directory
+                    .GetFiles(ApplicationContentsPath, fileName, SearchOption.AllDirectories)
+                    .FirstOrDefault();
+                if (foundFile == null)
+                {
+                    throw new Exception($"Unable to find '{fileName}', make sure Editor version supports it. You can also add preprocessor directive 'FastScriptReload_CompileViaMCS' which will use Mono compiler instead");
+                }
+
+                return foundFile;
+            });
+        }
+
+        public static CompileResult Compile(List<string> filePathsWithSourceCode, UnityMainThreadDispatcher unityMainThreadDispatcher)
+        {
+            var sourceCodeCombinedFilePath = string.Empty;
+            try
+            {
+                var asmName = Guid.NewGuid().ToString().Replace("-", "");
+                var rspFile = _tempFolder + $"{asmName}.rsp";
+                var assemblyAttributeFilePath = _tempFolder + $"{asmName}.DynamicallyCreatedAssemblyAttribute.cs";
+                sourceCodeCombinedFilePath = _tempFolder + $"{asmName}.SourceCodeCombined.cs";
+                var outLibraryPath = $"{_tempFolder}{asmName}.dll";
+
+                var createSourceCodeCombinedResult = CreateSourceCodeCombinedContents(filePathsWithSourceCode, ActiveScriptCompilationDefines.ToList());
+                CreateFileAndTrackAsCleanup(sourceCodeCombinedFilePath, createSourceCodeCombinedResult.SourceCode, _createdFilesToCleanUp);
+#if UNITY_EDITOR
+                unityMainThreadDispatcher.Enqueue(() =>
+                {
+                    if ((bool)FastScriptReloadPreference.IsAutoOpenGeneratedSourceFileOnChangeEnabled.GetEditorPersistedValueOrDefault())
+                    {
+                        UnityEditorInternal.InternalEditorUtility.OpenFileAtLineExternal(sourceCodeCombinedFilePath, 0);
+                    }
+                });
+#endif
+
+                var originalAssemblyPathToAsmWithInternalsVisibleToCompiled = PerfMeasure.Elapsed(
+                    () => CreateAssemblyCopiesWithInternalsVisibleTo(createSourceCodeCombinedResult, asmName),
+                    out var createInternalVisibleToAsmElapsedMilliseconds);
+
+                var shouldAddUnsafeFlag = createSourceCodeCombinedResult.SourceCode.Contains("unsafe"); //TODO: not ideal as 'unsafe' can be part of comment, not code. But compiling with that flag in more cases shouldn't cause issues
+                var rspFileContent = GenerateCompilerArgsRspFileContents(outLibraryPath, sourceCodeCombinedFilePath, assemblyAttributeFilePath, 
+                    originalAssemblyPathToAsmWithInternalsVisibleToCompiled, shouldAddUnsafeFlag);
+                CreateFileAndTrackAsCleanup(rspFile, rspFileContent, _createdFilesToCleanUp);
+                CreateFileAndTrackAsCleanup(assemblyAttributeFilePath, DynamicallyCreatedAssemblyAttributeSourceCode, _createdFilesToCleanUp);
+
+                var exitCode = ExecuteDotnetExeCompilation(_dotnetExePath, _cscDll, rspFile, outLibraryPath, out var outputMessages);
+
+                var compiledAssembly = Assembly.LoadFrom(outLibraryPath);
+                return new CompileResult(outLibraryPath, outputMessages, exitCode, compiledAssembly, createSourceCodeCombinedResult.SourceCode, 
+                    sourceCodeCombinedFilePath, createInternalVisibleToAsmElapsedMilliseconds);
+            }
+            catch (SourceCodeHasErrorsException e)
+            {
+                // FastScriptReloadManager has a special case for reporting SourceCodeHasErrorsException.
+                // Just pass it through.
+                throw e;
+            }
+            catch (Exception e)
+            {
+                LoggerScoped.LogError($"Compilation error: temporary files were not removed so they can be inspected: " 
+                               + string.Join(", ", _createdFilesToCleanUp
+                                   .Select(f => $"<a href=\"{f}\" line=\"1\">{f}</a>")));
+                if (LogHowToFixMessageOnCompilationError)
+                {
+                    LoggerScoped.LogWarning($@"HOW TO FIX - INSTRUCTIONS:
+
+1) Open file that caused issue by looking at error log starting with: 'FSR: Compilation error: temporary files were not removed so they can be inspected: '. And click on file path to open.
+2) Look up other error in the console, which will be like 'Error When updating files:' - this one contains exact line that failed to compile (in XXX_SourceCodeGenerated.cs file). Those are same compilation errors as you see in Unity/IDE when developing.
+3) Read compiler error message as it'll help understand the issue
+
+Error could be caused by a normal compilation issue that you created in source file (eg typo), in that case please fix and it'll recompile.
+
+It's possible compilation fails due to existing limitation, in that case:
+
+<b><color='orange'>You can quickly specify custom script rewrite override for part of code that's failing.</color></b>
+
+Please use project panel to:
+1) Right-click on the original file that has compilation issue
+2) Click Fast Script Reload -> Add / Open User Script Rewrite Override
+3) Read top comment in opened file and it'll explain how to create overrides
+
+I'm continuously working on mitigating limitations.
+
+If you could please get in touch with me via 'support@immersivevrtools.com' and include error you see in the console as well as created files (from paths in previous error). This way I can get it fixed for you.
+
+You can also:
+1) Look at 'limitation' section in the docs - which will explain bit more around limitations and workarounds
+2) Move some of the code that you want to work on to different file - compilation happens on whole file, if you have multiple types there it could increase the chance of issues
+3) Have a look at compilation error, it shows error line (in the '*.SourceCodeCombined.cs' file, it's going to be something that compiler does not accept, likely easy to spot. To workaround you can change that part of code in original file. It's specific patterns that'll break it.
+
+*If you want to prevent that message from reappearing please go to Window -> Fast Script Reload -> Start Screen -> Logging -> tick off 'Log how to fix message on compilation error'*");
+
+                }
+                
+                throw new HotReloadCompilationException(e.Message, e, sourceCodeCombinedFilePath);
+            }
+        }
+
+        private static Dictionary<string, string> CreateAssemblyCopiesWithInternalsVisibleTo(CreateSourceCodeCombinedContentsResult createSourceCodeCombinedResult, string asmName)
+        {
+            var originalAssemblyPathToAsmWithInternalsVisibleToCompiled = new Dictionary<string, string>();
+            try
+            {
+                var assembliesForTypesInCombinedFile = createSourceCodeCombinedResult.TypeNamesDefinitions
+                    .Select(GetAssemblyByTypeName)
+                    .Where(t => t != null)
+                    .Distinct();
+
+                foreach (var assemblyForTypesInCombinedFile in assembliesForTypesInCombinedFile)
+                {
+                    var createdAssemblyWithInternalsVisibleToNewlyCompiled = AddInternalsVisibleToForAllUserAssembliesPostProcess.CreateAssemblyWithInternalsContentsVisibleTo(
+                        assemblyForTypesInCombinedFile, asmName
+                    );
+                    originalAssemblyPathToAsmWithInternalsVisibleToCompiled.Add(assemblyForTypesInCombinedFile.Location, createdAssemblyWithInternalsVisibleToNewlyCompiled);
+                }
+            }
+            catch (Exception e)
+            {
+                LoggerScoped.LogWarning($"Unable to create assembly with '{nameof(InternalsVisibleToAttribute)}' for dynamically recompiled code. {e}");
+            }
+
+            return originalAssemblyPathToAsmWithInternalsVisibleToCompiled;
+        }
+
+        private static void CreateFileAndTrackAsCleanup(string filePath, string contents, List<string> createdFilesToCleanUp)
+        {
+            File.WriteAllText(filePath, contents);
+            new FileInfo(filePath).IsReadOnly = true;
+            createdFilesToCleanUp.Add(filePath);
+        }
+
+        private static Assembly GetAssemblyByTypeName(string typeName)
+        {
+            // This cache is barely worth it on my machine - it's ~1ms without, ~0ms with.
+            // However, the number of assemblies to search is technically unbounded
+            //  - so this might be more important for somebody else.
+            if (_typeNameAssemblyCache.TryGetValue(typeName, out var assembly)) return assembly;
+
+            // FSR (via Harmony) originally did this search by enumerating assembly.GetTypes().
+            // I can't see anything in the documentation suggesting the assembly.GetType(typeName) version misses any cases.
+            // It's much faster.
+            assembly = AppDomain.CurrentDomain.GetAssemblies().SingleOrDefault(asm => asm.GetType(typeName, false) != null);
+
+            if (assembly != null) _typeNameAssemblyCache.Add(typeName, assembly);
+            return assembly;
+        }
+
+        private static string GenerateCompilerArgsRspFileContents(string outLibraryPath, string sourceCodeCombinedFilePath, string assemblyAttributeFilePath, 
+            Dictionary<string, string> originalAssemblyPathToAsmWithInternalsVisibleToCompiled, bool addUnsafeFlag)
+        {
+            var rspContents = new StringBuilder();
+            rspContents.AppendLine("-target:library");
+            rspContents.AppendLine($"-out:\"{outLibraryPath}\"");
+            // rspContents.AppendLine($"-refout:\"{tempFolder}{asmName}.ref.dll\""); //reference assembly for linking, not needed
+            foreach (var symbol in ActiveScriptCompilationDefines)
+            {
+                rspContents.AppendLine($"-define:{symbol}");
+            }
+
+            foreach (var referenceToAdd in ResolveReferencesToAdd(new List<string>()))
+            {
+                if (originalAssemblyPathToAsmWithInternalsVisibleToCompiled.TryGetValue(referenceToAdd, out var asmWithInternalsVisibleTo))
+                {
+                    //Changed assembly have InternalsVisibleTo added to it to avoid any issues where types are defined internal
+                    rspContents.AppendLine($"-r:\"{asmWithInternalsVisibleTo}\"");
+                }
+                else
+                {
+                    rspContents.AppendLine($"-r:\"{referenceToAdd}\"");
+                }
+            }
+
+            rspContents.AppendLine($"\"{sourceCodeCombinedFilePath}\"");
+            rspContents.AppendLine($"\"{assemblyAttributeFilePath}\"");
+
+            rspContents.AppendLine($"-langversion:latest");
+
+            rspContents.AppendLine("/deterministic");
+            rspContents.AppendLine("/optimize-");
+            rspContents.AppendLine("/debug:portable");
+            rspContents.AppendLine("/nologo");
+            rspContents.AppendLine("/RuntimeMetadataVersion:v4.0.30319");
+
+            if (addUnsafeFlag)
+            {
+                rspContents.AppendLine("/unsafe");
+            }
+
+            rspContents.AppendLine("/nowarn:0169");
+            rspContents.AppendLine("/nowarn:0649");
+            rspContents.AppendLine("/nowarn:1701");
+            rspContents.AppendLine("/nowarn:1702");
+            rspContents.AppendLine("/utf8output");
+            rspContents.AppendLine("/preferreduilang:en-US");
+            
+            var rspContentsString = rspContents.ToString();
+            return rspContentsString;
+        }
+
+        private static int ExecuteDotnetExeCompilation(string dotnetExePath, string cscDll, string rspFile,
+            string outLibraryPath, out List<string> outputMessages)
+        {
+            var process = new Process();
+            process.StartInfo.FileName = dotnetExePath;
+            process.StartInfo.Arguments = $"exec \"{cscDll}\" /nostdlib /noconfig /shared \"@{rspFile}\"";
+
+            var outMessages = new List<string>();
+
+            var stderr_completed = new ManualResetEvent(false);
+            var stdout_completed = new ManualResetEvent(false);
+
+            process.StartInfo.CreateNoWindow = true;
+            process.StartInfo.UseShellExecute = false;
+            process.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
+            process.StartInfo.RedirectStandardOutput = true;
+            process.StartInfo.RedirectStandardError = true;
+            process.ErrorDataReceived += (sender, args) =>
+            {
+                if (args.Data != null)
+                    outMessages.Add(args.Data);
+                else
+                    stderr_completed.Set();
+            };
+            process.OutputDataReceived += (sender, args) =>
+            {
+                if (args.Data != null)
+                {
+                    outMessages.Add(args.Data);
+                    return;
+                }
+
+                stdout_completed.Set();
+            };
+            process.StartInfo.StandardOutputEncoding = process.StartInfo.StandardErrorEncoding = Encoding.UTF8;
+
+            try
+            {
+                process.Start();
+            }
+            catch (Exception ex)
+            {
+                if (ex is Win32Exception win32Exception)
+                    throw new SystemException(string.Format("Error running {0}: {1}", process.StartInfo.FileName,
+                        typeof(Win32Exception)
+                            .GetMethod("GetErrorMessage", BindingFlags.Static | BindingFlags.NonPublic)?
+                            .Invoke(null, new object[] { win32Exception.NativeErrorCode }) ??
+                        $"<Unable to resolve GetErrorMessage function>, NativeErrorCode: {win32Exception.NativeErrorCode}"));
+                throw;
+            }
+
+            int exitCode = -1;
+            try
+            {
+                process.BeginOutputReadLine();
+                process.BeginErrorReadLine();
+                process.WaitForExit();
+
+                exitCode = process.ExitCode;
+            }
+            finally
+            {
+                stderr_completed.WaitOne(TimeSpan.FromSeconds(30.0));
+                stdout_completed.WaitOne(TimeSpan.FromSeconds(30.0));
+                process.Close();
+            }
+
+            if (!File.Exists(outLibraryPath))
+                throw new Exception("Compiler failed to produce the assembly. Output: '" +
+                                    string.Join(Environment.NewLine + Environment.NewLine, outMessages) + "'");
+
+            outputMessages = new List<string>();
+            outputMessages.AddRange(outMessages);
+            return exitCode;
+        }
+    }
+
+    public class HotReloadCompilationException : Exception
+    {
+        public string SourceCodeCombinedFileCreated { get; }
+
+        public HotReloadCompilationException(string message, Exception innerException, string sourceCodeCombinedFileCreated) : base(message, innerException)
+        {
+            SourceCodeCombinedFileCreated = sourceCodeCombinedFileCreated;
+        }
+    }
+}
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 334fb2fc5cff4e98bf0f1ced9058cfc2
+timeCreated: 1669637513
+AssetOrigin:
+  serializedVersion: 1
+  productId: 239351
+  packageName: Fast Script Reload
+  packageVersion: 1.6.1
+  assetPath: Assets/FastScriptReload/Scripts/Editor/Compilation/DotnetExeCompilator.cs
+  uploadId: 710802
@@ -0,0 +1,64 @@
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using FastScriptReload.Runtime;
+using ImmersiveVRTools.Runtime.Common;
+using ImmersiveVrToolsCommon.Runtime.Logging;
+using Debug = UnityEngine.Debug;
+
+namespace FastScriptReload.Editor.Compilation
+{
+    public class DynamicAssemblyCompiler
+    {
+        public static CompileResult Compile(List<string> filePathsWithSourceCode, UnityMainThreadDispatcher unityMainThreadDispatcher)
+        {
+            var sw = new Stopwatch();
+            sw.Start();
+        
+#if FastScriptReload_CompileViaMCS
+        var result = McsExeDynamicCompilation.Compile(filePathsWithSourceCode);
+#else
+            var compileResult = DotnetExeDynamicCompilation.Compile(filePathsWithSourceCode, unityMainThreadDispatcher);
+#endif  
+        
+            LoggerScoped.Log($"Files: {string.Join(",", filePathsWithSourceCode.Select(fn => new FileInfo(fn).Name))} changed " +
+#if UNITY_2021_1_OR_NEWER
+                             $"<a href=\"{compileResult.SourceCodeCombinedFileLocation}\" line=\"1\">(click here to debug [in bottom details pane])</a>" +
+#else
+                            "(to debug go to Fast Script Reload -> Start Screen -> Debugging -> Auto-open generated source file for debugging)" +
+#endif
+                             $" - compilation (took {sw.ElapsedMilliseconds}ms)"
+#if ImmersiveVrTools_DebugEnabled
+                            + $" (of which creating internal visible to assemblies {compileResult.CreatingAssemblyWithInternalsVisibleToTook})ms"
+#endif
+);
+            
+            return compileResult;
+        }
+    }
+
+    public class CompileResult
+    {
+        public Assembly CompiledAssembly { get; }
+        public string CompiledAssemblyPath { get; }
+        public List<string> MessagesFromCompilerProcess { get; }
+        public bool IsError => string.IsNullOrEmpty(CompiledAssemblyPath);
+        public int NativeCompilerReturnValue { get; }
+        public string SourceCodeCombined { get; }
+        public string SourceCodeCombinedFileLocation { get; }
+        public float CreatingAssemblyWithInternalsVisibleToTook { get; }
+
+        public CompileResult(string compiledAssemblyPath, List<string> messagesFromCompilerProcess, int nativeCompilerReturnValue, Assembly compiledAssembly, string sourceCodeCombined, string sourceCodeCombinedFileLocation, float creatingAssemblyWithInternalsVisibleToTook)
+        {
+            CompiledAssemblyPath = compiledAssemblyPath;
+            MessagesFromCompilerProcess = messagesFromCompilerProcess;
+            NativeCompilerReturnValue = nativeCompilerReturnValue;
+            CompiledAssembly = compiledAssembly;
+            SourceCodeCombined = sourceCodeCombined;
+            SourceCodeCombinedFileLocation = sourceCodeCombinedFileLocation;
+            CreatingAssemblyWithInternalsVisibleToTook = creatingAssemblyWithInternalsVisibleToTook;
+        }
+    }
+}
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 616fd2855e784e728009a00bc1f09255
+timeCreated: 1669110323
+AssetOrigin:
+  serializedVersion: 1
+  productId: 239351
+  packageName: Fast Script Reload
+  packageVersion: 1.6.1
+  assetPath: Assets/FastScriptReload/Scripts/Editor/Compilation/DynamicAssemblyCompiler.cs
+  uploadId: 710802
@@ -0,0 +1,387 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using FastScriptReload.Editor.Compilation.CodeRewriting;
+using FastScriptReload.Editor.Compilation.ScriptGenerationOverrides;
+using FastScriptReload.Runtime;
+using FastScriptReload.Scripts.Runtime;
+using ImmersiveVRTools.Editor.Common.Cache;
+using ImmersiveVRTools.Runtime.Common.Utilities;
+using ImmersiveVrToolsCommon.Runtime.Logging;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.Rendering;
+
+namespace FastScriptReload.Editor.Compilation
+{
+    [InitializeOnLoad]
+    public class DynamicCompilationBase
+    {
+        public static bool DebugWriteRewriteReasonAsComment;
+	    public static bool LogHowToFixMessageOnCompilationError;
+	    public static bool EnableExperimentalThisCallLimitationFix;
+        public static List<string> ReferencesExcludedFromHotReload = new List<string>();
+
+        public const string DebuggingInformationComment = 
+            @"// DEBUGGING READ-ME: DO NOT EDIT THIS AUTO-GENERATED FILE AS IT'LL BE DELETED " +
+#if !UNITY_2021_1_OR_NEWER
+"WARN: on Unity versions prior to 2021, opening files in that manner can cause static values to be reinitialized"
+#else
+            ""
+#endif
+            +
+            @"//
+// To debug simply add a breakpoint in this file.
+// 
+// With every code change - new file is generated, currently you'll need to re-set breakpoints after each change.
+// You can also:
+//    - step into the function that was changed (and that will get you to correct source file)
+//    - add a function breakpoint in your IDE (this way you won't have to re-add it every time)
+//
+// Tool can automatically open dynamically-compiled code file every time to make setting breakpoints easier.
+// You can adjust that behaviour via 'Window -> FastScriptReload -> Start Screen -> Debugging -> Do not auto-open generated cs file'.
+//
+// You can always open generated file when needed by clicking link in console, eg.
+// 'FSR: Files: FunctionLibrary.cs changed (click here to debug [in bottom details pane]) - compilation (took 240ms)'
+
+
+";
+	    
+        public static readonly string[] ActiveScriptCompilationDefines;
+        protected static readonly string DynamicallyCreatedAssemblyAttributeSourceCode = $"[assembly: {typeof(DynamicallyCreatedAssemblyAttribute).FullName}()]";
+        private static readonly string AssemblyCsharpFullPath;
+        
+        static DynamicCompilationBase()
+        {
+            //needs to be set from main thread
+            ActiveScriptCompilationDefines = EditorUserBuildSettings.activeScriptCompilationDefines;
+            AssemblyCsharpFullPath = SessionStateCache.GetOrCreateString(
+	            $"FSR:AssemblyCsharpFullPath", 
+	            () => AssetDatabase.FindAssets("Microsoft.CSharp")
+					            .Select(g => new System.IO.FileInfo(UnityEngine.Application.dataPath + "/../" + AssetDatabase.GUIDToAssetPath(g)))
+					            .First(fi => fi.Name.ToLower() == "Microsoft.CSharp.dll".ToLower()).FullName
+	        );
+
+        }
+        
+        protected static CreateSourceCodeCombinedContentsResult CreateSourceCodeCombinedContents(List<string> sourceCodeFiles, List<string> definedPreprocessorSymbols)
+        {
+            var combinedUsingStatements = new List<string>();
+            var typesDefined = new List<string>();
+
+            var trees = sourceCodeFiles
+                    .Select(sourceCodeFile =>
+                    {
+                        var fileCode = File.ReadAllText(sourceCodeFile);
+                        var tree = CSharpSyntaxTree.ParseText(fileCode, new CSharpParseOptions(preprocessorSymbols: definedPreprocessorSymbols));
+                        return tree.WithFilePath(sourceCodeFile);
+                    })
+                    .ToList();
+
+            if (FastScriptReloadManager.Instance.IsPartialClassSupportEnabled)
+            {
+                trees = trees.MergePartials(definedPreprocessorSymbols).ToList();
+            }
+
+            // It's important to check whether the compiler was able to correctly interpret the original code.
+            // When the compiler encounters errors, it actually continues and still produces a tree.
+            // This tree even still roundtrips to the original source code.
+            // However, because the code didn't parse correctly, the tree's structure may be wrong.
+            // If we don't detect this here, FSR continues on obliviously, applying transformations to the broken tree.
+            // This sometimes leads to correctly generated code, because the parts of the tree that FSR cared to look at happened to be correct.
+            // However, this should not be relied upon.
+            // Transformations applied to broken trees lead to weird bugs, e.g. things at wrong nesting levels.
+            // The safest thing is to bail on the whole process.
+            // 
+            // Note that this can happen with valid user code!!!
+            // This can trigger if FSR's compiler version is behind the one needed for language features in the code.
+            // The user may think their code is correct, but the compiler may disagree.
+            // In this scenario, it's particularly important to let the user know that something went wrong.
+            // Otherwise, they may expect valid output, and get nearly valid output from a broken tree.
+            // Trust me, these bugs are quite confusing when first encountered!
+            var errorDiagnostics = trees.SelectMany(tree => tree.GetDiagnostics()).Where(d => d.Severity == DiagnosticSeverity.Error);
+            if (errorDiagnostics.Any()) throw new SourceCodeHasErrorsException(errorDiagnostics);
+            
+            var sourceCodeWithAdjustments = trees.Select(tree =>
+            {
+                //skip if tree.FilePath null or empty
+                if (string.IsNullOrEmpty(tree.FilePath))
+                {
+                    LoggerScoped.LogError($"Skipping file as it has no path: {tree.FilePath}");
+                    return tree.GetRoot().ToFullString();
+                }
+
+                var root = tree.GetRoot();
+                
+                //WARN: needs to walk before root class name changes, otherwise it'll resolve wrong name
+                var fieldsWalker = new FieldsWalker();
+                fieldsWalker.Visit(root);
+                typesDefined.AddRange(fieldsWalker.GetTypeNames());
+                
+                var typeToNewFieldDeclarations = new Dictionary<string, List<string>>();
+                if (FastScriptReloadManager.Instance.AssemblyChangesLoaderEditorOptionsNeededInBuild.EnableExperimentalAddedFieldsSupport)
+                {
+                    var typeToFieldDeclarations = fieldsWalker.GetTypeToFieldDeclarations();
+                    typeToNewFieldDeclarations = typeToFieldDeclarations.ToDictionary(
+                        t => t.Key,
+                        t =>
+                        {
+                            if (!ProjectTypeCache.AllTypesInNonDynamicGeneratedAssemblies.TryGetValue(t.Key, out var existingType))
+                            {
+                                LoggerScoped.LogDebug($"Unable to find type: {t.Key} in loaded assemblies. If that's the class you've added field to then it may not be properly working. It's possible the class was not yet loaded / used and you can ignore that warning. If it's causing any issues please contact support");
+                                return new List<string>();
+                            }
+
+                            var existingTypeMembersToReplace = NewFieldsRewriter.GetReplaceableMembers(existingType).Select(m => m.Name).ToList();
+			
+                            var newFields = t.Value.Where(fD => !existingTypeMembersToReplace.Contains(fD.FieldName)).ToList();
+                            
+                            //TODO: ideally that registration would happen outside of this class
+                            //TODO: to work for LSR it needs to be handled in runtime
+                            TemporaryNewFieldValues.RegisterNewFields(
+                                existingType, 
+                                newFields.ToDictionary(
+                                    fD => fD.FieldName,
+                                    fD => new TemporaryNewFieldValues.GetNewFieldInitialValue((Type forNewlyGeneratedType) =>
+                                    {
+                                        //TODO: PERF: could cache those - they run to init every new value (for every instance when accessed)
+                                        return CreateNewFieldInitMethodRewriter.ResolveNewFieldsToCreateValueFn(forNewlyGeneratedType)[fD.FieldName]();
+                                    })
+                                ),
+                                newFields.ToDictionary(
+                                    fD => fD.FieldName,
+                                    fD => new TemporaryNewFieldValues.GetNewFieldType((Type forNewlyGeneratedType) =>
+                                    {
+                                        //TODO: PERF: could cache those - they run to init every new value (for every instance when accessed)
+                                        return (Type)CreateNewFieldInitMethodRewriter.ResolveNewFieldsToTypeFn(forNewlyGeneratedType)[fD.FieldName]();
+                                    })
+                                )
+                            );
+
+                            return newFields.Select(fD => fD.FieldName).ToList();
+                        }
+                    );
+
+#if LiveScriptReload_Enabled
+                    if (typeToNewFieldDeclarations.Any(kv => kv.Value.Any()))
+                    {
+                        LoggerScoped.LogWarning($"{nameof(FastScriptReloadManager.Instance.AssemblyChangesLoaderEditorOptionsNeededInBuild.EnableExperimentalAddedFieldsSupport)} is enabled. This is not supported in running build. Quite likely it'll crash remote client.");
+                    }
+#endif
+                }
+
+                //WARN: application order is important, eg ctors need to happen before class names as otherwise ctors will not be recognised as ctors
+                if (FastScriptReloadManager.Instance.EnableExperimentalThisCallLimitationFix)
+                {
+					root = new ThisCallRewriter(DebugWriteRewriteReasonAsComment).Visit(root);
+					root = new ThisAssignmentRewriter(DebugWriteRewriteReasonAsComment).Visit(root);
+                }
+
+                if (FastScriptReloadManager.Instance.AssemblyChangesLoaderEditorOptionsNeededInBuild.EnableExperimentalAddedFieldsSupport)
+                {
+                    root = new NewFieldsRewriter(typeToNewFieldDeclarations, DebugWriteRewriteReasonAsComment).Visit(root);
+                    root = new CreateNewFieldInitMethodRewriter(typeToNewFieldDeclarations, DebugWriteRewriteReasonAsComment).Visit(root);
+                }
+                
+                root = new RedundantTypeNameQualifierRewriter(DebugWriteRewriteReasonAsComment).Visit(root);
+                
+                root = new ConstructorRewriter(adjustCtorOnlyForNonNestedTypes: true, DebugWriteRewriteReasonAsComment).Visit(root);
+                
+                var hotReloadCompliantRewriter = new HotReloadCompliantRewriter(DebugWriteRewriteReasonAsComment);
+                root = hotReloadCompliantRewriter.Visit(root);
+                combinedUsingStatements.AddRange(hotReloadCompliantRewriter.StrippedUsingDirectives);
+                
+                root = new BuilderPatternFunctionsRewriter(DebugWriteRewriteReasonAsComment).Visit(root);
+                root = new RecordeRewriter(DebugWriteRewriteReasonAsComment).Visit(root);
+                root = new ExtensionMethodsCallingOtherExtensionMethodsInSameFileRewriter(DebugWriteRewriteReasonAsComment).Visit(root);
+                
+                //processed as last step to simply rewrite all changes made before
+                if (TryResolveUserDefinedOverridesRoot(tree.FilePath, definedPreprocessorSymbols, out var userDefinedOverridesRoot))
+                {
+                    root = ProcessUserDefinedOverridesReplacements(tree.FilePath, root, userDefinedOverridesRoot);
+                    root = AddUserDefinedOverridenTypes(userDefinedOverridesRoot, root);
+                }
+
+                return root.ToFullString();
+            }).ToList();
+
+            var sourceCodeCombinedSb = new StringBuilder();
+            sourceCodeCombinedSb.Append(DebuggingInformationComment);
+            
+            foreach (var usingStatement in combinedUsingStatements.Distinct())
+            {
+                sourceCodeCombinedSb.Append(usingStatement);
+            }
+
+            foreach (var sourceCodeWithAdjustment in sourceCodeWithAdjustments)
+            {
+                sourceCodeCombinedSb.AppendLine(sourceCodeWithAdjustment);
+            }
+            
+            LoggerScoped.LogDebug("Source Code Created:\r\n\r\n" + sourceCodeCombinedSb);
+            return new CreateSourceCodeCombinedContentsResult(sourceCodeCombinedSb.ToString(), typesDefined);
+        }
+
+        private static SyntaxNode AddUserDefinedOverridenTypes(SyntaxNode userDefinedOverridesRoot, SyntaxNode root)
+        {
+            try
+            {
+                var userDefinedOverrideTypes = userDefinedOverridesRoot.DescendantNodes().OfType<TypeDeclarationSyntax>()
+                    .ToDictionary(n => RoslynUtils.GetMemberFQDN(n, n.Identifier.ToString()));
+                var allDefinedTypesInRecompiledFile = root.DescendantNodes().OfType<TypeDeclarationSyntax>()
+                    .ToDictionary(n => RoslynUtils.GetMemberFQDN(n, n.Identifier.ToString())); //what about nested types?
+
+                var userDefinedOverrideTypesWithoutMatchnigInRecompiledFile = userDefinedOverrideTypes.Select(overridenType =>
+                    {
+                        if (!allDefinedTypesInRecompiledFile.ContainsKey(overridenType.Key))
+                        {
+                            return overridenType;
+                        }
+
+                        return default(KeyValuePair<string, TypeDeclarationSyntax>);
+                    })
+                    .Where(kv => kv.Key != default(string))
+                    .ToList();
+
+                //types should be added either to root namespace or root of document
+                var rootNamespace = root.DescendantNodes().OfType<NamespaceDeclarationSyntax>().FirstOrDefault();
+                foreach (var overridenTypeToAdd in userDefinedOverrideTypesWithoutMatchnigInRecompiledFile)
+                {
+                    var newMember = FastScriptReloadCodeRewriterBase.AddRewriteCommentIfNeeded(overridenTypeToAdd.Value,
+                        "New type defined in override file", 
+                        true, //always write reason so it's not easy to miss in generated file
+                        true);
+                    if (rootNamespace != null)
+                    {
+                        rootNamespace =
+                            root.DescendantNodes().OfType<NamespaceDeclarationSyntax>()
+                                .FirstOrDefault(); //need to search again to make sure it didn't change
+                        var newRootNamespace = rootNamespace.AddMembers(newMember);
+                        root = root.ReplaceNode(rootNamespace, newRootNamespace);
+                    }
+                    else
+                    {
+                        root = ((CompilationUnitSyntax)root).AddMembers(newMember);
+                    }
+                }
+            }
+            catch (Exception e)
+            {
+                Debug.LogError($"Unable to add user defined override types. {e}");
+            }
+
+            return root;
+        }
+
+        private static bool TryResolveUserDefinedOverridesRoot(string sourceCodeFile, List<string> definedPreprocessorSymbols, out SyntaxNode userDefinedOverridesRoot)
+        {
+            if (ScriptGenerationOverridesManager.TryGetScriptOverride(new FileInfo(sourceCodeFile), out var userDefinedOverridesFile))
+            {
+                try
+                {
+                    userDefinedOverridesRoot = CSharpSyntaxTree.ParseText(File.ReadAllText(userDefinedOverridesFile.FullName), new CSharpParseOptions(preprocessorSymbols: definedPreprocessorSymbols)).GetRoot();
+                    return true;
+                }
+                catch (Exception ex)
+                {
+                    Debug.LogError($"Unable to resolve user defined overrides for file: '{userDefinedOverridesFile.FullName}' - please make sure it's compilable. Error: '{ex}'");
+                }
+            }
+
+            userDefinedOverridesRoot = null;
+            return false;
+        }
+
+        private static SyntaxNode ProcessUserDefinedOverridesReplacements(string sourceCodeFile, SyntaxNode root, SyntaxNode userDefinedOverridesRoot)
+        {
+            if (ScriptGenerationOverridesManager.TryGetScriptOverride(new FileInfo(sourceCodeFile), out var userDefinedOverridesFile))
+            {
+                try
+                {
+                    var userDefinedScriptOverridesRewriter = new ManualUserDefinedScriptOverridesRewriter(userDefinedOverridesRoot, 
+                        true); //always write rewrite reason so it's not easy to miss
+                    root = userDefinedScriptOverridesRewriter.Visit(root);
+                }
+                catch (Exception ex)
+                {
+                    Debug.LogError($"Unable to resolve user defined overrides for file: '{userDefinedOverridesFile.FullName}' - please make sure it's compilable. Error: '{ex}'");
+                }
+            }
+
+            return root;
+        }
+
+        protected static List<string> ResolveReferencesToAdd(List<string> excludeAssyNames)
+        {
+            var referencesToAdd = new List<string>();
+            foreach (var assembly in AppDomain.CurrentDomain
+                         .GetAssemblies() //TODO: PERF: just need to load once and cache? or get assembly based on changed file only?
+                         .Where(a => excludeAssyNames.All(assyName => !a.FullName.StartsWith(assyName))
+												&& CustomAttributeExtensions.GetCustomAttribute<DynamicallyCreatedAssemblyAttribute>((Assembly)a) == null))
+            {
+                try
+                {
+                    if (string.IsNullOrEmpty(assembly.Location))
+                    {
+                        LoggerScoped.LogDebug($"FastScriptReload: Assembly location is null, usually dynamic assembly, harmless.");
+                        continue;
+                    }
+
+                    referencesToAdd.Add(assembly.Location);
+                }
+                catch (Exception)
+                {
+                    LoggerScoped.LogDebug($"Unable to add a reference to assembly as unable to get location or null: {assembly.FullName} when hot-reloading, this is likely dynamic assembly and won't cause issues");
+                }
+            }
+            
+            referencesToAdd = referencesToAdd.Where(r => !ReferencesExcludedFromHotReload.Any(rTe => r.EndsWith(rTe))).ToList();
+
+            if (EnableExperimentalThisCallLimitationFix || FastScriptReloadManager.Instance.AssemblyChangesLoaderEditorOptionsNeededInBuild.EnableExperimentalAddedFieldsSupport)
+            {
+	            IncludeMicrosoftCsharpReferenceToSupportDynamicKeyword(referencesToAdd);
+            }
+
+            return referencesToAdd;
+        }
+
+        private static void IncludeMicrosoftCsharpReferenceToSupportDynamicKeyword(List<string> referencesToAdd)
+        {
+	        //TODO: check .net4.5 backend not breaking?
+	        //ThisRewriters will cast to dynamic - if using .NET Standard 2.1 - reference is required
+	        referencesToAdd.Add(AssemblyCsharpFullPath);
+	        // referencesToAdd.Add(@"C:\Program Files\Unity\Hub\Editor\2021.3.12f1\Editor\Data\UnityReferenceAssemblies\unity-4.8-api\Microsoft.CSharp.dll");
+        }
+    }
+
+    public class CreateSourceCodeCombinedContentsResult
+    {
+        public string SourceCode { get; }
+        public List<string> TypeNamesDefinitions { get; }
+
+        public CreateSourceCodeCombinedContentsResult(string sourceCode, List<string> typeNamesDefinitions)
+        {
+            SourceCode = sourceCode;
+            TypeNamesDefinitions = typeNamesDefinitions;
+        }
+    }
+
+    public class SourceCodeHasErrorsException : Exception
+    {
+        public SourceCodeHasErrorsException(IEnumerable<Diagnostic> errorDiagnostics) : base(MakeMessage(errorDiagnostics))
+        {
+        }
+
+        private static string MakeMessage(IEnumerable<Diagnostic> errorDiagnostics)
+            => "Failed to compile the original source code. The compiler found the following errors:"
+            + Environment.NewLine
+            + Environment.NewLine
+            + string.Join(Environment.NewLine, errorDiagnostics.Select(d => d.ToString()));
+    }
+}
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 4301ea2066a04de58f95c515e910ae3e
+timeCreated: 1669637741
+AssetOrigin:
+  serializedVersion: 1
+  productId: 239351
+  packageName: Fast Script Reload
+  packageVersion: 1.6.1
+  assetPath: Assets/FastScriptReload/Scripts/Editor/Compilation/DynamicCompilationBase.cs
+  uploadId: 710802
@@ -0,0 +1,64 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using UnityEngine;
+
+#if FastScriptReload_CompileViaMCS
+public class McsExeDynamicCompilation : DynamicCompilationBase
+{
+    private const int ReferenceLenghtCountWarningThreshold = 32767 - 2000; //windows can accept up to 32767 chars as args, then it starts thorowing exceptions. MCS.exe is adding references via command /r:<full path>
+    
+    private static CompileResult Compile(List<string> filePathsWithSourceCode)
+    {
+        var fileSourceCode = filePathsWithSourceCode.Select(File.ReadAllText);
+
+        var providerOptions = new Dictionary<string, string>();
+        var provider = new Microsoft.CSharp.CSharpCodeProvider(providerOptions);
+        var param = new  System.CodeDom.Compiler.CompilerParameters();
+
+        var excludeAssyNames = new List<string> 
+        {
+            "mscorlib"
+        };
+        var referencesToAdd = ResolveReferencesToAdd(excludeAssyNames);
+
+        var referencePathCharLenght = referencesToAdd.Sum(r => r.Length);
+        if (referencePathCharLenght > ReferenceLenghtCountWarningThreshold)
+        {
+            LoggerScoped.LogWarning(
+                "Windows can accept up to 32767 chars as args, then it starts throwing exceptions. Dynamic compilation will use MCS.exe and will add references via command /r:<full path>, " +
+                $"currently your assembly have {referencesToAdd.Count} references which full paths amount to: {referencePathCharLenght} chars." +
+                $"\r\nIf you see this warning likely compilation will fail, you can:" +
+                $"\r\n1) Move your project to be more top-level, as references take full paths, eg 'c:\\my-source\\stuff\\unity\\my-project\\' - this then gets repeated for many references, moving it close to top level will help" +
+                $"\r\n2) Remove some of the assemblies if you don't need them" +
+                "\r\n Please let me know via support email if that's causing you issues, there may be a fix if it's affecting many users, sorry about that!");
+
+            //TODO: the process is started from Microsoft.CSharp.CSharpCodeGenerator.FromFileBatch, potentially all it'd be possible to patch that class to maybe copy all
+            //assemblies to some top-level location and change parameters to run from this folder, with a working directory set, this would drastically reduce char count used by full refs
+            //also mcs.exe allows to compile with -pkg:package1[,packageN], which somewhat bundles multiple references, maybe all unity engine refs could go in there, or all refs in general
+        }
+
+        param.ReferencedAssemblies.AddRange(referencesToAdd.ToArray());
+        param.GenerateExecutable = false;
+        param.GenerateInMemory = false;
+        providerOptions.Add(PatchMcsArgsGeneration.PreprocessorDirectivesProviderOptionsKey,
+            string.Join(";", ActiveScriptCompilationDefines));
+        
+        var sourceCodeCombined = CreateSourceCodeCombinedContents(fileSourceCode);
+        var result = provider.CompileAssemblyFromSource(param, sourceCodeCombined, DynamicallyCreatedAssemblyAttributeSourceCode);
+        var errors = new List<string>();
+        foreach (var error in result.Errors)
+        {
+            errors.Add(error.ToString());
+        }
+        return new CompileResult(
+            result.CompiledAssembly.FullName,
+            errors,
+            result.NativeCompilerReturnValue,
+            result.CompiledAssembly,
+            sourceCodeCombined,
+            string.Empty
+        );
+    }
+}
+#endif
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 5a359917ce85466389622feaf196d024
+timeCreated: 1669637866
+AssetOrigin:
+  serializedVersion: 1
+  productId: 239351
+  packageName: Fast Script Reload
+  packageVersion: 1.6.1
+  assetPath: Assets/FastScriptReload/Scripts/Editor/Compilation/McsExeDynamicCompilation.cs
+  uploadId: 710802
@@ -0,0 +1,110 @@
+#if FastScriptReload_CompileViaMCS
+using System;
+using System.CodeDom.Compiler;
+using System.Collections.Generic;
+using System.Text;
+using FastScriptReload.Runtime;
+using HarmonyLib;
+using UnityEditor;
+
+[InitializeOnLoad]
+[PreventHotReload]
+public class PatchMcsArgsGeneration
+{
+    public const string PreprocessorDirectivesProviderOptionsKey = "PreprocessorDirectives";
+
+    static PatchMcsArgsGeneration()
+    {
+        var harmony = new Harmony(nameof(PatchMcsArgsGeneration));
+
+        var original = AccessTools.Method("Microsoft.CSharp.CSharpCodeGenerator:BuildArgs");
+        var postfix = AccessTools.Method(typeof(PatchMcsArgsGeneration), nameof(BuildArgsPostfix));
+
+        harmony.Patch(original, postfix: new HarmonyMethod(postfix));
+    }
+    
+    //Copied from Microsoft.CSharp.CSharpCodeGenerator.BuildArgs
+    private static void BuildArgsPostfix(
+        CompilerParameters options,
+        string[] fileNames,
+        IDictionary<string, string> providerOptions,
+        ref string __result)
+    {
+        StringBuilder stringBuilder = new StringBuilder();
+        if (options.GenerateExecutable)
+            stringBuilder.Append("/target:exe ");
+        else
+            stringBuilder.Append("/target:library ");
+        string privateBinPath = AppDomain.CurrentDomain.SetupInformation.PrivateBinPath;
+        if (privateBinPath != null && privateBinPath.Length > 0)
+            stringBuilder.AppendFormat("/lib:\"{0}\" ", (object) privateBinPath);
+        if (options.Win32Resource != null)
+            stringBuilder.AppendFormat("/win32res:\"{0}\" ", (object) options.Win32Resource);
+        if (options.IncludeDebugInformation)
+            stringBuilder.Append("/debug+ /optimize- ");
+        else
+            stringBuilder.Append("/debug- /optimize+ ");
+        if (options.TreatWarningsAsErrors)
+            stringBuilder.Append("/warnaserror ");
+        if (options.WarningLevel >= 0)
+            stringBuilder.AppendFormat("/warn:{0} ", (object) options.WarningLevel);
+        if (options.OutputAssembly == null || options.OutputAssembly.Length == 0)
+        {
+            string extension = options.GenerateExecutable ? "exe" : "dll"; //TODO:readd
+            // options.OutputAssembly = CSharpCodeGenerator.GetTempFileNameWithExtension(options.TempFiles, extension, !options.GenerateInMemory);
+        }
+        stringBuilder.AppendFormat("/out:\"{0}\" ", (object) options.OutputAssembly);
+        foreach (string referencedAssembly in options.ReferencedAssemblies)
+        {
+            if (referencedAssembly != null && referencedAssembly.Length != 0)
+                stringBuilder.AppendFormat("/r:\"{0}\" ", (object) referencedAssembly);
+        }
+        if (options.CompilerOptions != null)
+        {
+            stringBuilder.Append(options.CompilerOptions);
+            stringBuilder.Append(" ");
+        }
+        foreach (string embeddedResource in options.EmbeddedResources)
+            stringBuilder.AppendFormat("/resource:\"{0}\" ", (object) embeddedResource);
+        foreach (string linkedResource in options.LinkedResources)
+            stringBuilder.AppendFormat("/linkresource:\"{0}\" ", (object) linkedResource);
+        
+        //WARN: that's how it's in source, quite odd, doesn't do much if compiler version specified?
+        // if (providerOptions != null && providerOptions.Count > 0)
+        // {
+        //     string str;
+        //     if (!providerOptions.TryGetValue("CompilerVersion", out str))
+        //         str = "3.5";
+        //     if (str.Length >= 1 && str[0] == 'v')
+        //         str = str.Substring(1);
+        //     if (str != "2.0")
+        //     {
+        //     }
+        //     else
+        //         stringBuilder.Append("/langversion:ISO-2 ");  
+        // }
+        
+        stringBuilder.Append("/langversion:experimental ");   
+        
+        CustomPatchAdditionAddPreprocessorDirectives(providerOptions, stringBuilder);
+
+        stringBuilder.Append("/noconfig ");
+        stringBuilder.Append(" -- ");
+        foreach (string fileName in fileNames)
+            stringBuilder.AppendFormat("\"{0}\" ", (object) fileName);
+
+        __result = stringBuilder.ToString();
+    }
+
+    private static void CustomPatchAdditionAddPreprocessorDirectives(IDictionary<string, string> providerOptions, StringBuilder stringBuilder)
+    {
+        if (providerOptions != null && providerOptions.Count > 0)
+        {
+            if (providerOptions.TryGetValue(PreprocessorDirectivesProviderOptionsKey, out var preprocessorDirectives))
+            {
+                stringBuilder.Append($"/d:\"{preprocessorDirectives}\" ");
+            }
+        }
+    }
+}
+#endif
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 26428224dc3f4d069690c15cbfb3a070
+timeCreated: 1669209480
+AssetOrigin:
+  serializedVersion: 1
+  productId: 239351
+  packageName: Fast Script Reload
+  packageVersion: 1.6.1
+  assetPath: Assets/FastScriptReload/Scripts/Editor/Compilation/PatchMcsArgsGeneration.cs
+  uploadId: 710802
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: a9e1198b8d42486bae230272101c0951
+timeCreated: 1678099546
@@ -0,0 +1,207 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using FastScriptReload.Runtime;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using UnityEditor;
+using UnityEditorInternal;
+using UnityEngine;
+
+namespace FastScriptReload.Editor.Compilation.ScriptGenerationOverrides
+{
+    [InitializeOnLoad]
+    public static class ScriptGenerationOverridesManager
+    {
+        private static float LoadOverridesFolderFilesEveryNSeconds = 5;
+        
+        private static readonly string TemplateInterfaceDeclaration = @"
+
+//New interface declaration, this is very useful in cases where code depends on some internal interfaces that re-compiled code can no longer access. Simply define them here and code will compile.
+//You can add any type in that manner
+public interface ITestNewInterface {
+    bool Test { get; set; }
+}";
+
+        private static readonly string TemplateTopComment = @"// You can use this file to specify custom code overrides. Those will be applied to resulting code.
+// This approach is very useful if your code is failing to compile due to one of the existing limitations.
+// 
+//  While I work on reducing limitations you can simply specify override with proper code to make sure you can continue working.
+// 
+// 1) Simply define code with same structure as your original class, make sure to include any namespace.
+// 2) Rename classes and types to have '<ClassPostfix>' postfix.
+// 
+// eg. 'MyClassName' needs to be changed to MyClassName<ClassPostfix> otherwise it won't be properly connected.
+//
+// 3) Add any methods that you want to override, using same method signature. Whole method body will be replaced and no code adjustments will be run on it.
+// 4) You can add any additional types - this is quite useful when you hit limitation with internal interfaces - where compiler can not access them due to protection modifiers. 
+// You can simply redefine those here, while not ideal it'll allow you to continue using Hot-Reload without modifying your code.
+// 
+// Tool will now attempt to create a template file for you with first found class and first method as override, please adjust as necessary. 
+// It'll also create an example redefined interface.
+// If you can't see anything please refer to the above and create overrides file manually.
+// 
+// You can also refer to documentation section 'User defined script rewrite overrides'
+";
+
+        public static DirectoryInfo UserDefinedScriptRewriteOverridesFolder { get; }
+        private static double _lastTimeOverridesFolderFilesRead;
+
+        public static List<UserDefinedScriptOverride> UserDefinedScriptOverrides { get; } = new List<UserDefinedScriptOverride>();
+
+        static ScriptGenerationOverridesManager()
+        {
+            //TODO: allow to customize later from code, eg for user that'd like to include in source control
+            UserDefinedScriptRewriteOverridesFolder = new DirectoryInfo(Application.persistentDataPath + @"\FastScriptReload\ScriptOverrides");
+            UpdateUserDefinedScriptOverridesFileCache();
+            EditorApplication.update += Update;
+        }
+
+        private static void Update()
+        {
+            var timeSinceStartup = EditorApplication.timeSinceStartup;
+            if (_lastTimeOverridesFolderFilesRead + LoadOverridesFolderFilesEveryNSeconds < timeSinceStartup)
+            {
+                _lastTimeOverridesFolderFilesRead = timeSinceStartup;
+
+                UpdateUserDefinedScriptOverridesFileCache();
+            }
+        }
+
+        private static void UpdateUserDefinedScriptOverridesFileCache()
+        {
+            UserDefinedScriptOverrides.Clear();
+            if (UserDefinedScriptRewriteOverridesFolder.Exists)
+            {
+                UserDefinedScriptOverrides.AddRange(UserDefinedScriptRewriteOverridesFolder.GetFiles().Select(f => new UserDefinedScriptOverride(f)));
+            }
+        }
+
+        public static void AddScriptOverride(MonoScript script)
+        {
+            AddScriptOverride(new FileInfo(Path.Combine(Path.Combine(Application.dataPath + "//..", AssetDatabase.GetAssetPath(script)))));
+        }
+
+        public static void AddScriptOverride(FileInfo originalFile)
+        {
+            EnsureOverrideFolderExists();
+
+            var overridenFile = new FileInfo(Path.Combine(UserDefinedScriptRewriteOverridesFolder.FullName, originalFile.Name));
+            if (!overridenFile.Exists)
+            {
+                var templateString = string.Empty;
+                try
+                {
+                    var fileCode = File.ReadAllText(originalFile.FullName);
+                    var tree = CSharpSyntaxTree.ParseText(fileCode, new CSharpParseOptions(preprocessorSymbols: DynamicCompilationBase.ActiveScriptCompilationDefines));
+                    var root = tree.GetRoot();
+
+                    var firstType = root.DescendantNodes().OfType<ClassDeclarationSyntax>().FirstOrDefault();
+                    if (firstType != null)
+                    {
+                        var members = new SyntaxList<MemberDeclarationSyntax>();
+                        var firstMethod = firstType.DescendantNodes().OfType<MethodDeclarationSyntax>().FirstOrDefault(m => m.Body != null);
+                        if (firstMethod != null)
+                        {
+                            var block = SyntaxFactory.Block();
+                            block = block.AddStatements(SyntaxFactory.EmptyStatement().WithLeadingTrivia(
+                                SyntaxFactory.Comment(@"/* Any code will be replaced with original method of same signature in same type*/"))
+                            );
+                            firstMethod = firstMethod
+                                .WithBody(block)
+                                .WithTriviaFrom(firstMethod);
+                            members = members.Add(firstMethod);
+                        }
+                        
+                        root = root.ReplaceNode(firstType, firstType
+                            .ReplaceToken(
+                                firstType.Identifier, 
+                                SyntaxFactory.Identifier(firstType.Identifier.ValueText + AssemblyChangesLoader.ClassnamePatchedPostfix)
+                            )
+                            .WithMembers(members)).NormalizeWhitespace();
+
+                        var interfaceDeclaration = CSharpSyntaxTree.ParseText(TemplateInterfaceDeclaration);
+                        
+                        root = ((CompilationUnitSyntax)root).AddMembers(
+                            interfaceDeclaration.GetRoot().DescendantNodes().OfType<InterfaceDeclarationSyntax>().First()
+                        );
+                    }
+
+                    templateString = root.ToFullString();
+                }
+                catch (Exception e)
+                {
+                    Debug.LogError($"Unable to generate user defined script override template from your file, please refer to note at the start of the file. {e}");
+                }
+
+                if (!overridenFile.Exists)
+                {
+                    File.WriteAllText(overridenFile.FullName, 
+                        TemplateTopComment.Replace("<ClassPostfix>", AssemblyChangesLoader.ClassnamePatchedPostfix) + templateString
+                    );
+                    UpdateUserDefinedScriptOverridesFileCache();
+                }
+            }
+            
+            InternalEditorUtility.OpenFileAtLineExternal(overridenFile.FullName, 0);
+        }
+        
+        public static bool TryRemoveScriptOverride(MonoScript originalScript)
+        {
+            EnsureOverrideFolderExists();
+
+            var overridenFile = new FileInfo(Path.Combine(UserDefinedScriptRewriteOverridesFolder.FullName, originalScript.name + ".cs"));
+            if (overridenFile.Exists)
+            {
+                return TryRemoveScriptOverride(overridenFile);
+            }
+
+            return false;
+        }
+
+        private static bool TryRemoveScriptOverride(FileInfo overridenFile)
+        {
+            try
+            {
+                overridenFile.Delete();
+                UpdateUserDefinedScriptOverridesFileCache();
+            }
+            catch (Exception)
+            {
+                Debug.Log($"Unable to remove: '{overridenFile.Name}' - make sure it's not locked / open in editor");
+                throw;
+            }
+
+            return true;
+        }
+
+        public static bool TryRemoveScriptOverride(UserDefinedScriptOverride scriptOverride)
+        {
+            return TryRemoveScriptOverride(scriptOverride.File);
+        }
+
+        public static bool TryGetScriptOverride(FileInfo changedFile, out FileInfo overridesFile)
+        {
+            overridesFile = UserDefinedScriptOverrides.FirstOrDefault(f => f.File.Name == changedFile.Name && f.File.Exists)?.File;
+            return overridesFile?.Exists ?? false;
+        }
+        
+        private static void EnsureOverrideFolderExists()
+        {
+            if (!UserDefinedScriptRewriteOverridesFolder.Exists)
+                UserDefinedScriptRewriteOverridesFolder.Create();
+        }
+    }
+
+    public class UserDefinedScriptOverride
+    {
+        public FileInfo File { get; }
+
+        public UserDefinedScriptOverride(FileInfo file)
+        {
+            File = file;
+        }
+    }
+}
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: f699ee76d75a40b290cad5dd79619842
+timeCreated: 1678099566
+AssetOrigin:
+  serializedVersion: 1
+  productId: 239351
+  packageName: Fast Script Reload
+  packageVersion: 1.6.1
+  assetPath: Assets/FastScriptReload/Scripts/Editor/Compilation/ScriptGenerationOverrides/ScriptGenerationOverridesManager.cs
+  uploadId: 710802