Boo.Lang.Compiler.Steps.BindBaseTypes.ResolveBaseTypes C# (CSharp) Метод

        void ResolveBaseTypes(Boo.Lang.List visited, TypeDefinition node)
        {
            // If type is generic, enter a special namespace to allow
            // correct resolution of generic parameters
            IType type = (IType)TypeSystemServices.GetEntity(node);
            if (type.GenericInfo != null)
            {
                EnterNamespace(new GenericParametersNamespaceExtender(
                    type, NameResolutionService.CurrentNamespace));
            }

            visited.Add(node);

            Boo.Lang.List visitedNonInterfaces = null;
            Boo.Lang.List visitedInterfaces = null;

            if (node is InterfaceDefinition)
            {
                visitedInterfaces = visited;
                // interfaces won't have noninterface base types so visitedNonInterfaces not necessary here
            }
            else
            {
                visitedNonInterfaces = visited;
                visitedInterfaces = new Boo.Lang.List();
            }

            int removed = 0;
            int index = 0;
            foreach (SimpleTypeReference baseType in node.BaseTypes.ToArray())
            {
                NameResolutionService.ResolveSimpleTypeReference(baseType);

                AbstractInternalType internalType = baseType.Entity as AbstractInternalType;
                if (null != internalType)
                {
                    if (internalType is InternalInterface)
                    {
                        if (visitedInterfaces.Contains(internalType.TypeDefinition))
                        {
                            Error(CompilerErrorFactory.InheritanceCycle(baseType, internalType.FullName));
                            node.BaseTypes.RemoveAt(index - removed);
                            ++removed;
                        }
                        else
                        {
                            ResolveBaseTypes(visitedInterfaces, internalType.TypeDefinition);
                        }
                    }
                    else
                    {
                        if (visitedNonInterfaces.Contains(internalType.TypeDefinition))
                    {
                        Error(CompilerErrorFactory.InheritanceCycle(baseType, internalType.FullName));
                        node.BaseTypes.RemoveAt(index - removed);
                        ++removed;
                    }
                    else
                    {
                            ResolveBaseTypes(visitedNonInterfaces, internalType.TypeDefinition);
                        }
                    }
                }
                ++index;
            }

            // Leave special namespace if we entered it before
            if (type.GenericInfo != null)
            {
                LeaveNamespace();
            }
        }