Integrating latest 47acbe8

Gems/ScriptCanvas/Code/Editor/Include/ScriptCanvas/Assets/Functions/ScriptCanvasFunctionAssetHandler.h

@@ -19,11 +19,6 @@
 #include <ScriptCanvas/Assets/ScriptCanvasAsset.h>
 #include <ScriptCanvas/Assets/ScriptCanvasAssetHandler.h>
 
-namespace ScriptCanvas 
-{ 
-    class ScriptCanvasFunctionAsset; 
-}
-
 namespace AZ
 {
     class SerializeContext;
@@ -31,6 +26,8 @@ namespace AZ
 
 namespace ScriptCanvasEditor
 {
+    class ScriptCanvasFunctionAsset;
+
     /**
     * Manages editor Script Canvas graph assets.
     */
@@ -51,9 +48,9 @@ namespace ScriptCanvasEditor
             const AZ::Data::AssetFilterCB& assetLoadFilterCB) override;
         bool SaveAssetData(const AZ::Data::Asset<AZ::Data::AssetData>& asset, AZ::IO::GenericStream* stream) override;
 
-        bool SaveAssetData(const ScriptCanvas::ScriptCanvasFunctionAsset* assetData, AZ::IO::GenericStream* stream);
+        bool SaveAssetData(const ScriptCanvasEditor::ScriptCanvasFunctionAsset* assetData, AZ::IO::GenericStream* stream);
 
-        bool SaveAssetData(const ScriptCanvas::ScriptCanvasFunctionAsset* assetData, AZ::IO::GenericStream* stream, AZ::DataStream::StreamType streamType);
+        bool SaveAssetData(const ScriptCanvasEditor::ScriptCanvasFunctionAsset* assetData, AZ::IO::GenericStream* stream, AZ::DataStream::StreamType streamType);
 
         // Called by asset database on registration.
         void GetAssetTypeExtensions(AZStd::vector<AZStd::string>& extensions) override;
@@ -70,7 +67,7 @@ namespace ScriptCanvasEditor
 
         static AZ::Data::AssetType GetAssetTypeStatic();
 
-        ScriptCanvas::ScriptCanvasFunctionAsset* m_scriptCanvasAsset;
+        ScriptCanvasEditor::ScriptCanvasFunctionAsset* m_scriptCanvasAsset;
 
     };
-} // namespace ScriptCanvasEditor
+}

Gems/ScriptCanvas/Code/Editor/Include/ScriptCanvas/Assets/ScriptCanvasAssetHandler.h

@@ -74,7 +74,12 @@ namespace ScriptCanvasEditor
 
         static AZ::Data::AssetType GetAssetTypeStatic();
 
+        // protected AZ::AssetTypeInfoBus::MultiHandler...
+        const char* GetGroup() const override;
+        const char* GetBrowserIcon() const override;
+
+
     protected:
         AZ::SerializeContext* m_serializeContext;
     };
-} // namespace ScriptCanvasEditor
+}

Gems/ScriptCanvas/Code/Editor/Include/ScriptCanvas/Bus/EditorScriptCanvasBus.h

@@ -28,6 +28,7 @@
 #include <Editor/Include/ScriptCanvas/Bus/NodeIdPair.h>
 #include <ScriptCanvas/Core/ExecutionNotificationsBus.h>
 #include <ScriptCanvas/Variable/VariableCore.h>
+#include <AzCore/Interface/Interface.h>
 
 namespace GraphCanvas
 {
@@ -149,10 +150,11 @@ namespace ScriptCanvasEditor
         virtual void HighlightNodes(const AZStd::vector<NodeIdPair>& nodes) = 0;
 
         virtual AZStd::vector<NodeIdPair> GetNodesOfType(const ScriptCanvas::NodeTypeIdentifier&) = 0;
-        virtual AZStd::vector<NodeIdPair> GetVariableNodes(const ScriptCanvas::VariableId&) = 0;        
+        virtual AZStd::vector<NodeIdPair> GetVariableNodes(const ScriptCanvas::VariableId&) = 0;
 
         virtual void RemoveUnusedVariables() = 0;
 
+        virtual bool CanConvertVariableNodeToReference(const GraphCanvas::NodeId& nodeId) = 0;
         virtual bool ConvertVariableNodeToReference(const GraphCanvas::NodeId& nodeId) = 0;
         virtual bool ConvertReferenceToVariableNode(const GraphCanvas::Endpoint& endpoint) = 0;
 
@@ -161,6 +163,8 @@ namespace ScriptCanvasEditor
         virtual bool IsRuntimeGraph() const = 0;
         virtual bool IsFunctionGraph() const = 0;
 
+        virtual bool CanExposeEndpoint(const GraphCanvas::Endpoint& endpoint) = 0;
+
         virtual ScriptCanvas::Endpoint ConvertToScriptCanvasEndpoint(const GraphCanvas::Endpoint& endpoinnt) const = 0;
         virtual GraphCanvas::Endpoint ConvertToGraphCanvasEndpoint(const ScriptCanvas::Endpoint& endpoint) const = 0;
     };
@@ -218,4 +222,38 @@ namespace ScriptCanvasEditor
     };
 
     using EditorLoggingComponentNotificationBus = AZ::EBus<EditorLoggingComponentNotifications>;
+
+    class IUpgradeRequests
+    {
+    public:
+        AZ_TYPE_INFO(IUpgradeRequests, "{D25318F2-4DDA-4E76-98CB-6D561BB6234D}");
+
+        using AssetList = AZStd::list<AZ::Data::AssetInfo>;
+        virtual AssetList& GetAssetsToUpgrade() = 0;
+
+        virtual void GraphNeedsManualUpgrade(const AZ::Data::AssetId&) = 0;
+        virtual AZStd::vector<AZ::Data::AssetId>& GetGraphsThatNeedManualUpgrade() = 0;
+
+        virtual bool IsUpgrading() = 0;
+        virtual void SetIsUpgrading(bool isUpgrading) = 0;
+    };
+
+    class UpgradeNotifications
+        : public AZ::EBusTraits
+    {
+    public:
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::Single;
+        static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Multiple;
+
+        using Bus = AZ::EBus<UpgradeNotifications>;
+
+        virtual void OnUpgradeStart() {}
+        virtual void OnUpgradeComplete() {}
+        virtual void OnUpgradeCancelled() {}
+
+        virtual void OnGraphUpgradeComplete(AZ::Data::Asset<AZ::Data::AssetData>&, bool skipped = false) { (void)skipped; }
+    };
+
+
+
 }

Gems/ScriptCanvas/Code/Editor/Include/ScriptCanvas/Bus/RequestBus.h

@@ -26,12 +26,19 @@
 
 #include <ScriptCanvas/Data/Data.h>
 
+class QLineEdit;
+class QPushButton;
+class QTableView;
+class QToolButton;
+
 namespace GraphCanvas
 {
     struct Endpoint;
 
     class GraphCanvasMimeEvent;
     class GraphCanvasTreeItem;
+
+    class NodePaletteDockWidget;
 }
 
 namespace ScriptCanvas
@@ -186,6 +193,8 @@ namespace ScriptCanvasEditor
         static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::Single;
 
         virtual void RegisterVariableType(const ScriptCanvas::Data::Type& variabletype) = 0;
+
+        virtual bool IsValidVariableType(const ScriptCanvas::Data::Type& variableType) const = 0;
     };
 
     using VariablePaletteRequestBus = AZ::EBus<VariablePaletteRequests>;
@@ -218,6 +227,16 @@ namespace ScriptCanvasEditor
 
             return dataTypes;
         }
+
+        virtual bool IsShowingVariablePalette() const = 0;
+        virtual bool IsShowingGraphVariables() const = 0;
+
+        virtual QPushButton* GetCreateVariableButton() const = 0;
+        virtual QTableView* GetGraphPaletteTableView() const = 0;
+        virtual QTableView* GetVariablePaletteTableView() const = 0;
+
+        virtual QLineEdit* GetVariablePaletteFilter() const = 0;
+        virtual QLineEdit* GetGraphVariablesFilter() const = 0;
     };
 
     using VariableAutomationRequestBus = AZ::EBus<VariableAutomationRequests>;
@@ -232,6 +251,8 @@ namespace ScriptCanvasEditor
 
         virtual void SignalAutomationBegin() = 0;
         virtual void SignalAutomationEnd() = 0;
+
+        virtual void ForceCloseActiveAsset() = 0;
     };
 
     using AutomationRequestBus = AZ::EBus<AutomationRequests>;

Gems/ScriptCanvas/Code/Editor/Include/ScriptCanvas/Bus/ScriptCanvasBus.h

@@ -17,7 +17,7 @@
 
 #include <ScriptCanvas/Data/Data.h>
 
-class QWidget;
+class QMainWindow;
 
 namespace ScriptCanvasEditor
 {
@@ -42,7 +42,7 @@ namespace ScriptCanvasEditor
     public:
         static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::Single;
 
-        virtual QWidget* GetMainWindow() = 0;
+        virtual QMainWindow* GetMainWindow() = 0;
 
         virtual void OpenValidationPanel() = 0;
     };
@@ -54,7 +54,7 @@ namespace ScriptCanvasEditor
     public:
         static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::Single;
 
-        virtual void MainWindowCreationEvent(QWidget* /*mainWindow*/) {};
+        virtual void MainWindowCreationEvent(QMainWindow* /*mainWindow*/) {};
     };
 
     using UINotificationBus = AZ::EBus<UINotifications>;

Gems/ScriptCanvas/Code/Editor/Include/ScriptCanvas/Bus/ScriptCanvasExecutionBus.h

@@ -14,10 +14,10 @@
 #include <AzCore/EBus/EBus.h>
 #include <Editor/Framework/ScriptCanvasReporter.h>
 #include <AzCore/std/string/string_view.h>
+#include <ScriptCanvas/Core/Core.h>
 
 namespace ScriptCanvasEditor
 {
-
     /* ScriptCanvasExecutionRequests - Execute a ScriptCanvas script in the Editor */
 
     class ScriptCanvasExecutionRequests : public AZ::EBusTraits
@@ -26,8 +26,9 @@ namespace ScriptCanvasEditor
         static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::Single;
         static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
 
-        virtual Reporter RunGraph(AZStd::string_view path) = 0;
+        virtual Reporter RunGraph(AZStd::string_view path, ScriptCanvas::ExecutionMode mode) = 0;
+        virtual Reporter RunAssetGraph(AZ::Data::Asset<AZ::Data::AssetData>, ScriptCanvas::ExecutionMode mode) = 0;
     };
     using ScriptCanvasExecutionBus = AZ::EBus<ScriptCanvasExecutionRequests>;
 
-}
+}

Gems/ScriptCanvas/Code/Editor/Include/ScriptCanvas/Bus/UnitTestVerificationBus.h

@@ -16,27 +16,25 @@
 
 namespace ScriptCanvasEditor
 {
-
     struct UnitTestResult
     {   
-        bool m_success;
-        bool m_running;
-        AZStd::string m_consoleOutput;
-        bool m_latestTestingRound;
+        bool m_compiled = false;
+        bool m_running = false;
+        bool m_completed = false;
+        bool m_latestTestingRound = true;
 
-        UnitTestResult()
-            : m_success(true)
-            , m_running(false)
-            , m_latestTestingRound(true)
+        AZStd::string m_consoleOutput;
+
+        AZ_INLINE static UnitTestResult AssumeFailure()
         {
+            return UnitTestResult();
         }
-        
-        UnitTestResult(bool newRunning, bool newSuccess, AZStd::string_view newConsoleOutput)
-            : m_success(newSuccess)
-            , m_running(newRunning)
-            , m_consoleOutput(newConsoleOutput)
-            , m_latestTestingRound(true)
+
+        AZ_INLINE static UnitTestResult AssumeSuccess()
         {
+            UnitTestResult u;
+            u.m_compiled = u.m_completed = u.m_running = true;
+            return u;
         }
     };
 
@@ -57,9 +55,9 @@ namespace ScriptCanvasEditor
         static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::Single;
         static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Multiple;
 
-        virtual void OnTestStart([[maybe_unused]] const AZ::Uuid& sourceID) {}
-        virtual void OnTestResult([[maybe_unused]] const AZ::Uuid& sourceID, UnitTestResult result) {}
-        virtual void OnCheckStateCountChange([[maybe_unused]] const int count) {}
+        virtual void OnTestStart(const AZ::Uuid&) {}
+        virtual void OnTestResult(const AZ::Uuid&, const UnitTestResult&) {}
+        virtual void OnCheckStateCountChange(const int) {}
     };
     using UnitTestWidgetNotificationBus = AZ::EBus<UnitTestWidgetNotifications>;
-}
+}

Gems/ScriptCanvas/Code/Editor/Include/ScriptCanvas/Components/EditorGraph.h

@@ -12,12 +12,13 @@
 #pragma once
 
 #include <AzCore/std/containers/unordered_map.h>
-
+#include <AzCore/Serialization/SerializeContext.h>
 #include <ScriptCanvas/Core/Graph.h>
 #include <ScriptCanvas/Bus/GraphBus.h>
 #include <ScriptCanvas/Bus/NodeIdPair.h>
 #include <ScriptCanvas/Bus/RequestBus.h>
 #include <ScriptCanvas/GraphCanvas/NodeDescriptorBus.h>
+#include <ScriptCanvas/Utils/VersioningUtils.h>
 
 #include <Editor/GraphCanvas/DataInterfaces/ScriptCanvasVariableDataInterface.h>
 
@@ -36,6 +37,12 @@
 
 #include <GraphCanvas/Widgets/NodePropertyBus.h>
 
+#include <Editor/Include/ScriptCanvas/Components/GraphUpgrade.h>
+
+namespace ScriptCanvas
+{
+    struct NodeConfiguration;
+}
 
 namespace ScriptCanvasEditor
 {
@@ -50,8 +57,26 @@ namespace ScriptCanvasEditor
         , private GraphItemCommandNotificationBus::Handler
         , private GraphCanvas::ToastNotificationBus::MultiHandler
         , private GeneralEditorNotificationBus::Handler
+        , private AZ::SystemTickBus::Handler
     {
     private:
+
+        friend class Start;
+        friend class PreRequisites;
+        friend class PreventUndo;
+        friend class CollectData;
+        friend class ReplaceDeprecatedNodes;
+        friend class RemapConnections;
+        friend class VerifySaveDataVersion;
+        friend class SanityChecks;
+        friend class UpgradeScriptEvents;
+        friend class UpdateOutOfDateNodes;
+        friend class BuildGraphCanvasMapping;
+        friend class FixLeakedData;
+        friend class RestoreUndo;
+        friend class DisplayReport;
+        friend class Finalize;
+
         typedef AZStd::unordered_map< AZ::EntityId, AZ::EntityId > WrappedNodeGroupingMap;
 
         static void ConvertToGetVariableNode(Graph* graph, ScriptCanvas::VariableId variableId, const AZ::EntityId& nodeId, AZStd::unordered_map<AZ::EntityId, AZ::EntityId>& setVariableRemapping);
@@ -87,13 +112,14 @@ namespace ScriptCanvasEditor
             , m_graphCanvasSceneEntity(nullptr)
             , m_ignoreSaveRequests(false)
             , m_graphCanvasSaveVersion(GraphCanvas::EntitySaveDataContainer::CurrentVersion)
+            , m_upgradeSM(this)
         {}
         
         ~Graph() override;
 
         void Activate() override;
         void Deactivate() override;
-
+        
         static void GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided)
         {
             ScriptCanvas::Graph::GetProvidedServices(provided);
@@ -128,8 +154,8 @@ namespace ScriptCanvasEditor
         void TriggerUndo() override;
         void TriggerRedo() override;
 
-        bool EnableNodes(const AZStd::unordered_set< GraphCanvas::NodeId >& nodeIds) override;
-        bool DisableNodes(const AZStd::unordered_set< GraphCanvas::NodeId >& nodeIds) override;
+        void EnableNodes(const AZStd::unordered_set< GraphCanvas::NodeId >& nodeIds) override;
+        void DisableNodes(const AZStd::unordered_set< GraphCanvas::NodeId >& nodeIds) override;
 
         GraphCanvas::NodePropertyDisplay* CreateDataSlotPropertyDisplay(const AZ::Uuid& dataType, const AZ::EntityId& nodeId, const AZ::EntityId& slotId) const override;
         GraphCanvas::NodePropertyDisplay* CreatePropertySlotPropertyDisplay(const AZ::Crc32& propertyId, const AZ::EntityId& nodeId, const AZ::EntityId& slotId) const override;
@@ -159,7 +185,7 @@ namespace ScriptCanvasEditor
 
         bool ConvertSlotToReference(const GraphCanvas::Endpoint& endpoint) override;
         bool CanConvertSlotToReference(const GraphCanvas::Endpoint& endpoint) override;
-        bool CanHandleReferenceMimeEvent(const GraphCanvas::Endpoint& endpoint, const QMimeData* mimeData) override;
+        GraphCanvas::CanHandleMimeEventOutcome CanHandleReferenceMimeEvent(const GraphCanvas::Endpoint& endpoint, const QMimeData* mimeData) override;
         bool HandleReferenceMimeEvent(const GraphCanvas::Endpoint& endpoint, const QMimeData* mimeData) override;
         bool CanPromoteToVariable(const GraphCanvas::Endpoint& endpoint) const override;
         bool PromoteToVariableAction(const GraphCanvas::Endpoint& endpoint) override;
@@ -167,7 +193,7 @@ namespace ScriptCanvasEditor
 
         bool ConvertSlotToValue(const GraphCanvas::Endpoint& endpoint) override;
         bool CanConvertSlotToValue(const GraphCanvas::Endpoint& endpoint) override;
-        bool CanHandleValueMimeEvent(const GraphCanvas::Endpoint& endpoint, const QMimeData* mimeData) override;
+        GraphCanvas::CanHandleMimeEventOutcome CanHandleValueMimeEvent(const GraphCanvas::Endpoint& endpoint, const QMimeData* mimeData) override;
         bool HandleValueMimeEvent(const GraphCanvas::Endpoint& endpoint, const QMimeData* mimeData) override;
 
         GraphCanvas::SlotId RequestExtension(const GraphCanvas::NodeId& nodeId, const GraphCanvas::ExtenderId& extenderId) override;
@@ -209,6 +235,17 @@ namespace ScriptCanvasEditor
         void ClearGraphCanvasScene() override;
         void DisplayGraphCanvasScene() override;
 
+        /////
+        EditorGraphUpgradeMachine m_upgradeSM;
+        bool UpgradeGraph(const AZ::Data::Asset<AZ::Data::AssetData>& asset);
+        void ConnectGraphCanvasBuses();
+        void DisconnectGraphCanvasBuses();
+        ///////
+
+        // SystemTickBus
+        void OnSystemTick() override;
+        ////
+
         void OnGraphCanvasSceneVisible() override;
 
         GraphCanvas::GraphId GetGraphCanvasGraphId() const override;
@@ -232,14 +269,17 @@ namespace ScriptCanvasEditor
         
         void RemoveUnusedVariables() override;
 
+        bool CanConvertVariableNodeToReference(const GraphCanvas::NodeId& nodeId) override;
         bool ConvertVariableNodeToReference(const GraphCanvas::NodeId& nodeId) override;
         bool ConvertReferenceToVariableNode(const GraphCanvas::Endpoint& endpoint) override;
 
         void QueueVersionUpdate(const AZ::EntityId& graphCanvasNodeId) override;
-
+        
         bool IsRuntimeGraph() const override;
         bool IsFunctionGraph() const override;
 
+        bool CanExposeEndpoint(const GraphCanvas::Endpoint& endpoint) override;
+        
         ScriptCanvas::Endpoint ConvertToScriptCanvasEndpoint(const GraphCanvas::Endpoint& endpoint) const override;
         GraphCanvas::Endpoint ConvertToGraphCanvasEndpoint(const ScriptCanvas::Endpoint& endpoint) const override;
         ////
@@ -294,7 +334,6 @@ namespace ScriptCanvasEditor
 
         void UnregisterToast(const GraphCanvas::ToastId& toastId);
 
-    private:
         Graph(const Graph&) = delete;
 
         void DisplayUpdateToast();
@@ -319,6 +358,10 @@ namespace ScriptCanvasEditor
         AZStd::unordered_map< GraphCanvas::ToastId, AZ::EntityId > m_toastNodeIds;
 
         //// Version Update code
+        AZ::Outcome<ScriptCanvas::Node*> ReplaceNodeByConfig(ScriptCanvas::Node*, const ScriptCanvas::NodeConfiguration&, ScriptCanvas::ReplacementConnectionMap&);
+        bool SanityCheckNodeReplacement(ScriptCanvas::Node*, ScriptCanvas::Node*, AZStd::unordered_map<ScriptCanvas::SlotId, AZStd::vector<ScriptCanvas::SlotId>>&);
+
+        bool m_allowVersionUpdate = false;
         AZStd::unordered_set< AZ::EntityId > m_queuedConvertingNodes;
         AZStd::unordered_set< AZ::EntityId > m_convertingNodes;
         AZStd::unordered_multimap< AZ::EntityId, ScriptCanvas::SlotId > m_versionedSlots;

Gems/ScriptCanvas/Code/Editor/Include/ScriptCanvas/Components/EditorScriptCanvasComponent.h

@@ -20,6 +20,7 @@
 #include <ScriptCanvas/Bus/EditorScriptCanvasBus.h>
 #include <ScriptCanvas/Variable/VariableBus.h>
 #include <ScriptCanvas/Variable/VariableData.h>
+#include <AzToolsFramework/Entity/EditorEntityContextBus.h>
 
 namespace ScriptCanvasEditor
 {
@@ -41,6 +42,8 @@ namespace ScriptCanvasEditor
         , private EditorScriptCanvasComponentLoggingBus::Handler
         , private EditorScriptCanvasComponentRequestBus::Handler
         , private AssetTrackerNotificationBus::Handler
+        , private AzToolsFramework::EditorEntityContextNotificationBus::Handler
+
     {
     public:
         AZ_COMPONENT(EditorScriptCanvasComponent, "{C28E2D29-0746-451D-A639-7F113ECF5D72}", AzToolsFramework::Components::EditorComponentBase);
@@ -96,6 +99,13 @@ namespace ScriptCanvasEditor
         void OnAssetReloaded(const ScriptCanvasMemoryAsset::pointer asset) override;
         //=====================================================================
 
+
+        //=====================================================================
+        // EditorEntityContextNotificationBus
+        void OnStartPlayInEditor() override;
+
+        void OnStopPlayInEditor() override;
+
     protected:
         static void Reflect(AZ::ReflectContext* context);
 
@@ -146,9 +156,5 @@ namespace ScriptCanvasEditor
         ScriptCanvasAssetHolder m_scriptCanvasAssetHolder;
         
         ScriptCanvas::EditableVariableData m_editableData;
-
-        //< Contains a mapping of the EntityId value from the ScriptCanvasAsset stored as an AZ::u64 so that it does not get remapped
-        //< to itself stored as an EntityId
-        AZStd::unordered_map<AZ::u64, AZ::EntityId> m_variableEntityIdMap; 
     };
 }

Gems/ScriptCanvas/Code/Editor/Include/ScriptCanvas/Components/GraphUpgrade.h

@@ -0,0 +1,364 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#pragma once
+
+#include <AzCore/Component/TickBus.h>
+#include <ScriptCanvas/Core/Core.h>
+#include <ScriptCanvas/Utils/VersioningUtils.h>
+#include <GraphCanvas/Editor/EditorTypes.h>
+
+namespace ScriptCanvas
+{
+    class Node;
+}
+
+namespace ScriptCanvasEditor
+{
+    class Graph;
+    class StateMachine;
+
+    //! StateTraits provides each state the ability to provide its own compile time ID
+    template <AZ::u32 Id>
+    struct StateTraits
+    {
+        static int StateID() { return Id; }
+    };
+
+    //! State interface, provides the framework for any given state that may run through the state machine
+    class IState
+    {
+    public:
+
+        friend class StateMachine;
+
+        static constexpr int EXIT_STATE_ID = (-1);
+
+        enum class ExitStatus
+        {
+            Default,
+            Skipped,
+            Upgraded
+        };
+
+    protected:
+
+        virtual int GetStateId() const = 0;
+
+        virtual void Enter() { OnEnter(); }
+        virtual ExitStatus Exit() { return OnExit(); }
+
+        virtual void OnEnter() {}
+        virtual void Run() {}
+        virtual ExitStatus OnExit() { return ExitStatus::Default; }
+
+        virtual StateMachine* GetStateMachine() { return nullptr; }
+
+        virtual int EvaluateTransition()
+        {
+            return EXIT_STATE_ID;
+        }
+
+        virtual const char* GetName() const { return "IState"; }
+    };
+
+    //! Base class for all states in the system, users must provide a state ID through StateTraits
+    template <typename Traits>
+    class State : public IState
+    {
+    public:
+
+        explicit State(StateMachine* stateMachine)
+            : m_stateMachine(stateMachine)
+        {}
+
+        template <typename T>
+        T* GetStateMachine() { return azrtti_cast<T*>(m_stateMachine); }
+
+        StateMachine* GetStateMachine() override { return m_stateMachine; }
+
+        virtual int GetStateId() const { return Traits::StateID(); }
+
+        static int StateID() { return Traits::StateID(); }
+
+        void Enter() override
+        {
+            //Log("ENTER >> %s", GetName());
+            OnEnter();
+        }
+
+        ExitStatus Exit() override
+        {
+            //Log("EXIT  << %s", GetName());
+            return OnExit();
+        }
+
+        // Simplified function to trace messages
+        void Log(const char* format, ...);
+
+    private:
+
+        bool m_verbose = true;
+
+        StateMachine* m_stateMachine;
+    };
+
+#define DefineState(className) class className##Id : public StateTraits<AZ_CRC_CE(#className)> {}; \
+                               class className : public State<className##Id>
+
+#define DeclareState(className)     public: \
+                                    className(StateMachine* stateMachine) \
+                                        : State<className##Id>(stateMachine) {} \
+                                    virtual ~className() = default; \
+                                    protected: \
+                                        const char* GetName() const override { return #className; }
+
+    //! A state machine that operates on the SystemTickBus
+    //! Only one state at a time will execute in a given frame
+    class StateMachine : private AZ::SystemTickBus::Handler
+    {
+    public:
+        AZ_RTTI(StateMachine, "{A3B08B4F-1E5D-492A-84DA-99AD58BA7AE0}");
+
+        void Run(int startStateID);
+
+        virtual void OnComplete(IState::ExitStatus /*exitStatus*/) {}
+
+        void OnSystemTick() override;
+
+        AZStd::shared_ptr<IState> m_currentState = nullptr;
+        AZStd::vector<AZStd::shared_ptr<IState>> m_states;
+    };
+
+    //! This state machine will collect and share a variety of data from the EditorGraph
+    //! Each state will operate on the data as needed in order to upgrade different
+    //! elements of a graph. It is done with discreet states in order to avoid
+    //! blocking the main thread with too many long running operations
+    class EditorGraphUpgradeMachine : public StateMachine
+    {
+    public:
+        AZ_RTTI(EditorGraphUpgradeMachine, "{C7EABC22-A3DD-4ABE-8303-418EA3CD1246}", StateMachine);
+
+        EditorGraphUpgradeMachine(Graph* graph);
+
+        AZStd::unordered_set<ScriptCanvas::Node*> m_allNodes;
+        AZStd::unordered_set<ScriptCanvas::Node*> m_outOfDateNodes;
+        AZStd::unordered_set<ScriptCanvas::Node*> m_deprecatedNodes;
+        AZStd::unordered_set<ScriptCanvas::Node*> m_sanityCheckRequiredNodes;
+
+        AZStd::unordered_set< AZ::EntityId > graphCanvasNodesToDelete;
+
+        AZStd::unordered_set<AZ::EntityId> m_deletedNodes;
+        AZStd::unordered_set<AZ::EntityId> m_assetSanitizationSet;
+        ScriptCanvas::ReplacementConnectionMap m_replacementConnections;
+
+        AZStd::unordered_map< AZ::EntityId, AZ::EntityId > m_scriptCanvasToGraphCanvasMapping;
+
+        ScriptCanvas::ScriptCanvasId m_scriptCanvasId;
+        GraphCanvas::GraphId m_graphCanvasGraphId;
+
+        AZ::Entity m_scriptCanvasNodeId;
+
+        bool m_graphNeedsDirtying = false;
+
+        Graph* m_graph = nullptr;
+        AZ::Data::Asset<AZ::Data::AssetData> m_asset;
+
+        void SetAsset(const AZ::Data::Asset<AZ::Data::AssetData>& asset);
+
+        void OnComplete(IState::ExitStatus exitStatus) override;
+
+    };
+
+    DefineState(ReplaceDeprecatedConnections)
+    {
+        DeclareState(ReplaceDeprecatedConnections);
+
+        void Run() override;
+
+        int EvaluateTransition() override;
+    };
+
+    DefineState(ReplaceDeprecatedNodes)
+    {
+        DeclareState(ReplaceDeprecatedNodes);
+
+        void Run() override;
+
+        int EvaluateTransition() override;
+    };
+
+    DefineState(CollectData)
+    {
+        DeclareState(CollectData);
+
+        void Run() override;
+
+        ExitStatus OnExit() override;
+
+        int EvaluateTransition() override;
+    };
+
+    DefineState(PreRequisites)
+    {
+        DeclareState(PreRequisites);
+
+        void Run() override;
+
+        int EvaluateTransition() override;
+    };
+
+    DefineState(PreventUndo)
+    {
+        DeclareState(PreventUndo);
+
+        void OnEnter() override;
+
+        int EvaluateTransition() override;
+    };
+
+    DefineState(Start)
+    {
+        DeclareState(Start);
+
+        void OnEnter() override;
+
+        int EvaluateTransition() override;
+    };
+
+    DefineState(DisplayReport)
+    {
+        DeclareState(DisplayReport);
+
+        void Run() override;
+        ExitStatus OnExit() override { return IState::ExitStatus::Upgraded; }
+
+        int EvaluateTransition() override;
+    };
+
+    DefineState(Finalize)
+    {
+        DeclareState(Finalize);
+
+        void Run() override;
+
+        int EvaluateTransition() override;
+    };
+
+    DefineState(VerifySaveDataVersion)
+    {
+        DeclareState(VerifySaveDataVersion);
+
+        void Run() override;
+
+        int EvaluateTransition() override;
+    };
+
+    DefineState(SanityChecks)
+    {
+        DeclareState(SanityChecks);
+
+        void Run() override;
+        ExitStatus OnExit() override;
+
+        int EvaluateTransition() override;
+    };
+
+    DefineState(UpgradeScriptEvents)
+    {
+        DeclareState(UpgradeScriptEvents);
+
+        void Run() override;
+
+        int EvaluateTransition() override;
+    };
+
+    DefineState(FixLeakedData)
+    {
+        DeclareState(FixLeakedData);
+
+        void Run() override;
+
+        int EvaluateTransition() override;
+    };
+
+    DefineState(UpgradeConnections)
+    {
+        DeclareState(UpgradeConnections);
+
+        void Run() override;
+
+        int EvaluateTransition() override;
+    };
+
+    DefineState(UpdateOutOfDateNodes)
+    {
+        DeclareState(UpdateOutOfDateNodes);
+
+        void Run() override;
+
+        int EvaluateTransition() override;
+    };
+
+    DefineState(BuildGraphCanvasMapping)
+    {
+        DeclareState(BuildGraphCanvasMapping);
+
+        void Run() override;
+
+        int EvaluateTransition() override;
+    };
+
+    DefineState(RestoreUndo)
+    {
+        DeclareState(RestoreUndo);
+
+        void Run() override;
+
+        int EvaluateTransition() override;
+    };
+
+    DefineState(Skip)
+    {
+        DeclareState(Skip);
+
+        void Run() override;
+        ExitStatus OnExit() override { return IState::ExitStatus::Skipped; }
+
+        int EvaluateTransition() override;
+    };
+
+    DefineState(ParseGraph)
+    {
+        DeclareState(ParseGraph);
+
+        void Run() override;
+
+        int EvaluateTransition() override;
+    };
+
+    template <typename Traits>
+    void ScriptCanvasEditor::State<Traits>::Log(const char* format, ...)
+    {
+        if (m_verbose)
+        {
+            char sBuffer[1024];
+            va_list ArgList;
+            va_start(ArgList, format);
+            azvsnprintf(sBuffer, sizeof(sBuffer), format, ArgList);
+            sBuffer[sizeof(sBuffer) - 1] = '\0';
+            va_end(ArgList);
+
+            AZ_TracePrintf("Script Canvas", "%s\n", sBuffer);
+        }
+    }
+}

Gems/ScriptCanvas/Code/Editor/Include/ScriptCanvas/GraphCanvas/NodeDescriptorBus.h

@@ -49,8 +49,8 @@ namespace ScriptCanvasEditor
         UserDefined,
         ClassMethod,
         FunctionNode,
-        ExecutionNodeling,
-        
+        FunctionDefinitionNode,
+        AzEventHandler,
         Invalid
     };