ABB.Swum.UnigramMethodRule.CheckOverlap C# (CSharp) Метод

        private void CheckOverlap(MethodDeclarationNode mdn, bool checkDO, bool checkIO)
        {
            if (mdn.ParsedName[0].Text.ToLower() == "set") 
            { 
                return; //special case
            }

            PhraseNode theme = null;
            ArgumentNode arg = null;

            //get DO word from name
            string wordDO = "";
            if (checkDO) //theme is in the method name
            {
                theme = (PhraseNode)mdn.Theme;
                wordDO = theme.LastWord().Text;
            }

            //get IO word from name
            string wordIO = "";
            if (checkIO) //IO is in the method name
            {
                arg = mdn.SecondaryArguments[0];
                PhraseNode argn = (PhraseNode)arg.Argument;
                wordIO = argn.LastWord().Text;
                if (wordDO == wordIO)
                {
                    return; //no equivalence if multiple overlap
                }
            }

            //find overlap
            List<Node> unknownArgs = mdn.UnknownArguments;
            List<Node> DOOverlappingArgs = new List<Node>();
            List<Node> IOOverlappingArgs = new List<Node>();
            for (int i = 0; i < unknownArgs.Count; i++)
            {
                if (unknownArgs[i] is VariableDeclarationNode)
                {
                    VariableDeclarationNode var = (VariableDeclarationNode)unknownArgs[i];
                    PhraseNode name = var.ParsedName;
                    PhraseNode type = var.Type.ParsedName;
                    bool DOOverlaps = false;
                    bool IOOverlaps = false;

                    if (checkDO)
                    {
                        DOOverlaps = HasOverlap(name, wordDO) || HasOverlap(type, wordDO);
                        if (DOOverlaps) { DOOverlappingArgs.Add(unknownArgs[i]); }
                    }
                    if (checkIO)
                    {
                        IOOverlaps = HasOverlap(name, wordIO) || HasOverlap(type, wordIO);
                        if (IOOverlaps) { IOOverlappingArgs.Add(unknownArgs[i]); }
                    }

                    if (DOOverlaps && IOOverlaps)
                    {
                        return; //no equivalence if multiple overlap
                    }
                }
            }

            //Create overlap in SWUM
            if (DOOverlappingArgs.Count > 0)
            {
                EquivalenceNode en = mdn.CreateEquivalenceFromUnknownArguments(theme, DOOverlappingArgs);
                mdn.Theme = en; //reset theme in MethodDeclarationNode to new equivalence node
            }
            if (IOOverlappingArgs.Count > 0)
            {
                EquivalenceNode en = mdn.CreateEquivalenceFromUnknownArguments(arg.Argument, IOOverlappingArgs);
                arg.Argument = en; //reset mdn.SecondaryArguments to point to new equivalence node
            }
        }