7,013 Commits over 3,561 Days - 0.08cph!
Failing test involving generics causing EntryPointNotFoundException
Fixed resolving generic methods
Fixed possible stack overflow when fixing references
Expanded GenericReference test to help investigate
Replacing method now thinks it's inside the original assembly
Fixed references to the wrong assembly in fast hotload
Don't need to relink variable types
Expanded GenericReference test to help investigate
Replacing method now thinks it's inside the original assembly
Failing test involving generics causing EntryPointNotFoundException
Fixed resolving generic methods
Fixed possible stack overflow when fixing references
Added failing test for changing the body of a lambda
Fixed not being able to resolve private nested types
Fixed #947
Failing test for async methods
#947
Fixed #947 for state machine types
Some safety if ILHotload AST processing throws during Parallel.ForEach
Only run ILHotload AST processing when hotload_fast >= 1
Fixed #947 for state machine types
Failing test for async methods
#947
Added failing test for changing the body of a lambda
Fixed not being able to resolve private nested types
Fall back to normal hotload if exception is thrown during FixReferences
Fast method body hotload (#931)
* 0ms hotload fast path poc when only method bodies change using MonoMod
* Print individual changes during compile, show node paths
* WIP check if all changes are in method bodies
* Add attributes to package assemblies describing changed methods
* SupportsILHotloadAttribute is added if only method bodies change
* MethodBodyChangeAttribute is added for each changed method
* ILHotload looks for SupportsILHotload and MethodBodyChange attributes
* Fixed methods with identical IL not being replaced by ILHotload
* ILHotload should never run with a debugger attached
* Clean up dead code
* Detour using a generated dynamic method copy from the replacing method
* Documentation for Compiler.SyntaxTree.cs
* Added CompilerSettings.SourcePathFilter predicate
* Boilerplate for writing ILHotload tests
* Fixed how file changes are emulated in FastPathTest
* A bit more flexibility in fast path test case code preprocessing
* Added failing fast path hotload test for changing method signatures
* ILHotload: changes must be specifically within a BlockSyntax of a method
* Added Compiler.UpdateParseOptions() for tests to use
* Don't use ILHotload if a preprocessor define changed
* Incremental syntax tree parsing
* Throw when trying to debug an ILHotload swap during a test
* Basic incremental compilation
* Make generated code more deterministic, nicer for incremental compile
* Keep track of which assembly types are actually loaded from
* Re-use compiler options where possible
* Changed fast hotload log to a trace
* Make OnlyMethodBodiesChanged multithreaded, fixed multiple changes in one file
* Failing test for property body changes
* Cleanup ILHotload tests, failing test for overloaded method
* Refactor AST processing for ILHotload
* Fixes after refactor, a bit ugly at the moment
* Support fast hotload for property accessors
* NoticeWidget shows ms if duration < 1s
* Call UISystem.OnHotload after an ILHotload
* ILHotload test for nested blocks
* Fixed ILHotload change detection for nested blocks
* Added hotload_fast engine convar to enable / disable IL hotload
* Added failing test of typeof(T) in method body hotloads
* Failing test for static references
* Fix references to members / types in fast-hotloaded method bodies
* Allow debugging ILHotload in Sandbox.Test
* Test for fast-hotloaded methods with parameter / return types defined in the changed module
* Added failing fast hotload test for compiler-generated type changes
* Don't attempt fast hotload if any compiler-generated type definitions change
* Record event when we ILHotload, matches naming of existing hotloads so we can derive % easily
* Remove defunct code about using cecil as the DMDType, not needed since we fix the references ourselves
---------
Co-authored-by: Matt Stevens <matt@mattstevens.co.uk>
Don't attempt fast hotload if any compiler-generated type definitions change
Will happen if you change / add / remove things like lambda methods
Added failing fast hotload test for compiler-generated type changes
0ms hotload fast path poc when only method bodies change using MonoMod
Biggest flaw of this is detecting the changes, Ziks has some good ideas with comparing the AST
https://files.facepunch.com/matt/1b2611b1/sbox-dev_My23jH4uYG.mp4
Print individual changes during compile, show node paths
WIP check if all changes are in method bodies
Add attributes to package assemblies describing changed methods
* SupportsILHotloadAttribute is added if only method bodies change
* MethodBodyChangeAttribute is added for each changed method
Yet to properly support nested declaring types and methods with overloads.
ILHotload looks for SupportsILHotload and MethodBodyChange attributes
Fixed methods with identical IL not being replaced by ILHotload
ILHotload should never run with a debugger attached
Clean up dead code
Detour using a generated dynamic method copy from the replacing method
Documentation for Compiler.SyntaxTree.cs
Added CompilerSettings.SourcePathFilter predicate
Boilerplate for writing ILHotload tests
Fixed how file changes are emulated in FastPathTest
A bit more flexibility in fast path test case code preprocessing
Added failing fast path hotload test for changing method signatures
ILHotload: changes must be specifically within a BlockSyntax of a method
Added Compiler.UpdateParseOptions() for tests to use
Don't use ILHotload if a preprocessor define changed
Incremental syntax tree parsing
Throw when trying to debug an ILHotload swap during a test
Basic incremental compilation
Make generated code more deterministic, nicer for incremental compile
Keep track of which assembly types are actually loaded from
Re-use compiler options where possible
Changed fast hotload log to a trace
Make OnlyMethodBodiesChanged multithreaded, fixed multiple changes in one file
Failing test for property body changes
Cleanup ILHotload tests, failing test for overloaded method
Refactor AST processing for ILHotload
Moved to Sandbox.Generator, and now tags changed methods with an attribute rather than referencing them from assembly-level attributes
Fixes after refactor, a bit ugly at the moment
Support fast hotload for property accessors
NoticeWidget shows ms if duration < 1s
Call UISystem.OnHotload after an ILHotload
ILHotload test for nested blocks
Fixed ILHotload change detection for nested blocks
Added hotload_fast engine convar to enable / disable IL hotload
Added failing test of typeof(T) in method body hotloads
Failing test for static references
Fix references to members / types in fast-hotloaded method bodies
Allow debugging ILHotload in Sandbox.Test
Test for fast-hotloaded methods with parameter / return types defined in the changed module
Test for fast-hotloaded methods with parameter / return types defined in the changed module
Fix references to members / types in fast-hotloaded method bodies
Allow debugging ILHotload in Sandbox.Test
Added failing test of typeof(T) in method body hotloads
0ms hotload fast path poc when only method bodies change using MonoMod
Biggest flaw of this is detecting the changes, Ziks has some good ideas with comparing the AST
https://files.facepunch.com/matt/1b2611b1/sbox-dev_My23jH4uYG.mp4
Print individual changes during compile, show node paths
WIP check if all changes are in method bodies
Add attributes to package assemblies describing changed methods
* SupportsILHotloadAttribute is added if only method bodies change
* MethodBodyChangeAttribute is added for each changed method
Yet to properly support nested declaring types and methods with overloads.
ILHotload looks for SupportsILHotload and MethodBodyChange attributes
Fixed methods with identical IL not being replaced by ILHotload
ILHotload should never run with a debugger attached
Clean up dead code
Detour using a generated dynamic method copy from the replacing method
Documentation for Compiler.SyntaxTree.cs
Added CompilerSettings.SourcePathFilter predicate
Boilerplate for writing ILHotload tests
Fixed how file changes are emulated in FastPathTest
A bit more flexibility in fast path test case code preprocessing
Added failing fast path hotload test for changing method signatures
ILHotload: changes must be specifically within a BlockSyntax of a method
Added Compiler.UpdateParseOptions() for tests to use
Don't use ILHotload if a preprocessor define changed
Incremental syntax tree parsing
Throw when trying to debug an ILHotload swap during a test
Basic incremental compilation
Make generated code more deterministic, nicer for incremental compile
Keep track of which assembly types are actually loaded from
Re-use compiler options where possible
Changed fast hotload log to a trace
Make OnlyMethodBodiesChanged multithreaded, fixed multiple changes in one file
Failing test for property body changes
Cleanup ILHotload tests, failing test for overloaded method
Refactor AST processing for ILHotload
Moved to Sandbox.Generator, and now tags changed methods with an attribute rather than referencing them from assembly-level attributes
Fixes after refactor, a bit ugly at the moment
Support fast hotload for property accessors
NoticeWidget shows ms if duration < 1s
Call UISystem.OnHotload after an ILHotload
ILHotload test for nested blocks
Fixed ILHotload change detection for nested blocks
Added hotload_fast engine convar to enable / disable IL hotload
Handle encountering MethodBase operands in GetStackDelta
0ms hotload fast path poc when only method bodies change using MonoMod
Biggest flaw of this is detecting the changes, Ziks has some good ideas with comparing the AST
https://files.facepunch.com/matt/1b2611b1/sbox-dev_My23jH4uYG.mp4
Print individual changes during compile, show node paths
WIP check if all changes are in method bodies
Add attributes to package assemblies describing changed methods
* SupportsILHotloadAttribute is added if only method bodies change
* MethodBodyChangeAttribute is added for each changed method
Yet to properly support nested declaring types and methods with overloads.
ILHotload looks for SupportsILHotload and MethodBodyChange attributes
Fixed methods with identical IL not being replaced by ILHotload
ILHotload should never run with a debugger attached
Clean up dead code
Detour using a generated dynamic method copy from the replacing method
Documentation for Compiler.SyntaxTree.cs
Added CompilerSettings.SourcePathFilter predicate
Boilerplate for writing ILHotload tests
Fixed how file changes are emulated in FastPathTest
A bit more flexibility in fast path test case code preprocessing
Added failing fast path hotload test for changing method signatures
ILHotload: changes must be specifically within a BlockSyntax of a method
Added Compiler.UpdateParseOptions() for tests to use
Don't use ILHotload if a preprocessor define changed
Incremental syntax tree parsing
Throw when trying to debug an ILHotload swap during a test
Basic incremental compilation
Make generated code more deterministic, nicer for incremental compile
Keep track of which assembly types are actually loaded from
Re-use compiler options where possible
Changed fast hotload log to a trace
Make OnlyMethodBodiesChanged multithreaded, fixed multiple changes in one file
Failing test for property body changes
Cleanup ILHotload tests, failing test for overloaded method
Refactor AST processing for ILHotload
Moved to Sandbox.Generator, and now tags changed methods with an attribute rather than referencing them from assembly-level attributes
Fixes after refactor, a bit ugly at the moment
Support fast hotload for property accessors
NoticeWidget shows ms if duration < 1s
Call UISystem.OnHotload after an ILHotload
ILHotload test for nested blocks
Fixed ILHotload change detection for nested blocks
Added hotload_fast engine convar to enable / disable IL hotload
0ms hotload fast path poc when only method bodies change using MonoMod
Biggest flaw of this is detecting the changes, Ziks has some good ideas with comparing the AST
https://files.facepunch.com/matt/1b2611b1/sbox-dev_My23jH4uYG.mp4
Print individual changes during compile, show node paths
WIP check if all changes are in method bodies
Add attributes to package assemblies describing changed methods
* SupportsILHotloadAttribute is added if only method bodies change
* MethodBodyChangeAttribute is added for each changed method
Yet to properly support nested declaring types and methods with overloads.
ILHotload looks for SupportsILHotload and MethodBodyChange attributes
Fixed methods with identical IL not being replaced by ILHotload
ILHotload should never run with a debugger attached
Clean up dead code
Detour using a generated dynamic method copy from the replacing method
Documentation for Compiler.SyntaxTree.cs
Added CompilerSettings.SourcePathFilter predicate
Boilerplate for writing ILHotload tests
Fixed how file changes are emulated in FastPathTest
A bit more flexibility in fast path test case code preprocessing
Added failing fast path hotload test for changing method signatures
ILHotload: changes must be specifically within a BlockSyntax of a method
Added Compiler.UpdateParseOptions() for tests to use
Don't use ILHotload if a preprocessor define changed
Incremental syntax tree parsing
Throw when trying to debug an ILHotload swap during a test
Basic incremental compilation
Make generated code more deterministic, nicer for incremental compile
Keep track of which assembly types are actually loaded from
Re-use compiler options where possible
Changed fast hotload log to a trace
Make OnlyMethodBodiesChanged multithreaded, fixed multiple changes in one file
Failing test for property body changes
Cleanup ILHotload tests, failing test for overloaded method
Refactor AST processing for ILHotload
Moved to Sandbox.Generator, and now tags changed methods with an attribute rather than referencing them from assembly-level attributes
Fixes after refactor, a bit ugly at the moment
Support fast hotload for property accessors
NoticeWidget shows ms if duration < 1s
Call UISystem.OnHotload after an ILHotload
ILHotload test for nested blocks
Fixed ILHotload change detection for nested blocks
More helpful error message when trying to get default value of new field
Warn rather than throw if a dictionary key becomes null
Failing test reproducing #933
Warn when unable to find a scope method, instead of error
Fixed error delegates causing an error themselves on upgrade
Fixes #933
NoticeWidget shows ms if duration < 1s
Call UISystem.OnHotload after an ILHotload
ILHotload test for nested blocks
Fixed ILHotload change detection for nested blocks
0ms hotload fast path poc when only method bodies change using MonoMod
Biggest flaw of this is detecting the changes, Ziks has some good ideas with comparing the AST
https://files.facepunch.com/matt/1b2611b1/sbox-dev_My23jH4uYG.mp4
Print individual changes during compile, show node paths
WIP check if all changes are in method bodies
Add attributes to package assemblies describing changed methods
* SupportsILHotloadAttribute is added if only method bodies change
* MethodBodyChangeAttribute is added for each changed method
Yet to properly support nested declaring types and methods with overloads.
ILHotload looks for SupportsILHotload and MethodBodyChange attributes
Fixed methods with identical IL not being replaced by ILHotload
ILHotload should never run with a debugger attached
Clean up dead code
Detour using a generated dynamic method copy from the replacing method
Documentation for Compiler.SyntaxTree.cs
Added CompilerSettings.SourcePathFilter predicate
Boilerplate for writing ILHotload tests
Fixed how file changes are emulated in FastPathTest
A bit more flexibility in fast path test case code preprocessing
Added failing fast path hotload test for changing method signatures
ILHotload: changes must be specifically within a BlockSyntax of a method
Added Compiler.UpdateParseOptions() for tests to use
Don't use ILHotload if a preprocessor define changed
Incremental syntax tree parsing
Throw when trying to debug an ILHotload swap during a test
Basic incremental compilation
Make generated code more deterministic, nicer for incremental compile
Keep track of which assembly types are actually loaded from
Re-use compiler options where possible
Changed fast hotload log to a trace
Make OnlyMethodBodiesChanged multithreaded, fixed multiple changes in one file
Failing test for property body changes
Cleanup ILHotload tests, failing test for overloaded method
Refactor AST processing for ILHotload
Moved to Sandbox.Generator, and now tags changed methods with an attribute rather than referencing them from assembly-level attributes
Fixes after refactor, a bit ugly at the moment
Support fast hotload for property accessors
Hotload timing info tweaks
Added hotload_paths convar
Added EnumUpgrader
Made DefaultUpgrader more strict
WIP code gen in DefaultUpgrader
Skip IntPtr / UIntPtr
Failing test for upgrading nested structs with codegen
Fixed directly upgrading struct fields using codegen
Added failing test reproducing #929
Stricter test for #929
Fixed #929
Fixed IServerDll hotload not being able to resolve package assemblies
Fixed ReflectionExtensions.ResolveType
Used to not respect the assembly load context of the target module
Support fast hotload for property accessors
0ms hotload fast path poc when only method bodies change using MonoMod
Biggest flaw of this is detecting the changes, Ziks has some good ideas with comparing the AST
https://files.facepunch.com/matt/1b2611b1/sbox-dev_My23jH4uYG.mp4
Print individual changes during compile, show node paths
WIP check if all changes are in method bodies
Add attributes to package assemblies describing changed methods
* SupportsILHotloadAttribute is added if only method bodies change
* MethodBodyChangeAttribute is added for each changed method
Yet to properly support nested declaring types and methods with overloads.
ILHotload looks for SupportsILHotload and MethodBodyChange attributes
Fixed methods with identical IL not being replaced by ILHotload
ILHotload should never run with a debugger attached
Clean up dead code
Detour using a generated dynamic method copy from the replacing method
Documentation for Compiler.SyntaxTree.cs
Added CompilerSettings.SourcePathFilter predicate
Boilerplate for writing ILHotload tests
Fixed how file changes are emulated in FastPathTest
A bit more flexibility in fast path test case code preprocessing
Added failing fast path hotload test for changing method signatures
ILHotload: changes must be specifically within a BlockSyntax of a method
Added Compiler.UpdateParseOptions() for tests to use
Don't use ILHotload if a preprocessor define changed
Incremental syntax tree parsing
Throw when trying to debug an ILHotload swap during a test
Basic incremental compilation
Make generated code more deterministic, nicer for incremental compile
Keep track of which assembly types are actually loaded from
Re-use compiler options where possible
Changed fast hotload log to a trace
Make OnlyMethodBodiesChanged multithreaded, fixed multiple changes in one file
Failing test for property body changes
Cleanup ILHotload tests, failing test for overloaded method
Refactor AST processing for ILHotload
Moved to Sandbox.Generator, and now tags changed methods with an attribute rather than referencing them from assembly-level attributes
Fixes after refactor, a bit ugly at the moment
Fixes after refactor, a bit ugly at the moment
Refactor AST processing for ILHotload
Moved to Sandbox.Generator, and now tags changed methods with an attribute rather than referencing them from assembly-level attributes
Re-use compiler options where possible
Changed fast hotload log to a trace
Make OnlyMethodBodiesChanged multithreaded, fixed multiple changes in one file
Failing test for property body changes
Cleanup ILHotload tests, failing test for overloaded method
A bit more flexibility in fast path test case code preprocessing
Added failing fast path hotload test for changing method signatures
ILHotload: changes must be specifically within a BlockSyntax of a method
Added Compiler.UpdateParseOptions() for tests to use
Don't use ILHotload if a preprocessor define changed
Incremental syntax tree parsing
Throw when trying to debug an ILHotload swap during a test
Basic incremental compilation
Make generated code more deterministic, nicer for incremental compile
Keep track of which assembly types are actually loaded from
0ms hotload fast path poc when only method bodies change using MonoMod
Biggest flaw of this is detecting the changes, Ziks has some good ideas with comparing the AST
https://files.facepunch.com/matt/1b2611b1/sbox-dev_My23jH4uYG.mp4
Print individual changes during compile, show node paths
WIP check if all changes are in method bodies
Add attributes to package assemblies describing changed methods
* SupportsILHotloadAttribute is added if only method bodies change
* MethodBodyChangeAttribute is added for each changed method
Yet to properly support nested declaring types and methods with overloads.
ILHotload looks for SupportsILHotload and MethodBodyChange attributes
Fixed methods with identical IL not being replaced by ILHotload
ILHotload should never run with a debugger attached
Clean up dead code
Detour using a generated dynamic method copy from the replacing method
Documentation for Compiler.SyntaxTree.cs
Added CompilerSettings.SourcePathFilter predicate
Boilerplate for writing ILHotload tests
Fixed how file changes are emulated in FastPathTest
Fixed how file changes are emulated in FastPathTest
Documentation for Compiler.SyntaxTree.cs
Added CompilerSettings.SourcePathFilter predicate
Boilerplate for writing ILHotload tests
Fixed methods with identical IL not being replaced by ILHotload
Print individual changes during compile, show node paths
WIP check if all changes are in method bodies
Add attributes to package assemblies describing changed methods
* SupportsILHotloadAttribute is added if only method bodies change
* MethodBodyChangeAttribute is added for each changed method
Yet to properly support nested declaring types and methods with overloads.
ILHotload looks for SupportsILHotload and MethodBodyChange attributes
Hotload timing info tweaks
Added hotload_paths convar
Added EnumUpgrader
Made DefaultUpgrader more strict
WIP code gen in DefaultUpgrader
Skip IntPtr / UIntPtr
Failing test for upgrading nested structs with codegen
Fixed directly upgrading struct fields using codegen
Print individual changes during compile, show node paths
WIP check if all changes are in method bodies
Incremental compile proof of concept
Failing test for upgrading nested structs with codegen
Fixed directly upgrading struct fields using codegen
Hotload timing info tweaks
Added hotload_paths convar
Added EnumUpgrader
Made DefaultUpgrader more strict
WIP code gen in DefaultUpgrader
Skip IntPtr / UIntPtr
Disable detailed hotload diagnostics unless hotload_log >= 2
Box tool interaction fixes
Can draw new geometry with the box tool
MoveTool tweaks to stay aligned to the grid
ToolBar options are now checkable
Nicer behaviour when dragging nested CSGs into viewport
Fixed gizmos being invisible
Add some logging to AsyncTasks.TaskCancel2
To help investigate #210
Allow TaskSource async methods to persist, so they can cancel nicely
Use framework methods to find async state machines / tasks
A bit more protected against changes
Bump up max async task cancellation count
Get rid of debug hotload log
