ue-mcp 1.2.3 → 1.3.0

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/Tests/LevelQueryComponentsTests.cpp

@@ -0,0 +1,195 @@
+// Coverage for level(query_components) that is safe to run anywhere.
+//
+// run_automation_tests dispatches every EditorContext/EngineFilter test in the
+// process against whatever project the bridge is attached to, so nothing here
+// may write. query_components never writes by design, which makes most of it
+// testable directly: the assertions below run the real handler against the
+// open editor world and check the contract (registration, argument rejection,
+// bounded output, the read guarantee, clean enum names) rather than any
+// particular level's contents.
+
+#if WITH_DEV_AUTOMATION_TESTS
+
+#include "HandlerRegistry.h"
+#include "Handlers/LevelHandlers.h"
+#include "Misc/AutomationTest.h"
+
+namespace
+{
+	TSharedPtr<FJsonObject> MCPQueryTestRun(FMCPHandlerRegistry& Registry, const TSharedPtr<FJsonObject>& Request)
+	{
+		const TSharedPtr<FJsonValue> Response = Registry.ExecuteHandler(TEXT("query_components"), Request);
+		if (!Response.IsValid() || Response->Type != EJson::Object)
+		{
+			return nullptr;
+		}
+		return Response->AsObject();
+	}
+
+	TSharedPtr<FJsonObject> MCPQueryTestPredicate(const FString& Field, const FString& Op)
+	{
+		TSharedPtr<FJsonObject> Predicate = MakeShared<FJsonObject>();
+		Predicate->SetStringField(TEXT("field"), Field);
+		Predicate->SetStringField(TEXT("op"), Op);
+		return Predicate;
+	}
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FLevelQueryComponentsContractTest,
+	"UE.MCP.Level.QueryComponents.Contract",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FLevelQueryComponentsContractTest::RunTest(const FString& Parameters)
+{
+	FMCPHandlerRegistry Registry;
+	FLevelHandlers::RegisterHandlers(Registry);
+
+	TestTrue(TEXT("query_components is registered"), Registry.HasHandler(TEXT("query_components")));
+	TestTrue(
+		TEXT("query_components carries its own timeout, because a whole-map scan outlives the default"),
+		Registry.GetHandlerTimeout(TEXT("query_components")) > 0.0f);
+
+	// An unknown field group is an error rather than a silently empty
+	// projection. A projection that quietly produces nothing is how a caller
+	// ends up trusting a confident zero.
+	{
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetArrayField(TEXT("fields"), { MakeShared<FJsonValueString>(TEXT("nonsense")) });
+		const TSharedPtr<FJsonObject> Response = MCPQueryTestRun(Registry, Request);
+		TestTrue(TEXT("unknown field group returns an object"), Response.IsValid());
+		if (Response.IsValid())
+		{
+			TestFalse(TEXT("unknown field group fails"), Response->GetBoolField(TEXT("success")));
+			TestTrue(
+				TEXT("unknown field group names the offending entry"),
+				Response->GetStringField(TEXT("error")).Contains(TEXT("nonsense")));
+		}
+	}
+
+	// An unknown operator is likewise rejected, and the message lists the
+	// operators that do exist.
+	{
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetArrayField(TEXT("where"), {
+			MakeShared<FJsonValueObject>(MCPQueryTestPredicate(TEXT("shadow.castShadow"), TEXT("approximately"))) });
+		const TSharedPtr<FJsonObject> Response = MCPQueryTestRun(Registry, Request);
+		TestTrue(TEXT("unknown operator returns an object"), Response.IsValid());
+		if (Response.IsValid())
+		{
+			TestFalse(TEXT("unknown operator fails"), Response->GetBoolField(TEXT("success")));
+			TestTrue(
+				TEXT("unknown operator lists the valid ones"),
+				Response->GetStringField(TEXT("error")).Contains(TEXT("isTrue")));
+		}
+	}
+
+	// A predicate missing its field is rejected by index, so a caller with
+	// twenty predicates knows which one.
+	{
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetArrayField(TEXT("where"), { MakeShared<FJsonValueObject>(MakeShared<FJsonObject>()) });
+		const TSharedPtr<FJsonObject> Response = MCPQueryTestRun(Registry, Request);
+		if (Response.IsValid())
+		{
+			TestFalse(TEXT("predicate without a field fails"), Response->GetBoolField(TEXT("success")));
+			TestTrue(
+				TEXT("predicate rejection names the index"),
+				Response->GetStringField(TEXT("error")).Contains(TEXT("where[0]")));
+		}
+	}
+
+	// suspectOnly is an AND, so combining it with whereMode 'any' would change
+	// what the other predicates mean. That is refused rather than guessed at.
+	{
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetBoolField(TEXT("suspectOnly"), true);
+		Request->SetStringField(TEXT("whereMode"), TEXT("any"));
+		Request->SetArrayField(TEXT("where"), {
+			MakeShared<FJsonValueObject>(MCPQueryTestPredicate(TEXT("shadow.castShadow"), TEXT("isTrue"))) });
+		const TSharedPtr<FJsonObject> Response = MCPQueryTestRun(Registry, Request);
+		if (Response.IsValid())
+		{
+			TestFalse(TEXT("suspectOnly with whereMode any fails"), Response->GetBoolField(TEXT("success")));
+		}
+	}
+
+	// A levelPath that is not a map is refused before anything is opened.
+	{
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetStringField(TEXT("levelPath"), TEXT("/Game/UEMCPDefinitelyNotAMap"));
+		const TSharedPtr<FJsonObject> Response = MCPQueryTestRun(Registry, Request);
+		if (Response.IsValid())
+		{
+			TestFalse(TEXT("a missing level package fails"), Response->GetBoolField(TEXT("success")));
+		}
+	}
+
+	return true;
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FLevelQueryComponentsBoundsTest,
+	"UE.MCP.Level.QueryComponents.BoundedAndReadOnly",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FLevelQueryComponentsBoundsTest::RunTest(const FString& Parameters)
+{
+	FMCPHandlerRegistry Registry;
+	FLevelHandlers::RegisterHandlers(Registry);
+
+	// An unfiltered query against whatever map is open. This is the shape that
+	// used to return over a megabyte, so the assertions are about the caps.
+	TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+	Request->SetNumberField(TEXT("limit"), 5);
+	Request->SetArrayField(TEXT("fields"), {
+		MakeShared<FJsonValueString>(TEXT("shadow")),
+		MakeShared<FJsonValueString>(TEXT("navigation")) });
+
+	const TSharedPtr<FJsonObject> Response = MCPQueryTestRun(Registry, Request);
+	if (!Response.IsValid() || !Response->GetBoolField(TEXT("success")))
+	{
+		// No editor world (a cook or commandlet context) is not a failure of
+		// this handler, and this test is not allowed to open a map to create
+		// one. Everything above already ran without a world.
+		return true;
+	}
+
+	const TArray<TSharedPtr<FJsonValue>>& Rows = Response->GetArrayField(TEXT("rows"));
+	TestTrue(TEXT("the row array honours 'limit'"), Rows.Num() <= 5);
+	TestTrue(
+		TEXT("'matched' is reported independently of how many rows came back"),
+		Response->GetNumberField(TEXT("matched")) >= Rows.Num());
+
+	// The #912 guarantee: a map-wide read leaves nothing dirty.
+	TestFalse(TEXT("a query dirties no packages"), Response->GetBoolField(TEXT("dirtiedPackages")));
+
+	// The #943 trap: a clean enum name, never EComponentMobility.MOVABLE.
+	for (const TSharedPtr<FJsonValue>& RowValue : Rows)
+	{
+		if (!RowValue.IsValid() || RowValue->Type != EJson::Object) continue;
+		const TSharedPtr<FJsonObject> Row = RowValue->AsObject();
+		if (!Row->HasTypedField<EJson::Object>(TEXT("navigation"))) continue;
+		const FString Mobility = Row->GetObjectField(TEXT("navigation"))->GetStringField(TEXT("mobility"));
+		TestFalse(
+			FString::Printf(TEXT("mobility '%s' carries no enum type prefix"), *Mobility),
+			Mobility.Contains(TEXT("EComponentMobility")));
+	}
+
+	// countOnly answers the aggregate question without paying for rows.
+	{
+		TSharedPtr<FJsonObject> CountRequest = MakeShared<FJsonObject>();
+		CountRequest->SetBoolField(TEXT("countOnly"), true);
+		CountRequest->SetStringField(TEXT("groupBy"), TEXT("actorClass"));
+		const TSharedPtr<FJsonObject> CountResponse = MCPQueryTestRun(Registry, CountRequest);
+		if (CountResponse.IsValid() && CountResponse->GetBoolField(TEXT("success")))
+		{
+			TestFalse(TEXT("countOnly returns no rows array"), CountResponse->HasField(TEXT("rows")));
+			TestTrue(TEXT("countOnly still groups"), CountResponse->HasField(TEXT("groups")));
+		}
+	}
+
+	return true;
+}
+
+#endif // WITH_DEV_AUTOMATION_TESTS

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/Tests/LevelRefreshTests.cpp

@@ -0,0 +1,142 @@
+// Coverage for the level refresh and inspect actions (#944, #915, #914).
+//
+// run_automation_tests dispatches every EditorContext/EngineFilter test in the
+// process against whatever project the bridge is attached to. Two of these
+// three actions rebuild engine state, so the assertions stay on the paths
+// specified to change nothing: the refusals that keep them from running
+// unbounded, and the dry run.
+
+#if WITH_DEV_AUTOMATION_TESTS
+
+#include "HandlerRegistry.h"
+#include "Handlers/LevelHandlers.h"
+#include "Misc/AutomationTest.h"
+
+namespace
+{
+	TSharedPtr<FJsonObject> MCPRefreshTestRun(
+		FMCPHandlerRegistry& Registry,
+		const TCHAR* Method,
+		const TSharedPtr<FJsonObject>& Request)
+	{
+		const TSharedPtr<FJsonValue> Response = Registry.ExecuteHandler(Method, Request);
+		if (!Response.IsValid() || Response->Type != EJson::Object)
+		{
+			return nullptr;
+		}
+		return Response->AsObject();
+	}
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FLevelRefreshRefusesUnboundedTest,
+	"UE.MCP.Level.Refresh.RefusesAnUnboundedRequest",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FLevelRefreshRefusesUnboundedTest::RunTest(const FString& Parameters)
+{
+	FMCPHandlerRegistry Registry;
+	FLevelHandlers::RegisterHandlers(Registry);
+
+	for (const TCHAR* Method : {
+		TEXT("rerun_construction_scripts"),
+		TEXT("recreate_physics_state"),
+		TEXT("test_component_overlap") })
+	{
+		TestTrue(FString::Printf(TEXT("%s is registered"), Method), Registry.HasHandler(Method));
+	}
+
+	// Rerunning every construction script in a map destroys and rebuilds every
+	// generated component in it, so an empty request is refused rather than
+	// treated as "all".
+	{
+		const TSharedPtr<FJsonObject> Response =
+			MCPRefreshTestRun(Registry, TEXT("rerun_construction_scripts"), MakeShared<FJsonObject>());
+		if (Response.IsValid())
+		{
+			TestFalse(TEXT("an unbounded rerun fails"), Response->GetBoolField(TEXT("success")));
+			TestTrue(TEXT("and says which selectors it wants"),
+				Response->GetStringField(TEXT("error")).Contains(TEXT("actorLabels")));
+		}
+	}
+
+	// Same for the physics rebuild, which is long and disruptive and whose bug
+	// is always localised to the meshes that changed.
+	{
+		const TSharedPtr<FJsonObject> Response =
+			MCPRefreshTestRun(Registry, TEXT("recreate_physics_state"), MakeShared<FJsonObject>());
+		if (Response.IsValid())
+		{
+			TestFalse(TEXT("an unbounded physics rebuild fails"), Response->GetBoolField(TEXT("success")));
+			TestTrue(TEXT("and says so explicitly"),
+				Response->GetStringField(TEXT("error")).Contains(TEXT("whole world")));
+		}
+	}
+
+	// An unknown overlap method is named rather than silently treated as OBB.
+	{
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetStringField(TEXT("actorLabelA"), TEXT("A"));
+		Request->SetStringField(TEXT("actorLabelB"), TEXT("B"));
+		Request->SetStringField(TEXT("method"), TEXT("Sphere"));
+		const TSharedPtr<FJsonObject> Response =
+			MCPRefreshTestRun(Registry, TEXT("test_component_overlap"), Request);
+		if (Response.IsValid())
+		{
+			TestFalse(TEXT("an unknown method fails"), Response->GetBoolField(TEXT("success")));
+			TestTrue(TEXT("and lists the ones that exist"),
+				Response->GetStringField(TEXT("error")).Contains(TEXT("AABB")));
+		}
+	}
+
+	// Both labels are required, and a missing one is named.
+	{
+		TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+		Request->SetStringField(TEXT("actorLabelA"), TEXT("A"));
+		const TSharedPtr<FJsonObject> Response =
+			MCPRefreshTestRun(Registry, TEXT("test_component_overlap"), Request);
+		if (Response.IsValid())
+		{
+			TestFalse(TEXT("a one-sided overlap test fails"), Response->GetBoolField(TEXT("success")));
+			TestTrue(TEXT("and names the missing parameter"),
+				Response->GetStringField(TEXT("error")).Contains(TEXT("actorLabelB")));
+		}
+	}
+
+	return true;
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FLevelRecreatePhysicsPreviewTest,
+	"UE.MCP.Level.Refresh.PhysicsRebuildPreviewsByDefault",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FLevelRecreatePhysicsPreviewTest::RunTest(const FString& Parameters)
+{
+	FMCPHandlerRegistry Registry;
+	FLevelHandlers::RegisterHandlers(Registry);
+
+	// A bounded request with no dryRun given. The preflight is the default,
+	// which is what #915 asked for: see what would be rebuilt, and what its
+	// collision state is now, before rebuilding it.
+	TSharedPtr<FJsonObject> Request = MakeShared<FJsonObject>();
+	Request->SetStringField(TEXT("componentClass"), TEXT("StaticMeshComponent"));
+
+	const TSharedPtr<FJsonObject> Response =
+		MCPRefreshTestRun(Registry, TEXT("recreate_physics_state"), Request);
+	if (!Response.IsValid() || !Response->GetBoolField(TEXT("success")))
+	{
+		// No editor world in this context, and this test may not open a map.
+		return true;
+	}
+
+	TestTrue(TEXT("dryRun defaults to true"), Response->GetBoolField(TEXT("dryRun")));
+	TestTrue(TEXT("a preview reports what it would rebuild"), Response->HasField(TEXT("wouldRecreate")));
+	TestFalse(TEXT("and does not claim to have rebuilt anything"), Response->HasField(TEXT("recreated")));
+	TestTrue(TEXT("a preview still returns the current collision summary"),
+		Response->HasField(TEXT("collisionSummary")));
+
+	return true;
+}
+
+#endif // WITH_DEV_AUTOMATION_TESTS

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/Tests/LevelSaveReportTests.cpp

@@ -0,0 +1,125 @@
+// Coverage for level(save) reporting the truth about the packages it touched
+// (#964).
+//
+// The failure this guards is a FALSE failure: the old action answered
+// {"success": false, "error": "Failed to save current level"} on a map that
+// editor(save_dirty) then wrote seconds later. An agent that believes a save
+// did not happen redoes work that was already on disk, so a save reporting
+// failure when nothing failed is more expensive than one that reports nothing.
+//
+// The test deliberately writes nothing. It runs only when the level and its
+// external packages are already clean, and then asserts that a save with
+// nothing to do is reported as the success it is, names the package it
+// considered, and carries no error. A test that saved the map to check saving
+// would leave exactly the kind of unasked-for commit this repo works to avoid.
+
+#if WITH_DEV_AUTOMATION_TESTS
+
+#include "Editor.h"
+#include "Engine/Level.h"
+#include "Engine/World.h"
+#include "HandlerRegistry.h"
+#include "Handlers/LevelHandlers.h"
+#include "Misc/AutomationTest.h"
+#include "UObject/Package.h"
+
+namespace
+{
+	TSharedPtr<FJsonObject> MCPLevelSaveTestRun(
+		FMCPHandlerRegistry& Registry,
+		const TSharedPtr<FJsonObject>& Request)
+	{
+		const TSharedPtr<FJsonValue> Response = Registry.ExecuteHandler(TEXT("save_level"), Request);
+		if (!Response.IsValid() || Response->Type != EJson::Object)
+		{
+			return nullptr;
+		}
+		return Response->AsObject();
+	}
+
+	/** True when saving would write nothing at all, so the test is safe to run. */
+	bool MCPLevelSaveTestNothingIsDirty(UWorld* World)
+	{
+		if (!World) return false;
+		ULevel* Level = World->GetCurrentLevel();
+		if (!Level) Level = World->PersistentLevel;
+		if (!Level) return false;
+		UPackage* Package = Level->GetOutermost();
+		if (!Package || Package->IsDirty()) return false;
+		if (Level->IsUsingExternalObjects())
+		{
+			for (UPackage* External : Level->GetLoadedExternalObjectPackages())
+			{
+				if (External && External->IsDirty()) return false;
+			}
+		}
+		return true;
+	}
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FLevelSaveReportsWhatHappenedTest,
+	"UE.MCP.Level.Save.ReportsWhatHappenedToEachPackage",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FLevelSaveReportsWhatHappenedTest::RunTest(const FString& Parameters)
+{
+	FMCPHandlerRegistry Registry;
+	FLevelHandlers::RegisterHandlers(Registry);
+	TestTrue(TEXT("save_level is registered"), Registry.HasHandler(TEXT("save_level")));
+
+	UWorld* World = GEditor ? GEditor->GetEditorWorldContext().World() : nullptr;
+	if (!World) return true;
+	if (GEditor->PlayWorld != nullptr || GEditor->bIsSimulatingInEditor) return true;
+	if (!MCPLevelSaveTestNothingIsDirty(World))
+	{
+		// Something is unsaved. Running the action here would write it, and
+		// this test is not permitted to commit anybody's work for them.
+		AddInfo(TEXT("Skipped: the open level has unsaved changes, and this test never writes."));
+		return true;
+	}
+
+	const TSharedPtr<FJsonObject> Response = MCPLevelSaveTestRun(Registry, MakeShared<FJsonObject>());
+	if (!Response.IsValid()) return true;
+
+	// The regression: nothing failed, so nothing may be reported as a failure.
+	TestTrue(TEXT("a save with nothing to do succeeds"), Response->GetBoolField(TEXT("success")));
+	FString Error;
+	TestFalse(TEXT("and carries no error"), Response->TryGetStringField(TEXT("error"), Error));
+	TestEqual(TEXT("and reports that nothing failed"),
+		static_cast<int32>(Response->GetNumberField(TEXT("failedCount"))), 0);
+	TestEqual(TEXT("and that nothing needed writing"),
+		static_cast<int32>(Response->GetNumberField(TEXT("savedCount"))), 0);
+
+	// The diagnostic half: the response names what it considered, so a caller
+	// can tell "already saved" from "saved nothing because it looked nowhere".
+	FString LevelPackage;
+	TestTrue(TEXT("the response names the level package"),
+		Response->TryGetStringField(TEXT("levelPackage"), LevelPackage));
+	TestTrue(TEXT("which is not empty"), !LevelPackage.IsEmpty());
+	FString Message;
+	TestTrue(TEXT("and says in words that nothing needed writing"),
+		Response->TryGetStringField(TEXT("message"), Message));
+
+	// A clean package appears as skipped with its reason, never as a failure.
+	const TArray<TSharedPtr<FJsonValue>>* SkippedRows = nullptr;
+	if (Response->TryGetArrayField(TEXT("skipped"), SkippedRows) && SkippedRows)
+	{
+		TestTrue(TEXT("the clean level package is listed as skipped"), SkippedRows->Num() >= 1);
+		if (SkippedRows->Num() > 0)
+		{
+			const TSharedPtr<FJsonObject> Row = (*SkippedRows)[0]->AsObject();
+			if (Row.IsValid())
+			{
+				TestFalse(TEXT("a skipped package is not marked saved"), Row->GetBoolField(TEXT("saved")));
+				TestFalse(TEXT("and was not dirty"), Row->GetBoolField(TEXT("wasDirty")));
+				FString RowError;
+				TestFalse(TEXT("and is not an error"), Row->TryGetStringField(TEXT("error"), RowError));
+			}
+		}
+	}
+
+	return true;
+}
+
+#endif // WITH_DEV_AUTOMATION_TESTS

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/Tests/LevelScriptHandlersTests.cpp

@@ -0,0 +1,42 @@
+#if WITH_DEV_AUTOMATION_TESTS
+
+#include "Handlers/LevelHandlers.h"
+#include "EdGraph/EdGraph.h"
+#include "EdGraph/EdGraphNode.h"
+#include "Engine/Blueprint.h"
+#include "EdGraphSchema_K2.h"
+#include "Kismet2/BlueprintEditorUtils.h"
+#include "Misc/AutomationTest.h"
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FLevelScriptClearGraphNodesTest,
+	"UE.MCP.Level.ClearLevelScript.GraphNodes",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
+
+bool FLevelScriptClearGraphNodesTest::RunTest(const FString& Parameters)
+{
+	UBlueprint* Blueprint = NewObject<UBlueprint>(GetTransientPackage());
+	UEdGraph* Graph = NewObject<UEdGraph>(Blueprint, TEXT("EventGraph"));
+	Blueprint->UbergraphPages.Add(Graph);
+	Graph->AddNode(NewObject<UEdGraphNode>(Graph, TEXT("FirstNode")));
+	Graph->AddNode(NewObject<UEdGraphNode>(Graph, TEXT("SecondNode")));
+	FEdGraphPinType VariableType;
+	VariableType.PinCategory = UEdGraphSchema_K2::PC_Boolean;
+	FBlueprintEditorUtils::AddMemberVariable(Blueprint, TEXT("LegacyReference"), VariableType);
+
+	TArray<TSharedPtr<FJsonValue>> Graphs;
+	TestEqual(TEXT("dry run reports both nodes"),
+		FLevelHandlers::ClearBlueprintGraphNodes(Blueprint, true, Graphs), 2);
+	TestEqual(TEXT("dry run keeps both nodes"), Graph->Nodes.Num(), 2);
+	TestEqual(TEXT("dry run reports the graph"), Graphs.Num(), 1);
+
+	Graphs.Reset();
+	TestEqual(TEXT("apply removes both nodes"),
+		FLevelHandlers::ClearBlueprintGraphNodes(Blueprint, false, Graphs), 2);
+	TestEqual(TEXT("apply leaves the graph empty"), Graph->Nodes.Num(), 0);
+	FBlueprintEditorUtils::RemoveMemberVariable(Blueprint, TEXT("LegacyReference"));
+	TestEqual(TEXT("member variable can be removed"), Blueprint->NewVariables.Num(), 0);
+	return true;
+}
+
+#endif