/// Action to be executed at completion of semantic analysis of an invocation expression in the target project.
        /// <param name="context">context for a symbol action.</param>
        private static void AnalyzeNode(SyntaxNodeAnalysisContext context)
        {
            UEASettingReader uEASettingReader  = new UEASettingReader();
            UEASettings      uEASettings       = uEASettingReader.ReadConfigFile();
            List <string>    noConstansMethods = uEASettings.noConstansFunctionRegexStrings;

            // check for exclusion
            if (context.IsExcluded(DiagnosticIDs.DoNotUseConstantStringMethodsFromConfig))
            {
                return;
            }

            // early out
            var invocation = context.Node as InvocationExpressionSyntax;

            if (invocation == null)
            {
                return;
            }

            var  methodSymbol         = context.SemanticModel.GetSymbolInfo(invocation).Symbol;
            var  symbolInfo           = methodSymbol as IMethodSymbol;
            var  methodFullDefinition = symbolInfo.OriginalDefinition.ToDisplayString().Split('(')[0];
            bool notMatchMethod       = true;

            foreach (var noConstansMethod in noConstansMethods)
            {
                if (noConstansMethod.Equals(methodFullDefinition))
                {
                    notMatchMethod = false;
                    break;
                }
            }

            if (notMatchMethod)
            {
                return;
            }


            bool hasContent   = false;
            var  argumentList = invocation.ArgumentList.ToFullString().Replace("(", "").Replace(")", "").Split(',');

            foreach (var argument in argumentList)
            {
                if (System.Text.RegularExpressions.Regex.IsMatch(argument, "\""))
                {
                    hasContent = true;
                }
            }

            if (hasContent)
            {
                // represents a diagnostic, such as a compiler error or a warning, along with the location where it occurred
                var diagnostic = Diagnostic.Create(DiagnosticDescriptors.DoNotUseConstantStringMethodsFromConfig, invocation.GetLocation(), methodFullDefinition);

                // report a Diagnostic result
                context.ReportDiagnostic(diagnostic);
            }
        }
        /// Action to be executed at completion of syntax of method declaration in the target project.
        /// <param name="context">context for a syntax action.</param>
        private static void AnalyzeSymbol(SyntaxNodeAnalysisContext context)
        {
            UEASettingReader uEASettingReader = new UEASettingReader();
            UEASettings      uEASettings      = uEASettingReader.ReadConfigFile();

            // check for exclusion
            if (context.IsExcluded(DiagnosticIDs.EmptyMonoBehaviourMethod))
            {
                return;
            }

            // retrieve method syntax
            var methodSyntax = context.Node as MethodDeclarationSyntax;

            // retrieve method symbol
            var methodSymbol = context.SemanticModel.GetDeclaredSymbol(methodSyntax);

            if (methodSymbol == null)
            {
                return;
            }

            // check if method name is a MonoBehaviour method name
            if (!MonoBehaviourMethods.Contains(methodSymbol.Name))
            {
                return;
            }

            int rowsCount2ThisMethod = CheckExceedRowMethod(context, methodSymbol, new Dictionary <IMethodSymbol, int>());

            // from the method syntax, check if awake or start method is out off rawlimeted
            if (rowsCount2ThisMethod <= uEASettings.startAndAwakeFunctinMAXRows)
            {
                return;
            }

            // at this point, we have a method with a MonoBehaviour method name and an empty body
            // finally, check if this method is contained in a class which extends UnityEngine.MonoBehaviour
            var containingClass = methodSymbol.ContainingType;
            var baseClass       = containingClass.BaseType;

            if (baseClass?.ContainingNamespace?.Name.Equals("UnityEngine") == true &&
                baseClass?.Name?.Equals("MonoBehaviour") == true)
            {
                // represents a diagnostic, such as a compiler error or a warning, along with the location where it occurred
                var diagnostic = Diagnostic.Create(DiagnosticDescriptors.BeyondRowLimitMonoBehaviourMethod, methodSyntax.GetLocation(), containingClass.Name, methodSymbol.Name, rowsCount2ThisMethod);

                // report a Diagnostic result
                context.ReportDiagnostic(diagnostic);
            }
        }
        /// Action to be executed at completion of semantic analysis of an invocation expression in the target project.
        /// <param name="context">context for a symbol action.</param>
        private static void AnalyzeNode(SyntaxNodeAnalysisContext context)
        {
            UEASettingReader uEASettingReader = new UEASettingReader();
            UEASettings      uEASettings      = uEASettingReader.ReadConfigFile();
            List <string>    forbiddenMethods = uEASettings.prohibitedFunctionRegexStrings;

            // check for exclusion
            if (context.IsExcluded(DiagnosticIDs.ForbiddenMethods))
            {
                return;
            }

            // early out
            var invocation = context.Node as InvocationExpressionSyntax;

            if (invocation == null)
            {
                return;
            }

            var methodSymbol         = context.SemanticModel.GetSymbolInfo(invocation).Symbol;
            var symbolInfo           = methodSymbol as IMethodSymbol;
            var methodFullDefinition = symbolInfo.OriginalDefinition.ToDisplayString().Split('(')[0];
            // check if any forbidden methods are used
            bool isForbidden = false;

            foreach (var forbiddenMethod in forbiddenMethods)
            {
                if (forbiddenMethod.Equals(methodFullDefinition))
                {
                    isForbidden = true;
                    break;
                }
            }


            if (isForbidden)
            {
                // represents a diagnostic, such as a compiler error or a warning, along with the location where it occurred
                var diagnostic = Diagnostic.Create(DiagnosticDescriptors.ForbiddenMethods, invocation.GetLocation(), methodFullDefinition);

                // report a Diagnostic result
                context.ReportDiagnostic(diagnostic);
            }
        }