I have an error in the button - the "button component" is missing

I’m completely new to Unity, so I don’t know how to fix it. Can anyone help? I will be very grateful.
I’m missing the button component in the button, and an error occurred instead:

[195983-screancshot1.jpg*|195983]

The last time I just saved a project (at that time all the buttons were working) and the next time I opened the project, all the buttons stopped working - this error occurred.

My attempts to fix:
if create a new button and run the project then again the “component button” is replaced by an error and gives the following error to the console:

NullReferenceException: Object reference not set to an instance of an object
UnityEditor.UI.SelectableEditor.OnEnable () (at Library/PackageCache/com.unity.ugui@1.0.0/Editor/UI/SelectableEditor.cs:51)
UnityEditor.UI.ButtonEditor.OnEnable () (at Library/PackageCache/com.unity.ugui@1.0.0/Editor/UI/ButtonEditor.cs:17)

[195984-screancshot2.jpg*|195984]

These are errors in the script. I did not write these scripts.

UnityEditor.UI.SelectableEditor.OnEnable () (at Library/PackageCache/com.unity.ugui@1.0.0/Editor/UI/SelectableEditor.cs: 51)
UnityEditor.UI.ButtonEditor.OnEnable () (at Library/PackageCache/com.unity.ugui@1.0.0/Editor/UI/ButtonEditor.cs: 17)
UnityEditor.UI.SelectableEditor.OnEnable () (at Library/PackageCache/com.unity.ugui@1.0.0/Editor/UI/SelectableEditor.cs: 51):

This code:

    using System.Collections.Generic;
    using System.Text;
    using System.Linq;
    using UnityEngine;
    using UnityEngine.UI;
    using UnityEditor.AnimatedValues;
    
    namespace UnityEditor.UI
    {
        [CustomEditor(typeof(Selectable), true)]
        /// <summary>
        /// Custom Editor for the Selectable Component.
        /// Extend this class to write a custom editor for a component derived from Selectable.
        /// </summary>
        public class SelectableEditor : Editor
        {
            SerializedProperty m_Script;
            SerializedProperty m_InteractableProperty;
            SerializedProperty m_TargetGraphicProperty;
            SerializedProperty m_TransitionProperty;
            SerializedProperty m_ColorBlockProperty;
            SerializedProperty m_SpriteStateProperty;
            SerializedProperty m_AnimTriggerProperty;
            SerializedProperty m_NavigationProperty;
    
            GUIContent m_VisualizeNavigation = EditorGUIUtility.TrTextContent("Visualize", "Show navigation flows between selectable UI elements.");
    
            AnimBool m_ShowColorTint       = new AnimBool();
            AnimBool m_ShowSpriteTrasition = new AnimBool();
            AnimBool m_ShowAnimTransition  = new AnimBool();
    
            private static List<SelectableEditor> s_Editors = new List<SelectableEditor>();
            private static bool s_ShowNavigation = false;
            private static string s_ShowNavigationKey = "SelectableEditor.ShowNavigation";
    
            // Whenever adding new SerializedProperties to the Selectable and SelectableEditor
            // Also update this guy in OnEnable. This makes the inherited classes from Selectable not require a CustomEditor.
            private string[] m_PropertyPathToExcludeForChildClasses;
    
            protected virtual void OnEnable()
            {
                m_Script                = serializedObject.FindProperty("m_Script");
                m_InteractableProperty  = serializedObject.FindProperty("m_Interactable");
                m_TargetGraphicProperty = serializedObject.FindProperty("m_TargetGraphic");
                m_TransitionProperty    = serializedObject.FindProperty("m_Transition");
                m_ColorBlockProperty    = serializedObject.FindProperty("m_Colors");
                m_SpriteStateProperty   = serializedObject.FindProperty("m_SpriteState");
                m_AnimTriggerProperty   = serializedObject.FindProperty("m_AnimationTriggers");
                m_NavigationProperty    = serializedObject.FindProperty("m_Navigation");
    
                m_PropertyPathToExcludeForChildClasses = new[]
                {
                    m_Script.propertyPath,
                    m_NavigationProperty.propertyPath,
                    m_TransitionProperty.propertyPath,
                    m_ColorBlockProperty.propertyPath,
                    m_SpriteStateProperty.propertyPath,
                    m_AnimTriggerProperty.propertyPath,
                    m_InteractableProperty.propertyPath,
                    m_TargetGraphicProperty.propertyPath,
                };
    
                var trans = GetTransition(m_TransitionProperty);
                m_ShowColorTint.value       = (trans == Selectable.Transition.ColorTint);
                m_ShowSpriteTrasition.value = (trans == Selectable.Transition.SpriteSwap);
                m_ShowAnimTransition.value  = (trans == Selectable.Transition.Animation);
    
                m_ShowColorTint.valueChanged.AddListener(Repaint);
                m_ShowSpriteTrasition.valueChanged.AddListener(Repaint);
    
                s_Editors.Add(this);
                RegisterStaticOnSceneGUI();
    
                s_ShowNavigation = EditorPrefs.GetBool(s_ShowNavigationKey);
            }
    
            protected virtual void OnDisable()
            {
                m_ShowColorTint.valueChanged.RemoveListener(Repaint);
                m_ShowSpriteTrasition.valueChanged.RemoveListener(Repaint);
    
                s_Editors.Remove(this);
                RegisterStaticOnSceneGUI();
            }
    
            private void RegisterStaticOnSceneGUI()
            {
                SceneView.duringSceneGui -= StaticOnSceneGUI;
                if (s_Editors.Count > 0)
                    SceneView.duringSceneGui += StaticOnSceneGUI;
            }
    
            static Selectable.Transition GetTransition(SerializedProperty transition)
            {
                return (Selectable.Transition)transition.enumValueIndex;
            }
    
            public override void OnInspectorGUI()
            {
                serializedObject.Update();
    
                EditorGUILayout.PropertyField(m_InteractableProperty);
    
                var trans = GetTransition(m_TransitionProperty);
    
                var graphic = m_TargetGraphicProperty.objectReferenceValue as Graphic;
                if (graphic == null)
                    graphic = (target as Selectable).GetComponent<Graphic>();
    
                var animator = (target as Selectable).GetComponent<Animator>();
                m_ShowColorTint.target = (!m_TransitionProperty.hasMultipleDifferentValues && trans == Button.Transition.ColorTint);
                m_ShowSpriteTrasition.target = (!m_TransitionProperty.hasMultipleDifferentValues && trans == Button.Transition.SpriteSwap);
                m_ShowAnimTransition.target = (!m_TransitionProperty.hasMultipleDifferentValues && trans == Button.Transition.Animation);
    
                EditorGUILayout.PropertyField(m_TransitionProperty);
    
                ++EditorGUI.indentLevel;
                {
                    if (trans == Selectable.Transition.ColorTint || trans == Selectable.Transition.SpriteSwap)
                    {
                        EditorGUILayout.PropertyField(m_TargetGraphicProperty);
                    }
    
                    switch (trans)
                    {
                        case Selectable.Transition.ColorTint:
                            if (graphic == null)
                                EditorGUILayout.HelpBox("You must have a Graphic target in order to use a color transition.", MessageType.Warning);
                            break;
    
                        case Selectable.Transition.SpriteSwap:
                            if (graphic as Image == null)
                                EditorGUILayout.HelpBox("You must have a Image target in order to use a sprite swap transition.", MessageType.Warning);
                            break;
                    }
    
                    if (EditorGUILayout.BeginFadeGroup(m_ShowColorTint.faded))
                    {
                        EditorGUILayout.PropertyField(m_ColorBlockProperty);
                    }
                    EditorGUILayout.EndFadeGroup();
    
                    if (EditorGUILayout.BeginFadeGroup(m_ShowSpriteTrasition.faded))
                    {
                        EditorGUILayout.PropertyField(m_SpriteStateProperty);
                    }
                    EditorGUILayout.EndFadeGroup();
    
                    if (EditorGUILayout.BeginFadeGroup(m_ShowAnimTransition.faded))
                    {
                        EditorGUILayout.PropertyField(m_AnimTriggerProperty);
    
                        if (animator == null || animator.runtimeAnimatorController == null)
                        {
                            Rect buttonRect = EditorGUILayout.GetControlRect();
                            buttonRect.xMin += EditorGUIUtility.labelWidth;
                            if (GUI.Button(buttonRect, "Auto Generate Animation", EditorStyles.miniButton))
                            {
                                var controller = GenerateSelectableAnimatorContoller((target as Selectable).animationTriggers, target as Selectable);
                                if (controller != null)
                                {
                                    if (animator == null)
                                        animator = (target as Selectable).gameObject.AddComponent<Animator>();
    
                                    Animations.AnimatorController.SetAnimatorController(animator, controller);
                                }
                            }
                        }
                    }
                    EditorGUILayout.EndFadeGroup();
                }
                --EditorGUI.indentLevel;
    
                EditorGUILayout.Space();
    
                EditorGUILayout.PropertyField(m_NavigationProperty);
    
                EditorGUI.BeginChangeCheck();
                Rect toggleRect = EditorGUILayout.GetControlRect();
                toggleRect.xMin += EditorGUIUtility.labelWidth;
                s_ShowNavigation = GUI.Toggle(toggleRect, s_ShowNavigation, m_VisualizeNavigation, EditorStyles.miniButton);
                if (EditorGUI.EndChangeCheck())
                {
                    EditorPrefs.SetBool(s_ShowNavigationKey, s_ShowNavigation);
                    SceneView.RepaintAll();
                }
    
                // We do this here to avoid requiring the user to also write a Editor for their Selectable-derived classes.
                // This way if we are on a derived class we dont draw anything else, otherwise draw the remaining properties.
                ChildClassPropertiesGUI();
    
                serializedObject.ApplyModifiedProperties();
            }
    
            // Draw the extra SerializedProperties of the child class.
            // We need to make sure that m_PropertyPathToExcludeForChildClasses has all the Selectable properties and in the correct order.
            // TODO: find a nicer way of doing this. (creating a InheritedEditor class that automagically does this)
            private void ChildClassPropertiesGUI()
            {
                if (IsDerivedSelectableEditor())
                    return;
    
                DrawPropertiesExcluding(serializedObject, m_PropertyPathToExcludeForChildClasses);
            }
    
            private bool IsDerivedSelectableEditor()
            {
                return GetType() != typeof(SelectableEditor);
            }
    
            private static Animations.AnimatorController GenerateSelectableAnimatorContoller(AnimationTriggers animationTriggers, Selectable target)
            {
                if (target == null)
                    return null;
    
                // Where should we create the controller?
                var path = GetSaveControllerPath(target);
                if (string.IsNullOrEmpty(path))
                    return null;
    
                // figure out clip names
                var normalName = string.IsNullOrEmpty(animationTriggers.normalTrigger) ? "Normal" : animationTriggers.normalTrigger;
                var highlightedName = string.IsNullOrEmpty(animationTriggers.highlightedTrigger) ? "Highlighted" : animationTriggers.highlightedTrigger;
                var pressedName = string.IsNullOrEmpty(animationTriggers.pressedTrigger) ? "Pressed" : animationTriggers.pressedTrigger;
                var selectedName = string.IsNullOrEmpty(animationTriggers.selectedTrigger) ? "Selected" : animationTriggers.selectedTrigger;
                var disabledName = string.IsNullOrEmpty(animationTriggers.disabledTrigger) ? "Disabled" : animationTriggers.disabledTrigger;
    
                // Create controller and hook up transitions.
                var controller = Animations.AnimatorController.CreateAnimatorControllerAtPath(path);
                GenerateTriggerableTransition(normalName, controller);
                GenerateTriggerableTransition(highlightedName, controller);
                GenerateTriggerableTransition(pressedName, controller);
                GenerateTriggerableTransition(selectedName, controller);
                GenerateTriggerableTransition(disabledName, controller);
    
                AssetDatabase.ImportAsset(path);
    
                return controller;
            }
    
            private static string GetSaveControllerPath(Selectable target)
            {
                var defaultName = target.gameObject.name;
                var message = string.Format("Create a new animator for the game object '{0}':", defaultName);
                return EditorUtility.SaveFilePanelInProject("New Animation Contoller", defaultName, "controller", message);
            }
    
            private static void SetUpCurves(AnimationClip highlightedClip, AnimationClip pressedClip, string animationPath)
            {
                string[] channels = { "m_LocalScale.x", "m_LocalScale.y", "m_LocalScale.z" };
    
                var highlightedKeys = new[] { new Keyframe(0f, 1f), new Keyframe(0.5f, 1.1f), new Keyframe(1f, 1f) };
                var highlightedCurve = new AnimationCurve(highlightedKeys);
                foreach (var channel in channels)
                    AnimationUtility.SetEditorCurve(highlightedClip, EditorCurveBinding.FloatCurve(animationPath, typeof(Transform), channel), highlightedCurve);
    
                var pressedKeys = new[] { new Keyframe(0f, 1.15f) };
                var pressedCurve = new AnimationCurve(pressedKeys);
                foreach (var channel in channels)
                    AnimationUtility.SetEditorCurve(pressedClip, EditorCurveBinding.FloatCurve(animationPath, typeof(Transform), channel), pressedCurve);
            }
    
            private static string BuildAnimationPath(Selectable target)
            {
                // if no target don't hook up any curves.
                var highlight = target.targetGraphic;
                if (highlight == null)
                    return string.Empty;
    
                var startGo = highlight.gameObject;
                var toFindGo = target.gameObject;
    
                var pathComponents = new Stack<string>();
                while (toFindGo != startGo)
                {
                    pathComponents.Push(startGo.name);
    
                    // didn't exist in hierarchy!
                    if (startGo.transform.parent == null)
                        return string.Empty;
    
                    startGo = startGo.transform.parent.gameObject;
                }
    
                // calculate path
                var animPath = new StringBuilder();
                if (pathComponents.Count > 0)
                    animPath.Append(pathComponents.Pop());
    
                while (pathComponents.Count > 0)
                    animPath.Append("/").Append(pathComponents.Pop());
    
                return animPath.ToString();
            }
    
            private static AnimationClip GenerateTriggerableTransition(string name, Animations.AnimatorController controller)
            {
                // Create the clip
                var clip = Animations.AnimatorController.AllocateAnimatorClip(name);
                AssetDatabase.AddObjectToAsset(clip, controller);
    
                // Create a state in the animatior controller for this clip
                var state = controller.AddMotion(clip);
    
                // Add a transition property
                controller.AddParameter(name, AnimatorControllerParameterType.Trigger);
    
                // Add an any state transition
                var stateMachine = controller.layers[0].stateMachine;
                var transition = stateMachine.AddAnyStateTransition(state);
                transition.AddCondition(Animations.AnimatorConditionMode.If, 0, name);
                return clip;
            }
    
            private static void StaticOnSceneGUI(SceneView view)
            {
                if (!s_ShowNavigation)
                    return;
    
                Selectable[] selectables = Selectable.allSelectablesArray;
    
                for (int i = 0; i < selectables.Length; i++)
                {
                    Selectable s = selectables*;*
 *if (SceneManagement.StageUtility.IsGameObjectRenderedByCamera(s.gameObject, Camera.current))*
 *DrawNavigationForSelectable(s);*
 *}*
 *}*
 
 *private static void DrawNavigationForSelectable(Selectable sel)*
 *{*
 *if (sel == null)*
 *return;*
 
 *Transform transform = sel.transform;*
 *bool active = Selection.transforms.Any(e => e == transform);*
 
 *Handles.color = new Color(1.0f, 0.6f, 0.2f, active ? 1.0f : 0.4f);*
 *DrawNavigationArrow(-Vector2.right, sel, sel.FindSelectableOnLeft());*
 *DrawNavigationArrow(Vector2.up, sel, sel.FindSelectableOnUp());*
 
 *Handles.color = new Color(1.0f, 0.9f, 0.1f, active ? 1.0f : 0.4f);*
 *DrawNavigationArrow(Vector2.right, sel, sel.FindSelectableOnRight());*
 *DrawNavigationArrow(-Vector2.up, sel, sel.FindSelectableOnDown());*
 *}*
 
 *const float kArrowThickness = 2.5f;*
 *const float kArrowHeadSize = 1.2f;*
 
 *private static void DrawNavigationArrow(Vector2 direction, Selectable fromObj, Selectable toObj)*
 *{*
 *if (fromObj == null || toObj == null)*
 *return;*
 *Transform fromTransform = fromObj.transform;*
 *Transform toTransform = toObj.transform;*
 
 *Vector2 sideDir = new Vector2(direction.y, -direction.x);*
 *Vector3 fromPoint = fromTransform.TransformPoint(GetPointOnRectEdge(fromTransform as RectTransform, direction));*
 *Vector3 toPoint = toTransform.TransformPoint(GetPointOnRectEdge(toTransform as RectTransform, -direction));*
 _float fromSize = HandleUtility.GetHandleSize(fromPoint) * 0.05f;_
 _float toSize = HandleUtility.GetHandleSize(toPoint) * 0.05f;_
 _fromPoint += fromTransform.TransformDirection(sideDir) * fromSize;_
 _toPoint += toTransform.TransformDirection(sideDir) * toSize;_
 *float length = Vector3.Distance(fromPoint, toPoint);*
 _Vector3 fromTangent = fromTransform.rotation * direction * length * 0.3f;_
 _Vector3 toTangent = toTransform.rotation * -direction * length * 0.3f;_
 
 *Handles.DrawBezier(fromPoint, toPoint, fromPoint + fromTangent, toPoint + toTangent, Handles.color, null, kArrowThickness);*
 _Handles.DrawAAPolyLine(kArrowThickness, toPoint, toPoint + toTransform.rotation * (-direction - sideDir) * toSize * kArrowHeadSize);_
 _Handles.DrawAAPolyLine(kArrowThickness, toPoint, toPoint + toTransform.rotation * (-direction + sideDir) * toSize * kArrowHeadSize);_
 *}*
 
 *private static Vector3 GetPointOnRectEdge(RectTransform rect, Vector2 dir)*
 *{*
 *if (rect == null)*
 *return Vector3.zero;*
 *if (dir != Vector2.zero)*
 *dir /= Mathf.Max(Mathf.Abs(dir.x), Mathf.Abs(dir.y));*
 _dir = rect.rect.center + Vector2.Scale(rect.rect.size, dir * 0.5f);_
 *return dir;*
 *}*
 *}*
 *}*
 
*UnityEditor.UI.ButtonEditor.OnEnable () (at Library/PackageCache/com.unity.ugui@1.0.0/Editor/UI/ButtonEditor.cs: 17):*
 *using UnityEngine.UI;*
 
 *namespace UnityEditor.UI*
 *{*
 *[CustomEditor(typeof(Button), true)]*
 *[CanEditMultipleObjects]*
 */// <summary>*
 *///   Custom Editor for the Button Component.*
 *///   Extend this class to write a custom editor for a component derived from Button.*
 */// </summary>*
 *public class ButtonEditor : SelectableEditor*
 *{*
 *SerializedProperty m_OnClickProperty;*
 
 *protected override void OnEnable()*
 *{*
 *base.OnEnable();*
 *m_OnClickProperty = serializedObject.FindProperty("m_OnClick");*
 *}*
 
 *public override void OnInspectorGUI()*
 *{*
 *base.OnInspectorGUI();*
 *EditorGUILayout.Space();*
 
 *serializedObject.Update();*
 *EditorGUILayout.PropertyField(m_OnClickProperty);*
 *serializedObject.ApplyModifiedProperties();*
 *}*
 *}*
 *}*

How to fix it all?

  1. Close the project
  2. Delete the full PROJECT/Library/ folder
  3. Open the project again

Wow man thank you very much! I forgot that I ask that. I rebuilt this project from scratch. And now found this broken old project in dug it up in the depths of Google Drive and try your advice and it really work. So again thanks!