CSharpSourceEmitter.Utils.GetHiddenBaseClassMethod C# (CSharp) Method

    public static IMethodDefinition GetHiddenBaseClassMethod(IMethodDefinition derivedClassMethod) {
      if (derivedClassMethod.IsConstructor) return Dummy.MethodDefinition;
      if (derivedClassMethod.IsVirtual && !derivedClassMethod.IsNewSlot) return Dummy.MethodDefinition;   // an override
      var typeDef = derivedClassMethod.ContainingTypeDefinition;
      var bases = typeDef.IsInterface ? typeDef.Interfaces : typeDef.BaseClasses;
      foreach (ITypeReference baseClassReference in bases) {
        IMethodDefinition overriddenMethod = GetHiddenBaseClassMethod(derivedClassMethod, baseClassReference.ResolvedType);
        if (!(overriddenMethod is Dummy)) return overriddenMethod;
      }
      return Dummy.MethodDefinition;
    }
    private static IMethodDefinition GetHiddenBaseClassMethod(IMethodDefinition derivedClassMethod, ITypeDefinition baseClass) {

        public virtual void PrintMethodDefinitionModifiers(IMethodDefinition methodDefinition)
        {
            Contract.Requires(methodDefinition != null);

            // This algorithm is probably not exactly right yet.
            // TODO: Compare to FrameworkDesignStudio rules (see CCIModifiers project, and AssemblyDocumentWriter.WriteMemberStart)

            if (IsMethodUnsafe(methodDefinition))
            {
                PrintKeywordUnsafe();
            }

            if (!(Utils.GetHiddenBaseClassMethod(methodDefinition) is Dummy))
            {
                PrintKeywordNew();
            }

            if (methodDefinition.ContainingTypeDefinition.IsInterface)
            {
                // Defining an interface method - 'unsafe' and 'new' are the only valid modifier
                return;
            }

            if (!methodDefinition.IsAbstract && methodDefinition.IsExternal)
            {
                PrintKeywordExtern();
            }

            if (IsDestructor(methodDefinition))
            {
                return;
            }

            if (methodDefinition.IsStatic)
            {
                PrintKeywordStatic();
            }
            else if (methodDefinition.IsVirtual)
            {
                if (methodDefinition.IsNewSlot &&
                    (IteratorHelper.EnumerableIsNotEmpty(MemberHelper.GetImplicitlyImplementedInterfaceMethods(methodDefinition)) ||
                     IteratorHelper.EnumerableIsNotEmpty(MemberHelper.GetExplicitlyOverriddenMethods(methodDefinition))))
                {
                    // Implementing a method defined on an interface: implicitly virtual and sealed
                    if (methodDefinition.IsAbstract)
                    {
                        PrintKeywordAbstract();
                    }
                    else if (!methodDefinition.IsSealed)
                    {
                        PrintKeywordVirtual();
                    }
                }
                else
                {
                    // Instance method on a class
                    if (methodDefinition.IsAbstract)
                    {
                        PrintKeywordAbstract();
                    }

                    if (methodDefinition.IsNewSlot)
                    {
                        // Only overrides (or interface impls) can be sealed in C#.  If this is
                        // a new sealed virtual then just emit as non-virtual which is a similar thing.
                        // We get these in reference assemblies for methods which were implementations of private (and so removed)
                        // interfaces.
                        if (!methodDefinition.IsSealed && !methodDefinition.IsAbstract)
                        {
                            PrintKeywordVirtual();
                        }
                    }
                    else
                    {
                        PrintKeywordOverride();
                        if (methodDefinition.IsSealed)
                        {
                            PrintKeywordSealed();
                        }
                    }
                }
            }
        }