DiagnosticEventHandler.g.cs

Go to the documentation of this file.

#nullable enable
 
namespace IKVM.CoreLib.Diagnostics
{
 
    internal abstract partial class DiagnosticEventHandler
    {
 
        public void MainMethodFound(string arg0)
        {
            if (IsEnabled(Diagnostic.MainMethodFound))
                Report(Diagnostic.MainMethodFound.Event([arg0]));
        }
 
        public void OutputFileIs(string arg0)
        {
            if (IsEnabled(Diagnostic.OutputFileIs))
                Report(Diagnostic.OutputFileIs.Event([arg0]));
        }
 
        public void AutoAddRef(string arg0)
        {
            if (IsEnabled(Diagnostic.AutoAddRef))
                Report(Diagnostic.AutoAddRef.Event([arg0]));
        }
 
        public void MainMethodFromManifest(string arg0)
        {
            if (IsEnabled(Diagnostic.MainMethodFromManifest))
                Report(Diagnostic.MainMethodFromManifest.Event([arg0]));
        }
 
        public void GenericCompilerInfo(string arg0)
        {
            if (IsEnabled(Diagnostic.GenericCompilerInfo))
                Report(Diagnostic.GenericCompilerInfo.Event([arg0]));
        }
 
        public void GenericClassLoadingInfo(string arg0)
        {
            if (IsEnabled(Diagnostic.GenericClassLoadingInfo))
                Report(Diagnostic.GenericClassLoadingInfo.Event([arg0]));
        }
 
        public void GenericVerifierInfo(string arg0)
        {
            if (IsEnabled(Diagnostic.GenericVerifierInfo))
                Report(Diagnostic.GenericVerifierInfo.Event([arg0]));
        }
 
        public void GenericRuntimeInfo(string arg0)
        {
            if (IsEnabled(Diagnostic.GenericRuntimeInfo))
                Report(Diagnostic.GenericRuntimeInfo.Event([arg0]));
        }
 
        public void GenericJniInfo(string arg0)
        {
            if (IsEnabled(Diagnostic.GenericJniInfo))
                Report(Diagnostic.GenericJniInfo.Event([arg0]));
        }
 
        public void ClassNotFound(string arg0)
        {
            if (IsEnabled(Diagnostic.ClassNotFound))
                Report(Diagnostic.ClassNotFound.Event([arg0]));
        }
 
        public void ClassFormatError(string arg0, string arg1)
        {
            if (IsEnabled(Diagnostic.ClassFormatError))
                Report(Diagnostic.ClassFormatError.Event([arg0, arg1]));
        }
 
        public void DuplicateClassName(string arg0)
        {
            if (IsEnabled(Diagnostic.DuplicateClassName))
                Report(Diagnostic.DuplicateClassName.Event([arg0]));
        }
 
        public void IllegalAccessError(string arg0, string arg1)
        {
            if (IsEnabled(Diagnostic.IllegalAccessError))
                Report(Diagnostic.IllegalAccessError.Event([arg0, arg1]));
        }
 
        public void VerificationError(string arg0, string arg1)
        {
            if (IsEnabled(Diagnostic.VerificationError))
                Report(Diagnostic.VerificationError.Event([arg0, arg1]));
        }
 
        public void NoClassDefFoundError(string arg0, string arg1)
        {
            if (IsEnabled(Diagnostic.NoClassDefFoundError))
                Report(Diagnostic.NoClassDefFoundError.Event([arg0, arg1]));
        }
 
        public void GenericUnableToCompileError(string arg0, string arg1, string arg2)
        {
            if (IsEnabled(Diagnostic.GenericUnableToCompileError))
                Report(Diagnostic.GenericUnableToCompileError.Event([arg0, arg1, arg2]));
        }
 
        public void DuplicateResourceName(string arg0)
        {
            if (IsEnabled(Diagnostic.DuplicateResourceName))
                Report(Diagnostic.DuplicateResourceName.Event([arg0]));
        }
 
        public void SkippingReferencedClass(string arg0, string arg1)
        {
            if (IsEnabled(Diagnostic.SkippingReferencedClass))
                Report(Diagnostic.SkippingReferencedClass.Event([arg0, arg1]));
        }
 
        public void NoJniRuntime()
        {
            if (IsEnabled(Diagnostic.NoJniRuntime))
                Report(Diagnostic.NoJniRuntime.Event([]));
        }
 
        public void EmittedNoClassDefFoundError(string arg0, string arg1)
        {
            if (IsEnabled(Diagnostic.EmittedNoClassDefFoundError))
                Report(Diagnostic.EmittedNoClassDefFoundError.Event([arg0, arg1]));
        }
 
        public void EmittedIllegalAccessError(string arg0, string arg1)
        {
            if (IsEnabled(Diagnostic.EmittedIllegalAccessError))
                Report(Diagnostic.EmittedIllegalAccessError.Event([arg0, arg1]));
        }
 
        public void EmittedInstantiationError(string arg0, string arg1)
        {
            if (IsEnabled(Diagnostic.EmittedInstantiationError))
                Report(Diagnostic.EmittedInstantiationError.Event([arg0, arg1]));
        }
 
        public void EmittedIncompatibleClassChangeError(string arg0, string arg1)
        {
            if (IsEnabled(Diagnostic.EmittedIncompatibleClassChangeError))
                Report(Diagnostic.EmittedIncompatibleClassChangeError.Event([arg0, arg1]));
        }
 
        public void EmittedNoSuchFieldError(string arg0, string arg1)
        {
            if (IsEnabled(Diagnostic.EmittedNoSuchFieldError))
                Report(Diagnostic.EmittedNoSuchFieldError.Event([arg0, arg1]));
        }
 
        public void EmittedAbstractMethodError(string arg0, string arg1)
        {
            if (IsEnabled(Diagnostic.EmittedAbstractMethodError))
                Report(Diagnostic.EmittedAbstractMethodError.Event([arg0, arg1]));
        }
 
        public void EmittedNoSuchMethodError(string arg0, string arg1)
        {
            if (IsEnabled(Diagnostic.EmittedNoSuchMethodError))
                Report(Diagnostic.EmittedNoSuchMethodError.Event([arg0, arg1]));
        }
 
        public void EmittedLinkageError(string arg0, string arg1)
        {
            if (IsEnabled(Diagnostic.EmittedLinkageError))
                Report(Diagnostic.EmittedLinkageError.Event([arg0, arg1]));
        }
 
        public void EmittedVerificationError(string arg0, string arg1)
        {
            if (IsEnabled(Diagnostic.EmittedVerificationError))
                Report(Diagnostic.EmittedVerificationError.Event([arg0, arg1]));
        }
 
        public void EmittedClassFormatError(string arg0, string arg1)
        {
            if (IsEnabled(Diagnostic.EmittedClassFormatError))
                Report(Diagnostic.EmittedClassFormatError.Event([arg0, arg1]));
        }
 
        public void InvalidCustomAttribute(string arg0, string arg1)
        {
            if (IsEnabled(Diagnostic.InvalidCustomAttribute))
                Report(Diagnostic.InvalidCustomAttribute.Event([arg0, arg1]));
        }
 
        public void IgnoredCustomAttribute(string arg0, string arg1)
        {
            if (IsEnabled(Diagnostic.IgnoredCustomAttribute))
                Report(Diagnostic.IgnoredCustomAttribute.Event([arg0, arg1]));
        }
 
        public void AssumeAssemblyVersionMatch(string arg0, string arg1)
        {
            if (IsEnabled(Diagnostic.AssumeAssemblyVersionMatch))
                Report(Diagnostic.AssumeAssemblyVersionMatch.Event([arg0, arg1]));
        }
 
        public void InvalidDirectoryInLibOptionPath(string arg0)
        {
            if (IsEnabled(Diagnostic.InvalidDirectoryInLibOptionPath))
                Report(Diagnostic.InvalidDirectoryInLibOptionPath.Event([arg0]));
        }
 
        public void InvalidDirectoryInLibEnvironmentPath(string arg0)
        {
            if (IsEnabled(Diagnostic.InvalidDirectoryInLibEnvironmentPath))
                Report(Diagnostic.InvalidDirectoryInLibEnvironmentPath.Event([arg0]));
        }
 
        public void LegacySearchRule(string arg0)
        {
            if (IsEnabled(Diagnostic.LegacySearchRule))
                Report(Diagnostic.LegacySearchRule.Event([arg0]));
        }
 
        public void AssemblyLocationIgnored(string arg0, string arg1, string arg2)
        {
            if (IsEnabled(Diagnostic.AssemblyLocationIgnored))
                Report(Diagnostic.AssemblyLocationIgnored.Event([arg0, arg1, arg2]));
        }
 
        public void InterfaceMethodCantBeInternal(string arg0, string arg1, string arg2)
        {
            if (IsEnabled(Diagnostic.InterfaceMethodCantBeInternal))
                Report(Diagnostic.InterfaceMethodCantBeInternal.Event([arg0, arg1, arg2]));
        }
 
        public void DuplicateAssemblyReference(string arg0)
        {
            if (IsEnabled(Diagnostic.DuplicateAssemblyReference))
                Report(Diagnostic.DuplicateAssemblyReference.Event([arg0]));
        }
 
        public void UnableToResolveType(string arg0, string arg1, string arg2)
        {
            if (IsEnabled(Diagnostic.UnableToResolveType))
                Report(Diagnostic.UnableToResolveType.Event([arg0, arg1, arg2]));
        }
 
        public void StubsAreDeprecated(string arg0)
        {
            if (IsEnabled(Diagnostic.StubsAreDeprecated))
                Report(Diagnostic.StubsAreDeprecated.Event([arg0]));
        }
 
        public void WrongClassName(string arg0, string arg1)
        {
            if (IsEnabled(Diagnostic.WrongClassName))
                Report(Diagnostic.WrongClassName.Event([arg0, arg1]));
        }
 
        public void ReflectionCallerClassRequiresCallerID(string arg0, string arg1, string arg2)
        {
            if (IsEnabled(Diagnostic.ReflectionCallerClassRequiresCallerID))
                Report(Diagnostic.ReflectionCallerClassRequiresCallerID.Event([arg0, arg1, arg2]));
        }
 
        public void LegacyAssemblyAttributesFound()
        {
            if (IsEnabled(Diagnostic.LegacyAssemblyAttributesFound))
                Report(Diagnostic.LegacyAssemblyAttributesFound.Event([]));
        }
 
        public void UnableToCreateLambdaFactory()
        {
            if (IsEnabled(Diagnostic.UnableToCreateLambdaFactory))
                Report(Diagnostic.UnableToCreateLambdaFactory.Event([]));
        }
 
        public void UnknownWarning(string arg0)
        {
            if (IsEnabled(Diagnostic.UnknownWarning))
                Report(Diagnostic.UnknownWarning.Event([arg0]));
        }
 
        public void DuplicateIkvmLangProperty(string arg0, string arg1)
        {
            if (IsEnabled(Diagnostic.DuplicateIkvmLangProperty))
                Report(Diagnostic.DuplicateIkvmLangProperty.Event([arg0, arg1]));
        }
 
        public void MalformedIkvmLangProperty(string arg0, string arg1)
        {
            if (IsEnabled(Diagnostic.MalformedIkvmLangProperty))
                Report(Diagnostic.MalformedIkvmLangProperty.Event([arg0, arg1]));
        }
 
        public void GenericCompilerWarning(string arg0)
        {
            if (IsEnabled(Diagnostic.GenericCompilerWarning))
                Report(Diagnostic.GenericCompilerWarning.Event([arg0]));
        }
 
        public void GenericClassLoadingWarning(string arg0)
        {
            if (IsEnabled(Diagnostic.GenericClassLoadingWarning))
                Report(Diagnostic.GenericClassLoadingWarning.Event([arg0]));
        }
 
        public void GenericVerifierWarning(string arg0)
        {
            if (IsEnabled(Diagnostic.GenericVerifierWarning))
                Report(Diagnostic.GenericVerifierWarning.Event([arg0]));
        }
 
        public void GenericRuntimeWarning(string arg0)
        {
            if (IsEnabled(Diagnostic.GenericRuntimeWarning))
                Report(Diagnostic.GenericRuntimeWarning.Event([arg0]));
        }
 
        public void GenericJniWarning(string arg0)
        {
            if (IsEnabled(Diagnostic.GenericJniWarning))
                Report(Diagnostic.GenericJniWarning.Event([arg0]));
        }
 
        public void UnableToCreateProxy(string arg0, string arg1)
        {
            if (IsEnabled(Diagnostic.UnableToCreateProxy))
                Report(Diagnostic.UnableToCreateProxy.Event([arg0, arg1]));
        }
 
        public void DuplicateProxy(string arg0)
        {
            if (IsEnabled(Diagnostic.DuplicateProxy))
                Report(Diagnostic.DuplicateProxy.Event([arg0]));
        }
 
        public void MapXmlUnableToResolveOpCode(string arg0)
        {
            if (IsEnabled(Diagnostic.MapXmlUnableToResolveOpCode))
                Report(Diagnostic.MapXmlUnableToResolveOpCode.Event([arg0]));
        }
 
        public void MapXmlError(string arg0)
        {
            if (IsEnabled(Diagnostic.MapXmlError))
                Report(Diagnostic.MapXmlError.Event([arg0]));
        }
 
        public void InputFileNotFound(string arg0)
        {
            if (IsEnabled(Diagnostic.InputFileNotFound))
                Report(Diagnostic.InputFileNotFound.Event([arg0]));
        }
 
        public void UnknownFileType(string arg0)
        {
            if (IsEnabled(Diagnostic.UnknownFileType))
                Report(Diagnostic.UnknownFileType.Event([arg0]));
        }
 
        public void UnknownElementInMapFile(string arg0, string arg1, string arg2)
        {
            if (IsEnabled(Diagnostic.UnknownElementInMapFile))
                Report(Diagnostic.UnknownElementInMapFile.Event([arg0, arg1, arg2]));
        }
 
        public void UnknownAttributeInMapFile(string arg0, string arg1, string arg2)
        {
            if (IsEnabled(Diagnostic.UnknownAttributeInMapFile))
                Report(Diagnostic.UnknownAttributeInMapFile.Event([arg0, arg1, arg2]));
        }
 
        public void InvalidMemberNameInMapFile(string arg0, string arg1, string arg2)
        {
            if (IsEnabled(Diagnostic.InvalidMemberNameInMapFile))
                Report(Diagnostic.InvalidMemberNameInMapFile.Event([arg0, arg1, arg2]));
        }
 
        public void InvalidMemberSignatureInMapFile(string arg0, string arg1, string arg2, string arg3)
        {
            if (IsEnabled(Diagnostic.InvalidMemberSignatureInMapFile))
                Report(Diagnostic.InvalidMemberSignatureInMapFile.Event([arg0, arg1, arg2, arg3]));
        }
 
        public void InvalidPropertyNameInMapFile(string arg0, string arg1, string arg2, string arg3)
        {
            if (IsEnabled(Diagnostic.InvalidPropertyNameInMapFile))
                Report(Diagnostic.InvalidPropertyNameInMapFile.Event([arg0, arg1, arg2, arg3]));
        }
 
        public void InvalidPropertySignatureInMapFile(string arg0, string arg1, string arg2, string arg3)
        {
            if (IsEnabled(Diagnostic.InvalidPropertySignatureInMapFile))
                Report(Diagnostic.InvalidPropertySignatureInMapFile.Event([arg0, arg1, arg2, arg3]));
        }
 
        public void NonPrimaryAssemblyReference(string arg0, string arg1)
        {
            if (IsEnabled(Diagnostic.NonPrimaryAssemblyReference))
                Report(Diagnostic.NonPrimaryAssemblyReference.Event([arg0, arg1]));
        }
 
        public void MissingType(string arg0, string arg1)
        {
            if (IsEnabled(Diagnostic.MissingType))
                Report(Diagnostic.MissingType.Event([arg0, arg1]));
        }
 
        public void MissingReference(string arg0, string arg1)
        {
            if (IsEnabled(Diagnostic.MissingReference))
                Report(Diagnostic.MissingReference.Event([arg0, arg1]));
        }
 
        public void CallerSensitiveOnUnsupportedMethod(string arg0, string arg1, string arg2)
        {
            if (IsEnabled(Diagnostic.CallerSensitiveOnUnsupportedMethod))
                Report(Diagnostic.CallerSensitiveOnUnsupportedMethod.Event([arg0, arg1, arg2]));
        }
 
        public void RemappedTypeMissingDefaultInterfaceMethod(string arg0, string arg1)
        {
            if (IsEnabled(Diagnostic.RemappedTypeMissingDefaultInterfaceMethod))
                Report(Diagnostic.RemappedTypeMissingDefaultInterfaceMethod.Event([arg0, arg1]));
        }
 
        public void GenericCompilerError(string arg0)
        {
            if (IsEnabled(Diagnostic.GenericCompilerError))
                Report(Diagnostic.GenericCompilerError.Event([arg0]));
        }
 
        public void GenericClassLoadingError(string arg0)
        {
            if (IsEnabled(Diagnostic.GenericClassLoadingError))
                Report(Diagnostic.GenericClassLoadingError.Event([arg0]));
        }
 
        public void GenericVerifierError(string arg0)
        {
            if (IsEnabled(Diagnostic.GenericVerifierError))
                Report(Diagnostic.GenericVerifierError.Event([arg0]));
        }
 
        public void GenericRuntimeError(string arg0)
        {
            if (IsEnabled(Diagnostic.GenericRuntimeError))
                Report(Diagnostic.GenericRuntimeError.Event([arg0]));
        }
 
        public void GenericJniError(string arg0)
        {
            if (IsEnabled(Diagnostic.GenericJniError))
                Report(Diagnostic.GenericJniError.Event([arg0]));
        }
 
        public void ExportingImportsNotSupported()
        {
            if (IsEnabled(Diagnostic.ExportingImportsNotSupported))
                Report(Diagnostic.ExportingImportsNotSupported.Event([]));
        }
 
        public void ResponseFileDepthExceeded()
        {
            if (IsEnabled(Diagnostic.ResponseFileDepthExceeded))
                Report(Diagnostic.ResponseFileDepthExceeded.Event([]));
        }
 
        public void ErrorReadingFile(string arg0, string arg1)
        {
            if (IsEnabled(Diagnostic.ErrorReadingFile))
                Report(Diagnostic.ErrorReadingFile.Event([arg0, arg1]));
        }
 
        public void NoTargetsFound()
        {
            if (IsEnabled(Diagnostic.NoTargetsFound))
                Report(Diagnostic.NoTargetsFound.Event([]));
        }
 
        public void FileFormatLimitationExceeded(string arg0)
        {
            if (IsEnabled(Diagnostic.FileFormatLimitationExceeded))
                Report(Diagnostic.FileFormatLimitationExceeded.Event([arg0]));
        }
 
        public void CannotSpecifyBothKeyFileAndContainer()
        {
            if (IsEnabled(Diagnostic.CannotSpecifyBothKeyFileAndContainer))
                Report(Diagnostic.CannotSpecifyBothKeyFileAndContainer.Event([]));
        }
 
        public void DelaySignRequiresKey()
        {
            if (IsEnabled(Diagnostic.DelaySignRequiresKey))
                Report(Diagnostic.DelaySignRequiresKey.Event([]));
        }
 
        public void InvalidStrongNameKeyPair(string arg0, string arg1)
        {
            if (IsEnabled(Diagnostic.InvalidStrongNameKeyPair))
                Report(Diagnostic.InvalidStrongNameKeyPair.Event([arg0, arg1]));
        }
 
        public void ReferenceNotFound(string arg0)
        {
            if (IsEnabled(Diagnostic.ReferenceNotFound))
                Report(Diagnostic.ReferenceNotFound.Event([arg0]));
        }
 
        public void OptionsMustPreceedChildLevels()
        {
            if (IsEnabled(Diagnostic.OptionsMustPreceedChildLevels))
                Report(Diagnostic.OptionsMustPreceedChildLevels.Event([]));
        }
 
        public void UnrecognizedTargetType(string arg0)
        {
            if (IsEnabled(Diagnostic.UnrecognizedTargetType))
                Report(Diagnostic.UnrecognizedTargetType.Event([arg0]));
        }
 
        public void UnrecognizedPlatform(string arg0)
        {
            if (IsEnabled(Diagnostic.UnrecognizedPlatform))
                Report(Diagnostic.UnrecognizedPlatform.Event([arg0]));
        }
 
        public void UnrecognizedApartment(string arg0)
        {
            if (IsEnabled(Diagnostic.UnrecognizedApartment))
                Report(Diagnostic.UnrecognizedApartment.Event([arg0]));
        }
 
        public void MissingFileSpecification(string arg0)
        {
            if (IsEnabled(Diagnostic.MissingFileSpecification))
                Report(Diagnostic.MissingFileSpecification.Event([arg0]));
        }
 
        public void PathTooLong(string arg0)
        {
            if (IsEnabled(Diagnostic.PathTooLong))
                Report(Diagnostic.PathTooLong.Event([arg0]));
        }
 
        public void PathNotFound(string arg0)
        {
            if (IsEnabled(Diagnostic.PathNotFound))
                Report(Diagnostic.PathNotFound.Event([arg0]));
        }
 
        public void InvalidPath(string arg0)
        {
            if (IsEnabled(Diagnostic.InvalidPath))
                Report(Diagnostic.InvalidPath.Event([arg0]));
        }
 
        public void InvalidOptionSyntax(string arg0)
        {
            if (IsEnabled(Diagnostic.InvalidOptionSyntax))
                Report(Diagnostic.InvalidOptionSyntax.Event([arg0]));
        }
 
        public void ExternalResourceNotFound(string arg0)
        {
            if (IsEnabled(Diagnostic.ExternalResourceNotFound))
                Report(Diagnostic.ExternalResourceNotFound.Event([arg0]));
        }
 
        public void ExternalResourceNameInvalid(string arg0)
        {
            if (IsEnabled(Diagnostic.ExternalResourceNameInvalid))
                Report(Diagnostic.ExternalResourceNameInvalid.Event([arg0]));
        }
 
        public void InvalidVersionFormat(string arg0)
        {
            if (IsEnabled(Diagnostic.InvalidVersionFormat))
                Report(Diagnostic.InvalidVersionFormat.Event([arg0]));
        }
 
        public void InvalidFileAlignment(string arg0)
        {
            if (IsEnabled(Diagnostic.InvalidFileAlignment))
                Report(Diagnostic.InvalidFileAlignment.Event([arg0]));
        }
 
        public void ErrorWritingFile(string arg0, string arg1)
        {
            if (IsEnabled(Diagnostic.ErrorWritingFile))
                Report(Diagnostic.ErrorWritingFile.Event([arg0, arg1]));
        }
 
        public void UnrecognizedOption(string arg0)
        {
            if (IsEnabled(Diagnostic.UnrecognizedOption))
                Report(Diagnostic.UnrecognizedOption.Event([arg0]));
        }
 
        public void NoOutputFileSpecified()
        {
            if (IsEnabled(Diagnostic.NoOutputFileSpecified))
                Report(Diagnostic.NoOutputFileSpecified.Event([]));
        }
 
        public void SharedClassLoaderCannotBeUsedOnModuleTarget()
        {
            if (IsEnabled(Diagnostic.SharedClassLoaderCannotBeUsedOnModuleTarget))
                Report(Diagnostic.SharedClassLoaderCannotBeUsedOnModuleTarget.Event([]));
        }
 
        public void RuntimeNotFound()
        {
            if (IsEnabled(Diagnostic.RuntimeNotFound))
                Report(Diagnostic.RuntimeNotFound.Event([]));
        }
 
        public void MainClassRequiresExe()
        {
            if (IsEnabled(Diagnostic.MainClassRequiresExe))
                Report(Diagnostic.MainClassRequiresExe.Event([]));
        }
 
        public void ExeRequiresMainClass()
        {
            if (IsEnabled(Diagnostic.ExeRequiresMainClass))
                Report(Diagnostic.ExeRequiresMainClass.Event([]));
        }
 
        public void PropertiesRequireExe()
        {
            if (IsEnabled(Diagnostic.PropertiesRequireExe))
                Report(Diagnostic.PropertiesRequireExe.Event([]));
        }
 
        public void ModuleCannotHaveClassLoader()
        {
            if (IsEnabled(Diagnostic.ModuleCannotHaveClassLoader))
                Report(Diagnostic.ModuleCannotHaveClassLoader.Event([]));
        }
 
        public void ErrorParsingMapFile(string arg0, string arg1)
        {
            if (IsEnabled(Diagnostic.ErrorParsingMapFile))
                Report(Diagnostic.ErrorParsingMapFile.Event([arg0, arg1]));
        }
 
        public void BootstrapClassesMissing()
        {
            if (IsEnabled(Diagnostic.BootstrapClassesMissing))
                Report(Diagnostic.BootstrapClassesMissing.Event([]));
        }
 
        public void StrongNameRequiresStrongNamedRefs()
        {
            if (IsEnabled(Diagnostic.StrongNameRequiresStrongNamedRefs))
                Report(Diagnostic.StrongNameRequiresStrongNamedRefs.Event([]));
        }
 
        public void MainClassNotFound()
        {
            if (IsEnabled(Diagnostic.MainClassNotFound))
                Report(Diagnostic.MainClassNotFound.Event([]));
        }
 
        public void MainMethodNotFound()
        {
            if (IsEnabled(Diagnostic.MainMethodNotFound))
                Report(Diagnostic.MainMethodNotFound.Event([]));
        }
 
        public void UnsupportedMainMethod()
        {
            if (IsEnabled(Diagnostic.UnsupportedMainMethod))
                Report(Diagnostic.UnsupportedMainMethod.Event([]));
        }
 
        public void ExternalMainNotAccessible()
        {
            if (IsEnabled(Diagnostic.ExternalMainNotAccessible))
                Report(Diagnostic.ExternalMainNotAccessible.Event([]));
        }
 
        public void ClassLoaderNotFound()
        {
            if (IsEnabled(Diagnostic.ClassLoaderNotFound))
                Report(Diagnostic.ClassLoaderNotFound.Event([]));
        }
 
        public void ClassLoaderNotAccessible()
        {
            if (IsEnabled(Diagnostic.ClassLoaderNotAccessible))
                Report(Diagnostic.ClassLoaderNotAccessible.Event([]));
        }
 
        public void ClassLoaderIsAbstract()
        {
            if (IsEnabled(Diagnostic.ClassLoaderIsAbstract))
                Report(Diagnostic.ClassLoaderIsAbstract.Event([]));
        }
 
        public void ClassLoaderNotClassLoader()
        {
            if (IsEnabled(Diagnostic.ClassLoaderNotClassLoader))
                Report(Diagnostic.ClassLoaderNotClassLoader.Event([]));
        }
 
        public void ClassLoaderConstructorMissing()
        {
            if (IsEnabled(Diagnostic.ClassLoaderConstructorMissing))
                Report(Diagnostic.ClassLoaderConstructorMissing.Event([]));
        }
 
        public void MapFileTypeNotFound(string arg0)
        {
            if (IsEnabled(Diagnostic.MapFileTypeNotFound))
                Report(Diagnostic.MapFileTypeNotFound.Event([arg0]));
        }
 
        public void MapFileClassNotFound(string arg0)
        {
            if (IsEnabled(Diagnostic.MapFileClassNotFound))
                Report(Diagnostic.MapFileClassNotFound.Event([arg0]));
        }
 
        public void MaximumErrorCountReached()
        {
            if (IsEnabled(Diagnostic.MaximumErrorCountReached))
                Report(Diagnostic.MaximumErrorCountReached.Event([]));
        }
 
        public void LinkageError(string arg0)
        {
            if (IsEnabled(Diagnostic.LinkageError))
                Report(Diagnostic.LinkageError.Event([arg0]));
        }
 
        public void RuntimeMismatch(string referencedAssemblyPath, string runtimeAssemblyName, string referencedAssemblyName)
        {
            if (IsEnabled(Diagnostic.RuntimeMismatch))
                Report(Diagnostic.RuntimeMismatch.Event([referencedAssemblyPath, runtimeAssemblyName, referencedAssemblyName]));
        }
 
        public void RuntimeMismatchStrongName()
        {
            if (IsEnabled(Diagnostic.RuntimeMismatchStrongName))
                Report(Diagnostic.RuntimeMismatchStrongName.Event([]));
        }
 
        public void CoreClassesMissing()
        {
            if (IsEnabled(Diagnostic.CoreClassesMissing))
                Report(Diagnostic.CoreClassesMissing.Event([]));
        }
 
        public void CriticalClassNotFound(string arg0)
        {
            if (IsEnabled(Diagnostic.CriticalClassNotFound))
                Report(Diagnostic.CriticalClassNotFound.Event([arg0]));
        }
 
        public void AssemblyContainsDuplicateClassNames(string arg0, string arg1, string arg2, string arg3)
        {
            if (IsEnabled(Diagnostic.AssemblyContainsDuplicateClassNames))
                Report(Diagnostic.AssemblyContainsDuplicateClassNames.Event([arg0, arg1, arg2, arg3]));
        }
 
        public void CallerIDRequiresHasCallerIDAnnotation()
        {
            if (IsEnabled(Diagnostic.CallerIDRequiresHasCallerIDAnnotation))
                Report(Diagnostic.CallerIDRequiresHasCallerIDAnnotation.Event([]));
        }
 
        public void UnableToResolveInterface(string arg0, string arg1)
        {
            if (IsEnabled(Diagnostic.UnableToResolveInterface))
                Report(Diagnostic.UnableToResolveInterface.Event([arg0, arg1]));
        }
 
        public void MissingBaseType(string arg0, string arg1, string arg2, string arg3)
        {
            if (IsEnabled(Diagnostic.MissingBaseType))
                Report(Diagnostic.MissingBaseType.Event([arg0, arg1, arg2, arg3]));
        }
 
        public void MissingBaseTypeReference(string arg0, string arg1)
        {
            if (IsEnabled(Diagnostic.MissingBaseTypeReference))
                Report(Diagnostic.MissingBaseTypeReference.Event([arg0, arg1]));
        }
 
        public void FileNotFound(string arg0)
        {
            if (IsEnabled(Diagnostic.FileNotFound))
                Report(Diagnostic.FileNotFound.Event([arg0]));
        }
 
        public void RuntimeMethodMissing(string arg0)
        {
            if (IsEnabled(Diagnostic.RuntimeMethodMissing))
                Report(Diagnostic.RuntimeMethodMissing.Event([arg0]));
        }
 
        public void MapFileFieldNotFound(string arg0, string arg1)
        {
            if (IsEnabled(Diagnostic.MapFileFieldNotFound))
                Report(Diagnostic.MapFileFieldNotFound.Event([arg0, arg1]));
        }
 
        public void GhostInterfaceMethodMissing(string arg0, string arg1, string arg2, string arg3)
        {
            if (IsEnabled(Diagnostic.GhostInterfaceMethodMissing))
                Report(Diagnostic.GhostInterfaceMethodMissing.Event([arg0, arg1, arg2, arg3]));
        }
 
        public void ModuleInitializerMethodRequirements(string arg1, string arg2, string arg3)
        {
            if (IsEnabled(Diagnostic.ModuleInitializerMethodRequirements))
                Report(Diagnostic.ModuleInitializerMethodRequirements.Event([arg1, arg2, arg3]));
        }
 
        public void InvalidZip(string name)
        {
            if (IsEnabled(Diagnostic.InvalidZip))
                Report(Diagnostic.InvalidZip.Event([name]));
        }
 
        public void CoreAssemblyVersionMismatch(string arg0, string arg1)
        {
            if (IsEnabled(Diagnostic.CoreAssemblyVersionMismatch))
                Report(Diagnostic.CoreAssemblyVersionMismatch.Event([arg0, arg1]));
        }
 
        public void GenericRuntimeTrace(string arg0)
        {
            if (IsEnabled(Diagnostic.GenericRuntimeTrace))
                Report(Diagnostic.GenericRuntimeTrace.Event([arg0]));
        }
 
        public void GenericJniTrace(string arg0)
        {
            if (IsEnabled(Diagnostic.GenericJniTrace))
                Report(Diagnostic.GenericJniTrace.Event([arg0]));
        }
 
        public void GenericCompilerTrace(string arg0)
        {
            if (IsEnabled(Diagnostic.GenericCompilerTrace))
                Report(Diagnostic.GenericCompilerTrace.Event([arg0]));
        }
 
    }
 
}