// <auto-generated> using System.Reflection; namespace Microsoft.CodeAnalysis { internal static partial class CodeAnalysisDiagnosticsResources { private static global::System.Resources.ResourceManager s_resourceManager; internal static global::System.Resources.ResourceManager ResourceManager => s_resourceManager ?? (s_resourceManager = new global::System.Resources.ResourceManager(typeof(CodeAnalysisDiagnosticsResources))); internal static global::System.Globalization.CultureInfo Culture { get; set; } #if !NET20 [global::System.Runtime.CompilerServices.MethodImpl(global::System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)] #endif internal static string GetResourceString(string resourceKey, string defaultValue = null) => ResourceManager.GetString(resourceKey, Culture); /// <summary>Missing '{0}' attribute</summary> internal static string @MissingAttributeMessage => GetResourceString("MissingAttributeMessage"); /// <summary>Missing diagnostic analyzer attribute</summary> internal static string @MissingDiagnosticAnalyzerAttributeTitle => GetResourceString("MissingDiagnosticAnalyzerAttributeTitle"); /// <summary>Non-abstract sub-types of DiagnosticAnalyzer should be marked with DiagnosticAnalyzerAttribute(s). The argument to this attribute(s), if any, determine the supported languages for the analyzer. Analyzer types without this attribute will be ignored by the a ...</summary> internal static string @MissingDiagnosticAnalyzerAttributeDescription => GetResourceString("MissingDiagnosticAnalyzerAttributeDescription"); /// <summary>Diagnostic analyzer '{0}' may be able to support both C# and Visual Basic. Consider adding an argument to DiagnosticAnalyzerAttribute for '{1}' language support.</summary> internal static string @AddLanguageSupportToAnalyzerMessage => GetResourceString("AddLanguageSupportToAnalyzerMessage"); /// <summary>Recommend adding language support to diagnostic analyzer</summary> internal static string @AddLanguageSupportToAnalyzerTitle => GetResourceString("AddLanguageSupportToAnalyzerTitle"); /// <summary>Diagnostic analyzer is marked as supporting only one language, but the analyzer assembly doesn't seem to refer to any language specific CodeAnalysis assemblies, and so is likely to work for more than one language. Consider adding an additional language arg ...</summary> internal static string @AddLanguageSupportToAnalyzerDescription => GetResourceString("AddLanguageSupportToAnalyzerDescription"); /// <summary>Apply DiagnosticAnalyzer attribute for '{0}'.</summary> internal static string @ApplyDiagnosticAnalyzerAttribute_1 => GetResourceString("ApplyDiagnosticAnalyzerAttribute_1"); /// <summary>Apply DiagnosticAnalyzer attribute for both '{0}' and '{1}'.</summary> internal static string @ApplyDiagnosticAnalyzerAttribute_2 => GetResourceString("ApplyDiagnosticAnalyzerAttribute_2"); /// <summary>Specify at least one SymbolKind of interest when registering a symbol analyzer action</summary> internal static string @MissingSymbolKindArgumentToRegisterActionMessage => GetResourceString("MissingSymbolKindArgumentToRegisterActionMessage"); /// <summary>Specify at least one SyntaxKind of interest when registering a syntax node analyzer action</summary> internal static string @MissingSyntaxKindArgumentToRegisterActionMessage => GetResourceString("MissingSyntaxKindArgumentToRegisterActionMessage"); /// <summary>Specify at least one OperationKind of interest when registering an operation analyzer action</summary> internal static string @MissingOperationKindArgumentToRegisterActionMessage => GetResourceString("MissingOperationKindArgumentToRegisterActionMessage"); /// <summary>Missing kind argument when registering an analyzer action</summary> internal static string @MissingKindArgumentToRegisterActionTitle => GetResourceString("MissingKindArgumentToRegisterActionTitle"); /// <summary>You must specify at least one syntax, symbol or operation kind when registering a syntax, symbol, or operation analyzer action respectively. Otherwise, the registered action will never be invoked during analysis.</summary> internal static string @MissingKindArgumentToRegisterActionDescription => GetResourceString("MissingKindArgumentToRegisterActionDescription"); /// <summary>SymbolKind '{0}' is not supported for symbol analyzer actions</summary> internal static string @UnsupportedSymbolKindArgumentToRegisterActionMessage => GetResourceString("UnsupportedSymbolKindArgumentToRegisterActionMessage"); /// <summary>Unsupported SymbolKind argument when registering a symbol analyzer action</summary> internal static string @UnsupportedSymbolKindArgumentToRegisterActionTitle => GetResourceString("UnsupportedSymbolKindArgumentToRegisterActionTitle"); /// <summary>ReportDiagnostic invoked with an unsupported DiagnosticDescriptor '{0}'</summary> internal static string @InvalidReportDiagnosticMessage => GetResourceString("InvalidReportDiagnosticMessage"); /// <summary>ReportDiagnostic invoked with an unsupported DiagnosticDescriptor</summary> internal static string @InvalidReportDiagnosticTitle => GetResourceString("InvalidReportDiagnosticTitle"); /// <summary>ReportDiagnostic should only be invoked with supported DiagnosticDescriptors that are returned from DiagnosticAnalyzer.SupportedDiagnostics property. Otherwise, the reported diagnostic will be filtered out by the analysis engine.</summary> internal static string @InvalidReportDiagnosticDescription => GetResourceString("InvalidReportDiagnosticDescription"); /// <summary>Type argument '{0}' for type parameter '{1}' of method '{2}' is not a SyntaxKind enum</summary> internal static string @InvalidSyntaxKindTypeArgumentMessage => GetResourceString("InvalidSyntaxKindTypeArgumentMessage"); /// <summary>Invalid type argument for DiagnosticAnalyzer's Register method</summary> internal static string @InvalidSyntaxKindTypeArgumentTitle => GetResourceString("InvalidSyntaxKindTypeArgumentTitle"); /// <summary>DiagnosticAnalyzer's language-specific Register methods, such as RegisterSyntaxNodeAction, RegisterCodeBlockStartAction and RegisterCodeBlockEndAction, expect a language-specific 'SyntaxKind' type argument for it's '{0}' type parameter. Otherwise, the regi ...</summary> internal static string @InvalidSyntaxKindTypeArgumentDescription => GetResourceString("InvalidSyntaxKindTypeArgumentDescription"); /// <summary>Start action has no registered non-end actions</summary> internal static string @StartActionWithOnlyEndActionTitle => GetResourceString("StartActionWithOnlyEndActionTitle"); /// <summary>'{0}' does not register any analyzer actions. Consider moving actions registered in '{1}' that depend on this start action to '{0}'.</summary> internal static string @StartActionWithNoRegisteredActionsMessage => GetResourceString("StartActionWithNoRegisteredActionsMessage"); /// <summary>Start action has no registered actions</summary> internal static string @StartActionWithNoRegisteredActionsTitle => GetResourceString("StartActionWithNoRegisteredActionsTitle"); /// <summary>'{0}' does not register any analyzer actions, except for a '{1}'. Consider replacing this start/end action pair with a '{2}' or moving actions registered in '{3}' that depend on this start action to '{0}'.</summary> internal static string @StartActionWithOnlyEndActionMessage => GetResourceString("StartActionWithOnlyEndActionMessage"); /// <summary>An analyzer start action enables performing stateful analysis over a given code unit, such as a code block, compilation, etc. Careful design is necessary to achieve efficient analyzer execution without memory leaks. Use the following guidelines for writing ...</summary> internal static string @StatefulAnalyzerRegisterActionsDescription => GetResourceString("StatefulAnalyzerRegisterActionsDescription"); /// <summary>Consider providing localizable arguments of type '{0}' to diagnostic descriptor constructor to ensure the descriptor is localizable</summary> internal static string @UseLocalizableStringsInDescriptorMessage => GetResourceString("UseLocalizableStringsInDescriptorMessage"); /// <summary>Provide localizable arguments to diagnostic descriptor constructor</summary> internal static string @UseLocalizableStringsInDescriptorTitle => GetResourceString("UseLocalizableStringsInDescriptorTitle"); /// <summary>If your diagnostic analyzer and it's reported diagnostics need to be localizable, then the supported DiagnosticDescriptors used for constructing the diagnostics must also be localizable. If so, then localizable argument(s) must be provided for parameter 't ...</summary> internal static string @UseLocalizableStringsInDescriptorDescription => GetResourceString("UseLocalizableStringsInDescriptorDescription"); /// <summary>Consider providing a non-null 'helpLinkUri' to diagnostic descriptor constructor to show information when this diagnostic appears in the error list</summary> internal static string @ProvideHelpUriInDescriptorMessage => GetResourceString("ProvideHelpUriInDescriptorMessage"); /// <summary>Provide non-null 'helpLinkUri' value to diagnostic descriptor constructor</summary> internal static string @ProvideHelpUriInDescriptorTitle => GetResourceString("ProvideHelpUriInDescriptorTitle"); /// <summary>The 'helpLinkUri' value is used to show information when this diagnostic in the error list. Every analyzer should have a helpLinkUri specified which points to a help page that does not change over time.</summary> internal static string @ProvideHelpUriInDescriptorDescription => GetResourceString("ProvideHelpUriInDescriptorDescription"); /// <summary>Avoid storing per-compilation data of type '{0}' into the fields of a diagnostic analyzer</summary> internal static string @DoNotStorePerCompilationDataOntoFieldsMessage => GetResourceString("DoNotStorePerCompilationDataOntoFieldsMessage"); /// <summary>Avoid storing per-compilation data into the fields of a diagnostic analyzer</summary> internal static string @DoNotStorePerCompilationDataOntoFieldsTitle => GetResourceString("DoNotStorePerCompilationDataOntoFieldsTitle"); /// <summary>Instance of a diagnostic analyzer might outlive the lifetime of compilation. Hence, storing per-compilation data, such as symbols, into the fields of a diagnostic analyzer might cause stale compilations to stay alive and cause memory leaks. Instead, you s ...</summary> internal static string @DoNotStorePerCompilationDataOntoFieldsDescription => GetResourceString("DoNotStorePerCompilationDataOntoFieldsDescription"); /// <summary>The author of this interface did not intend to have third party implementations of this interface and reserves the right to change it. Implementing this interface could therefore result in a source or binary compatibility issue with a future version of thi ...</summary> internal static string @InternalImplementationOnlyDescription => GetResourceString("InternalImplementationOnlyDescription"); /// <summary>Type {0} cannot implement interface {1} because {1} is not available for public implementation</summary> internal static string @InternalImplementationOnlyMessage => GetResourceString("InternalImplementationOnlyMessage"); /// <summary>Only internal implementations of this interface are allowed</summary> internal static string @InternalImplementationOnlyTitle => GetResourceString("InternalImplementationOnlyTitle"); /// <summary>A CodeFixProvider that intends to support fix all occurrences must classify the registered code actions into equivalence classes by assigning it an explicit, non-null equivalence key which is unique for each kind of code action created by this fixer. This ...</summary> internal static string @CodeActionNeedsEquivalenceKeyDescription => GetResourceString("CodeActionNeedsEquivalenceKeyDescription"); /// <summary>Provide an explicit argument for optional parameter '{0}', which is non-null and unique for each kind of code action created by this fixer</summary> internal static string @CreateCodeActionWithEquivalenceKeyMessage => GetResourceString("CreateCodeActionWithEquivalenceKeyMessage"); /// <summary>Create code actions should have a unique EquivalenceKey for FixAll occurrences support</summary> internal static string @CreateCodeActionWithEquivalenceKeyTitle => GetResourceString("CreateCodeActionWithEquivalenceKeyTitle"); /// <summary>'{0}' has the default value of 'null' for property '{1}'. Either override this property on '{0}' to return a non-null and unique value across all code actions per-fixer or use such an existing code action.</summary> internal static string @OverrideCodeActionEquivalenceKeyMessage => GetResourceString("OverrideCodeActionEquivalenceKeyMessage"); /// <summary>Use code actions that have a unique EquivalenceKey for FixAll occurrences support</summary> internal static string @OverrideCodeActionEquivalenceKeyTitle => GetResourceString("OverrideCodeActionEquivalenceKeyTitle"); /// <summary>Code fix providers should provide FixAll support</summary> internal static string @OverrideGetFixAllProviderTitle => GetResourceString("OverrideGetFixAllProviderTitle"); /// <summary>'{0}' registers one or more code fixes, but does not override the method 'CodeFixProvider.GetFixAllProvider'. Override this method and provide a non-null FixAllProvider for FixAll support, potentially 'WellKnownFixAllProviders.BatchFixer', or 'null' to exp ...</summary> internal static string @OverrideGetFixAllProviderMessage => GetResourceString("OverrideGetFixAllProviderMessage"); /// <summary>A CodeFixProvider should provide FixAll support to enable users to fix multiple instances of the underlying diagnostic with a single code fix. See documentation at https://github.com/dotnet/roslyn/blob/main/docs/analyzers/FixAllProvider.md for further deta ...</summary> internal static string @OverrideGetFixAllProviderDescription => GetResourceString("OverrideGetFixAllProviderDescription"); /// <summary>Override GetFixAllProvider.</summary> internal static string @OverrideGetFixAllProviderCodeFixTitle => GetResourceString("OverrideGetFixAllProviderCodeFixTitle"); /// <summary>Many objects exposed by Roslyn are immutable. The return value from a method invocation on these objects should not be ignored.</summary> internal static string @DoNotIgnoreReturnValueOnImmutableObjectMethodInvocationDescription => GetResourceString("DoNotIgnoreReturnValueOnImmutableObjectMethodInvocationDescription"); /// <summary>'{0}' is immutable and '{1}' will not have any effect on it. Consider using the return value from '{1}'.</summary> internal static string @DoNotIgnoreReturnValueOnImmutableObjectMethodInvocationMessage => GetResourceString("DoNotIgnoreReturnValueOnImmutableObjectMethodInvocationMessage"); /// <summary>Do not ignore values returned by methods on immutable objects</summary> internal static string @DoNotIgnoreReturnValueOnImmutableObjectMethodInvocationTitle => GetResourceString("DoNotIgnoreReturnValueOnImmutableObjectMethodInvocationTitle"); /// <summary>DiagnosticId for analyzers must be a non-null constant</summary> internal static string @DiagnosticIdMustBeAConstantTitle => GetResourceString("DiagnosticIdMustBeAConstantTitle"); /// <summary>Diagnostic Id for rule '{0}' must be a non-null constant</summary> internal static string @DiagnosticIdMustBeAConstantMessage => GetResourceString("DiagnosticIdMustBeAConstantMessage"); /// <summary>DiagnosticId for analyzers must be a non-null constant.</summary> internal static string @DiagnosticIdMustBeAConstantDescription => GetResourceString("DiagnosticIdMustBeAConstantDescription"); /// <summary>DiagnosticId for analyzers must be in specified format</summary> internal static string @DiagnosticIdMustBeInSpecifiedFormatTitle => GetResourceString("DiagnosticIdMustBeInSpecifiedFormatTitle"); /// <summary>Diagnostic Id '{0}' belonging to category '{1}' is not in the required range and/or format '{2}' specified in the file '{3}'</summary> internal static string @DiagnosticIdMustBeInSpecifiedFormatMessage => GetResourceString("DiagnosticIdMustBeInSpecifiedFormatMessage"); /// <summary>DiagnosticId for analyzers must be in specified format.</summary> internal static string @DiagnosticIdMustBeInSpecifiedFormatDescription => GetResourceString("DiagnosticIdMustBeInSpecifiedFormatDescription"); /// <summary>DiagnosticId must be unique across analyzers</summary> internal static string @UseUniqueDiagnosticIdTitle => GetResourceString("UseUniqueDiagnosticIdTitle"); /// <summary>Diagnostic Id '{0}' is already used by analyzer '{1}'. Please use a different diagnostic ID.</summary> internal static string @UseUniqueDiagnosticIdMessage => GetResourceString("UseUniqueDiagnosticIdMessage"); /// <summary>DiagnosticId must be unique across analyzers.</summary> internal static string @UseUniqueDiagnosticIdDescription => GetResourceString("UseUniqueDiagnosticIdDescription"); /// <summary>Category for analyzers must be from the specified values</summary> internal static string @UseCategoriesFromSpecifiedRangeTitle => GetResourceString("UseCategoriesFromSpecifiedRangeTitle"); /// <summary>Category '{0}' is not from the allowed categories specified in the file '{1}'</summary> internal static string @UseCategoriesFromSpecifiedRangeMessage => GetResourceString("UseCategoriesFromSpecifiedRangeMessage"); /// <summary>Category for analyzers must be from the specified values.</summary> internal static string @UseCategoriesFromSpecifiedRangeDescription => GetResourceString("UseCategoriesFromSpecifiedRangeDescription"); /// <summary>Invalid entry in analyzer category and diagnostic ID range specification file</summary> internal static string @AnalyzerCategoryAndIdRangeFileInvalidTitle => GetResourceString("AnalyzerCategoryAndIdRangeFileInvalidTitle"); /// <summary>Invalid entry '{0}' in analyzer category and diagnostic ID range specification file '{1}'</summary> internal static string @AnalyzerCategoryAndIdRangeFileInvalidMessage => GetResourceString("AnalyzerCategoryAndIdRangeFileInvalidMessage"); /// <summary>Invalid entry in analyzer category and diagnostic ID range specification file.</summary> internal static string @AnalyzerCategoryAndIdRangeFileInvalidDescription => GetResourceString("AnalyzerCategoryAndIdRangeFileInvalidDescription"); /// <summary>Diagnostic analyzer types should not use types from Workspaces assemblies. Workspaces assemblies are only available when the analyzer executes in Visual Studio IDE live analysis, but are not available during command line build. Referencing types from Works ...</summary> internal static string @DoNotUseTypesFromAssemblyRuleDescription => GetResourceString("DoNotUseTypesFromAssemblyRuleDescription"); /// <summary>Change diagnostic analyzer type '{0}' to remove all direct accesses to type(s) '{1}'</summary> internal static string @DoNotUseTypesFromAssemblyRuleDirectMessage => GetResourceString("DoNotUseTypesFromAssemblyRuleDirectMessage"); /// <summary>Change diagnostic analyzer type '{0}' to remove all direct and/or indirect accesses to type(s) '{1}', which access type(s) '{2}'</summary> internal static string @DoNotUseTypesFromAssemblyRuleIndirectMessage => GetResourceString("DoNotUseTypesFromAssemblyRuleIndirectMessage"); /// <summary>Do not use types from Workspaces assembly in an analyzer</summary> internal static string @DoNotUseTypesFromAssemblyRuleTitle => GetResourceString("DoNotUseTypesFromAssemblyRuleTitle"); /// <summary>MSBuildWorkspace has moved to the Microsoft.CodeAnalysis.Workspaces.MSBuild NuGet package and there are breaking API changes.</summary> internal static string @UpgradeMSBuildWorkspaceDescription => GetResourceString("UpgradeMSBuildWorkspaceDescription"); /// <summary>Please upgrade MSBuildWorkspace by adding a package reference to the Microsoft.CodeAnalysis.Workspaces.MSBuild NuGet package. See https://go.microsoft.com/fwlink/?linkid=874285 for details on using MSBuildWorkspace successfully.</summary> internal static string @UpgradeMSBuildWorkspaceMessage => GetResourceString("UpgradeMSBuildWorkspaceMessage"); /// <summary>Upgrade MSBuildWorkspace</summary> internal static string @UpgradeMSBuildWorkspaceTitle => GetResourceString("UpgradeMSBuildWorkspaceTitle"); /// <summary>Symbols should be compared for equality, not identity. Use an overload accepting an 'IEqualityComparer' and pass 'SymbolEqualityComparer'.</summary> internal static string @CompareSymbolsCorrectlyDescription => GetResourceString("CompareSymbolsCorrectlyDescription"); /// <summary>Use 'SymbolEqualityComparer' when comparing symbols</summary> internal static string @CompareSymbolsCorrectlyMessage => GetResourceString("CompareSymbolsCorrectlyMessage"); /// <summary>Symbols should be compared for equality</summary> internal static string @CompareSymbolsCorrectlyTitle => GetResourceString("CompareSymbolsCorrectlyTitle"); /// <summary>Use a 'SymbolEqualityComparer' for symbol comparison</summary> internal static string @CompareSymbolsCorrectlyCodeFix => GetResourceString("CompareSymbolsCorrectlyCodeFix"); /// <summary>Configure generated code analysis</summary> internal static string @ConfigureGeneratedCodeAnalysisMessage => GetResourceString("ConfigureGeneratedCodeAnalysisMessage"); /// <summary>Configure generated code analysis</summary> internal static string @ConfigureGeneratedCodeAnalysisTitle => GetResourceString("ConfigureGeneratedCodeAnalysisTitle"); /// <summary>Enable concurrent execution</summary> internal static string @EnableConcurrentExecutionMessage => GetResourceString("EnableConcurrentExecutionMessage"); /// <summary>Enable concurrent execution</summary> internal static string @EnableConcurrentExecutionTitle => GetResourceString("EnableConcurrentExecutionTitle"); /// <summary>Configure generated code analysis</summary> internal static string @ConfigureGeneratedCodeAnalysisFix => GetResourceString("ConfigureGeneratedCodeAnalysisFix"); /// <summary>Enable concurrent execution</summary> internal static string @EnableConcurrentExecutionFix => GetResourceString("EnableConcurrentExecutionFix"); /// <summary>Inherit type '{0}' from DiagnosticAnalyzer or remove the DiagnosticAnalyzerAttribute(s)</summary> internal static string @ClassIsNotDiagnosticAnalyzerMessage => GetResourceString("ClassIsNotDiagnosticAnalyzerMessage"); /// <summary>Types marked with DiagnosticAnalyzerAttribute(s) should inherit from DiagnosticAnalyzer</summary> internal static string @ClassIsNotDiagnosticAnalyzerTitle => GetResourceString("ClassIsNotDiagnosticAnalyzerTitle"); /// <summary>The 'customTags' value is used as a way to enable specific actions and filters on diagnostic descriptors based on the specific values of the tags. Every Roslyn analyzer should have at least one tag from the 'WellKnownDiagnosticTags' class.</summary> internal static string @ProvideCustomTagsInDescriptorDescription => GetResourceString("ProvideCustomTagsInDescriptorDescription"); /// <summary>Consider providing a non-null 'customTags' to diagnostic descriptor constructor to enable metatada filtering of diagnostic descriptors</summary> internal static string @ProvideCustomTagsInDescriptorMessage => GetResourceString("ProvideCustomTagsInDescriptorMessage"); /// <summary>Provide non-null 'customTags' value to diagnostic descriptor constructor</summary> internal static string @ProvideCustomTagsInDescriptorTitle => GetResourceString("ProvideCustomTagsInDescriptorTitle"); /// <summary>DiagnosticId for analyzers should not use reserved IDs.</summary> internal static string @DoNotUseReservedDiagnosticIdDescription => GetResourceString("DoNotUseReservedDiagnosticIdDescription"); /// <summary>'{0}' is a reserved diagnostic ID</summary> internal static string @DoNotUseReservedDiagnosticIdMessage => GetResourceString("DoNotUseReservedDiagnosticIdMessage"); /// <summary>Do not use reserved diagnostic IDs</summary> internal static string @DoNotUseReservedDiagnosticIdTitle => GetResourceString("DoNotUseReservedDiagnosticIdTitle"); /// <summary>'GetSemanticModel' is an expensive method to invoke within a diagnostic analyzer because it creates a completely new semantic model, which does not share compilation data with the compiler or other analyzers. This incurs an additional performance cost duri ...</summary> internal static string @DoNotUseCompilationGetSemanticModelDescription => GetResourceString("DoNotUseCompilationGetSemanticModelDescription"); /// <summary>Do not invoke Compilation.GetSemanticModel() method within a diagnostic analyzer</summary> internal static string @DoNotUseCompilationGetSemanticModelMessage => GetResourceString("DoNotUseCompilationGetSemanticModelMessage"); /// <summary>Do not invoke Compilation.GetSemanticModel() method within a diagnostic analyzer</summary> internal static string @DoNotUseCompilationGetSemanticModelTitle => GetResourceString("DoNotUseCompilationGetSemanticModelTitle"); /// <summary>Add analyzer diagnostic IDs to analyzer release</summary> internal static string @DeclareDiagnosticIdInAnalyzerReleaseTitle => GetResourceString("DeclareDiagnosticIdInAnalyzerReleaseTitle"); /// <summary>Rule '{0}' is not part of any analyzer release</summary> internal static string @DeclareDiagnosticIdInAnalyzerReleaseMessage => GetResourceString("DeclareDiagnosticIdInAnalyzerReleaseMessage"); /// <summary>All supported analyzer diagnostic IDs should be part of an analyzer release.</summary> internal static string @DeclareDiagnosticIdInAnalyzerReleaseDescription => GetResourceString("DeclareDiagnosticIdInAnalyzerReleaseDescription"); /// <summary>Add rule entry to unshipped release file</summary> internal static string @AddEntryForDiagnosticIdInAnalyzerReleaseCodeFixTitle => GetResourceString("AddEntryForDiagnosticIdInAnalyzerReleaseCodeFixTitle"); /// <summary>Ensure up-to-date entry for analyzer diagnostic IDs are added to analyzer release</summary> internal static string @UpdateDiagnosticIdInAnalyzerReleaseTitle => GetResourceString("UpdateDiagnosticIdInAnalyzerReleaseTitle"); /// <summary>Rule '{0}' has a changed 'Category' or 'Severity' from the last release. Either revert the update(s) in source or add a new up-to-date entry to unshipped release file.</summary> internal static string @UpdateDiagnosticIdInAnalyzerReleaseMessage => GetResourceString("UpdateDiagnosticIdInAnalyzerReleaseMessage"); /// <summary>Ensure up-to-date entry for analyzer diagnostic IDs are added to analyzer release.</summary> internal static string @UpdateDiagnosticIdInAnalyzerReleaseDescription => GetResourceString("UpdateDiagnosticIdInAnalyzerReleaseDescription"); /// <summary>Update rule entry in unshipped release file</summary> internal static string @UpdateEntryForDiagnosticIdInAnalyzerReleaseCodeFixTitle => GetResourceString("UpdateEntryForDiagnosticIdInAnalyzerReleaseCodeFixTitle"); /// <summary>Do not add removed analyzer diagnostic IDs to unshipped analyzer release</summary> internal static string @RemoveUnshippedDeletedDiagnosticIdTitle => GetResourceString("RemoveUnshippedDeletedDiagnosticIdTitle"); /// <summary>Rule '{0}' is part of the next unshipped analyzer release, but is not a supported diagnostic for any analyzer</summary> internal static string @RemoveUnshippedDeletedDiagnosticIdMessage => GetResourceString("RemoveUnshippedDeletedDiagnosticIdMessage"); /// <summary>Entries for analyzer diagnostic IDs that are no longer reported and never shipped can be removed from unshipped analyzer release.</summary> internal static string @RemoveUnshippedDeletedDiagnosticIdDescription => GetResourceString("RemoveUnshippedDeletedDiagnosticIdDescription"); /// <summary>Shipped diagnostic IDs that are no longer reported should have an entry in the 'Removed Rules' table in unshipped file</summary> internal static string @RemoveShippedDeletedDiagnosticIdTitle => GetResourceString("RemoveShippedDeletedDiagnosticIdTitle"); /// <summary>Rule '{0}' was shipped in analyzer release '{1}', but is no longer a supported diagnostic for any analyzer. Add an entry for this rule in a 'Removed Rules' table to unshipped file.</summary> internal static string @RemoveShippedDeletedDiagnosticIdMessage => GetResourceString("RemoveShippedDeletedDiagnosticIdMessage"); /// <summary>Shipped diagnostic IDs that are no longer reported should have an entry in the 'Removed Rules' table in unshipped file.</summary> internal static string @RemoveShippedDeletedDiagnosticIdDescription => GetResourceString("RemoveShippedDeletedDiagnosticIdDescription"); /// <summary>Diagnostic IDs marked as removed in analyzer release file should not be reported by analyzers</summary> internal static string @UnexpectedAnalyzerDiagnosticForRemovedDiagnosticIdTitle => GetResourceString("UnexpectedAnalyzerDiagnosticForRemovedDiagnosticIdTitle"); /// <summary>Rule '{0}' is marked as removed in the latest analyzer release, but is still being reported</summary> internal static string @UnexpectedAnalyzerDiagnosticForRemovedDiagnosticIdMessage => GetResourceString("UnexpectedAnalyzerDiagnosticForRemovedDiagnosticIdMessage"); /// <summary>Diagnostic IDs marked as removed in analyzer release file should not be reported by analyzers.</summary> internal static string @UnexpectedAnalyzerDiagnosticForRemovedDiagnosticIdDescription => GetResourceString("UnexpectedAnalyzerDiagnosticForRemovedDiagnosticIdDescription"); /// <summary>Remove duplicate entries for diagnostic ID in the same analyzer release</summary> internal static string @RemoveDuplicateEntriesForAnalyzerReleaseRuleTitle => GetResourceString("RemoveDuplicateEntriesForAnalyzerReleaseRuleTitle"); /// <summary>Rule '{0}' has more then one entry for release '{1}' in analyzer release file '{2}'</summary> internal static string @RemoveDuplicateEntriesForAnalyzerReleaseRuleMessage => GetResourceString("RemoveDuplicateEntriesForAnalyzerReleaseRuleMessage"); /// <summary>Remove duplicate entries for diagnostic ID in the same analyzer release.</summary> internal static string @RemoveDuplicateEntriesForAnalyzerReleaseRuleDescription => GetResourceString("RemoveDuplicateEntriesForAnalyzerReleaseRuleDescription"); /// <summary>Remove duplicate entries for diagnostic ID between analyzer releases</summary> internal static string @RemoveDuplicateEntriesBetweenAnalyzerReleasesRuleTitle => GetResourceString("RemoveDuplicateEntriesBetweenAnalyzerReleasesRuleTitle"); /// <summary>Rule '{0}' has duplicate entry between release '{1}' and release '{2}'</summary> internal static string @RemoveDuplicateEntriesBetweenAnalyzerReleasesRuleMessage => GetResourceString("RemoveDuplicateEntriesBetweenAnalyzerReleasesRuleMessage"); /// <summary>Remove duplicate entries for diagnostic ID between analyzer releases.</summary> internal static string @RemoveDuplicateEntriesBetweenAnalyzerReleasesRuleDescription => GetResourceString("RemoveDuplicateEntriesBetweenAnalyzerReleasesRuleDescription"); /// <summary>Invalid entry in analyzer release file</summary> internal static string @InvalidEntryInAnalyzerReleasesFileRuleTitle => GetResourceString("InvalidEntryInAnalyzerReleasesFileRuleTitle"); /// <summary>Analyzer release file '{0}' has an invalid entry '{1}'</summary> internal static string @InvalidEntryInAnalyzerReleasesFileRuleMessage => GetResourceString("InvalidEntryInAnalyzerReleasesFileRuleMessage"); /// <summary>Analyzer release file '{0}' has a missing or invalid release header '{1}'</summary> internal static string @InvalidHeaderInAnalyzerReleasesFileRuleMessage => GetResourceString("InvalidHeaderInAnalyzerReleasesFileRuleMessage"); /// <summary>Analyzer release file '{0}' has an entry with one or more 'Undetected' fields that need to be manually filled in '{1}'</summary> internal static string @InvalidUndetectedEntryInAnalyzerReleasesFileRuleMessage => GetResourceString("InvalidUndetectedEntryInAnalyzerReleasesFileRuleMessage"); /// <summary>Analyzer release file '{0}' has an invalid '{1}' entry without a prior shipped release for the rule '{2}'. Instead, add a separate '{1}' entry for the rule in unshipped release file.</summary> internal static string @InvalidRemovedOrChangedWithoutPriorNewEntryInAnalyzerReleasesFileRuleMessageMessage => GetResourceString("InvalidRemovedOrChangedWithoutPriorNewEntryInAnalyzerReleasesFileRuleMessageMessage"); /// <summary>Invalid entry in analyzer release file.</summary> internal static string @InvalidEntryInAnalyzerReleasesFileRuleDescription => GetResourceString("InvalidEntryInAnalyzerReleasesFileRuleDescription"); /// <summary>Enable analyzer release tracking</summary> internal static string @EnableAnalyzerReleaseTrackingRuleTitle => GetResourceString("EnableAnalyzerReleaseTrackingRuleTitle"); /// <summary>Enable analyzer release tracking for the analyzer project containing rule '{0}'</summary> internal static string @EnableAnalyzerReleaseTrackingRuleMessage => GetResourceString("EnableAnalyzerReleaseTrackingRuleMessage"); /// <summary>Enabling release tracking for analyzer packages helps in tracking and documenting the analyzer diagnostics that ship and/or change with each analyzer release. See details at https://github.com/dotnet/roslyn/blob/main/src/RoslynAnalyzers/Microsoft.CodeAnaly ...</summary> internal static string @EnableAnalyzerReleaseTrackingRuleDescription => GetResourceString("EnableAnalyzerReleaseTrackingRuleDescription"); /// <summary>The diagnostic title should not contain a period, nor any line return character, nor any leading or trailing whitespaces</summary> internal static string @DefineDiagnosticTitleCorrectlyMessage => GetResourceString("DefineDiagnosticTitleCorrectlyMessage"); /// <summary>Define diagnostic title correctly</summary> internal static string @DefineDiagnosticTitleCorrectlyTitle => GetResourceString("DefineDiagnosticTitleCorrectlyTitle"); /// <summary>The diagnostic message should not contain any line return character nor any leading or trailing whitespaces and should either be a single sentence without a trailing period or a multi-sentences with a trailing period</summary> internal static string @DefineDiagnosticMessageCorrectlyMessage => GetResourceString("DefineDiagnosticMessageCorrectlyMessage"); /// <summary>Define diagnostic message correctly</summary> internal static string @DefineDiagnosticMessageCorrectlyTitle => GetResourceString("DefineDiagnosticMessageCorrectlyTitle"); /// <summary>The diagnostic description should be one or multiple sentences ending with a punctuation sign and should not have any leading or trailing whitespaces</summary> internal static string @DefineDiagnosticDescriptionCorrectlyMessage => GetResourceString("DefineDiagnosticDescriptionCorrectlyMessage"); /// <summary>Define diagnostic description correctly</summary> internal static string @DefineDiagnosticDescriptionCorrectlyTitle => GetResourceString("DefineDiagnosticDescriptionCorrectlyTitle"); /// <summary>'DiagnosticDescriptor' assigned to field is used to report a compilation end diagnostic, but the 'DiagnosticDescriptor' constructor used to initialize it does not pass in the required custom tag "CompilationEnd". See documentation for 'WellKnownDiagnosticT ...</summary> internal static string @AddCompilationEndCustomTagDescription => GetResourceString("AddCompilationEndCustomTagDescription"); /// <summary>Add "CompilationEnd" custom tag to the diagnostic descriptor used to initialize field '{0}' as it is used to report a compilation end diagnostic</summary> internal static string @AddCompilationEndCustomTagMessage => GetResourceString("AddCompilationEndCustomTagMessage"); /// <summary>Add "CompilationEnd" custom tag to compilation end diagnostic descriptor</summary> internal static string @AddCompilationEndCustomTagTitle => GetResourceString("AddCompilationEndCustomTagTitle"); /// <summary>Symbols should be compared for equality, not identity. An explicit call to 'GetHashCode' will likely result in the wrong behavior.</summary> internal static string @CompareSymbolsCorrectlyDescriptionGetHashCode => GetResourceString("CompareSymbolsCorrectlyDescriptionGetHashCode"); /// <summary>Prefer 'syntax.IsKind(kind)' to 'syntax.Kind() == kind' when checking syntax kinds. Code using 'IsKind' is slightly more efficient at runtime, so consistent use of this form where applicable helps improve performance in complex analysis scenarios.</summary> internal static string @PreferIsKindDescription => GetResourceString("PreferIsKindDescription"); /// <summary>Prefer 'IsKind' for checking syntax kinds</summary> internal static string @PreferIsKindMessage => GetResourceString("PreferIsKindMessage"); /// <summary>Prefer 'IsKind' for checking syntax kinds</summary> internal static string @PreferIsKindTitle => GetResourceString("PreferIsKindTitle"); /// <summary>Use 'IsKind' instead of 'Kind'</summary> internal static string @PreferIsKindFix => GetResourceString("PreferIsKindFix"); /// <summary>The symbol has been marked as banned for use in analyzers, and an alternate should be used instead.</summary> internal static string @SymbolIsBannedInAnalyzersDescription => GetResourceString("SymbolIsBannedInAnalyzersDescription"); /// <summary>The symbol '{0}' is banned for use by analyzers{1}</summary> internal static string @SymbolIsBannedInAnalyzersMessage => GetResourceString("SymbolIsBannedInAnalyzersMessage"); /// <summary>Do not use APIs banned for analyzers</summary> internal static string @SymbolIsBannedInAnalyzersTitle => GetResourceString("SymbolIsBannedInAnalyzersTitle"); /// <summary>A project containing analyzers or source generators should specify the property '<EnforceExtendedAnalyzerRules>true</EnforceExtendedAnalyzerRules>'.</summary> internal static string @NoSettingSpecifiedSymbolIsBannedInAnalyzersDescription => GetResourceString("NoSettingSpecifiedSymbolIsBannedInAnalyzersDescription"); /// <summary>'{0}': A project containing analyzers or source generators should specify the property '<EnforceExtendedAnalyzerRules>true</EnforceExtendedAnalyzerRules>'</summary> internal static string @NoSettingSpecifiedSymbolIsBannedInAnalyzersMessage => GetResourceString("NoSettingSpecifiedSymbolIsBannedInAnalyzersMessage"); /// <summary>Specify analyzer banned API enforcement setting</summary> internal static string @NoSettingSpecifiedSymbolIsBannedInAnalyzersTitle => GetResourceString("NoSettingSpecifiedSymbolIsBannedInAnalyzersTitle"); /// <summary>This compiler extension should not be implemented in an assembly containing a reference to Microsoft.CodeAnalysis.Workspaces. The Microsoft.CodeAnalysis.Workspaces assembly is not provided during command line compilation scenarios, so references to it coul ...</summary> internal static string @DoNotDeclareCompilerFeatureInAssemblyWithWorkspacesReferenceMessage => GetResourceString("DoNotDeclareCompilerFeatureInAssemblyWithWorkspacesReferenceMessage"); /// <summary>This C# compiler extension should not be implemented in an assembly containing a reference to Microsoft.CodeAnalysis.VisualBasic. The Microsoft.CodeAnalysis.VisualBasic assembly is not always provided during C# compilation scenarios, so references to it co ...</summary> internal static string @DoNotDeclareCSharpCompilerFeatureInAssemblyWithVisualBasicReferenceMessage => GetResourceString("DoNotDeclareCSharpCompilerFeatureInAssemblyWithVisualBasicReferenceMessage"); /// <summary>This Visual Basic compiler extension should not be implemented in an assembly containing a reference to Microsoft.CodeAnalysis.CSharp. The Microsoft.CodeAnalysis.CSharp assembly is not always provided during Visual Basic compilation scenarios, so reference ...</summary> internal static string @DoNotDeclareVisualBasicCompilerFeatureInAssemblyWithCSharpReferenceMessage => GetResourceString("DoNotDeclareVisualBasicCompilerFeatureInAssemblyWithCSharpReferenceMessage"); /// <summary>Types which implement compiler extension points should not be declared in assemblies that contain references to assemblies which are not provided by all compilation scenarios. Doing so may cause the feature to behave unpredictably.</summary> internal static string @DoNotRegisterCompilerTypesWithBadAssemblyReferenceRuleDescription => GetResourceString("DoNotRegisterCompilerTypesWithBadAssemblyReferenceRuleDescription"); /// <summary>Compiler extensions should be implemented in assemblies with compiler-provided references</summary> internal static string @DoNotRegisterCompilerTypesWithBadAssemblyReferenceRuleTitle => GetResourceString("DoNotRegisterCompilerTypesWithBadAssemblyReferenceRuleTitle"); /// <summary>Calling 'SemanticModel.GetDeclaredSymbol' with on certain types inheriting from 'SyntaxNode', for example 'GlobalStatementSyntax' and 'IncompleteMemberSyntax' will always return 'null'.</summary> internal static string @SemanticModelGetDeclaredSymbolAlwaysReturnsNullDescription => GetResourceString("SemanticModelGetDeclaredSymbolAlwaysReturnsNullDescription"); /// <summary>A call to 'SemanticModel.GetDeclaredSymbol({0})' will always return 'null'</summary> internal static string @SemanticModelGetDeclaredSymbolAlwaysReturnsNullMessage => GetResourceString("SemanticModelGetDeclaredSymbolAlwaysReturnsNullMessage"); /// <summary>This call to 'SemanticModel.GetDeclaredSymbol()' will always return 'null'</summary> internal static string @SemanticModelGetDeclaredSymbolAlwaysReturnsNullTitle => GetResourceString("SemanticModelGetDeclaredSymbolAlwaysReturnsNullTitle"); /// <summary>Calling 'SemanticModel.GetDeclaredSymbol' with an argument of type 'FieldDeclarationSyntax' or 'EventFieldDeclarationSyntax' will always return 'null'. Call 'GetDeclaredSymbol' with the variable declarators from the field instead.</summary> internal static string @SemanticModelGetDeclaredSymbolAlwaysReturnsNullForFieldDescription => GetResourceString("SemanticModelGetDeclaredSymbolAlwaysReturnsNullForFieldDescription"); /// <summary>A call to 'SemanticModel.GetDeclaredSymbol({0})' will always return 'null'</summary> internal static string @SemanticModelGetDeclaredSymbolAlwaysReturnsNullForFieldMessage => GetResourceString("SemanticModelGetDeclaredSymbolAlwaysReturnsNullForFieldMessage"); /// <summary>This compiler extension should not be implemented in an assembly with target framework '{0}'. References to other target frameworks will cause the compiler to behave unpredictably.</summary> internal static string @DoNotDeclareCompilerFeatureInAssemblyWithUnsupportedTargetFrameworkMessage => GetResourceString("DoNotDeclareCompilerFeatureInAssemblyWithUnsupportedTargetFrameworkMessage"); /// <summary>Types which implement compiler extension points should only be declared in assemblies targeting netstandard2.0. More specific target frameworks are only available in a subset of supported compilation scenarios, so targeting them may cause the feature to be ...</summary> internal static string @DoNotDeclareCompilerFeatureInAssemblyWithUnsupportedTargetFrameworkRuleDescription => GetResourceString("DoNotDeclareCompilerFeatureInAssemblyWithUnsupportedTargetFrameworkRuleDescription"); /// <summary>Compiler extensions should be implemented in assemblies targeting netstandard2.0</summary> internal static string @DoNotDeclareCompilerFeatureInAssemblyWithUnsupportedTargetFrameworkRuleTitle => GetResourceString("DoNotDeclareCompilerFeatureInAssemblyWithUnsupportedTargetFrameworkRuleTitle"); /// <summary>The author of this interface has deprecated implementing this interface.</summary> internal static string @ImplementationIsObsoleteDescription => GetResourceString("ImplementationIsObsoleteDescription"); /// <summary>Type {0} cannot implement interface {1} because {1} is obsolete for implementation. See {2} for more details.</summary> internal static string @ImplementationIsObsoleteMessage => GetResourceString("ImplementationIsObsoleteMessage"); /// <summary>Implementations of this interface are not allowed</summary> internal static string @ImplementationIsObsoleteTitle => GetResourceString("ImplementationIsObsoleteTitle"); /// <summary>Using a 'file' type is not allowed for implementing analyzers, generators, or code fixers. This can break analyzer loading on some platforms.</summary> internal static string @DoNotUseFileTypesForAnalyzersOrGeneratorsDescription => GetResourceString("DoNotUseFileTypesForAnalyzersOrGeneratorsDescription"); /// <summary>Type '{0}' should not be marked with 'file'</summary> internal static string @DoNotUseFileTypesForAnalyzersOrGeneratorsMessage => GetResourceString("DoNotUseFileTypesForAnalyzersOrGeneratorsMessage"); /// <summary>Do not use file types for implementing analyzers, generators, and code fixers</summary> internal static string @DoNotUseFileTypesForAnalyzersOrGeneratorsTitle => GetResourceString("DoNotUseFileTypesForAnalyzersOrGeneratorsTitle"); } } |