internal static void ReportUndocumentedExceptions(
        this OperationAnalysisContext @this,
        DiagnosticDescriptor descriptorForThrow,
        DiagnosticDescriptor descriptorForInvocation,
        TypeSet documented,
        IEnumerable <ExceptionalOperation> exceptions
        )
    {
        foreach (ExceptionalOperation exception in exceptions)
        {
            Boolean isDocumented = documented.Contains(exception.Type);

            if (!isDocumented)
            {
                @this.ReportUndocumentedException(
                    descriptorForThrow: descriptorForThrow,
                    descriptorForInvocation: descriptorForInvocation,
                    exception: exception
                    );
            }
        }
    }
    private void AnalyzeSymbolInitializer(OperationAnalysisContext context)
    {
        ISymbolInitializerOperation operation = ((ISymbolInitializerOperation)context.Operation);
        Compilation compilation = context.Compilation;

        ISymbol initializedMember = operation.GetInitializedMembers().First();
        IEnumerable <ExceptionalOperation> initializerExceptions = operation.GetExceptionalOperations(compilation);

        if (initializedMember.IsStatic)
        {
            foreach (ExceptionalOperation initializerException in initializerExceptions)
            {
                context.ReportDiagnostic(Diagnostic.Create(
                                             Descriptors.StaticInitializersShouldNotThrowExceptions,
                                             initializerException.Location
                                             ));
            }
        }
        else
        {
            IEnumerable <IMethodSymbol> initializationConstructors = operation.GetInitializationConstructors();

            TypeSet documentedExceptionsInAllInitializationConstructors = TypeSet.Universal;

            foreach (IMethodSymbol constructor in initializationConstructors)
            {
                TypeSet documentedExceptions = constructor.GetDocumentedExceptionSet(compilation);

                documentedExceptionsInAllInitializationConstructors &= documentedExceptions;

                foreach (ExceptionalOperation exception in initializerExceptions)
                {
                    ITypeSymbol exceptionType = exception.Type;

                    if (!documentedExceptions.Contains(exceptionType))
                    {
                        foreach (Location location in constructor.Locations)
                        {
                            context.ReportDiagnostic(Diagnostic.Create(
                                                         Descriptors.DocumentInstanceMemberInitializerExceptions,
                                                         location,
                                                         exceptionType.ToDisplayString(SymbolDisplayFormat.CSharpShortErrorMessageFormat),
                                                         initializedMember.Name
                                                         ));
                        }
                    }
                }
            }

            // For each exception that isn't documented in all the right places, add an additional diagnostic at the throw/invocation site
            foreach (ExceptionalOperation exception in initializerExceptions)
            {
                Boolean documentedInAllInitializationConstructors =
                    documentedExceptionsInAllInitializationConstructors.Contains(exception.Type);

                if (!documentedInAllInitializationConstructors)
                {
                    context.ReportUndocumentedException(
                        descriptorForThrow: Descriptors.DocumentInstanceMemberInitializerThrownExceptions,
                        descriptorForInvocation: Descriptors.DocumentInstanceMemberInitializerCalleeExceptions,
                        exception: exception
                        );
                }
            }
        }
    }