file
function     FReply SModuleUI::FModuleListItem::OnRecompileClicked

	GWarn->BeginSlowTask( FText::Format( NSLOCTEXT("ModuleUI", "Recompile_SlowTaskName", "Compiling {ModuleName}..."), Args ), bShowProgressDialog, bShowCancelButton );

	// Does the module have any UObject classes in it?  If so we'll use HotReload to recompile it.
	FModuleStatus ModuleStatus;
	if( ensure( FModuleManager::Get().QueryModule( ModuleName, ModuleStatus ) ) )
	{
		//@todo This is for content-only packages that show up in the
		// Module UI... don't crash when recompile is clicked
		if (FPaths::IsProjectFilePathSet())

file
function     void RecompileGameplayAbilitiesEditor

	GWarn->BeginSlowTask( NSLOCTEXT("GameplayAbilities", "BeginRecompileGameplayAbilitiesTask", "Recompiling GameplayAbilitiesEditor Module..."), true);
	
	IHotReloadInterface* HotReload = IHotReloadInterface::GetPtr();
	if(HotReload != nullptr)
	{
		TArray< UPackage* > PackagesToRebind;
		UPackage* Package = FindPackage( NULL, TEXT("/Script/GameplayAbilitiesEditor"));
		if( Package != NULL )
		{
			PackagesToRebind.Add( Package );
		}

		HotReload->RebindPackages(PackagesToRebind, EHotReloadFlags::WaitForCompletion, *GLog);
	}

	GWarn->EndSlowTask();
}

FAutoConsoleCommand RecompileGameplayAbilitiesEditorCommand(

file
function     void RecompileReplicationGraph

	GWarn->BeginSlowTask( FText::FromString(TEXT("Recompiling rep graph")), true);
	
	IHotReloadInterface* HotReload = IHotReloadInterface::GetPtr();
	if(HotReload != nullptr)
	{
		TArray< UPackage* > PackagesToRebind;
		UPackage* Package = FindPackage( NULL, TEXT("/Script/ReplicationGraph"));
		if( Package != NULL )
		{
			PackagesToRebind.Add( Package );
		}

		HotReload->RebindPackages(PackagesToRebind, EHotReloadFlags::WaitForCompletion, *GLog);
	}

	GWarn->EndSlowTask();
}

FAutoConsoleCommand RecompileReplicationGraphCmd( TEXT("ReplicationGraph.Reload"), TEXT(""), FConsoleCommandWithArgsDelegate::CreateStatic(&RecompileReplicationGraph) );

file
function     void FFramePerformanceProvider::HandleAssetReload

	{
		FString Name = InPackageReloadedEvent->GetOldPackage()->GetFullName();
		ProviderThread->PushLoadInfo({EStageMonitorNodeStatus::HotReload, Name});
		IStageDataProvider::SendMessage<FAssetLoadingStateProviderMessage>(
			EStageMessageFlags::Reliable, EStageLoadingState::PreLoad, Name);
	}
	else if (InPackageReloadPhase == EPackageReloadPhase::PostPackageFixup)
	{
		TOptional<FFrameProviderRunner::FLoadInfo> Info = ProviderThread->PopLoadInfo();

	LoadingMap,
	Ready,
	HotReload,
	AssetCompiling
};


/**
 * Message containing information about frame timings.

file
function     FText SDataProviderTableRow::GetStatus

	case EStageMonitorNodeStatus::Ready:
		return LOCTEXT("Status_Ready", "Ready");
	case EStageMonitorNodeStatus::HotReload:
		return LOCTEXT("Status_HotReload", "Reloading");
	case EStageMonitorNodeStatus::AssetCompiling:
		return LOCTEXT("Status_AssetCompiling", "Asset Compiling");
	case EStageMonitorNodeStatus::Unknown:
		return LOCTEXT("Status_Unknown", "Unknown");
	default:

#define LOCTEXT_NAMESPACE "HotReload"

LLM_DEFINE_TAG(HotReload);

namespace EThreeStateBool
{
	enum Type
	{
		False,

file
class        class FScopedHotReload
function     FScopedHotReload

		: UniquePtr(InUniquePtr)
	{
		UniquePtr.Reset(new FReload(EActiveReloadType::HotReload, TEXT("HOTRELOAD"), InPackages, *GLog));
	}

	FScopedHotReload(TUniquePtr<FReload>& InUniquePtr)
		: UniquePtr(InUniquePtr)
	{
		UniquePtr.Reset(new FReload(EActiveReloadType::HotReload, TEXT("HOTRELOAD"), *GLog));
	}

	~FScopedHotReload()
	{
		UniquePtr.Reset();
	}

/**
 * Module for HotReload support
 */
class FHotReloadModule : public IHotReloadModule, FSelfRegisteringExec
{
public:

	FHotReloadModule()
	{
		ModuleCompileReadPipe = nullptr;

};

IMPLEMENT_MODULE(FHotReloadModule, HotReload);

namespace HotReloadDefs
{
	static const TCHAR* CompilationInfoConfigSection = TEXT("ModuleFileTracking");

	// These strings should match the values of the enum EModuleCompileMethod in ModuleManager.h

file
function     void FHotReloadModule::StartupModule

void FHotReloadModule::StartupModule()
{
	LLM_SCOPE_BYTAG(HotReload);

	UEHotReload_Private::CreateFileThatIndicatesEditorRunIfNeeded();

	bIsHotReloadingFromEditor = false;

#if WITH_ENGINE

file
function     FString FHotReloadModule::GetModuleCompileMethod

FString FHotReloadModule::GetModuleCompileMethod(FName InModuleName)
{
	LLM_SCOPE_BYTAG(HotReload);

	if (!ModuleCompileData.Contains(InModuleName))
	{
		UpdateModuleCompileData(InModuleName);
	}

file
function     void UEditorEngine::LoadDefaultEditorModules

	FModuleManager::Get().LoadModule(TEXT("LogVisualizer"));
	FModuleManager::Get().LoadModule(TEXT("WidgetRegistration"));
	FModuleManager::Get().LoadModule(TEXT("HotReload"));

	FModuleManager::Get().LoadModuleChecked(TEXT("ClothPainter"));

	// Load VR Editor support
	FModuleManager::Get().LoadModuleChecked( TEXT( "ViewportInteraction" ) );
	FModuleManager::Get().LoadModuleChecked( TEXT( "VREditor" ) );

file
function     void FUnrealEdMisc::InitEngineAnalytics

		// Record known modules' compilation methods
		IHotReloadInterface* HotReload = IHotReloadInterface::GetPtr();
		if(HotReload != nullptr)
		{
			TArray<FModuleStatus> Modules;
			FModuleManager::Get().QueryModules(Modules);
			for (auto& Module : Modules)
			{
				// Record only game modules as these are the only ones that should be hot-reloaded

file
function     void FUnrealEdMisc::InitEngineAnalytics

					TArray< FAnalyticsEventAttribute > ModuleAttributes;
					ModuleAttributes.Add(FAnalyticsEventAttribute(FString("ModuleName"), Module.Name));
					ModuleAttributes.Add(FAnalyticsEventAttribute(FString("CompilationMethod"), HotReload->GetModuleCompileMethod(*Module.Name)));
					EngineAnalytics.RecordEvent(FString("Editor.Usage.Modules"), ModuleAttributes);
				}
			}
		}
	}
}

#if WITH_RELOAD
	// Unlike HotReload, Live Coding does global initialization outside of the main thread.  During global initialization,
	// Live Coding does have the main thread stalled so there is a "reduced" chance of threading issues.  During global
	// initialization with live coding, this code only gets called when a new instance of an existing CVar is created.
	// Normally this shouldn't happen unless a source file shuffles between two different unity files.
	if (IsInGameThread() || IsReloadActive())
#else
	if(IsInGameThread())

file
function     IConsoleObject* FConsoleManager::AddConsoleObject

		if( !bCanUpdateOrReplaceObj )
		{
			// NOTE: The reason we don't assert here is because when using HotReload, locally-initialized static console variables will be
			//       re-registered, and it's desirable for the new variables to clobber the old ones.  Because this happen outside of the
			//       reload stack frame (IsActiveReload()=true), we can't detect and handle only those cases, so we opt to warn instead.
			UE_LOG(LogConsoleManager, Warning, TEXT( "Console object named '%s' already exists but is being registered again, but we weren't expected it to be! (FConsoleManager::AddConsoleObject)"), Name );
		}

		IConsoleVariable* ExistingVar = ExistingObj->AsVariable();

#if WITH_HOT_RELOAD
	/** If true, we are reloading a class for HotReload */
	CORE_API bool GIsHotReload = false;
#endif

#if WITH_ENGINE
	TMap<UClass*, UClass*>& GetClassesToReinstanceForHotReload()
	{

file
function     void FModuleManager::MakeUniqueModuleFilename

void FModuleManager::MakeUniqueModuleFilename( const FName InModuleName, FString& UniqueSuffix, FString& UniqueModuleFileName ) const
{
	// NOTE: Formatting of the module file name must match with the code in HotReload.cs, ReplaceSuffix.

	TSharedRef<const FModuleInfo, ESPMode::ThreadSafe> Module = FindModuleChecked(InModuleName);

	IFileManager& FileManager = IFileManager::Get();

	do

file
function     EActiveReloadType GetActiveReloadType

	{
		check(GActiveReloadInterface);
		return EActiveReloadType::HotReload;
	}
	PRAGMA_ENABLE_DEPRECATION_WARNINGS
#endif

	return GActiveReloadType;
}

file
function     void BeginReload

#if WITH_HOT_RELOAD
	PRAGMA_DISABLE_DEPRECATION_WARNINGS
	GIsHotReload = ActiveReloadType == EActiveReloadType::HotReload;
	PRAGMA_ENABLE_DEPRECATION_WARNINGS
#endif

	GActiveReloadType = ActiveReloadType;
	GActiveReloadInterface = &Interface;
}

#if WITH_HOT_RELOAD
	/** If true, we are reloading a class for HotReload */
	UE_DEPRECATED(5.0, "GIsHotReload has been deprecated, use IsReloadActive to test to see if a reload is in progress.")
	extern CORE_API bool GIsHotReload;
#endif

#if WITH_ENGINE
	extern CORE_API TMap<UClass*, UClass*>& GetClassesToReinstanceForHotReload(); 

	Reinstancing,
#if WITH_HOT_RELOAD
	HotReload,
#endif
#if WITH_LIVE_CODING
	LiveCoding,
#endif
};

/**
 * HotReload module interface
 */
class IHotReloadInterface : public IModuleInterface
{
public:
	/**
	 * Tries to gets a pointer to the active HotReload implementation. 
	 */
	static inline IHotReloadInterface* GetPtr()
	{
		static FName HotReload("HotReload");
		return FModuleManager::GetModulePtr<IHotReloadInterface>(HotReload);
	}

	/**
	 * Save the current state to disk before quitting.
	 */
	virtual void SaveConfig() = 0;

	/**
	 * HotReload: Reloads the DLLs for given packages.
	 *
	 * @param	Package		Packages to reload.
	 * @param	Flags		Flags which control the hot reload.
	 * @param	Ar			Output device for logging compilation status
	 * 
	 * @return	If bWaitForCompletion was set to true, this will return the result of the compilation, otherwise will return ECompilationResult::Unknown
	 */
	virtual ECompilationResult::Type RebindPackages(const TArray<UPackage*>& Packages, EHotReloadFlags Flags, FOutputDevice &Ar) = 0;

	/** Called when a Hot Reload event has completed. 
	 * 
	 * @param	bWasTriggeredAutomatically	True if the hot reload was invoked automatically by the hot reload system after detecting a changed DLL
	 */
	DECLARE_MULTICAST_DELEGATE_OneParam(FHotReloadEvent, bool /* bWasTriggeredAutomatically */ );

file
function     void RecompileRendererModule

void RecompileRendererModule()
{
	IHotReloadInterface* HotReload = IHotReloadInterface::GetPtr();
	if(HotReload != nullptr)
	{
		const FName RendererModuleName = TEXT("Renderer");
		// Unload first so that RecompileModule will not using a rolling module name
		verify(FModuleManager::Get().UnloadModule(RendererModuleName));

		bool bCompiledSuccessfully = false;
		do 
		{
			bCompiledSuccessfully = HotReload->RecompileModule(RendererModuleName, *GLog, ERecompileModuleFlags::FailIfGeneratedCodeChanges);

			if (!bCompiledSuccessfully)
			{
				// Pop up a blocking dialog if there were compilation errors
				// Compiler output will be in the log
				FPlatformMisc::MessageBoxExt(EAppMsgType::Ok, *FText::Format(

file
function     bool UEngine::Exec_Dev

#if	!(UE_BUILD_SHIPPING || UE_BUILD_TEST) && WITH_HOT_RELOAD
	else if (FParse::Command(&Cmd, TEXT("HotReload")))
	{
		return HandleHotReloadCommand(Cmd, Ar);
	}
#endif // !(UE_BUILD_SHIPPING || UE_BUILD_TEST) && WITH_HOT_RELOAD

	return false;

file
function     void FEngineLoop::Exit

#if WITH_ENGINE
	// Save the hot reload state
	IHotReloadInterface* HotReload = IHotReloadInterface::GetPtr();
	if(HotReload != nullptr)
	{
		HotReload->SaveConfig();
	}
#endif

	// Unload all modules.  Note that this doesn't actually unload the module DLLs (that happens at
	// process exit by the OS), but it does call ShutdownModule() on all loaded modules in the reverse
	// order they were loaded in, so that systems can unregister and perform general clean up.

file
lambda-function
lambda-function
lambda-function

				{
#if WITH_HOT_RELOAD
					IHotReloadInterface* HotReload = FModuleManager::GetModulePtr<IHotReloadInterface>(HotReloadModule);
					if (HotReload != nullptr && !HotReload->IsCurrentlyCompiling())
					{
						HotReload->DoHotReloadFromEditor(EHotReloadFlags::None);
					}
#endif
				}
			});
		});
	});

file
function     bool FRiderLCModule::Tick

	{
#if WITH_HOT_RELOAD
		const IHotReloadInterface* HotReload = FModuleManager::GetModulePtr<IHotReloadInterface>(HotReloadModule);
		if (HotReload != nullptr)
		{
			bIsAvailable = true;
			bIsCompiling = HotReload->IsCurrentlyCompiling();
		}
#endif
	}
	IRiderLinkModule& RiderLinkModule = IRiderLinkModule::Get();
	RiderLinkModule.QueueModelAction([bIsAvailable, bIsCompiling](JetBrains::EditorPlugin::RdEditorModel const& RdEditorModel)
	{