Creating new objects inside ForEachObjectWithOuter may cause the bucket of the iterated outer to be read-locked permanently

// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "ActorBug.generated.h"

UCLASS()
class UTestObject : public UObject
{
	GENERATED_BODY()
};

UCLASS()
class UObjBug : public UObject
{
	GENERATED_BODY()

public:
	UObjBug();

	UPROPERTY()
		UTestObject* TestObj1;

	UPROPERTY()
		UTestObject* TestObj2;
};

UCLASS()
class LQA00404557_API AActorBug : public AActor
{
	GENERATED_BODY()

public:
	// Sets default values for this actor's properties
	AActorBug();

protected:
	// Called when the game starts or when spawned
	virtual void BeginPlay() override;

public:
	// Called every frame
	virtual void Tick(float DeltaTime) override;

private:
	UPROPERTY()
		UObjBug* TestParentObject;
};

// Fill out your copyright notice in the Description page of Project Settings.


#include "ActorBug.h"

UObjBug::UObjBug()
	: TestObj1(nullptr)
	, TestObj2(nullptr)
{
}

// Sets default values
AActorBug::AActorBug()
{
	// Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
	PrimaryActorTick.bCanEverTick = true;

	TestParentObject = nullptr;
}

// Called when the game starts or when spawned
void AActorBug::BeginPlay()
{
	Super::BeginPlay();

	UPackage* const Pkg = CreatePackage(TEXT("/Game/TestPackage"));

	TestParentObject = NewObject<UObjBug>(Pkg, "TestPackage", RF_Public | RF_Standalone);

	// Create an object that will contain at least 1 object (so there is something to iterate).
	TestParentObject->TestObj1 = NewObject<UTestObject>(TestParentObject, "FailingOuter");
	UTestObject* const NewObj = NewObject<UTestObject>(TestParentObject->TestObj1, "TestObject");

	// Create another object where many objects will be created in it.
	TestParentObject->TestObj2 = NewObject<UTestObject>(TestParentObject, "NewObjects");

	// Iterate TestObj1 and create many objects containing a children in TestObj2.
	// This will cause ThreadHash.ObjectOuterMap to be rehashed (when it reaches HashSize, so 4096).
	// Elements in ObjectOuterMap will then be reallocated, causing Inners in ForEachObjectWithOuter to be invalid,
	// leading to undefined behavior (the hash bucked will not be able to be unlocked).
	ForEachObjectWithOuter(TestParentObject->TestObj1, [this](UObject* Obj)
	{
		for (SIZE_T Idx = 1; Idx <= 5000; Idx++)
		{
			UTestObject* const NewObj = NewObject<UTestObject>(TestParentObject->TestObj2, FName("DupObj", Idx));
			NewObject<UTestObject>(NewObj, "Children");
		}
	}, false);

	// Now create an object inside TestObj1: it will try to add the new object in the TestObj1 outer,
	// but the associated hash bucket of TestObj1 is permanently locked because of the bug above,
	// causing a failure when adding the new object to the hash bucket.
	NewObject<UTestObject>(TestParentObject->TestObj1, "CrashingObject");
}

// Called every frame
void AActorBug::Tick(float DeltaTime)
{
	Super::Tick(DeltaTime);

}