From 68b7999e06eb7af3fc601b9cb18f8ebe2a4aed60 Mon Sep 17 00:00:00 2001 From: John Date: Fri, 10 Jul 2026 09:55:05 +0200 Subject: [PATCH 01/11] use-parameter-descriptions linter tests and logic added --- .../ExtensibilityTests.cs | 1 + .../ModuleTests.cs | 2 + .../BicepTestConstants.cs | 4 +- .../UseParameterDescriptionsRuleTests.cs | 126 ++++++++++++++++++ .../WhatIfShortCircuitingRuleTests.cs | 1 + .../Rules/UseParameterDescriptionsRule.cs | 48 +++++++ src/Bicep.Core/CoreResources.Designer.cs | 20 ++- src/Bicep.Core/CoreResources.resx | 7 + .../schemas/bicepconfig.schema.json | 10 ++ 9 files changed, 216 insertions(+), 3 deletions(-) create mode 100644 src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseParameterDescriptionsRuleTests.cs create mode 100644 src/Bicep.Core/Analyzers/Linter/Rules/UseParameterDescriptionsRule.cs diff --git a/src/Bicep.Core.IntegrationTests/ExtensibilityTests.cs b/src/Bicep.Core.IntegrationTests/ExtensibilityTests.cs index 77dc7334af9..c7e5ea770fc 100644 --- a/src/Bicep.Core.IntegrationTests/ExtensibilityTests.cs +++ b/src/Bicep.Core.IntegrationTests/ExtensibilityTests.cs @@ -182,6 +182,7 @@ public void Foo_import_basic_test_loops_and_referencing() { var result = CompilationHelper.Compile(CreateServiceBuilder(), """ extension foo as foo + #disable-next-line use-parameter-descriptions param numApps int resource myApp 'application' = { diff --git a/src/Bicep.Core.IntegrationTests/ModuleTests.cs b/src/Bicep.Core.IntegrationTests/ModuleTests.cs index ea0d478e4d9..cd4d5c35257 100644 --- a/src/Bicep.Core.IntegrationTests/ModuleTests.cs +++ b/src/Bicep.Core.IntegrationTests/ModuleTests.cs @@ -205,7 +205,9 @@ public async Task Module_should_include_diagnostic_if_module_file_cannot_be_reso { var mainFileUri = new Uri("file:///path/to/main.bicep"); var mainFileText = @" +#disable-next-line use-parameter-descriptions param inputa string +#disable-next-line use-parameter-descriptions param inputb string module modulea 'modulea.bicep' = { diff --git a/src/Bicep.Core.UnitTests/BicepTestConstants.cs b/src/Bicep.Core.UnitTests/BicepTestConstants.cs index f26ee2d67c9..ad28e80bb4d 100644 --- a/src/Bicep.Core.UnitTests/BicepTestConstants.cs +++ b/src/Bicep.Core.UnitTests/BicepTestConstants.cs @@ -67,10 +67,10 @@ public static class BicepTestConstants public static readonly ITemplateSpecRepositoryFactory TemplateSpecRepositoryFactory = StrictMock.Of().Object; // Linter rules added to this list will be automatically disabled for most tests. - public static readonly string[] NonStableAnalyzerRules = [UseRecentApiVersionRule.Code, UseRecentModuleVersionsRule.Code, NoHardcodedOutputsRule.Code]; + public static readonly string[] NonStableAnalyzerRules = [UseRecentApiVersionRule.Code, UseRecentModuleVersionsRule.Code, NoHardcodedOutputsRule.Code, UseParameterDescriptionsRule.Code]; // Rules that are currently skipped due to configuration for ProgramsShouldProduceExpectedDiagnostics - public static readonly string[] TestAnalyzersToSkip = [UseRecentApiVersionRule.Code, UseRecentModuleVersionsRule.Code, NoHardcodedLocationRule.Code, ExplicitValuesForLocationParamsRule.Code, NoLocationExprOutsideParamsRule.Code, NoModuleNameRule.Code, NoHardcodedOutputsRule.Code]; + public static readonly string[] TestAnalyzersToSkip = [UseRecentApiVersionRule.Code, UseRecentModuleVersionsRule.Code, NoHardcodedLocationRule.Code, ExplicitValuesForLocationParamsRule.Code, NoLocationExprOutsideParamsRule.Code, NoModuleNameRule.Code, NoHardcodedOutputsRule.Code, UseParameterDescriptionsRule.Code]; public static readonly RootConfiguration BuiltInConfigurationWithAllAnalyzersDisabled = IConfigurationManager.GetBuiltInConfiguration().WithAllAnalyzersDisabled(); public static readonly RootConfiguration BuiltInConfigurationWithStableAnalyzers = IConfigurationManager.GetBuiltInConfiguration().WithAllAnalyzers().WithAnalyzersDisabled(NonStableAnalyzerRules); diff --git a/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseParameterDescriptionsRuleTests.cs b/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseParameterDescriptionsRuleTests.cs new file mode 100644 index 00000000000..f52d469d72c --- /dev/null +++ b/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseParameterDescriptionsRuleTests.cs @@ -0,0 +1,126 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using Bicep.Core.Analyzers.Linter.Rules; +using Bicep.Core.Configuration; +using Bicep.Core.Diagnostics; +using Bicep.Core.Extensions; +using FluentAssertions; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace Bicep.Core.UnitTests.Diagnostics.LinterRuleTests; + +[TestClass] +public class UseParameterDescriptionsRuleTests : LinterRuleTestsBase +{ + private static readonly Options RuleOptions = new( + OnCompileErrors.Ignore, + ConfigurationPatch: EnableRule); + + private static RootConfiguration EnableRule(RootConfiguration configuration) => + configuration.WithAnalyzersConfiguration( + configuration.Analyzers.SetValue($"core.rules.{UseParameterDescriptionsRule.Code}.level", "warning")); + + [TestMethod] + public void Rule_defaults_to_warning() + { + new UseParameterDescriptionsRule().DefaultDiagnosticLevel.Should().Be(DiagnosticLevel.Warning); + } + + [TestMethod] + public void Parameters_without_descriptions_are_reported() + { + AssertLinterRuleDiagnostics( + UseParameterDescriptionsRule.Code, + """ + param first string + + @secure() + param second string + """, + [ + """[1] Parameter "first" must have a non-empty description.""", + """[4] Parameter "second" must have a non-empty description.""", + ], + RuleOptions); + } + + [TestMethod] + public void Unqualified_and_sys_qualified_descriptions_are_accepted() + { + AssertLinterRuleDiagnostics( + UseParameterDescriptionsRule.Code, + """ + @description('First parameter.') + param first string + + @sys.description('Second parameter.') + param second string + """, + 0, + RuleOptions); + } + + [TestMethod] + public void Empty_and_whitespace_descriptions_are_reported_for_both_decorator_forms() + { + AssertLinterRuleDiagnostics( + UseParameterDescriptionsRule.Code, + """ + @description('') + param empty string + + @description(' ') + param spaces string + + @sys.description('') + param qualifiedEmpty string + + @sys.description(''' + + ''') + param qualifiedNewline string + """, + 4, + RuleOptions); + } + + [TestMethod] + public void Metadata_description_does_not_satisfy_the_rule() + { + AssertLinterRuleDiagnostics( + UseParameterDescriptionsRule.Code, + """ + @metadata({ description: 'Metadata description.' }) + param input string + """, + ["""[2] Parameter "input" must have a non-empty description."""], + RuleOptions); + } + + [TestMethod] + public void Descriptions_on_other_declarations_are_ignored() + { + AssertLinterRuleDiagnostics( + UseParameterDescriptionsRule.Code, + """ + @description('Variable description.') + var value = 'value' + + @description('Output description.') + output result string = value + """, + 0, + RuleOptions); + } + + [TestMethod] + public void Malformed_parameter_without_a_name_is_ignored() + { + AssertLinterRuleDiagnostics( + UseParameterDescriptionsRule.Code, + "param", + 0, + RuleOptions); + } +} diff --git a/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/WhatIfShortCircuitingRuleTests.cs b/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/WhatIfShortCircuitingRuleTests.cs index d2285a903ca..a520ddab15c 100644 --- a/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/WhatIfShortCircuitingRuleTests.cs +++ b/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/WhatIfShortCircuitingRuleTests.cs @@ -78,6 +78,7 @@ public void WhatIfShortCircuiting_NoDiagnostics() [ ("createSA.bicep", SAModuleContent), ("main.bicep", """ + #disable-next-line use-parameter-descriptions param input string module creatingSA 'createSA.bicep' = { params: { diff --git a/src/Bicep.Core/Analyzers/Linter/Rules/UseParameterDescriptionsRule.cs b/src/Bicep.Core/Analyzers/Linter/Rules/UseParameterDescriptionsRule.cs new file mode 100644 index 00000000000..303d8971a3d --- /dev/null +++ b/src/Bicep.Core/Analyzers/Linter/Rules/UseParameterDescriptionsRule.cs @@ -0,0 +1,48 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using Bicep.Core.Diagnostics; +using Bicep.Core.Semantics; +using Bicep.Core.Semantics.Namespaces; + +namespace Bicep.Core.Analyzers.Linter.Rules; + +public sealed class UseParameterDescriptionsRule : LinterRuleBase +{ + public new const string Code = "use-parameter-descriptions"; + + public UseParameterDescriptionsRule() : base( + code: Code, + description: CoreResources.UseParameterDescriptionsRuleDescription, + LinterRuleCategory.BestPractice) + { } + + public override string FormatMessage(params object[] values) + => string.Format(CoreResources.UseParameterDescriptionsRuleMessageFormat, values); + + public override IEnumerable AnalyzeInternal(SemanticModel model, DiagnosticLevel diagnosticLevel) + { + foreach (var parameter in model.Root.ParameterDeclarations.Where(parameter => parameter.NameSource.IsValid)) + { + var descriptionDecorator = parameter.TryGetDecorator( + model, + SystemNamespaceType.BuiltInName, + LanguageConstants.MetadataDescriptionPropertyName); + + if (descriptionDecorator is null) + { + yield return CreateDiagnosticForSpan(diagnosticLevel, parameter.NameSource.Span, parameter.Name); + continue; + } + + if (DescriptionHelper.TryGetFromDecorator(model, parameter.DeclaringParameter) is { } description && + string.IsNullOrWhiteSpace(description)) + { + yield return CreateDiagnosticForSpan( + diagnosticLevel, + descriptionDecorator.Arguments.First().Expression.Span, + parameter.Name); + } + } + } +} diff --git a/src/Bicep.Core/CoreResources.Designer.cs b/src/Bicep.Core/CoreResources.Designer.cs index 320f14eaef7..8ac5109a57c 100644 --- a/src/Bicep.Core/CoreResources.Designer.cs +++ b/src/Bicep.Core/CoreResources.Designer.cs @@ -185,7 +185,7 @@ internal static string ExperimentalFeatureNames_OciEnabled { return ResourceManager.GetString("ExperimentalFeatureNames_OciEnabled", resourceCulture); } } - + /// /// Looks up a localized string similar to Resource info code generation. /// @@ -951,6 +951,24 @@ internal static string UseParentPropertyRule_MessageFormat { } } + /// + /// Looks up a localized string similar to Parameters should have non-empty descriptions.. + /// + internal static string UseParameterDescriptionsRuleDescription { + get { + return ResourceManager.GetString("UseParameterDescriptionsRule_Description", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Parameter "{0}" must have a non-empty description.. + /// + internal static string UseParameterDescriptionsRuleMessageFormat { + get { + return ResourceManager.GetString("UseParameterDescriptionsRule_MessageFormat", resourceCulture); + } + } + /// /// Looks up a localized string similar to Acceptable versions: {0}. /// diff --git a/src/Bicep.Core/CoreResources.resx b/src/Bicep.Core/CoreResources.resx index 03f39b56a7c..de27249ab42 100644 --- a/src/Bicep.Core/CoreResources.resx +++ b/src/Bicep.Core/CoreResources.resx @@ -381,6 +381,13 @@ Use parent property + + Parameters should have non-empty descriptions. + + + Parameter "{0}" must have a non-empty description. + {0} is the parameter name + Property '{0}' expects a secure value, but the value provided may not be secure. {0} property name diff --git a/src/vscode-bicep/schemas/bicepconfig.schema.json b/src/vscode-bicep/schemas/bicepconfig.schema.json index af1492c80a5..3a4855f0131 100644 --- a/src/vscode-bicep/schemas/bicepconfig.schema.json +++ b/src/vscode-bicep/schemas/bicepconfig.schema.json @@ -765,6 +765,16 @@ } ] }, + "use-parameter-descriptions": { + "allOf": [ + { + "description": "Parameters should have non-empty descriptions. Defaults to 'Warning'. See https://aka.ms/bicep/linter-diagnostics#use-parameter-descriptions" + }, + { + "$ref": "#/definitions/rule-def-level-warning" + } + ] + }, "use-safe-access": { "allOf": [ { From 084c064a7f41a6a577d01e054519c91b23464856 Mon Sep 17 00:00:00 2001 From: John Date: Fri, 10 Jul 2026 10:24:17 +0200 Subject: [PATCH 02/11] Implement new linter rule for parameter descriptions and update related tests --- .../ExtensibilityTests.cs | 1 - .../ModuleTests.cs | 2 - .../UseParameterDescriptionsRuleTests.cs | 140 +++++++++--------- .../Rules/UseParameterDescriptionsRule.cs | 3 +- .../schemas/bicepconfig.schema.json | 4 +- 5 files changed, 78 insertions(+), 72 deletions(-) diff --git a/src/Bicep.Core.IntegrationTests/ExtensibilityTests.cs b/src/Bicep.Core.IntegrationTests/ExtensibilityTests.cs index c7e5ea770fc..77dc7334af9 100644 --- a/src/Bicep.Core.IntegrationTests/ExtensibilityTests.cs +++ b/src/Bicep.Core.IntegrationTests/ExtensibilityTests.cs @@ -182,7 +182,6 @@ public void Foo_import_basic_test_loops_and_referencing() { var result = CompilationHelper.Compile(CreateServiceBuilder(), """ extension foo as foo - #disable-next-line use-parameter-descriptions param numApps int resource myApp 'application' = { diff --git a/src/Bicep.Core.IntegrationTests/ModuleTests.cs b/src/Bicep.Core.IntegrationTests/ModuleTests.cs index cd4d5c35257..ea0d478e4d9 100644 --- a/src/Bicep.Core.IntegrationTests/ModuleTests.cs +++ b/src/Bicep.Core.IntegrationTests/ModuleTests.cs @@ -205,9 +205,7 @@ public async Task Module_should_include_diagnostic_if_module_file_cannot_be_reso { var mainFileUri = new Uri("file:///path/to/main.bicep"); var mainFileText = @" -#disable-next-line use-parameter-descriptions param inputa string -#disable-next-line use-parameter-descriptions param inputb string module modulea 'modulea.bicep' = { diff --git a/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseParameterDescriptionsRuleTests.cs b/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseParameterDescriptionsRuleTests.cs index f52d469d72c..10817f2aa36 100644 --- a/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseParameterDescriptionsRuleTests.cs +++ b/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseParameterDescriptionsRuleTests.cs @@ -3,8 +3,9 @@ using Bicep.Core.Analyzers.Linter.Rules; using Bicep.Core.Configuration; -using Bicep.Core.Diagnostics; using Bicep.Core.Extensions; +using Bicep.Core.UnitTests.Assertions; +using Bicep.Core.UnitTests.Utils; using FluentAssertions; using Microsoft.VisualStudio.TestTools.UnitTesting; @@ -13,25 +14,43 @@ namespace Bicep.Core.UnitTests.Diagnostics.LinterRuleTests; [TestClass] public class UseParameterDescriptionsRuleTests : LinterRuleTestsBase { - private static readonly Options RuleOptions = new( - OnCompileErrors.Ignore, - ConfigurationPatch: EnableRule); + private static readonly Options RuleOptions = new(ConfigurationPatch: EnableRule); private static RootConfiguration EnableRule(RootConfiguration configuration) => configuration.WithAnalyzersConfiguration( configuration.Analyzers.SetValue($"core.rules.{UseParameterDescriptionsRule.Code}.level", "warning")); + private void AssertDiagnostics(string inputFile, int expectedCount = 1) + => AssertLinterRuleDiagnostics(UseParameterDescriptionsRule.Code, inputFile, expectedCount, RuleOptions); + + private void AssertDiagnostics(string inputFile, string[] expectedMessages) + => AssertLinterRuleDiagnostics(UseParameterDescriptionsRule.Code, inputFile, expectedMessages, RuleOptions); + + private void AssertNoDiagnostics(string inputFile, OnCompileErrors onCompileErrors = OnCompileErrors.IncludeErrors) + => AssertLinterRuleDiagnostics( + UseParameterDescriptionsRule.Code, + inputFile, + [], + RuleOptions with + { + OnCompileErrors = onCompileErrors, + IncludePosition = IncludePosition.None, + }); + [TestMethod] - public void Rule_defaults_to_warning() + public void Rule_defaults_to_off() { - new UseParameterDescriptionsRule().DefaultDiagnosticLevel.Should().Be(DiagnosticLevel.Warning); + var result = CompilationHelper.Compile(""" + param input string + """); + + result.ExcludingDiagnostics("no-unused-params").Should().NotHaveAnyDiagnostics(); } [TestMethod] public void Parameters_without_descriptions_are_reported() { - AssertLinterRuleDiagnostics( - UseParameterDescriptionsRule.Code, + AssertDiagnostics( """ param first string @@ -41,86 +60,75 @@ param second string [ """[1] Parameter "first" must have a non-empty description.""", """[4] Parameter "second" must have a non-empty description.""", - ], - RuleOptions); + ]); } - [TestMethod] - public void Unqualified_and_sys_qualified_descriptions_are_accepted() + [DataRow(""" + @description('Parameter description.') + param input string + """)] + [DataRow(""" + @sys.description('Parameter description.') + param input string + """)] + [DataTestMethod] + public void Non_empty_descriptions_are_accepted(string text) { - AssertLinterRuleDiagnostics( - UseParameterDescriptionsRule.Code, - """ - @description('First parameter.') - param first string - - @sys.description('Second parameter.') - param second string - """, - 0, - RuleOptions); + AssertNoDiagnostics(text); } - [TestMethod] - public void Empty_and_whitespace_descriptions_are_reported_for_both_decorator_forms() + [DataRow(""" + @description('') + param input string + """)] + [DataRow(""" + @description(' ') + param input string + """)] + [DataRow(""" + @sys.description('') + param input string + """)] + [DataRow(""" + @sys.description(''' + + ''') + param input string + """)] + [DataTestMethod] + public void Empty_and_whitespace_descriptions_are_reported(string text) { - AssertLinterRuleDiagnostics( - UseParameterDescriptionsRule.Code, - """ - @description('') - param empty string - - @description(' ') - param spaces string - - @sys.description('') - param qualifiedEmpty string - - @sys.description(''' - - ''') - param qualifiedNewline string - """, - 4, - RuleOptions); + AssertDiagnostics(text); } [TestMethod] public void Metadata_description_does_not_satisfy_the_rule() { - AssertLinterRuleDiagnostics( - UseParameterDescriptionsRule.Code, + AssertDiagnostics( """ @metadata({ description: 'Metadata description.' }) param input string """, - ["""[2] Parameter "input" must have a non-empty description."""], - RuleOptions); + ["""[2] Parameter "input" must have a non-empty description."""]); } - [TestMethod] - public void Descriptions_on_other_declarations_are_ignored() + [DataRow(""" + @description('Variable description.') + var value = 'value' + """)] + [DataRow(""" + @description('Output description.') + output result string = 'value' + """)] + [DataTestMethod] + public void Descriptions_on_other_declarations_are_ignored(string text) { - AssertLinterRuleDiagnostics( - UseParameterDescriptionsRule.Code, - """ - @description('Variable description.') - var value = 'value' - - @description('Output description.') - output result string = value - """, - 0, - RuleOptions); + AssertNoDiagnostics(text); } [TestMethod] public void Malformed_parameter_without_a_name_is_ignored() { - AssertLinterRuleDiagnostics( - UseParameterDescriptionsRule.Code, - "param", - 0, - RuleOptions); + AssertNoDiagnostics("param", OnCompileErrors.Ignore); } } diff --git a/src/Bicep.Core/Analyzers/Linter/Rules/UseParameterDescriptionsRule.cs b/src/Bicep.Core/Analyzers/Linter/Rules/UseParameterDescriptionsRule.cs index 303d8971a3d..b8d390a8952 100644 --- a/src/Bicep.Core/Analyzers/Linter/Rules/UseParameterDescriptionsRule.cs +++ b/src/Bicep.Core/Analyzers/Linter/Rules/UseParameterDescriptionsRule.cs @@ -14,7 +14,8 @@ public sealed class UseParameterDescriptionsRule : LinterRuleBase public UseParameterDescriptionsRule() : base( code: Code, description: CoreResources.UseParameterDescriptionsRuleDescription, - LinterRuleCategory.BestPractice) + LinterRuleCategory.BestPractice, + overrideCategoryDefaultDiagnosticLevel: DiagnosticLevel.Off) { } public override string FormatMessage(params object[] values) diff --git a/src/vscode-bicep/schemas/bicepconfig.schema.json b/src/vscode-bicep/schemas/bicepconfig.schema.json index 3a4855f0131..504741e193c 100644 --- a/src/vscode-bicep/schemas/bicepconfig.schema.json +++ b/src/vscode-bicep/schemas/bicepconfig.schema.json @@ -768,10 +768,10 @@ "use-parameter-descriptions": { "allOf": [ { - "description": "Parameters should have non-empty descriptions. Defaults to 'Warning'. See https://aka.ms/bicep/linter-diagnostics#use-parameter-descriptions" + "description": "Parameters should have non-empty descriptions. Defaults to 'Off'. See https://aka.ms/bicep/linter-diagnostics#use-parameter-descriptions" }, { - "$ref": "#/definitions/rule-def-level-warning" + "$ref": "#/definitions/rule-def-level-off" } ] }, From a1734645e8d36f47cfa90e5ff003b37e20248391 Mon Sep 17 00:00:00 2001 From: John Date: Fri, 10 Jul 2026 10:54:18 +0200 Subject: [PATCH 03/11] Removed disable next line comment --- .../LinterRuleTests/WhatIfShortCircuitingRuleTests.cs | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/WhatIfShortCircuitingRuleTests.cs b/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/WhatIfShortCircuitingRuleTests.cs index a520ddab15c..64f18c50a60 100644 --- a/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/WhatIfShortCircuitingRuleTests.cs +++ b/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/WhatIfShortCircuitingRuleTests.cs @@ -78,7 +78,6 @@ public void WhatIfShortCircuiting_NoDiagnostics() [ ("createSA.bicep", SAModuleContent), ("main.bicep", """ - #disable-next-line use-parameter-descriptions param input string module creatingSA 'createSA.bicep' = { params: { @@ -248,8 +247,8 @@ param condition bool } """), ("mod3.bicep", """ - param name string - + param name string + resource vnet 'Microsoft.Network/virtualNetworks@2024-07-01' = { name: name } From 9ad91124bfb2a1e912d0684b8148e43d7159cd3f Mon Sep 17 00:00:00 2001 From: John Date: Fri, 7 Aug 2026 08:49:22 +0200 Subject: [PATCH 04/11] Renamed parameter description linter rule and added vars description linter rule --- .../BicepTestConstants.cs | 4 +- ...s => UseDescriptionParametersRuleTests.cs} | 10 +- .../UseDescriptionVarsRuleTests.cs | 133 ++++++++++++++++++ .../Rules/UseDescriptionParametersRule.cs | 24 ++++ .../Linter/Rules/UseDescriptionRuleBase.cs | 59 ++++++++ .../Linter/Rules/UseDescriptionVarsRule.cs | 24 ++++ .../Rules/UseParameterDescriptionsRule.cs | 49 ------- src/Bicep.Core/CoreResources.Designer.cs | 26 +++- src/Bicep.Core/CoreResources.resx | 11 +- .../schemas/bicepconfig.schema.json | 20 ++- 10 files changed, 293 insertions(+), 67 deletions(-) rename src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/{UseParameterDescriptionsRuleTests.cs => UseDescriptionParametersRuleTests.cs} (91%) create mode 100644 src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseDescriptionVarsRuleTests.cs create mode 100644 src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionParametersRule.cs create mode 100644 src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionRuleBase.cs create mode 100644 src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionVarsRule.cs delete mode 100644 src/Bicep.Core/Analyzers/Linter/Rules/UseParameterDescriptionsRule.cs diff --git a/src/Bicep.Core.UnitTests/BicepTestConstants.cs b/src/Bicep.Core.UnitTests/BicepTestConstants.cs index ad28e80bb4d..f0a40971dc3 100644 --- a/src/Bicep.Core.UnitTests/BicepTestConstants.cs +++ b/src/Bicep.Core.UnitTests/BicepTestConstants.cs @@ -67,10 +67,10 @@ public static class BicepTestConstants public static readonly ITemplateSpecRepositoryFactory TemplateSpecRepositoryFactory = StrictMock.Of().Object; // Linter rules added to this list will be automatically disabled for most tests. - public static readonly string[] NonStableAnalyzerRules = [UseRecentApiVersionRule.Code, UseRecentModuleVersionsRule.Code, NoHardcodedOutputsRule.Code, UseParameterDescriptionsRule.Code]; + public static readonly string[] NonStableAnalyzerRules = [UseRecentApiVersionRule.Code, UseRecentModuleVersionsRule.Code, NoHardcodedOutputsRule.Code, UseDescriptionParametersRule.Code, UseDescriptionVarsRule.Code]; // Rules that are currently skipped due to configuration for ProgramsShouldProduceExpectedDiagnostics - public static readonly string[] TestAnalyzersToSkip = [UseRecentApiVersionRule.Code, UseRecentModuleVersionsRule.Code, NoHardcodedLocationRule.Code, ExplicitValuesForLocationParamsRule.Code, NoLocationExprOutsideParamsRule.Code, NoModuleNameRule.Code, NoHardcodedOutputsRule.Code, UseParameterDescriptionsRule.Code]; + public static readonly string[] TestAnalyzersToSkip = [UseRecentApiVersionRule.Code, UseRecentModuleVersionsRule.Code, NoHardcodedLocationRule.Code, ExplicitValuesForLocationParamsRule.Code, NoLocationExprOutsideParamsRule.Code, NoModuleNameRule.Code, NoHardcodedOutputsRule.Code, UseDescriptionParametersRule.Code, UseDescriptionVarsRule.Code]; public static readonly RootConfiguration BuiltInConfigurationWithAllAnalyzersDisabled = IConfigurationManager.GetBuiltInConfiguration().WithAllAnalyzersDisabled(); public static readonly RootConfiguration BuiltInConfigurationWithStableAnalyzers = IConfigurationManager.GetBuiltInConfiguration().WithAllAnalyzers().WithAnalyzersDisabled(NonStableAnalyzerRules); diff --git a/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseParameterDescriptionsRuleTests.cs b/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseDescriptionParametersRuleTests.cs similarity index 91% rename from src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseParameterDescriptionsRuleTests.cs rename to src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseDescriptionParametersRuleTests.cs index 10817f2aa36..df1fb0f812a 100644 --- a/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseParameterDescriptionsRuleTests.cs +++ b/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseDescriptionParametersRuleTests.cs @@ -12,23 +12,23 @@ namespace Bicep.Core.UnitTests.Diagnostics.LinterRuleTests; [TestClass] -public class UseParameterDescriptionsRuleTests : LinterRuleTestsBase +public class UseDescriptionParametersRuleTests : LinterRuleTestsBase { private static readonly Options RuleOptions = new(ConfigurationPatch: EnableRule); private static RootConfiguration EnableRule(RootConfiguration configuration) => configuration.WithAnalyzersConfiguration( - configuration.Analyzers.SetValue($"core.rules.{UseParameterDescriptionsRule.Code}.level", "warning")); + configuration.Analyzers.SetValue($"core.rules.{UseDescriptionParametersRule.Code}.level", "warning")); private void AssertDiagnostics(string inputFile, int expectedCount = 1) - => AssertLinterRuleDiagnostics(UseParameterDescriptionsRule.Code, inputFile, expectedCount, RuleOptions); + => AssertLinterRuleDiagnostics(UseDescriptionParametersRule.Code, inputFile, expectedCount, RuleOptions); private void AssertDiagnostics(string inputFile, string[] expectedMessages) - => AssertLinterRuleDiagnostics(UseParameterDescriptionsRule.Code, inputFile, expectedMessages, RuleOptions); + => AssertLinterRuleDiagnostics(UseDescriptionParametersRule.Code, inputFile, expectedMessages, RuleOptions); private void AssertNoDiagnostics(string inputFile, OnCompileErrors onCompileErrors = OnCompileErrors.IncludeErrors) => AssertLinterRuleDiagnostics( - UseParameterDescriptionsRule.Code, + UseDescriptionParametersRule.Code, inputFile, [], RuleOptions with diff --git a/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseDescriptionVarsRuleTests.cs b/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseDescriptionVarsRuleTests.cs new file mode 100644 index 00000000000..bdf5342ab81 --- /dev/null +++ b/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseDescriptionVarsRuleTests.cs @@ -0,0 +1,133 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using Bicep.Core.Analyzers.Linter.Rules; +using Bicep.Core.Configuration; +using Bicep.Core.Extensions; +using Bicep.Core.UnitTests.Assertions; +using Bicep.Core.UnitTests.Utils; +using FluentAssertions; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace Bicep.Core.UnitTests.Diagnostics.LinterRuleTests; + +[TestClass] +public class UseDescriptionVarsRuleTests : LinterRuleTestsBase +{ + private static readonly Options RuleOptions = new(ConfigurationPatch: EnableRule); + + private static RootConfiguration EnableRule(RootConfiguration configuration) => + configuration.WithAnalyzersConfiguration( + configuration.Analyzers.SetValue($"core.rules.{UseDescriptionVarsRule.Code}.level", "warning")); + + private void AssertDiagnostics(string inputFile, int expectedCount = 1) + => AssertLinterRuleDiagnostics(UseDescriptionVarsRule.Code, inputFile, expectedCount, RuleOptions); + + private void AssertDiagnostics(string inputFile, string[] expectedMessages) + => AssertLinterRuleDiagnostics(UseDescriptionVarsRule.Code, inputFile, expectedMessages, RuleOptions); + + private void AssertNoDiagnostics(string inputFile, OnCompileErrors onCompileErrors = OnCompileErrors.IncludeErrors) + => AssertLinterRuleDiagnostics( + UseDescriptionVarsRule.Code, + inputFile, + [], + RuleOptions with + { + OnCompileErrors = onCompileErrors, + IncludePosition = IncludePosition.None, + }); + + [TestMethod] + public void Rule_defaults_to_off() + { + var result = CompilationHelper.Compile(""" + var input = 'value' + """); + + result.ExcludingDiagnostics("no-unused-vars").Should().NotHaveAnyDiagnostics(); + } + + [TestMethod] + public void Variables_without_descriptions_are_reported() + { + AssertDiagnostics( + """ + var first = 'value' + + @export() + var second = 'value' + """, + [ + """[1] Variable "first" must have a non-empty description.""", + """[4] Variable "second" must have a non-empty description.""", + ]); + } + + [DataRow(""" + @description('Variable description.') + var input = 'value' + """)] + [DataRow(""" + @sys.description('Variable description.') + var input = 'value' + """)] + [DataTestMethod] + public void Non_empty_descriptions_are_accepted(string text) + { + AssertNoDiagnostics(text); + } + + [DataRow(""" + @description('') + var input = 'value' + """)] + [DataRow(""" + @description(' ') + var input = 'value' + """)] + [DataRow(""" + @sys.description('') + var input = 'value' + """)] + [DataRow(""" + @sys.description(''' + + ''') + var input = 'value' + """)] + [DataTestMethod] + public void Empty_and_whitespace_descriptions_are_reported(string text) + { + AssertDiagnostics(text); + } + + [TestMethod] + public void Loop_variables_are_reported() + { + AssertDiagnostics( + """ + var items = [for i in range(0, 3): i] + """, + ["""[1] Variable "items" must have a non-empty description."""]); + } + + [DataRow(""" + @description('Parameter description.') + param input string + """)] + [DataRow(""" + @description('Output description.') + output result string = 'value' + """)] + [DataTestMethod] + public void Descriptions_on_other_declarations_are_ignored(string text) + { + AssertNoDiagnostics(text); + } + + [TestMethod] + public void Malformed_variable_without_a_name_is_ignored() + { + AssertNoDiagnostics("var", OnCompileErrors.Ignore); + } +} diff --git a/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionParametersRule.cs b/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionParametersRule.cs new file mode 100644 index 00000000000..3305e22d1d0 --- /dev/null +++ b/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionParametersRule.cs @@ -0,0 +1,24 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using Bicep.Core.Semantics; + +namespace Bicep.Core.Analyzers.Linter.Rules; + +public sealed class UseDescriptionParametersRule : UseDescriptionRuleBase +{ + public new const string Code = "use-description-parameters"; + + public UseDescriptionParametersRule() : base( + code: Code, + description: CoreResources.UseDescriptionParametersRuleDescription) + { } + + public override string FormatMessage(params object[] values) + => string.Format(CoreResources.UseDescriptionParametersRuleMessageFormat, values); + + protected override IEnumerable GetTargets(SemanticModel model) + => model.Root.ParameterDeclarations + .Where(parameter => parameter.NameSource.IsValid) + .Select(parameter => new DescriptionTarget(parameter.DeclaringParameter, parameter.Name, parameter.NameSource.Span)); +} diff --git a/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionRuleBase.cs b/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionRuleBase.cs new file mode 100644 index 00000000000..d70e6731ab5 --- /dev/null +++ b/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionRuleBase.cs @@ -0,0 +1,59 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using Bicep.Core.Diagnostics; +using Bicep.Core.Semantics; +using Bicep.Core.Semantics.Namespaces; +using Bicep.Core.Syntax; +using Bicep.Core.Text; + +namespace Bicep.Core.Analyzers.Linter.Rules; + +/// +/// Base class for rules requiring a non-empty @description decorator on a given kind of declaration. +/// +public abstract class UseDescriptionRuleBase : LinterRuleBase +{ + protected UseDescriptionRuleBase(string code, string description) : base( + code, + description, + LinterRuleCategory.BestPractice, + overrideCategoryDefaultDiagnosticLevel: DiagnosticLevel.Off) + { } + + /// + /// A single declaration that is expected to carry a non-empty @description decorator. + /// Modelled on syntax rather than symbols so that declarations without a symbol, + /// such as user-defined type properties, can be covered by derived rules. + /// + protected readonly record struct DescriptionTarget(DecorableSyntax Decorable, string Name, TextSpan NameSpan); + + protected abstract IEnumerable GetTargets(SemanticModel model); + + public override IEnumerable AnalyzeInternal(SemanticModel model, DiagnosticLevel diagnosticLevel) + { + foreach (var target in GetTargets(model)) + { + var descriptionDecorator = SemanticModelHelper.TryGetDecoratorInNamespace( + model, + target.Decorable, + SystemNamespaceType.BuiltInName, + LanguageConstants.MetadataDescriptionPropertyName); + + if (descriptionDecorator is null) + { + yield return CreateDiagnosticForSpan(diagnosticLevel, target.NameSpan, target.Name); + continue; + } + + if (DescriptionHelper.TryGetFromDecorator(model, target.Decorable) is { } description && + string.IsNullOrWhiteSpace(description)) + { + yield return CreateDiagnosticForSpan( + diagnosticLevel, + descriptionDecorator.Arguments.First().Expression.Span, + target.Name); + } + } + } +} diff --git a/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionVarsRule.cs b/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionVarsRule.cs new file mode 100644 index 00000000000..80c5c5fc5d4 --- /dev/null +++ b/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionVarsRule.cs @@ -0,0 +1,24 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using Bicep.Core.Semantics; + +namespace Bicep.Core.Analyzers.Linter.Rules; + +public sealed class UseDescriptionVarsRule : UseDescriptionRuleBase +{ + public new const string Code = "use-description-vars"; + + public UseDescriptionVarsRule() : base( + code: Code, + description: CoreResources.UseDescriptionVarsRuleDescription) + { } + + public override string FormatMessage(params object[] values) + => string.Format(CoreResources.UseDescriptionVarsRuleMessageFormat, values); + + protected override IEnumerable GetTargets(SemanticModel model) + => model.Root.VariableDeclarations + .Where(variable => variable.NameSource.IsValid) + .Select(variable => new DescriptionTarget(variable.DeclaringVariable, variable.Name, variable.NameSource.Span)); +} diff --git a/src/Bicep.Core/Analyzers/Linter/Rules/UseParameterDescriptionsRule.cs b/src/Bicep.Core/Analyzers/Linter/Rules/UseParameterDescriptionsRule.cs deleted file mode 100644 index b8d390a8952..00000000000 --- a/src/Bicep.Core/Analyzers/Linter/Rules/UseParameterDescriptionsRule.cs +++ /dev/null @@ -1,49 +0,0 @@ -// Copyright (c) Microsoft Corporation. -// Licensed under the MIT License. - -using Bicep.Core.Diagnostics; -using Bicep.Core.Semantics; -using Bicep.Core.Semantics.Namespaces; - -namespace Bicep.Core.Analyzers.Linter.Rules; - -public sealed class UseParameterDescriptionsRule : LinterRuleBase -{ - public new const string Code = "use-parameter-descriptions"; - - public UseParameterDescriptionsRule() : base( - code: Code, - description: CoreResources.UseParameterDescriptionsRuleDescription, - LinterRuleCategory.BestPractice, - overrideCategoryDefaultDiagnosticLevel: DiagnosticLevel.Off) - { } - - public override string FormatMessage(params object[] values) - => string.Format(CoreResources.UseParameterDescriptionsRuleMessageFormat, values); - - public override IEnumerable AnalyzeInternal(SemanticModel model, DiagnosticLevel diagnosticLevel) - { - foreach (var parameter in model.Root.ParameterDeclarations.Where(parameter => parameter.NameSource.IsValid)) - { - var descriptionDecorator = parameter.TryGetDecorator( - model, - SystemNamespaceType.BuiltInName, - LanguageConstants.MetadataDescriptionPropertyName); - - if (descriptionDecorator is null) - { - yield return CreateDiagnosticForSpan(diagnosticLevel, parameter.NameSource.Span, parameter.Name); - continue; - } - - if (DescriptionHelper.TryGetFromDecorator(model, parameter.DeclaringParameter) is { } description && - string.IsNullOrWhiteSpace(description)) - { - yield return CreateDiagnosticForSpan( - diagnosticLevel, - descriptionDecorator.Arguments.First().Expression.Span, - parameter.Name); - } - } - } -} diff --git a/src/Bicep.Core/CoreResources.Designer.cs b/src/Bicep.Core/CoreResources.Designer.cs index 8ac5109a57c..0ccffbbbcdd 100644 --- a/src/Bicep.Core/CoreResources.Designer.cs +++ b/src/Bicep.Core/CoreResources.Designer.cs @@ -954,18 +954,36 @@ internal static string UseParentPropertyRule_MessageFormat { /// /// Looks up a localized string similar to Parameters should have non-empty descriptions.. /// - internal static string UseParameterDescriptionsRuleDescription { + internal static string UseDescriptionParametersRuleDescription { get { - return ResourceManager.GetString("UseParameterDescriptionsRule_Description", resourceCulture); + return ResourceManager.GetString("UseDescriptionParametersRule_Description", resourceCulture); } } /// /// Looks up a localized string similar to Parameter "{0}" must have a non-empty description.. /// - internal static string UseParameterDescriptionsRuleMessageFormat { + internal static string UseDescriptionParametersRuleMessageFormat { get { - return ResourceManager.GetString("UseParameterDescriptionsRule_MessageFormat", resourceCulture); + return ResourceManager.GetString("UseDescriptionParametersRule_MessageFormat", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Variables should have non-empty descriptions.. + /// + internal static string UseDescriptionVarsRuleDescription { + get { + return ResourceManager.GetString("UseDescriptionVarsRule_Description", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Variable "{0}" must have a non-empty description.. + /// + internal static string UseDescriptionVarsRuleMessageFormat { + get { + return ResourceManager.GetString("UseDescriptionVarsRule_MessageFormat", resourceCulture); } } diff --git a/src/Bicep.Core/CoreResources.resx b/src/Bicep.Core/CoreResources.resx index de27249ab42..40109202006 100644 --- a/src/Bicep.Core/CoreResources.resx +++ b/src/Bicep.Core/CoreResources.resx @@ -381,13 +381,20 @@ Use parent property - + Parameters should have non-empty descriptions. - + Parameter "{0}" must have a non-empty description. {0} is the parameter name + + Variables should have non-empty descriptions. + + + Variable "{0}" must have a non-empty description. + {0} is the variable name + Property '{0}' expects a secure value, but the value provided may not be secure. {0} property name diff --git a/src/vscode-bicep/schemas/bicepconfig.schema.json b/src/vscode-bicep/schemas/bicepconfig.schema.json index 504741e193c..df4ebafc8ec 100644 --- a/src/vscode-bicep/schemas/bicepconfig.schema.json +++ b/src/vscode-bicep/schemas/bicepconfig.schema.json @@ -755,26 +755,36 @@ } ] }, - "use-parent-property": { + "use-description-parameters": { "allOf": [ { - "description": "Use the parent property instead of formatting child resource names with '/' characters. Defaults to 'Warning'. See https://aka.ms/bicep/linter-diagnostics#use-parent-property" + "description": "Parameters should have non-empty descriptions. Defaults to 'Off'. See https://aka.ms/bicep/linter-diagnostics#use-description-parameters" }, { - "$ref": "#/definitions/rule-def-level-warning" + "$ref": "#/definitions/rule-def-level-off" } ] }, - "use-parameter-descriptions": { + "use-description-vars": { "allOf": [ { - "description": "Parameters should have non-empty descriptions. Defaults to 'Off'. See https://aka.ms/bicep/linter-diagnostics#use-parameter-descriptions" + "description": "Variables should have non-empty descriptions. Defaults to 'Off'. See https://aka.ms/bicep/linter-diagnostics#use-description-vars" }, { "$ref": "#/definitions/rule-def-level-off" } ] }, + "use-parent-property": { + "allOf": [ + { + "description": "Use the parent property instead of formatting child resource names with '/' characters. Defaults to 'Warning'. See https://aka.ms/bicep/linter-diagnostics#use-parent-property" + }, + { + "$ref": "#/definitions/rule-def-level-warning" + } + ] + }, "use-safe-access": { "allOf": [ { From 896a220a0951b3161b905ed3f674bdfdd755a88c Mon Sep 17 00:00:00 2001 From: John Date: Fri, 7 Aug 2026 11:45:04 +0200 Subject: [PATCH 05/11] Added description enforcement linter rules for output, type and type properties --- .../BicepTestConstants.cs | 4 +- .../UseDescriptionOutputRuleTests.cs | 130 ++++++++++++++ .../UseDescriptionTypePropertyRuleTests.cs | 166 ++++++++++++++++++ .../UseDescriptionTypeRuleTests.cs | 133 ++++++++++++++ .../Linter/Rules/UseDescriptionOutputRule.cs | 24 +++ .../Rules/UseDescriptionTypePropertyRule.cs | 36 ++++ .../Linter/Rules/UseDescriptionTypeRule.cs | 24 +++ src/Bicep.Core/CoreResources.Designer.cs | 54 ++++++ src/Bicep.Core/CoreResources.resx | 21 +++ .../schemas/bicepconfig.schema.json | 30 ++++ 10 files changed, 620 insertions(+), 2 deletions(-) create mode 100644 src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseDescriptionOutputRuleTests.cs create mode 100644 src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseDescriptionTypePropertyRuleTests.cs create mode 100644 src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseDescriptionTypeRuleTests.cs create mode 100644 src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionOutputRule.cs create mode 100644 src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionTypePropertyRule.cs create mode 100644 src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionTypeRule.cs diff --git a/src/Bicep.Core.UnitTests/BicepTestConstants.cs b/src/Bicep.Core.UnitTests/BicepTestConstants.cs index f0a40971dc3..efd1c1a3378 100644 --- a/src/Bicep.Core.UnitTests/BicepTestConstants.cs +++ b/src/Bicep.Core.UnitTests/BicepTestConstants.cs @@ -67,10 +67,10 @@ public static class BicepTestConstants public static readonly ITemplateSpecRepositoryFactory TemplateSpecRepositoryFactory = StrictMock.Of().Object; // Linter rules added to this list will be automatically disabled for most tests. - public static readonly string[] NonStableAnalyzerRules = [UseRecentApiVersionRule.Code, UseRecentModuleVersionsRule.Code, NoHardcodedOutputsRule.Code, UseDescriptionParametersRule.Code, UseDescriptionVarsRule.Code]; + public static readonly string[] NonStableAnalyzerRules = [UseRecentApiVersionRule.Code, UseRecentModuleVersionsRule.Code, NoHardcodedOutputsRule.Code, UseDescriptionParametersRule.Code, UseDescriptionVarsRule.Code, UseDescriptionOutputRule.Code, UseDescriptionTypeRule.Code, UseDescriptionTypePropertyRule.Code]; // Rules that are currently skipped due to configuration for ProgramsShouldProduceExpectedDiagnostics - public static readonly string[] TestAnalyzersToSkip = [UseRecentApiVersionRule.Code, UseRecentModuleVersionsRule.Code, NoHardcodedLocationRule.Code, ExplicitValuesForLocationParamsRule.Code, NoLocationExprOutsideParamsRule.Code, NoModuleNameRule.Code, NoHardcodedOutputsRule.Code, UseDescriptionParametersRule.Code, UseDescriptionVarsRule.Code]; + public static readonly string[] TestAnalyzersToSkip = [UseRecentApiVersionRule.Code, UseRecentModuleVersionsRule.Code, NoHardcodedLocationRule.Code, ExplicitValuesForLocationParamsRule.Code, NoLocationExprOutsideParamsRule.Code, NoModuleNameRule.Code, NoHardcodedOutputsRule.Code, UseDescriptionParametersRule.Code, UseDescriptionVarsRule.Code, UseDescriptionOutputRule.Code, UseDescriptionTypeRule.Code, UseDescriptionTypePropertyRule.Code]; public static readonly RootConfiguration BuiltInConfigurationWithAllAnalyzersDisabled = IConfigurationManager.GetBuiltInConfiguration().WithAllAnalyzersDisabled(); public static readonly RootConfiguration BuiltInConfigurationWithStableAnalyzers = IConfigurationManager.GetBuiltInConfiguration().WithAllAnalyzers().WithAnalyzersDisabled(NonStableAnalyzerRules); diff --git a/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseDescriptionOutputRuleTests.cs b/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseDescriptionOutputRuleTests.cs new file mode 100644 index 00000000000..df2d79ee547 --- /dev/null +++ b/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseDescriptionOutputRuleTests.cs @@ -0,0 +1,130 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using Bicep.Core.Analyzers.Linter.Rules; +using Bicep.Core.Configuration; +using Bicep.Core.Extensions; +using Bicep.Core.UnitTests.Assertions; +using Bicep.Core.UnitTests.Utils; +using FluentAssertions; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace Bicep.Core.UnitTests.Diagnostics.LinterRuleTests; + +[TestClass] +public class UseDescriptionOutputRuleTests : LinterRuleTestsBase +{ + private static readonly Options RuleOptions = new(ConfigurationPatch: EnableRule); + + private static RootConfiguration EnableRule(RootConfiguration configuration) => + configuration.WithAnalyzersConfiguration( + configuration.Analyzers.SetValue($"core.rules.{UseDescriptionOutputRule.Code}.level", "warning")); + + private void AssertDiagnostics(string inputFile, int expectedCount = 1) + => AssertLinterRuleDiagnostics(UseDescriptionOutputRule.Code, inputFile, expectedCount, RuleOptions); + + private void AssertDiagnostics(string inputFile, string[] expectedMessages) + => AssertLinterRuleDiagnostics(UseDescriptionOutputRule.Code, inputFile, expectedMessages, RuleOptions); + + private void AssertNoDiagnostics(string inputFile, OnCompileErrors onCompileErrors = OnCompileErrors.IncludeErrors) + => AssertLinterRuleDiagnostics( + UseDescriptionOutputRule.Code, + inputFile, + [], + RuleOptions with + { + OnCompileErrors = onCompileErrors, + IncludePosition = IncludePosition.None, + }); + + [TestMethod] + public void Rule_defaults_to_off() + { + var result = CompilationHelper.Compile(""" + output result string = 'value' + """); + + result.Should().NotHaveAnyDiagnostics(); + } + + [TestMethod] + public void Outputs_without_descriptions_are_reported() + { + AssertDiagnostics( + """ + output first string = 'value' + + @secure() + output second string = 'value' + """, + [ + """[1] Output "first" must have a non-empty description.""", + """[4] Output "second" must have a non-empty description.""", + ]); + } + + [DataRow(""" + @description('Output description.') + output result string = 'value' + """)] + [DataRow(""" + @sys.description('Output description.') + output result string = 'value' + """)] + [DataTestMethod] + public void Non_empty_descriptions_are_accepted(string text) + { + AssertNoDiagnostics(text); + } + + [DataRow(""" + @description('') + output result string = 'value' + """)] + [DataRow(""" + @description(' ') + output result string = 'value' + """)] + [DataRow(""" + @sys.description(''' + + ''') + output result string = 'value' + """)] + [DataTestMethod] + public void Empty_and_whitespace_descriptions_are_reported(string text) + { + AssertDiagnostics(text); + } + + [TestMethod] + public void Metadata_description_does_not_satisfy_the_rule() + { + AssertDiagnostics( + """ + @metadata({ description: 'Metadata description.' }) + output result string = 'value' + """, + ["""[2] Output "result" must have a non-empty description."""]); + } + + [DataRow(""" + @description('Parameter description.') + param input string + """)] + [DataRow(""" + @description('Variable description.') + var value = 'value' + """)] + [DataTestMethod] + public void Descriptions_on_other_declarations_are_ignored(string text) + { + AssertNoDiagnostics(text); + } + + [TestMethod] + public void Malformed_output_without_a_name_is_ignored() + { + AssertNoDiagnostics("output", OnCompileErrors.Ignore); + } +} diff --git a/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseDescriptionTypePropertyRuleTests.cs b/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseDescriptionTypePropertyRuleTests.cs new file mode 100644 index 00000000000..ffcf0fb1e6c --- /dev/null +++ b/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseDescriptionTypePropertyRuleTests.cs @@ -0,0 +1,166 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using Bicep.Core.Analyzers.Linter.Rules; +using Bicep.Core.Configuration; +using Bicep.Core.Extensions; +using Bicep.Core.UnitTests.Assertions; +using Bicep.Core.UnitTests.Utils; +using FluentAssertions; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace Bicep.Core.UnitTests.Diagnostics.LinterRuleTests; + +[TestClass] +public class UseDescriptionTypePropertyRuleTests : LinterRuleTestsBase +{ + private static readonly Options RuleOptions = new(ConfigurationPatch: EnableRule); + + private static RootConfiguration EnableRule(RootConfiguration configuration) => + configuration.WithAnalyzersConfiguration( + configuration.Analyzers.SetValue($"core.rules.{UseDescriptionTypePropertyRule.Code}.level", "warning")); + + private void AssertDiagnostics(string inputFile, int expectedCount = 1) + => AssertLinterRuleDiagnostics(UseDescriptionTypePropertyRule.Code, inputFile, expectedCount, RuleOptions); + + private void AssertDiagnostics(string inputFile, string[] expectedMessages) + => AssertLinterRuleDiagnostics(UseDescriptionTypePropertyRule.Code, inputFile, expectedMessages, RuleOptions); + + private void AssertNoDiagnostics(string inputFile, OnCompileErrors onCompileErrors = OnCompileErrors.IncludeErrors) + => AssertLinterRuleDiagnostics( + UseDescriptionTypePropertyRule.Code, + inputFile, + [], + RuleOptions with + { + OnCompileErrors = onCompileErrors, + IncludePosition = IncludePosition.None, + }); + + [TestMethod] + public void Rule_defaults_to_off() + { + var result = CompilationHelper.Compile(""" + @export() + type myType = { + name: string + } + """); + + result.Should().NotHaveAnyDiagnostics(); + } + + [TestMethod] + public void Properties_without_descriptions_are_reported() + { + AssertDiagnostics( + """ + @export() + type myType = { + first: string + second: int + } + """, + [ + """[3] Type property "first" must have a non-empty description.""", + """[4] Type property "second" must have a non-empty description.""", + ]); + } + + [DataRow(""" + @export() + type myType = { + @description('Property description.') + name: string + } + """)] + [DataRow(""" + @export() + type myType = { + @sys.description('Property description.') + name: string + } + """)] + [DataTestMethod] + public void Non_empty_descriptions_are_accepted(string text) + { + AssertNoDiagnostics(text); + } + + [DataRow(""" + @export() + type myType = { + @description('') + name: string + } + """)] + [DataRow(""" + @export() + type myType = { + @description(' ') + name: string + } + """)] + [DataTestMethod] + public void Empty_and_whitespace_descriptions_are_reported(string text) + { + AssertDiagnostics(text); + } + + [TestMethod] + public void Nested_object_type_properties_are_reported() + { + AssertDiagnostics( + """ + @export() + type myType = { + @description('Outer property description.') + outer: { + inner: string + } + } + """, + ["""[5] Type property "inner" must have a non-empty description."""]); + } + + [TestMethod] + public void Quoted_property_names_are_reported() + { + AssertDiagnostics( + """ + @export() + type myType = { + 'my-property': string + } + """, + ["""[3] Type property "my-property" must have a non-empty description."""]); + } + + [TestMethod] + public void Description_on_the_type_itself_does_not_satisfy_the_rule() + { + AssertDiagnostics( + """ + @export() + @description('Type description.') + type myType = { + name: string + } + """, + ["""[4] Type property "name" must have a non-empty description."""]); + } + + [TestMethod] + public void Object_type_properties_outside_type_declarations_are_ignored() + { + AssertNoDiagnostics(""" + param input { + name: string + } = { + name: 'value' + } + + output result object = input + """); + } +} diff --git a/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseDescriptionTypeRuleTests.cs b/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseDescriptionTypeRuleTests.cs new file mode 100644 index 00000000000..9a89f41aef9 --- /dev/null +++ b/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseDescriptionTypeRuleTests.cs @@ -0,0 +1,133 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using Bicep.Core.Analyzers.Linter.Rules; +using Bicep.Core.Configuration; +using Bicep.Core.Extensions; +using Bicep.Core.UnitTests.Assertions; +using Bicep.Core.UnitTests.Utils; +using FluentAssertions; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace Bicep.Core.UnitTests.Diagnostics.LinterRuleTests; + +[TestClass] +public class UseDescriptionTypeRuleTests : LinterRuleTestsBase +{ + private static readonly Options RuleOptions = new(ConfigurationPatch: EnableRule); + + private static RootConfiguration EnableRule(RootConfiguration configuration) => + configuration.WithAnalyzersConfiguration( + configuration.Analyzers.SetValue($"core.rules.{UseDescriptionTypeRule.Code}.level", "warning")); + + private void AssertDiagnostics(string inputFile, int expectedCount = 1) + => AssertLinterRuleDiagnostics(UseDescriptionTypeRule.Code, inputFile, expectedCount, RuleOptions); + + private void AssertDiagnostics(string inputFile, string[] expectedMessages) + => AssertLinterRuleDiagnostics(UseDescriptionTypeRule.Code, inputFile, expectedMessages, RuleOptions); + + private void AssertNoDiagnostics(string inputFile, OnCompileErrors onCompileErrors = OnCompileErrors.IncludeErrors) + => AssertLinterRuleDiagnostics( + UseDescriptionTypeRule.Code, + inputFile, + [], + RuleOptions with + { + OnCompileErrors = onCompileErrors, + IncludePosition = IncludePosition.None, + }); + + [TestMethod] + public void Rule_defaults_to_off() + { + var result = CompilationHelper.Compile(""" + @export() + type myType = string + """); + + result.Should().NotHaveAnyDiagnostics(); + } + + [TestMethod] + public void Types_without_descriptions_are_reported() + { + AssertDiagnostics( + """ + @export() + type first = string + + @export() + type second = int + """, + [ + """[2] Type "first" must have a non-empty description.""", + """[5] Type "second" must have a non-empty description.""", + ]); + } + + [DataRow(""" + @export() + @description('Type description.') + type myType = string + """)] + [DataRow(""" + @export() + @sys.description('Type description.') + type myType = string + """)] + [DataTestMethod] + public void Non_empty_descriptions_are_accepted(string text) + { + AssertNoDiagnostics(text); + } + + [DataRow(""" + @export() + @description('') + type myType = string + """)] + [DataRow(""" + @export() + @description(' ') + type myType = string + """)] + [DataTestMethod] + public void Empty_and_whitespace_descriptions_are_reported(string text) + { + AssertDiagnostics(text); + } + + [TestMethod] + public void Descriptions_on_type_properties_do_not_satisfy_the_rule() + { + AssertDiagnostics( + """ + @export() + type myType = { + @description('Property description.') + name: string + } + """, + ["""[2] Type "myType" must have a non-empty description."""]); + } + + [DataRow(""" + @description('Parameter description.') + param input string + """)] + [DataRow(""" + @description('Output description.') + output result string = 'value' + """)] + [DataTestMethod] + public void Descriptions_on_other_declarations_are_ignored(string text) + { + AssertNoDiagnostics(text); + } + + [TestMethod] + public void Malformed_type_without_a_name_is_ignored() + { + AssertNoDiagnostics("type", OnCompileErrors.Ignore); + } +} diff --git a/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionOutputRule.cs b/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionOutputRule.cs new file mode 100644 index 00000000000..f608a6f8457 --- /dev/null +++ b/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionOutputRule.cs @@ -0,0 +1,24 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using Bicep.Core.Semantics; + +namespace Bicep.Core.Analyzers.Linter.Rules; + +public sealed class UseDescriptionOutputRule : UseDescriptionRuleBase +{ + public new const string Code = "use-description-output"; + + public UseDescriptionOutputRule() : base( + code: Code, + description: CoreResources.UseDescriptionOutputRuleDescription) + { } + + public override string FormatMessage(params object[] values) + => string.Format(CoreResources.UseDescriptionOutputRuleMessageFormat, values); + + protected override IEnumerable GetTargets(SemanticModel model) + => model.Root.OutputDeclarations + .Where(output => output.NameSource.IsValid) + .Select(output => new DescriptionTarget(output.DeclaringOutput, output.Name, output.NameSource.Span)); +} diff --git a/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionTypePropertyRule.cs b/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionTypePropertyRule.cs new file mode 100644 index 00000000000..8a4e5a09a76 --- /dev/null +++ b/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionTypePropertyRule.cs @@ -0,0 +1,36 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using Bicep.Core.Semantics; +using Bicep.Core.Syntax; +using Bicep.Core.Syntax.Visitors; + +namespace Bicep.Core.Analyzers.Linter.Rules; + +public sealed class UseDescriptionTypePropertyRule : UseDescriptionRuleBase +{ + public new const string Code = "use-description-type-property"; + + public UseDescriptionTypePropertyRule() : base( + code: Code, + description: CoreResources.UseDescriptionTypePropertyRuleDescription) + { } + + public override string FormatMessage(params object[] values) + => string.Format(CoreResources.UseDescriptionTypePropertyRuleMessageFormat, values); + + protected override IEnumerable GetTargets(SemanticModel model) + { + foreach (var type in model.Root.TypeDeclarations) + { + // Aggregating over the whole declaration also covers properties of nested object types. + foreach (var property in SyntaxAggregator.AggregateByType(type.DeclaringType)) + { + if (property.TryGetKeyText() is { } name) + { + yield return new DescriptionTarget(property, name, property.Key.Span); + } + } + } + } +} diff --git a/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionTypeRule.cs b/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionTypeRule.cs new file mode 100644 index 00000000000..377093f909a --- /dev/null +++ b/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionTypeRule.cs @@ -0,0 +1,24 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using Bicep.Core.Semantics; + +namespace Bicep.Core.Analyzers.Linter.Rules; + +public sealed class UseDescriptionTypeRule : UseDescriptionRuleBase +{ + public new const string Code = "use-description-type"; + + public UseDescriptionTypeRule() : base( + code: Code, + description: CoreResources.UseDescriptionTypeRuleDescription) + { } + + public override string FormatMessage(params object[] values) + => string.Format(CoreResources.UseDescriptionTypeRuleMessageFormat, values); + + protected override IEnumerable GetTargets(SemanticModel model) + => model.Root.TypeDeclarations + .Where(type => type.NameSource.IsValid) + .Select(type => new DescriptionTarget(type.DeclaringType, type.Name, type.NameSource.Span)); +} diff --git a/src/Bicep.Core/CoreResources.Designer.cs b/src/Bicep.Core/CoreResources.Designer.cs index 0ccffbbbcdd..5e0d6760164 100644 --- a/src/Bicep.Core/CoreResources.Designer.cs +++ b/src/Bicep.Core/CoreResources.Designer.cs @@ -987,6 +987,60 @@ internal static string UseDescriptionVarsRuleMessageFormat { } } + /// + /// Looks up a localized string similar to Outputs should have non-empty descriptions.. + /// + internal static string UseDescriptionOutputRuleDescription { + get { + return ResourceManager.GetString("UseDescriptionOutputRule_Description", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Output "{0}" must have a non-empty description.. + /// + internal static string UseDescriptionOutputRuleMessageFormat { + get { + return ResourceManager.GetString("UseDescriptionOutputRule_MessageFormat", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to User-defined types should have non-empty descriptions.. + /// + internal static string UseDescriptionTypeRuleDescription { + get { + return ResourceManager.GetString("UseDescriptionTypeRule_Description", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Type "{0}" must have a non-empty description.. + /// + internal static string UseDescriptionTypeRuleMessageFormat { + get { + return ResourceManager.GetString("UseDescriptionTypeRule_MessageFormat", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Properties of user-defined types should have non-empty descriptions.. + /// + internal static string UseDescriptionTypePropertyRuleDescription { + get { + return ResourceManager.GetString("UseDescriptionTypePropertyRule_Description", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Type property "{0}" must have a non-empty description.. + /// + internal static string UseDescriptionTypePropertyRuleMessageFormat { + get { + return ResourceManager.GetString("UseDescriptionTypePropertyRule_MessageFormat", resourceCulture); + } + } + /// /// Looks up a localized string similar to Acceptable versions: {0}. /// diff --git a/src/Bicep.Core/CoreResources.resx b/src/Bicep.Core/CoreResources.resx index 40109202006..b64e920eb11 100644 --- a/src/Bicep.Core/CoreResources.resx +++ b/src/Bicep.Core/CoreResources.resx @@ -395,6 +395,27 @@ Variable "{0}" must have a non-empty description. {0} is the variable name + + Outputs should have non-empty descriptions. + + + Output "{0}" must have a non-empty description. + {0} is the output name + + + User-defined types should have non-empty descriptions. + + + Type "{0}" must have a non-empty description. + {0} is the type name + + + Properties of user-defined types should have non-empty descriptions. + + + Type property "{0}" must have a non-empty description. + {0} is the type property name + Property '{0}' expects a secure value, but the value provided may not be secure. {0} property name diff --git a/src/vscode-bicep/schemas/bicepconfig.schema.json b/src/vscode-bicep/schemas/bicepconfig.schema.json index df4ebafc8ec..6bb97d8d001 100644 --- a/src/vscode-bicep/schemas/bicepconfig.schema.json +++ b/src/vscode-bicep/schemas/bicepconfig.schema.json @@ -755,6 +755,16 @@ } ] }, + "use-description-output": { + "allOf": [ + { + "description": "Outputs should have non-empty descriptions. Defaults to 'Off'. See https://aka.ms/bicep/linter-diagnostics#use-description-output" + }, + { + "$ref": "#/definitions/rule-def-level-off" + } + ] + }, "use-description-parameters": { "allOf": [ { @@ -765,6 +775,26 @@ } ] }, + "use-description-type": { + "allOf": [ + { + "description": "User-defined types should have non-empty descriptions. Defaults to 'Off'. See https://aka.ms/bicep/linter-diagnostics#use-description-type" + }, + { + "$ref": "#/definitions/rule-def-level-off" + } + ] + }, + "use-description-type-property": { + "allOf": [ + { + "description": "Properties of user-defined types should have non-empty descriptions. Defaults to 'Off'. See https://aka.ms/bicep/linter-diagnostics#use-description-type-property" + }, + { + "$ref": "#/definitions/rule-def-level-off" + } + ] + }, "use-description-vars": { "allOf": [ { From ca6aff95534c9238831e06aa1d5310db5d721690 Mon Sep 17 00:00:00 2001 From: John Date: Fri, 7 Aug 2026 11:59:10 +0200 Subject: [PATCH 06/11] Exclude description when discriminator is present --- bicep-test-john/bicepconfig.json | 20 ++++++ bicep-test-john/main.bicep | 26 ++++++++ .../UseDescriptionTypePropertyRuleTests.cs | 62 +++++++++++++++++++ .../UseDescriptionTypeRuleTests.cs | 22 +++++++ .../WhatIfShortCircuitingRuleTests.cs | 5 +- .../Rules/UseDescriptionTypePropertyRule.cs | 23 +++++-- .../Linter/Rules/UseDescriptionTypeRule.cs | 11 +++- 7 files changed, 163 insertions(+), 6 deletions(-) create mode 100644 bicep-test-john/bicepconfig.json create mode 100644 bicep-test-john/main.bicep diff --git a/bicep-test-john/bicepconfig.json b/bicep-test-john/bicepconfig.json new file mode 100644 index 00000000000..65d67c38865 --- /dev/null +++ b/bicep-test-john/bicepconfig.json @@ -0,0 +1,20 @@ +{ + "analyzers": { + "core": { + "enabled": true, + "rules": { + "no-unused-params": { + "level": "off" + }, + "no-unused-vars": { + "level": "off" + }, + "use-description-parameters": { "level": "warning" }, + "use-description-vars": { "level": "warning" }, + "use-description-output": { "level": "warning" }, + "use-description-type": { "level": "warning" }, + "use-description-type-property": { "level": "warning" } + } + } + } +} diff --git a/bicep-test-john/main.bicep b/bicep-test-john/main.bicep new file mode 100644 index 00000000000..876678f4150 --- /dev/null +++ b/bicep-test-john/main.bicep @@ -0,0 +1,26 @@ +@sys.description('Hello world!') +param parTest string + +@description('') +var varTest string = 'Hello world!' + +@description('Test') +output outSomething string = varTest + +@description('') +type FooConfig = { + type: 'foo' + value: int +} + +@description('') +type BarConfig = { + type: 'bar' + value: bool +} + +@discriminator('type') +type ServiceConfig = FooConfig | BarConfig | { + type: 'baz' + *: string +} diff --git a/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseDescriptionTypePropertyRuleTests.cs b/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseDescriptionTypePropertyRuleTests.cs index ffcf0fb1e6c..4aad47fc6d5 100644 --- a/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseDescriptionTypePropertyRuleTests.cs +++ b/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseDescriptionTypePropertyRuleTests.cs @@ -150,6 +150,68 @@ public void Description_on_the_type_itself_does_not_satisfy_the_rule() ["""[4] Type property "name" must have a non-empty description."""]); } + [TestMethod] + public void Additional_properties_without_descriptions_are_reported() + { + AssertDiagnostics( + """ + @export() + type myType = { + *: string + } + """, + ["""[3] Type property "*" must have a non-empty description."""]); + } + + [TestMethod] + public void Additional_properties_with_descriptions_are_accepted() + { + AssertNoDiagnostics(""" + @export() + type myType = { + @description('Any additional value.') + *: string + } + """); + } + + [TestMethod] + public void Additional_properties_with_empty_descriptions_are_reported() + { + AssertDiagnostics(""" + @export() + type myType = { + @description(' ') + *: string + } + """); + } + + [TestMethod] + public void Properties_of_object_types_in_a_discriminated_union_are_reported() + { + AssertDiagnostics( + """ + @export() + @description('Foo config.') + type fooConfig = { + @description('Discriminator value.') + type: 'foo' + } + + @export() + @discriminator('type') + type serviceConfig = fooConfig | { + type: 'baz' + *: string + } + """, + [ + """[11] Type property "type" must have a non-empty description.""", + """[12] Type property "*" must have a non-empty description.""", + ]); + } + [TestMethod] public void Object_type_properties_outside_type_declarations_are_ignored() { diff --git a/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseDescriptionTypeRuleTests.cs b/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseDescriptionTypeRuleTests.cs index 9a89f41aef9..5e025cd4369 100644 --- a/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseDescriptionTypeRuleTests.cs +++ b/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseDescriptionTypeRuleTests.cs @@ -125,6 +125,28 @@ public void Descriptions_on_other_declarations_are_ignored(string text) AssertNoDiagnostics(text); } + [TestMethod] + public void Discriminated_unions_are_exempt_from_the_rule() + { + AssertNoDiagnostics(""" + @export() + @description('Foo config.') + type fooConfig = { + type: 'foo' + } + + @export() + @description('Bar config.') + type barConfig = { + type: 'bar' + } + + @export() + @discriminator('type') + type serviceConfig = fooConfig | barConfig + """); + } + [TestMethod] public void Malformed_type_without_a_name_is_ignored() { diff --git a/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/WhatIfShortCircuitingRuleTests.cs b/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/WhatIfShortCircuitingRuleTests.cs index 64f18c50a60..fa0f720a918 100644 --- a/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/WhatIfShortCircuitingRuleTests.cs +++ b/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/WhatIfShortCircuitingRuleTests.cs @@ -19,7 +19,10 @@ public class WhatIfShortCircuitingRuleTests : LinterRuleTestsBase .WithRegistration(x => x.AddSingleton( IConfigurationManager.WithStaticConfiguration( IConfigurationManager.GetBuiltInConfiguration() - .WithAllAnalyzers()))); + .WithAllAnalyzers() + // Rules that are off by default would otherwise be promoted to warnings here + // and pollute the assertions of this rule's tests. + .WithAnalyzersDisabled(BicepTestConstants.NonStableAnalyzerRules)))); private readonly string SAModuleContent = """ param test string diff --git a/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionTypePropertyRule.cs b/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionTypePropertyRule.cs index 8a4e5a09a76..4a69aa7d605 100644 --- a/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionTypePropertyRule.cs +++ b/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionTypePropertyRule.cs @@ -11,6 +11,8 @@ public sealed class UseDescriptionTypePropertyRule : UseDescriptionRuleBase { public new const string Code = "use-description-type-property"; + private const string AdditionalPropertiesName = "*"; + public UseDescriptionTypePropertyRule() : base( code: Code, description: CoreResources.UseDescriptionTypePropertyRuleDescription) @@ -23,12 +25,25 @@ protected override IEnumerable GetTargets(SemanticModel model { foreach (var type in model.Root.TypeDeclarations) { - // Aggregating over the whole declaration also covers properties of nested object types. - foreach (var property in SyntaxAggregator.AggregateByType(type.DeclaringType)) + // Aggregating over the whole declaration also covers properties of nested object types + // and of object types that are members of a union. + var members = SyntaxAggregator.Aggregate( + type.DeclaringType, + syntax => syntax is ObjectTypePropertySyntax or ObjectTypeAdditionalPropertiesSyntax); + + foreach (var member in members) { - if (property.TryGetKeyText() is { } name) + switch (member) { - yield return new DescriptionTarget(property, name, property.Key.Span); + case ObjectTypePropertySyntax property when property.TryGetKeyText() is { } name: + yield return new DescriptionTarget(property, name, property.Key.Span); + break; + case ObjectTypeAdditionalPropertiesSyntax additionalProperties: + yield return new DescriptionTarget( + additionalProperties, + AdditionalPropertiesName, + additionalProperties.Asterisk.Span); + break; } } } diff --git a/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionTypeRule.cs b/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionTypeRule.cs index 377093f909a..23689d0ad47 100644 --- a/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionTypeRule.cs +++ b/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionTypeRule.cs @@ -2,6 +2,7 @@ // Licensed under the MIT License. using Bicep.Core.Semantics; +using Bicep.Core.Semantics.Namespaces; namespace Bicep.Core.Analyzers.Linter.Rules; @@ -19,6 +20,14 @@ public override string FormatMessage(params object[] values) protected override IEnumerable GetTargets(SemanticModel model) => model.Root.TypeDeclarations - .Where(type => type.NameSource.IsValid) + .Where(type => type.NameSource.IsValid && !HasDiscriminator(model, type)) .Select(type => new DescriptionTarget(type.DeclaringType, type.Name, type.NameSource.Span)); + + // A discriminated union documents itself through its members, so it is exempt from the rule. + private static bool HasDiscriminator(SemanticModel model, TypeAliasSymbol type) + => SemanticModelHelper.TryGetDecoratorInNamespace( + model, + type.DeclaringType, + SystemNamespaceType.BuiltInName, + LanguageConstants.TypeDiscriminatorDecoratorName) is not null; } From 19df3d1127c41f18e667c4d306a1795ffe78eaef Mon Sep 17 00:00:00 2001 From: John Date: Fri, 7 Aug 2026 12:55:04 +0200 Subject: [PATCH 07/11] Cleanup --- .../LinterRuleTests/WhatIfShortCircuitingRuleTests.cs | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/WhatIfShortCircuitingRuleTests.cs b/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/WhatIfShortCircuitingRuleTests.cs index fa0f720a918..64f18c50a60 100644 --- a/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/WhatIfShortCircuitingRuleTests.cs +++ b/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/WhatIfShortCircuitingRuleTests.cs @@ -19,10 +19,7 @@ public class WhatIfShortCircuitingRuleTests : LinterRuleTestsBase .WithRegistration(x => x.AddSingleton( IConfigurationManager.WithStaticConfiguration( IConfigurationManager.GetBuiltInConfiguration() - .WithAllAnalyzers() - // Rules that are off by default would otherwise be promoted to warnings here - // and pollute the assertions of this rule's tests. - .WithAnalyzersDisabled(BicepTestConstants.NonStableAnalyzerRules)))); + .WithAllAnalyzers()))); private readonly string SAModuleContent = """ param test string From d6b4023516517bc952bbe94bfdd049014090798b Mon Sep 17 00:00:00 2001 From: John Date: Fri, 7 Aug 2026 13:00:41 +0200 Subject: [PATCH 08/11] Cleanup bicep test files --- bicep-test-john/bicepconfig.json | 20 -------------- bicep-test-john/main.bicep | 26 ------------------- .../Linter/Rules/UseDescriptionRuleBase.cs | 10 +------ .../Rules/UseDescriptionTypePropertyRule.cs | 2 -- .../Linter/Rules/UseDescriptionTypeRule.cs | 1 - 5 files changed, 1 insertion(+), 58 deletions(-) delete mode 100644 bicep-test-john/bicepconfig.json delete mode 100644 bicep-test-john/main.bicep diff --git a/bicep-test-john/bicepconfig.json b/bicep-test-john/bicepconfig.json deleted file mode 100644 index 65d67c38865..00000000000 --- a/bicep-test-john/bicepconfig.json +++ /dev/null @@ -1,20 +0,0 @@ -{ - "analyzers": { - "core": { - "enabled": true, - "rules": { - "no-unused-params": { - "level": "off" - }, - "no-unused-vars": { - "level": "off" - }, - "use-description-parameters": { "level": "warning" }, - "use-description-vars": { "level": "warning" }, - "use-description-output": { "level": "warning" }, - "use-description-type": { "level": "warning" }, - "use-description-type-property": { "level": "warning" } - } - } - } -} diff --git a/bicep-test-john/main.bicep b/bicep-test-john/main.bicep deleted file mode 100644 index 876678f4150..00000000000 --- a/bicep-test-john/main.bicep +++ /dev/null @@ -1,26 +0,0 @@ -@sys.description('Hello world!') -param parTest string - -@description('') -var varTest string = 'Hello world!' - -@description('Test') -output outSomething string = varTest - -@description('') -type FooConfig = { - type: 'foo' - value: int -} - -@description('') -type BarConfig = { - type: 'bar' - value: bool -} - -@discriminator('type') -type ServiceConfig = FooConfig | BarConfig | { - type: 'baz' - *: string -} diff --git a/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionRuleBase.cs b/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionRuleBase.cs index d70e6731ab5..ab785a572bd 100644 --- a/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionRuleBase.cs +++ b/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionRuleBase.cs @@ -9,9 +9,7 @@ namespace Bicep.Core.Analyzers.Linter.Rules; -/// -/// Base class for rules requiring a non-empty @description decorator on a given kind of declaration. -/// + public abstract class UseDescriptionRuleBase : LinterRuleBase { protected UseDescriptionRuleBase(string code, string description) : base( @@ -20,12 +18,6 @@ protected UseDescriptionRuleBase(string code, string description) : base( LinterRuleCategory.BestPractice, overrideCategoryDefaultDiagnosticLevel: DiagnosticLevel.Off) { } - - /// - /// A single declaration that is expected to carry a non-empty @description decorator. - /// Modelled on syntax rather than symbols so that declarations without a symbol, - /// such as user-defined type properties, can be covered by derived rules. - /// protected readonly record struct DescriptionTarget(DecorableSyntax Decorable, string Name, TextSpan NameSpan); protected abstract IEnumerable GetTargets(SemanticModel model); diff --git a/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionTypePropertyRule.cs b/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionTypePropertyRule.cs index 4a69aa7d605..4b5a61b5a79 100644 --- a/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionTypePropertyRule.cs +++ b/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionTypePropertyRule.cs @@ -25,8 +25,6 @@ protected override IEnumerable GetTargets(SemanticModel model { foreach (var type in model.Root.TypeDeclarations) { - // Aggregating over the whole declaration also covers properties of nested object types - // and of object types that are members of a union. var members = SyntaxAggregator.Aggregate( type.DeclaringType, syntax => syntax is ObjectTypePropertySyntax or ObjectTypeAdditionalPropertiesSyntax); diff --git a/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionTypeRule.cs b/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionTypeRule.cs index 23689d0ad47..55a115590db 100644 --- a/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionTypeRule.cs +++ b/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionTypeRule.cs @@ -23,7 +23,6 @@ protected override IEnumerable GetTargets(SemanticModel model .Where(type => type.NameSource.IsValid && !HasDiscriminator(model, type)) .Select(type => new DescriptionTarget(type.DeclaringType, type.Name, type.NameSource.Span)); - // A discriminated union documents itself through its members, so it is exempt from the rule. private static bool HasDiscriminator(SemanticModel model, TypeAliasSymbol type) => SemanticModelHelper.TryGetDecoratorInNamespace( model, From f81b684ad9768de1fb059a266d9e159d28bfe9b2 Mon Sep 17 00:00:00 2001 From: John Date: Fri, 7 Aug 2026 13:30:00 +0200 Subject: [PATCH 09/11] Fix merge conflict --- Bicep.sln | 635 ++++++++++++------------ src/Bicep.Testing/TestConfigurations.cs | 7 +- 2 files changed, 320 insertions(+), 322 deletions(-) diff --git a/Bicep.sln b/Bicep.sln index 204b347fe82..287afe7594d 100644 --- a/Bicep.sln +++ b/Bicep.sln @@ -1,321 +1,314 @@ - -Microsoft Visual Studio Solution File, Format Version 12.00 -# Visual Studio Version 18 -VisualStudioVersion = 18.6.11828.311 oobstable -MinimumVisualStudioVersion = 10.0.40219.1 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.Cli", "src\Bicep.Cli\Bicep.Cli.csproj", "{58F20140-729B-41E0-91F0-7004C4E0CB1E}" -EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.Wasm", "src\Bicep.Wasm\Bicep.Wasm.csproj", "{6679B13D-BA2B-43C8-A548-6C6D22E19BE1}" -EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.Core", "src\Bicep.Core\Bicep.Core.csproj", "{D72C8232-24ED-4EDD-ABDB-16194681D9F2}" -EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.LangServer", "src\Bicep.LangServer\Bicep.LangServer.csproj", "{F4AF2603-C020-4A57-A428-AF3EFED21544}" -EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "CLI", "CLI", "{B02251C3-B01E-40EB-B145-2B03F25FE653}" -EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Core", "Core", "{FE323E78-E865-46E2-859A-E4F6FB312C0F}" -EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "LanguageServer", "LanguageServer", "{76F6CBAF-FE81-4B56-B0DB-DE6FD7174771}" -EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Web", "Web", "{9EBF2BF0-C968-4029-B21D-214D195EA148}" -EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.Core.IntegrationTests", "src\Bicep.Core.IntegrationTests\Bicep.Core.IntegrationTests.csproj", "{087ADE61-3D39-4884-8258-40D7A7DD833F}" -EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.Core.UnitTests", "src\Bicep.Core.UnitTests\Bicep.Core.UnitTests.csproj", "{166B8503-54F0-452F-88C5-1430BF05A604}" -EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.LangServer.UnitTests", "src\Bicep.LangServer.UnitTests\Bicep.LangServer.UnitTests.csproj", "{F7B0F06D-56CE-4F4A-8EF9-ED6EC3D77EE7}" -EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.Core.Samples", "src\Bicep.Core.Samples\Bicep.Core.Samples.csproj", "{A2E4B91C-3B7F-4CB1-B482-BE40F7709EB5}" -EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.Cli.UnitTests", "src\Bicep.Cli.UnitTests\Bicep.Cli.UnitTests.csproj", "{29A1AE2B-D47D-41DD-9824-279475D9B6C2}" -EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.LangServer.IntegrationTests", "src\Bicep.LangServer.IntegrationTests\Bicep.LangServer.IntegrationTests.csproj", "{0DE47D02-2BBE-4352-9E38-79A374F9C41E}" -EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.Cli.IntegrationTests", "src\Bicep.Cli.IntegrationTests\Bicep.Cli.IntegrationTests.csproj", "{34D7A843-55CB-4A3A-B268-2D4ABB7044D3}" -EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Decompiler", "Decompiler", "{61643BA1-BE82-4430-A3D3-CB7A16E747E3}" -EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.Decompiler", "src\Bicep.Decompiler\Bicep.Decompiler.csproj", "{4CD48B4A-6297-49FC-90AC-5DF9213C1527}" -EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.Decompiler.IntegrationTests", "src\Bicep.Decompiler.IntegrationTests\Bicep.Decompiler.IntegrationTests.csproj", "{695560CE-C6C3-4FCD-A488-09F06E608297}" -EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.Decompiler.UnitTests", "src\Bicep.Decompiler.UnitTests\Bicep.Decompiler.UnitTests.csproj", "{F3AF01F6-24E8-4129-80B6-84AC070B5C7D}" -EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "_SolutionItems", "_SolutionItems", "{594DDE3F-3A55-47BD-84AF-BAF8B2F8B4C3}" - ProjectSection(SolutionItems) = preProject - .editorconfig = .editorconfig - .gitattributes = .gitattributes - .gitignore = .gitignore - azure-pipelines.yml = azure-pipelines.yml - src\BannedSymbols.txt = src\BannedSymbols.txt - CODE_OF_CONDUCT.md = CODE_OF_CONDUCT.md - CONTRIBUTING.md = CONTRIBUTING.md - src\Directory.Build.props = src\Directory.Build.props - src\Directory.Build.targets = src\Directory.Build.targets - src\Directory.Packages.props = src\Directory.Packages.props - global.json = global.json - LICENSE = LICENSE - README.md = README.md - SECURITY.md = SECURITY.md - EndProjectSection -EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "scripts", "scripts", "{895557F9-3D8B-4752-878A-5F0AAF2E405C}" - ProjectSection(SolutionItems) = preProject - scripts\bcode.ps1 = scripts\bcode.ps1 - scripts\UpdateBaselines.ps1 = scripts\UpdateBaselines.ps1 - EndProjectSection -EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "MSBuild", "MSBuild", "{38A0A11F-72BD-4512-A4A9-AC953936C09F}" -EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.MSBuild", "src\Bicep.MSBuild\Bicep.MSBuild.csproj", "{61026689-70A0-403E-B616-DFAEEF259444}" -EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "RegistryModuleTool", "RegistryModuleTool", "{90126655-7A34-4F5B-A41A-50A468F4632D}" -EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.RegistryModuleTool", "src\Bicep.RegistryModuleTool\Bicep.RegistryModuleTool.csproj", "{DA24CBE9-E85F-4F0D-88D0-0EE5681B91D4}" -EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.RegistryModuleTool.UnitTests", "src\Bicep.RegistryModuleTool.UnitTests\Bicep.RegistryModuleTool.UnitTests.csproj", "{58E2E0C3-059A-4B00-BCC1-66FE78946A9E}" -EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.RegistryModuleTool.IntegrationTests", "src\Bicep.RegistryModuleTool.IntegrationTests\Bicep.RegistryModuleTool.IntegrationTests.csproj", "{8C2280F2-1E08-4022-B26B-59622DD8B126}" -EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.RegistryModuleTool.TestFixtures", "src\Bicep.RegistryModuleTool.TestFixtures\Bicep.RegistryModuleTool.TestFixtures.csproj", "{9F596D8D-5CDB-4830-B73C-26C33C0227D7}" -EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Tools", "Tools", "{C6CAFEE8-7779-4F48-BEA1-D59D3CD91A56}" -EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.Tools.Benchmark", "src\Bicep.Tools.Benchmark\Bicep.Tools.Benchmark.csproj", "{A4127F6F-A282-47F3-BAFE-6A154F994B4E}" -EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Local", "Local", "{8F8DCFBC-A0DC-4E40-93C8-B4FB99FBD757}" -EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.Local.Extension", "src\Bicep.Local.Extension\Bicep.Local.Extension.csproj", "{E84C0368-0D02-4284-A3CB-110B14FA8314}" -EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.Local.Deploy", "src\Bicep.Local.Deploy\Bicep.Local.Deploy.csproj", "{3F3A6387-DD5F-40A6-89D1-92653E4872D3}" -EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.Local.Deploy.IntegrationTests", "src\Bicep.Local.Deploy.IntegrationTests\Bicep.Local.Deploy.IntegrationTests.csproj", "{3F25D072-7A7E-419D-8425-6F2C7CF42BFD}" -EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.Local.Extension.Mock", "src\Bicep.Local.Extension.Mock\Bicep.Local.Extension.Mock.csproj", "{A7D359D9-654A-4FAF-9BC2-DA9667EF8756}" -EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "IO", "IO", "{83EF0BE8-E57C-499D-ABC8-019A7F68F407}" -EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.IO", "src\Bicep.IO\Bicep.IO.csproj", "{A8392FEA-CC1F-4630-85A0-E6BA97AD87D7}" -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Bicep.IO.UnitTests", "src\Bicep.IO.UnitTests\Bicep.IO.UnitTests.csproj", "{69FC508E-6FE7-4C01-942F-F3BF0F3C68E3}" -EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Testing", "Testing", "{02EA681E-C7D8-13C7-8484-4AC65E1B71E8}" -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Bicep.Testing", "src\Bicep.Testing\Bicep.Testing.csproj", "{AA960E8F-4186-4AFD-85FC-55996FAF70D8}" -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Bicep.Local.Extension.UnitTests", "src\Bicep.Local.Extension.UnitTests\Bicep.Local.Extension.UnitTests.csproj", "{DB318A8A-4E80-4D70-A53C-1E69310C5E49}" -EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{013E98B4-42CE-4009-BC62-2588ED9028CD}" -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Bicep.McpServer", "src\Bicep.McpServer\Bicep.McpServer.csproj", "{83AC12EE-E6B5-45FA-AADF-68AB652CC804}" -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Bicep.McpServer.UnitTests", "src\Bicep.McpServer.UnitTests\Bicep.McpServer.UnitTests.csproj", "{46780AD4-62F3-4AB4-9B3C-6A8AB305C260}" -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Bicep.Local.Rpc", "src\Bicep.Local.Rpc\Bicep.Local.Rpc.csproj", "{8585C44C-5093-4A32-AABA-9EC7B8A6118C}" -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Bicep.RpcClient", "src\Bicep.RpcClient\Bicep.RpcClient.csproj", "{EFC27293-4DBB-4D58-85E4-4B94A8F50C8B}" -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Bicep.RpcClient.Tests", "src\Bicep.RpcClient.Tests\Bicep.RpcClient.Tests.csproj", "{930BA3F9-160A-4EB6-80DC-AABFDE3BB919}" -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Bicep.MSBuild.UnitTests", "src\Bicep.MSBuild.UnitTests\Bicep.MSBuild.UnitTests.csproj", "{64F80A63-FF29-4B66-89EB-3F94A0F33E3B}" -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Bicep.McpServer.Core", "src\Bicep.McpServer.Core\Bicep.McpServer.Core.csproj", "{AAAC063A-C133-47AF-885D-8F6EBA608EC8}" -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Bicep.Wasm.UnitTests", "src\Bicep.Wasm.UnitTests\Bicep.Wasm.UnitTests.csproj", "{B887FEC4-2151-6199-35E5-688C1052BC06}" -EndProject -Global - GlobalSection(SolutionConfigurationPlatforms) = preSolution - Debug|Any CPU = Debug|Any CPU - Release|Any CPU = Release|Any CPU - EndGlobalSection - GlobalSection(ProjectConfigurationPlatforms) = postSolution - {58F20140-729B-41E0-91F0-7004C4E0CB1E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {58F20140-729B-41E0-91F0-7004C4E0CB1E}.Debug|Any CPU.Build.0 = Debug|Any CPU - {58F20140-729B-41E0-91F0-7004C4E0CB1E}.Release|Any CPU.ActiveCfg = Release|Any CPU - {58F20140-729B-41E0-91F0-7004C4E0CB1E}.Release|Any CPU.Build.0 = Release|Any CPU - {6679B13D-BA2B-43C8-A548-6C6D22E19BE1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {6679B13D-BA2B-43C8-A548-6C6D22E19BE1}.Debug|Any CPU.Build.0 = Debug|Any CPU - {6679B13D-BA2B-43C8-A548-6C6D22E19BE1}.Release|Any CPU.ActiveCfg = Release|Any CPU - {6679B13D-BA2B-43C8-A548-6C6D22E19BE1}.Release|Any CPU.Build.0 = Release|Any CPU - {D72C8232-24ED-4EDD-ABDB-16194681D9F2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {D72C8232-24ED-4EDD-ABDB-16194681D9F2}.Debug|Any CPU.Build.0 = Debug|Any CPU - {D72C8232-24ED-4EDD-ABDB-16194681D9F2}.Release|Any CPU.ActiveCfg = Release|Any CPU - {D72C8232-24ED-4EDD-ABDB-16194681D9F2}.Release|Any CPU.Build.0 = Release|Any CPU - {F4AF2603-C020-4A57-A428-AF3EFED21544}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {F4AF2603-C020-4A57-A428-AF3EFED21544}.Debug|Any CPU.Build.0 = Debug|Any CPU - {F4AF2603-C020-4A57-A428-AF3EFED21544}.Release|Any CPU.ActiveCfg = Release|Any CPU - {F4AF2603-C020-4A57-A428-AF3EFED21544}.Release|Any CPU.Build.0 = Release|Any CPU - {087ADE61-3D39-4884-8258-40D7A7DD833F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {087ADE61-3D39-4884-8258-40D7A7DD833F}.Debug|Any CPU.Build.0 = Debug|Any CPU - {087ADE61-3D39-4884-8258-40D7A7DD833F}.Release|Any CPU.ActiveCfg = Release|Any CPU - {087ADE61-3D39-4884-8258-40D7A7DD833F}.Release|Any CPU.Build.0 = Release|Any CPU - {166B8503-54F0-452F-88C5-1430BF05A604}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {166B8503-54F0-452F-88C5-1430BF05A604}.Debug|Any CPU.Build.0 = Debug|Any CPU - {166B8503-54F0-452F-88C5-1430BF05A604}.Release|Any CPU.ActiveCfg = Release|Any CPU - {166B8503-54F0-452F-88C5-1430BF05A604}.Release|Any CPU.Build.0 = Release|Any CPU - {F7B0F06D-56CE-4F4A-8EF9-ED6EC3D77EE7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {F7B0F06D-56CE-4F4A-8EF9-ED6EC3D77EE7}.Debug|Any CPU.Build.0 = Debug|Any CPU - {F7B0F06D-56CE-4F4A-8EF9-ED6EC3D77EE7}.Release|Any CPU.ActiveCfg = Release|Any CPU - {F7B0F06D-56CE-4F4A-8EF9-ED6EC3D77EE7}.Release|Any CPU.Build.0 = Release|Any CPU - {A2E4B91C-3B7F-4CB1-B482-BE40F7709EB5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {A2E4B91C-3B7F-4CB1-B482-BE40F7709EB5}.Debug|Any CPU.Build.0 = Debug|Any CPU - {A2E4B91C-3B7F-4CB1-B482-BE40F7709EB5}.Release|Any CPU.ActiveCfg = Release|Any CPU - {A2E4B91C-3B7F-4CB1-B482-BE40F7709EB5}.Release|Any CPU.Build.0 = Release|Any CPU - {29A1AE2B-D47D-41DD-9824-279475D9B6C2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {29A1AE2B-D47D-41DD-9824-279475D9B6C2}.Debug|Any CPU.Build.0 = Debug|Any CPU - {29A1AE2B-D47D-41DD-9824-279475D9B6C2}.Release|Any CPU.ActiveCfg = Release|Any CPU - {29A1AE2B-D47D-41DD-9824-279475D9B6C2}.Release|Any CPU.Build.0 = Release|Any CPU - {0DE47D02-2BBE-4352-9E38-79A374F9C41E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {0DE47D02-2BBE-4352-9E38-79A374F9C41E}.Debug|Any CPU.Build.0 = Debug|Any CPU - {0DE47D02-2BBE-4352-9E38-79A374F9C41E}.Release|Any CPU.ActiveCfg = Release|Any CPU - {0DE47D02-2BBE-4352-9E38-79A374F9C41E}.Release|Any CPU.Build.0 = Release|Any CPU - {34D7A843-55CB-4A3A-B268-2D4ABB7044D3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {34D7A843-55CB-4A3A-B268-2D4ABB7044D3}.Debug|Any CPU.Build.0 = Debug|Any CPU - {34D7A843-55CB-4A3A-B268-2D4ABB7044D3}.Release|Any CPU.ActiveCfg = Release|Any CPU - {34D7A843-55CB-4A3A-B268-2D4ABB7044D3}.Release|Any CPU.Build.0 = Release|Any CPU - {4CD48B4A-6297-49FC-90AC-5DF9213C1527}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {4CD48B4A-6297-49FC-90AC-5DF9213C1527}.Debug|Any CPU.Build.0 = Debug|Any CPU - {4CD48B4A-6297-49FC-90AC-5DF9213C1527}.Release|Any CPU.ActiveCfg = Release|Any CPU - {4CD48B4A-6297-49FC-90AC-5DF9213C1527}.Release|Any CPU.Build.0 = Release|Any CPU - {695560CE-C6C3-4FCD-A488-09F06E608297}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {695560CE-C6C3-4FCD-A488-09F06E608297}.Debug|Any CPU.Build.0 = Debug|Any CPU - {695560CE-C6C3-4FCD-A488-09F06E608297}.Release|Any CPU.ActiveCfg = Release|Any CPU - {695560CE-C6C3-4FCD-A488-09F06E608297}.Release|Any CPU.Build.0 = Release|Any CPU - {F3AF01F6-24E8-4129-80B6-84AC070B5C7D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {F3AF01F6-24E8-4129-80B6-84AC070B5C7D}.Debug|Any CPU.Build.0 = Debug|Any CPU - {F3AF01F6-24E8-4129-80B6-84AC070B5C7D}.Release|Any CPU.ActiveCfg = Release|Any CPU - {F3AF01F6-24E8-4129-80B6-84AC070B5C7D}.Release|Any CPU.Build.0 = Release|Any CPU - {61026689-70A0-403E-B616-DFAEEF259444}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {61026689-70A0-403E-B616-DFAEEF259444}.Debug|Any CPU.Build.0 = Debug|Any CPU - {61026689-70A0-403E-B616-DFAEEF259444}.Release|Any CPU.ActiveCfg = Release|Any CPU - {61026689-70A0-403E-B616-DFAEEF259444}.Release|Any CPU.Build.0 = Release|Any CPU - {DA24CBE9-E85F-4F0D-88D0-0EE5681B91D4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {DA24CBE9-E85F-4F0D-88D0-0EE5681B91D4}.Debug|Any CPU.Build.0 = Debug|Any CPU - {DA24CBE9-E85F-4F0D-88D0-0EE5681B91D4}.Release|Any CPU.ActiveCfg = Release|Any CPU - {DA24CBE9-E85F-4F0D-88D0-0EE5681B91D4}.Release|Any CPU.Build.0 = Release|Any CPU - {58E2E0C3-059A-4B00-BCC1-66FE78946A9E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {58E2E0C3-059A-4B00-BCC1-66FE78946A9E}.Debug|Any CPU.Build.0 = Debug|Any CPU - {58E2E0C3-059A-4B00-BCC1-66FE78946A9E}.Release|Any CPU.ActiveCfg = Release|Any CPU - {58E2E0C3-059A-4B00-BCC1-66FE78946A9E}.Release|Any CPU.Build.0 = Release|Any CPU - {8C2280F2-1E08-4022-B26B-59622DD8B126}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {8C2280F2-1E08-4022-B26B-59622DD8B126}.Debug|Any CPU.Build.0 = Debug|Any CPU - {8C2280F2-1E08-4022-B26B-59622DD8B126}.Release|Any CPU.ActiveCfg = Release|Any CPU - {8C2280F2-1E08-4022-B26B-59622DD8B126}.Release|Any CPU.Build.0 = Release|Any CPU - {9F596D8D-5CDB-4830-B73C-26C33C0227D7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {9F596D8D-5CDB-4830-B73C-26C33C0227D7}.Debug|Any CPU.Build.0 = Debug|Any CPU - {9F596D8D-5CDB-4830-B73C-26C33C0227D7}.Release|Any CPU.ActiveCfg = Release|Any CPU - {9F596D8D-5CDB-4830-B73C-26C33C0227D7}.Release|Any CPU.Build.0 = Release|Any CPU - {A4127F6F-A282-47F3-BAFE-6A154F994B4E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {A4127F6F-A282-47F3-BAFE-6A154F994B4E}.Debug|Any CPU.Build.0 = Debug|Any CPU - {A4127F6F-A282-47F3-BAFE-6A154F994B4E}.Release|Any CPU.ActiveCfg = Release|Any CPU - {A4127F6F-A282-47F3-BAFE-6A154F994B4E}.Release|Any CPU.Build.0 = Release|Any CPU - {E84C0368-0D02-4284-A3CB-110B14FA8314}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {E84C0368-0D02-4284-A3CB-110B14FA8314}.Debug|Any CPU.Build.0 = Debug|Any CPU - {E84C0368-0D02-4284-A3CB-110B14FA8314}.Release|Any CPU.ActiveCfg = Release|Any CPU - {E84C0368-0D02-4284-A3CB-110B14FA8314}.Release|Any CPU.Build.0 = Release|Any CPU - {3F3A6387-DD5F-40A6-89D1-92653E4872D3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {3F3A6387-DD5F-40A6-89D1-92653E4872D3}.Debug|Any CPU.Build.0 = Debug|Any CPU - {3F3A6387-DD5F-40A6-89D1-92653E4872D3}.Release|Any CPU.ActiveCfg = Release|Any CPU - {3F3A6387-DD5F-40A6-89D1-92653E4872D3}.Release|Any CPU.Build.0 = Release|Any CPU - {3F25D072-7A7E-419D-8425-6F2C7CF42BFD}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {3F25D072-7A7E-419D-8425-6F2C7CF42BFD}.Debug|Any CPU.Build.0 = Debug|Any CPU - {3F25D072-7A7E-419D-8425-6F2C7CF42BFD}.Release|Any CPU.ActiveCfg = Release|Any CPU - {3F25D072-7A7E-419D-8425-6F2C7CF42BFD}.Release|Any CPU.Build.0 = Release|Any CPU - {A7D359D9-654A-4FAF-9BC2-DA9667EF8756}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {A7D359D9-654A-4FAF-9BC2-DA9667EF8756}.Debug|Any CPU.Build.0 = Debug|Any CPU - {A7D359D9-654A-4FAF-9BC2-DA9667EF8756}.Release|Any CPU.ActiveCfg = Release|Any CPU - {A7D359D9-654A-4FAF-9BC2-DA9667EF8756}.Release|Any CPU.Build.0 = Release|Any CPU - {A8392FEA-CC1F-4630-85A0-E6BA97AD87D7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {A8392FEA-CC1F-4630-85A0-E6BA97AD87D7}.Debug|Any CPU.Build.0 = Debug|Any CPU - {A8392FEA-CC1F-4630-85A0-E6BA97AD87D7}.Release|Any CPU.ActiveCfg = Release|Any CPU - {A8392FEA-CC1F-4630-85A0-E6BA97AD87D7}.Release|Any CPU.Build.0 = Release|Any CPU - {69FC508E-6FE7-4C01-942F-F3BF0F3C68E3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {69FC508E-6FE7-4C01-942F-F3BF0F3C68E3}.Debug|Any CPU.Build.0 = Debug|Any CPU - {69FC508E-6FE7-4C01-942F-F3BF0F3C68E3}.Release|Any CPU.ActiveCfg = Release|Any CPU - {69FC508E-6FE7-4C01-942F-F3BF0F3C68E3}.Release|Any CPU.Build.0 = Release|Any CPU - {AA960E8F-4186-4AFD-85FC-55996FAF70D8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {AA960E8F-4186-4AFD-85FC-55996FAF70D8}.Debug|Any CPU.Build.0 = Debug|Any CPU - {AA960E8F-4186-4AFD-85FC-55996FAF70D8}.Release|Any CPU.ActiveCfg = Release|Any CPU - {AA960E8F-4186-4AFD-85FC-55996FAF70D8}.Release|Any CPU.Build.0 = Release|Any CPU - {DB318A8A-4E80-4D70-A53C-1E69310C5E49}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {DB318A8A-4E80-4D70-A53C-1E69310C5E49}.Debug|Any CPU.Build.0 = Debug|Any CPU - {DB318A8A-4E80-4D70-A53C-1E69310C5E49}.Release|Any CPU.ActiveCfg = Release|Any CPU - {DB318A8A-4E80-4D70-A53C-1E69310C5E49}.Release|Any CPU.Build.0 = Release|Any CPU - {83AC12EE-E6B5-45FA-AADF-68AB652CC804}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {83AC12EE-E6B5-45FA-AADF-68AB652CC804}.Debug|Any CPU.Build.0 = Debug|Any CPU - {83AC12EE-E6B5-45FA-AADF-68AB652CC804}.Release|Any CPU.ActiveCfg = Release|Any CPU - {83AC12EE-E6B5-45FA-AADF-68AB652CC804}.Release|Any CPU.Build.0 = Release|Any CPU - {46780AD4-62F3-4AB4-9B3C-6A8AB305C260}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {46780AD4-62F3-4AB4-9B3C-6A8AB305C260}.Debug|Any CPU.Build.0 = Debug|Any CPU - {46780AD4-62F3-4AB4-9B3C-6A8AB305C260}.Release|Any CPU.ActiveCfg = Release|Any CPU - {46780AD4-62F3-4AB4-9B3C-6A8AB305C260}.Release|Any CPU.Build.0 = Release|Any CPU - {8585C44C-5093-4A32-AABA-9EC7B8A6118C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {8585C44C-5093-4A32-AABA-9EC7B8A6118C}.Debug|Any CPU.Build.0 = Debug|Any CPU - {8585C44C-5093-4A32-AABA-9EC7B8A6118C}.Release|Any CPU.ActiveCfg = Release|Any CPU - {8585C44C-5093-4A32-AABA-9EC7B8A6118C}.Release|Any CPU.Build.0 = Release|Any CPU - {EFC27293-4DBB-4D58-85E4-4B94A8F50C8B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {EFC27293-4DBB-4D58-85E4-4B94A8F50C8B}.Debug|Any CPU.Build.0 = Debug|Any CPU - {EFC27293-4DBB-4D58-85E4-4B94A8F50C8B}.Release|Any CPU.ActiveCfg = Release|Any CPU - {EFC27293-4DBB-4D58-85E4-4B94A8F50C8B}.Release|Any CPU.Build.0 = Release|Any CPU - {930BA3F9-160A-4EB6-80DC-AABFDE3BB919}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {930BA3F9-160A-4EB6-80DC-AABFDE3BB919}.Debug|Any CPU.Build.0 = Debug|Any CPU - {930BA3F9-160A-4EB6-80DC-AABFDE3BB919}.Release|Any CPU.ActiveCfg = Release|Any CPU - {930BA3F9-160A-4EB6-80DC-AABFDE3BB919}.Release|Any CPU.Build.0 = Release|Any CPU - {64F80A63-FF29-4B66-89EB-3F94A0F33E3B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {64F80A63-FF29-4B66-89EB-3F94A0F33E3B}.Debug|Any CPU.Build.0 = Debug|Any CPU - {64F80A63-FF29-4B66-89EB-3F94A0F33E3B}.Release|Any CPU.ActiveCfg = Release|Any CPU - {64F80A63-FF29-4B66-89EB-3F94A0F33E3B}.Release|Any CPU.Build.0 = Release|Any CPU - {AAAC063A-C133-47AF-885D-8F6EBA608EC8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {AAAC063A-C133-47AF-885D-8F6EBA608EC8}.Debug|Any CPU.Build.0 = Debug|Any CPU - {AAAC063A-C133-47AF-885D-8F6EBA608EC8}.Release|Any CPU.ActiveCfg = Release|Any CPU - {AAAC063A-C133-47AF-885D-8F6EBA608EC8}.Release|Any CPU.Build.0 = Release|Any CPU - {B887FEC4-2151-6199-35E5-688C1052BC06}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {B887FEC4-2151-6199-35E5-688C1052BC06}.Debug|Any CPU.Build.0 = Debug|Any CPU - {B887FEC4-2151-6199-35E5-688C1052BC06}.Release|Any CPU.ActiveCfg = Release|Any CPU - {B887FEC4-2151-6199-35E5-688C1052BC06}.Release|Any CPU.Build.0 = Release|Any CPU - EndGlobalSection - GlobalSection(SolutionProperties) = preSolution - HideSolutionNode = FALSE - EndGlobalSection - GlobalSection(NestedProjects) = preSolution - {58F20140-729B-41E0-91F0-7004C4E0CB1E} = {B02251C3-B01E-40EB-B145-2B03F25FE653} - {6679B13D-BA2B-43C8-A548-6C6D22E19BE1} = {9EBF2BF0-C968-4029-B21D-214D195EA148} - {D72C8232-24ED-4EDD-ABDB-16194681D9F2} = {FE323E78-E865-46E2-859A-E4F6FB312C0F} - {F4AF2603-C020-4A57-A428-AF3EFED21544} = {76F6CBAF-FE81-4B56-B0DB-DE6FD7174771} - {087ADE61-3D39-4884-8258-40D7A7DD833F} = {FE323E78-E865-46E2-859A-E4F6FB312C0F} - {166B8503-54F0-452F-88C5-1430BF05A604} = {FE323E78-E865-46E2-859A-E4F6FB312C0F} - {F7B0F06D-56CE-4F4A-8EF9-ED6EC3D77EE7} = {76F6CBAF-FE81-4B56-B0DB-DE6FD7174771} - {A2E4B91C-3B7F-4CB1-B482-BE40F7709EB5} = {FE323E78-E865-46E2-859A-E4F6FB312C0F} - {29A1AE2B-D47D-41DD-9824-279475D9B6C2} = {B02251C3-B01E-40EB-B145-2B03F25FE653} - {0DE47D02-2BBE-4352-9E38-79A374F9C41E} = {76F6CBAF-FE81-4B56-B0DB-DE6FD7174771} - {34D7A843-55CB-4A3A-B268-2D4ABB7044D3} = {B02251C3-B01E-40EB-B145-2B03F25FE653} - {4CD48B4A-6297-49FC-90AC-5DF9213C1527} = {61643BA1-BE82-4430-A3D3-CB7A16E747E3} - {695560CE-C6C3-4FCD-A488-09F06E608297} = {61643BA1-BE82-4430-A3D3-CB7A16E747E3} - {F3AF01F6-24E8-4129-80B6-84AC070B5C7D} = {61643BA1-BE82-4430-A3D3-CB7A16E747E3} - {61026689-70A0-403E-B616-DFAEEF259444} = {38A0A11F-72BD-4512-A4A9-AC953936C09F} - {DA24CBE9-E85F-4F0D-88D0-0EE5681B91D4} = {90126655-7A34-4F5B-A41A-50A468F4632D} - {58E2E0C3-059A-4B00-BCC1-66FE78946A9E} = {90126655-7A34-4F5B-A41A-50A468F4632D} - {8C2280F2-1E08-4022-B26B-59622DD8B126} = {90126655-7A34-4F5B-A41A-50A468F4632D} - {9F596D8D-5CDB-4830-B73C-26C33C0227D7} = {90126655-7A34-4F5B-A41A-50A468F4632D} - {A4127F6F-A282-47F3-BAFE-6A154F994B4E} = {C6CAFEE8-7779-4F48-BEA1-D59D3CD91A56} - {E84C0368-0D02-4284-A3CB-110B14FA8314} = {8F8DCFBC-A0DC-4E40-93C8-B4FB99FBD757} - {3F3A6387-DD5F-40A6-89D1-92653E4872D3} = {8F8DCFBC-A0DC-4E40-93C8-B4FB99FBD757} - {3F25D072-7A7E-419D-8425-6F2C7CF42BFD} = {8F8DCFBC-A0DC-4E40-93C8-B4FB99FBD757} - {A7D359D9-654A-4FAF-9BC2-DA9667EF8756} = {8F8DCFBC-A0DC-4E40-93C8-B4FB99FBD757} - {A8392FEA-CC1F-4630-85A0-E6BA97AD87D7} = {83EF0BE8-E57C-499D-ABC8-019A7F68F407} - {69FC508E-6FE7-4C01-942F-F3BF0F3C68E3} = {83EF0BE8-E57C-499D-ABC8-019A7F68F407} - {AA960E8F-4186-4AFD-85FC-55996FAF70D8} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8} - {DB318A8A-4E80-4D70-A53C-1E69310C5E49} = {8F8DCFBC-A0DC-4E40-93C8-B4FB99FBD757} - {83AC12EE-E6B5-45FA-AADF-68AB652CC804} = {013E98B4-42CE-4009-BC62-2588ED9028CD} - {46780AD4-62F3-4AB4-9B3C-6A8AB305C260} = {013E98B4-42CE-4009-BC62-2588ED9028CD} - {8585C44C-5093-4A32-AABA-9EC7B8A6118C} = {013E98B4-42CE-4009-BC62-2588ED9028CD} - {EFC27293-4DBB-4D58-85E4-4B94A8F50C8B} = {013E98B4-42CE-4009-BC62-2588ED9028CD} - {930BA3F9-160A-4EB6-80DC-AABFDE3BB919} = {013E98B4-42CE-4009-BC62-2588ED9028CD} - {64F80A63-FF29-4B66-89EB-3F94A0F33E3B} = {38A0A11F-72BD-4512-A4A9-AC953936C09F} - {AAAC063A-C133-47AF-885D-8F6EBA608EC8} = {013E98B4-42CE-4009-BC62-2588ED9028CD} - {B887FEC4-2151-6199-35E5-688C1052BC06} = {9EBF2BF0-C968-4029-B21D-214D195EA148} - EndGlobalSection - GlobalSection(ExtensibilityGlobals) = postSolution - SolutionGuid = {21F77282-91E7-4304-B1EF-FADFA4F39E37} - EndGlobalSection -EndGlobal + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 18 +VisualStudioVersion = 18.6.11828.311 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.Cli", "src\Bicep.Cli\Bicep.Cli.csproj", "{58F20140-729B-41E0-91F0-7004C4E0CB1E}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.Wasm", "src\Bicep.Wasm\Bicep.Wasm.csproj", "{6679B13D-BA2B-43C8-A548-6C6D22E19BE1}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.Core", "src\Bicep.Core\Bicep.Core.csproj", "{D72C8232-24ED-4EDD-ABDB-16194681D9F2}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.LangServer", "src\Bicep.LangServer\Bicep.LangServer.csproj", "{F4AF2603-C020-4A57-A428-AF3EFED21544}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "CLI", "CLI", "{B02251C3-B01E-40EB-B145-2B03F25FE653}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Core", "Core", "{FE323E78-E865-46E2-859A-E4F6FB312C0F}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "LanguageServer", "LanguageServer", "{76F6CBAF-FE81-4B56-B0DB-DE6FD7174771}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Web", "Web", "{9EBF2BF0-C968-4029-B21D-214D195EA148}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.Core.IntegrationTests", "src\Bicep.Core.IntegrationTests\Bicep.Core.IntegrationTests.csproj", "{087ADE61-3D39-4884-8258-40D7A7DD833F}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.Core.UnitTests", "src\Bicep.Core.UnitTests\Bicep.Core.UnitTests.csproj", "{166B8503-54F0-452F-88C5-1430BF05A604}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.LangServer.UnitTests", "src\Bicep.LangServer.UnitTests\Bicep.LangServer.UnitTests.csproj", "{F7B0F06D-56CE-4F4A-8EF9-ED6EC3D77EE7}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.Core.Samples", "src\Bicep.Core.Samples\Bicep.Core.Samples.csproj", "{A2E4B91C-3B7F-4CB1-B482-BE40F7709EB5}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.Cli.UnitTests", "src\Bicep.Cli.UnitTests\Bicep.Cli.UnitTests.csproj", "{29A1AE2B-D47D-41DD-9824-279475D9B6C2}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.LangServer.IntegrationTests", "src\Bicep.LangServer.IntegrationTests\Bicep.LangServer.IntegrationTests.csproj", "{0DE47D02-2BBE-4352-9E38-79A374F9C41E}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.Cli.IntegrationTests", "src\Bicep.Cli.IntegrationTests\Bicep.Cli.IntegrationTests.csproj", "{34D7A843-55CB-4A3A-B268-2D4ABB7044D3}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Decompiler", "Decompiler", "{61643BA1-BE82-4430-A3D3-CB7A16E747E3}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.Decompiler", "src\Bicep.Decompiler\Bicep.Decompiler.csproj", "{4CD48B4A-6297-49FC-90AC-5DF9213C1527}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.Decompiler.IntegrationTests", "src\Bicep.Decompiler.IntegrationTests\Bicep.Decompiler.IntegrationTests.csproj", "{695560CE-C6C3-4FCD-A488-09F06E608297}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.Decompiler.UnitTests", "src\Bicep.Decompiler.UnitTests\Bicep.Decompiler.UnitTests.csproj", "{F3AF01F6-24E8-4129-80B6-84AC070B5C7D}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "_SolutionItems", "_SolutionItems", "{594DDE3F-3A55-47BD-84AF-BAF8B2F8B4C3}" + ProjectSection(SolutionItems) = preProject + .editorconfig = .editorconfig + .gitattributes = .gitattributes + .gitignore = .gitignore + azure-pipelines.yml = azure-pipelines.yml + src\BannedSymbols.txt = src\BannedSymbols.txt + CODE_OF_CONDUCT.md = CODE_OF_CONDUCT.md + CONTRIBUTING.md = CONTRIBUTING.md + src\Directory.Build.props = src\Directory.Build.props + src\Directory.Build.targets = src\Directory.Build.targets + src\Directory.Packages.props = src\Directory.Packages.props + global.json = global.json + LICENSE = LICENSE + README.md = README.md + SECURITY.md = SECURITY.md + EndProjectSection +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "scripts", "scripts", "{895557F9-3D8B-4752-878A-5F0AAF2E405C}" + ProjectSection(SolutionItems) = preProject + scripts\bcode.ps1 = scripts\bcode.ps1 + scripts\UpdateBaselines.ps1 = scripts\UpdateBaselines.ps1 + EndProjectSection +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "MSBuild", "MSBuild", "{38A0A11F-72BD-4512-A4A9-AC953936C09F}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.MSBuild", "src\Bicep.MSBuild\Bicep.MSBuild.csproj", "{61026689-70A0-403E-B616-DFAEEF259444}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "RegistryModuleTool", "RegistryModuleTool", "{90126655-7A34-4F5B-A41A-50A468F4632D}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.RegistryModuleTool", "src\Bicep.RegistryModuleTool\Bicep.RegistryModuleTool.csproj", "{DA24CBE9-E85F-4F0D-88D0-0EE5681B91D4}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.RegistryModuleTool.UnitTests", "src\Bicep.RegistryModuleTool.UnitTests\Bicep.RegistryModuleTool.UnitTests.csproj", "{58E2E0C3-059A-4B00-BCC1-66FE78946A9E}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.RegistryModuleTool.IntegrationTests", "src\Bicep.RegistryModuleTool.IntegrationTests\Bicep.RegistryModuleTool.IntegrationTests.csproj", "{8C2280F2-1E08-4022-B26B-59622DD8B126}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.RegistryModuleTool.TestFixtures", "src\Bicep.RegistryModuleTool.TestFixtures\Bicep.RegistryModuleTool.TestFixtures.csproj", "{9F596D8D-5CDB-4830-B73C-26C33C0227D7}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Tools", "Tools", "{C6CAFEE8-7779-4F48-BEA1-D59D3CD91A56}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.Tools.Benchmark", "src\Bicep.Tools.Benchmark\Bicep.Tools.Benchmark.csproj", "{A4127F6F-A282-47F3-BAFE-6A154F994B4E}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Local", "Local", "{8F8DCFBC-A0DC-4E40-93C8-B4FB99FBD757}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.Local.Extension", "src\Bicep.Local.Extension\Bicep.Local.Extension.csproj", "{E84C0368-0D02-4284-A3CB-110B14FA8314}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.Local.Deploy", "src\Bicep.Local.Deploy\Bicep.Local.Deploy.csproj", "{3F3A6387-DD5F-40A6-89D1-92653E4872D3}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.Local.Deploy.IntegrationTests", "src\Bicep.Local.Deploy.IntegrationTests\Bicep.Local.Deploy.IntegrationTests.csproj", "{3F25D072-7A7E-419D-8425-6F2C7CF42BFD}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.Local.Extension.Mock", "src\Bicep.Local.Extension.Mock\Bicep.Local.Extension.Mock.csproj", "{A7D359D9-654A-4FAF-9BC2-DA9667EF8756}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "IO", "IO", "{83EF0BE8-E57C-499D-ABC8-019A7F68F407}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Bicep.IO", "src\Bicep.IO\Bicep.IO.csproj", "{A8392FEA-CC1F-4630-85A0-E6BA97AD87D7}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Bicep.IO.UnitTests", "src\Bicep.IO.UnitTests\Bicep.IO.UnitTests.csproj", "{69FC508E-6FE7-4C01-942F-F3BF0F3C68E3}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "TestFixtures", "TestFixtures", "{02EA681E-C7D8-13C7-8484-4AC65E1B71E8}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Bicep.Local.Extension.UnitTests", "src\Bicep.Local.Extension.UnitTests\Bicep.Local.Extension.UnitTests.csproj", "{DB318A8A-4E80-4D70-A53C-1E69310C5E49}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{013E98B4-42CE-4009-BC62-2588ED9028CD}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Bicep.McpServer", "src\Bicep.McpServer\Bicep.McpServer.csproj", "{83AC12EE-E6B5-45FA-AADF-68AB652CC804}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Bicep.McpServer.UnitTests", "src\Bicep.McpServer.UnitTests\Bicep.McpServer.UnitTests.csproj", "{46780AD4-62F3-4AB4-9B3C-6A8AB305C260}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Bicep.Local.Rpc", "src\Bicep.Local.Rpc\Bicep.Local.Rpc.csproj", "{8585C44C-5093-4A32-AABA-9EC7B8A6118C}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Bicep.RpcClient", "src\Bicep.RpcClient\Bicep.RpcClient.csproj", "{EFC27293-4DBB-4D58-85E4-4B94A8F50C8B}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Bicep.RpcClient.Tests", "src\Bicep.RpcClient.Tests\Bicep.RpcClient.Tests.csproj", "{930BA3F9-160A-4EB6-80DC-AABFDE3BB919}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Bicep.MSBuild.UnitTests", "src\Bicep.MSBuild.UnitTests\Bicep.MSBuild.UnitTests.csproj", "{64F80A63-FF29-4B66-89EB-3F94A0F33E3B}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Bicep.McpServer.Core", "src\Bicep.McpServer.Core\Bicep.McpServer.Core.csproj", "{AAAC063A-C133-47AF-885D-8F6EBA608EC8}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Bicep.Wasm.UnitTests", "src\Bicep.Wasm.UnitTests\Bicep.Wasm.UnitTests.csproj", "{B887FEC4-2151-6199-35E5-688C1052BC06}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {58F20140-729B-41E0-91F0-7004C4E0CB1E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {58F20140-729B-41E0-91F0-7004C4E0CB1E}.Debug|Any CPU.Build.0 = Debug|Any CPU + {58F20140-729B-41E0-91F0-7004C4E0CB1E}.Release|Any CPU.ActiveCfg = Release|Any CPU + {58F20140-729B-41E0-91F0-7004C4E0CB1E}.Release|Any CPU.Build.0 = Release|Any CPU + {6679B13D-BA2B-43C8-A548-6C6D22E19BE1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {6679B13D-BA2B-43C8-A548-6C6D22E19BE1}.Debug|Any CPU.Build.0 = Debug|Any CPU + {6679B13D-BA2B-43C8-A548-6C6D22E19BE1}.Release|Any CPU.ActiveCfg = Release|Any CPU + {6679B13D-BA2B-43C8-A548-6C6D22E19BE1}.Release|Any CPU.Build.0 = Release|Any CPU + {D72C8232-24ED-4EDD-ABDB-16194681D9F2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {D72C8232-24ED-4EDD-ABDB-16194681D9F2}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D72C8232-24ED-4EDD-ABDB-16194681D9F2}.Release|Any CPU.ActiveCfg = Release|Any CPU + {D72C8232-24ED-4EDD-ABDB-16194681D9F2}.Release|Any CPU.Build.0 = Release|Any CPU + {F4AF2603-C020-4A57-A428-AF3EFED21544}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {F4AF2603-C020-4A57-A428-AF3EFED21544}.Debug|Any CPU.Build.0 = Debug|Any CPU + {F4AF2603-C020-4A57-A428-AF3EFED21544}.Release|Any CPU.ActiveCfg = Release|Any CPU + {F4AF2603-C020-4A57-A428-AF3EFED21544}.Release|Any CPU.Build.0 = Release|Any CPU + {087ADE61-3D39-4884-8258-40D7A7DD833F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {087ADE61-3D39-4884-8258-40D7A7DD833F}.Debug|Any CPU.Build.0 = Debug|Any CPU + {087ADE61-3D39-4884-8258-40D7A7DD833F}.Release|Any CPU.ActiveCfg = Release|Any CPU + {087ADE61-3D39-4884-8258-40D7A7DD833F}.Release|Any CPU.Build.0 = Release|Any CPU + {166B8503-54F0-452F-88C5-1430BF05A604}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {166B8503-54F0-452F-88C5-1430BF05A604}.Debug|Any CPU.Build.0 = Debug|Any CPU + {166B8503-54F0-452F-88C5-1430BF05A604}.Release|Any CPU.ActiveCfg = Release|Any CPU + {166B8503-54F0-452F-88C5-1430BF05A604}.Release|Any CPU.Build.0 = Release|Any CPU + {F7B0F06D-56CE-4F4A-8EF9-ED6EC3D77EE7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {F7B0F06D-56CE-4F4A-8EF9-ED6EC3D77EE7}.Debug|Any CPU.Build.0 = Debug|Any CPU + {F7B0F06D-56CE-4F4A-8EF9-ED6EC3D77EE7}.Release|Any CPU.ActiveCfg = Release|Any CPU + {F7B0F06D-56CE-4F4A-8EF9-ED6EC3D77EE7}.Release|Any CPU.Build.0 = Release|Any CPU + {A2E4B91C-3B7F-4CB1-B482-BE40F7709EB5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {A2E4B91C-3B7F-4CB1-B482-BE40F7709EB5}.Debug|Any CPU.Build.0 = Debug|Any CPU + {A2E4B91C-3B7F-4CB1-B482-BE40F7709EB5}.Release|Any CPU.ActiveCfg = Release|Any CPU + {A2E4B91C-3B7F-4CB1-B482-BE40F7709EB5}.Release|Any CPU.Build.0 = Release|Any CPU + {29A1AE2B-D47D-41DD-9824-279475D9B6C2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {29A1AE2B-D47D-41DD-9824-279475D9B6C2}.Debug|Any CPU.Build.0 = Debug|Any CPU + {29A1AE2B-D47D-41DD-9824-279475D9B6C2}.Release|Any CPU.ActiveCfg = Release|Any CPU + {29A1AE2B-D47D-41DD-9824-279475D9B6C2}.Release|Any CPU.Build.0 = Release|Any CPU + {0DE47D02-2BBE-4352-9E38-79A374F9C41E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {0DE47D02-2BBE-4352-9E38-79A374F9C41E}.Debug|Any CPU.Build.0 = Debug|Any CPU + {0DE47D02-2BBE-4352-9E38-79A374F9C41E}.Release|Any CPU.ActiveCfg = Release|Any CPU + {0DE47D02-2BBE-4352-9E38-79A374F9C41E}.Release|Any CPU.Build.0 = Release|Any CPU + {34D7A843-55CB-4A3A-B268-2D4ABB7044D3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {34D7A843-55CB-4A3A-B268-2D4ABB7044D3}.Debug|Any CPU.Build.0 = Debug|Any CPU + {34D7A843-55CB-4A3A-B268-2D4ABB7044D3}.Release|Any CPU.ActiveCfg = Release|Any CPU + {34D7A843-55CB-4A3A-B268-2D4ABB7044D3}.Release|Any CPU.Build.0 = Release|Any CPU + {4CD48B4A-6297-49FC-90AC-5DF9213C1527}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {4CD48B4A-6297-49FC-90AC-5DF9213C1527}.Debug|Any CPU.Build.0 = Debug|Any CPU + {4CD48B4A-6297-49FC-90AC-5DF9213C1527}.Release|Any CPU.ActiveCfg = Release|Any CPU + {4CD48B4A-6297-49FC-90AC-5DF9213C1527}.Release|Any CPU.Build.0 = Release|Any CPU + {695560CE-C6C3-4FCD-A488-09F06E608297}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {695560CE-C6C3-4FCD-A488-09F06E608297}.Debug|Any CPU.Build.0 = Debug|Any CPU + {695560CE-C6C3-4FCD-A488-09F06E608297}.Release|Any CPU.ActiveCfg = Release|Any CPU + {695560CE-C6C3-4FCD-A488-09F06E608297}.Release|Any CPU.Build.0 = Release|Any CPU + {F3AF01F6-24E8-4129-80B6-84AC070B5C7D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {F3AF01F6-24E8-4129-80B6-84AC070B5C7D}.Debug|Any CPU.Build.0 = Debug|Any CPU + {F3AF01F6-24E8-4129-80B6-84AC070B5C7D}.Release|Any CPU.ActiveCfg = Release|Any CPU + {F3AF01F6-24E8-4129-80B6-84AC070B5C7D}.Release|Any CPU.Build.0 = Release|Any CPU + {61026689-70A0-403E-B616-DFAEEF259444}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {61026689-70A0-403E-B616-DFAEEF259444}.Debug|Any CPU.Build.0 = Debug|Any CPU + {61026689-70A0-403E-B616-DFAEEF259444}.Release|Any CPU.ActiveCfg = Release|Any CPU + {61026689-70A0-403E-B616-DFAEEF259444}.Release|Any CPU.Build.0 = Release|Any CPU + {DA24CBE9-E85F-4F0D-88D0-0EE5681B91D4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {DA24CBE9-E85F-4F0D-88D0-0EE5681B91D4}.Debug|Any CPU.Build.0 = Debug|Any CPU + {DA24CBE9-E85F-4F0D-88D0-0EE5681B91D4}.Release|Any CPU.ActiveCfg = Release|Any CPU + {DA24CBE9-E85F-4F0D-88D0-0EE5681B91D4}.Release|Any CPU.Build.0 = Release|Any CPU + {58E2E0C3-059A-4B00-BCC1-66FE78946A9E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {58E2E0C3-059A-4B00-BCC1-66FE78946A9E}.Debug|Any CPU.Build.0 = Debug|Any CPU + {58E2E0C3-059A-4B00-BCC1-66FE78946A9E}.Release|Any CPU.ActiveCfg = Release|Any CPU + {58E2E0C3-059A-4B00-BCC1-66FE78946A9E}.Release|Any CPU.Build.0 = Release|Any CPU + {8C2280F2-1E08-4022-B26B-59622DD8B126}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {8C2280F2-1E08-4022-B26B-59622DD8B126}.Debug|Any CPU.Build.0 = Debug|Any CPU + {8C2280F2-1E08-4022-B26B-59622DD8B126}.Release|Any CPU.ActiveCfg = Release|Any CPU + {8C2280F2-1E08-4022-B26B-59622DD8B126}.Release|Any CPU.Build.0 = Release|Any CPU + {9F596D8D-5CDB-4830-B73C-26C33C0227D7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {9F596D8D-5CDB-4830-B73C-26C33C0227D7}.Debug|Any CPU.Build.0 = Debug|Any CPU + {9F596D8D-5CDB-4830-B73C-26C33C0227D7}.Release|Any CPU.ActiveCfg = Release|Any CPU + {9F596D8D-5CDB-4830-B73C-26C33C0227D7}.Release|Any CPU.Build.0 = Release|Any CPU + {A4127F6F-A282-47F3-BAFE-6A154F994B4E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {A4127F6F-A282-47F3-BAFE-6A154F994B4E}.Debug|Any CPU.Build.0 = Debug|Any CPU + {A4127F6F-A282-47F3-BAFE-6A154F994B4E}.Release|Any CPU.ActiveCfg = Release|Any CPU + {A4127F6F-A282-47F3-BAFE-6A154F994B4E}.Release|Any CPU.Build.0 = Release|Any CPU + {E84C0368-0D02-4284-A3CB-110B14FA8314}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {E84C0368-0D02-4284-A3CB-110B14FA8314}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E84C0368-0D02-4284-A3CB-110B14FA8314}.Release|Any CPU.ActiveCfg = Release|Any CPU + {E84C0368-0D02-4284-A3CB-110B14FA8314}.Release|Any CPU.Build.0 = Release|Any CPU + {3F3A6387-DD5F-40A6-89D1-92653E4872D3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {3F3A6387-DD5F-40A6-89D1-92653E4872D3}.Debug|Any CPU.Build.0 = Debug|Any CPU + {3F3A6387-DD5F-40A6-89D1-92653E4872D3}.Release|Any CPU.ActiveCfg = Release|Any CPU + {3F3A6387-DD5F-40A6-89D1-92653E4872D3}.Release|Any CPU.Build.0 = Release|Any CPU + {3F25D072-7A7E-419D-8425-6F2C7CF42BFD}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {3F25D072-7A7E-419D-8425-6F2C7CF42BFD}.Debug|Any CPU.Build.0 = Debug|Any CPU + {3F25D072-7A7E-419D-8425-6F2C7CF42BFD}.Release|Any CPU.ActiveCfg = Release|Any CPU + {3F25D072-7A7E-419D-8425-6F2C7CF42BFD}.Release|Any CPU.Build.0 = Release|Any CPU + {A7D359D9-654A-4FAF-9BC2-DA9667EF8756}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {A7D359D9-654A-4FAF-9BC2-DA9667EF8756}.Debug|Any CPU.Build.0 = Debug|Any CPU + {A7D359D9-654A-4FAF-9BC2-DA9667EF8756}.Release|Any CPU.ActiveCfg = Release|Any CPU + {A7D359D9-654A-4FAF-9BC2-DA9667EF8756}.Release|Any CPU.Build.0 = Release|Any CPU + {A8392FEA-CC1F-4630-85A0-E6BA97AD87D7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {A8392FEA-CC1F-4630-85A0-E6BA97AD87D7}.Debug|Any CPU.Build.0 = Debug|Any CPU + {A8392FEA-CC1F-4630-85A0-E6BA97AD87D7}.Release|Any CPU.ActiveCfg = Release|Any CPU + {A8392FEA-CC1F-4630-85A0-E6BA97AD87D7}.Release|Any CPU.Build.0 = Release|Any CPU + {69FC508E-6FE7-4C01-942F-F3BF0F3C68E3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {69FC508E-6FE7-4C01-942F-F3BF0F3C68E3}.Debug|Any CPU.Build.0 = Debug|Any CPU + {69FC508E-6FE7-4C01-942F-F3BF0F3C68E3}.Release|Any CPU.ActiveCfg = Release|Any CPU + {69FC508E-6FE7-4C01-942F-F3BF0F3C68E3}.Release|Any CPU.Build.0 = Release|Any CPU + {DB318A8A-4E80-4D70-A53C-1E69310C5E49}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {DB318A8A-4E80-4D70-A53C-1E69310C5E49}.Debug|Any CPU.Build.0 = Debug|Any CPU + {DB318A8A-4E80-4D70-A53C-1E69310C5E49}.Release|Any CPU.ActiveCfg = Release|Any CPU + {DB318A8A-4E80-4D70-A53C-1E69310C5E49}.Release|Any CPU.Build.0 = Release|Any CPU + {83AC12EE-E6B5-45FA-AADF-68AB652CC804}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {83AC12EE-E6B5-45FA-AADF-68AB652CC804}.Debug|Any CPU.Build.0 = Debug|Any CPU + {83AC12EE-E6B5-45FA-AADF-68AB652CC804}.Release|Any CPU.ActiveCfg = Release|Any CPU + {83AC12EE-E6B5-45FA-AADF-68AB652CC804}.Release|Any CPU.Build.0 = Release|Any CPU + {46780AD4-62F3-4AB4-9B3C-6A8AB305C260}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {46780AD4-62F3-4AB4-9B3C-6A8AB305C260}.Debug|Any CPU.Build.0 = Debug|Any CPU + {46780AD4-62F3-4AB4-9B3C-6A8AB305C260}.Release|Any CPU.ActiveCfg = Release|Any CPU + {46780AD4-62F3-4AB4-9B3C-6A8AB305C260}.Release|Any CPU.Build.0 = Release|Any CPU + {8585C44C-5093-4A32-AABA-9EC7B8A6118C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {8585C44C-5093-4A32-AABA-9EC7B8A6118C}.Debug|Any CPU.Build.0 = Debug|Any CPU + {8585C44C-5093-4A32-AABA-9EC7B8A6118C}.Release|Any CPU.ActiveCfg = Release|Any CPU + {8585C44C-5093-4A32-AABA-9EC7B8A6118C}.Release|Any CPU.Build.0 = Release|Any CPU + {EFC27293-4DBB-4D58-85E4-4B94A8F50C8B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {EFC27293-4DBB-4D58-85E4-4B94A8F50C8B}.Debug|Any CPU.Build.0 = Debug|Any CPU + {EFC27293-4DBB-4D58-85E4-4B94A8F50C8B}.Release|Any CPU.ActiveCfg = Release|Any CPU + {EFC27293-4DBB-4D58-85E4-4B94A8F50C8B}.Release|Any CPU.Build.0 = Release|Any CPU + {930BA3F9-160A-4EB6-80DC-AABFDE3BB919}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {930BA3F9-160A-4EB6-80DC-AABFDE3BB919}.Debug|Any CPU.Build.0 = Debug|Any CPU + {930BA3F9-160A-4EB6-80DC-AABFDE3BB919}.Release|Any CPU.ActiveCfg = Release|Any CPU + {930BA3F9-160A-4EB6-80DC-AABFDE3BB919}.Release|Any CPU.Build.0 = Release|Any CPU + {64F80A63-FF29-4B66-89EB-3F94A0F33E3B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {64F80A63-FF29-4B66-89EB-3F94A0F33E3B}.Debug|Any CPU.Build.0 = Debug|Any CPU + {64F80A63-FF29-4B66-89EB-3F94A0F33E3B}.Release|Any CPU.ActiveCfg = Release|Any CPU + {64F80A63-FF29-4B66-89EB-3F94A0F33E3B}.Release|Any CPU.Build.0 = Release|Any CPU + {AAAC063A-C133-47AF-885D-8F6EBA608EC8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {AAAC063A-C133-47AF-885D-8F6EBA608EC8}.Debug|Any CPU.Build.0 = Debug|Any CPU + {AAAC063A-C133-47AF-885D-8F6EBA608EC8}.Release|Any CPU.ActiveCfg = Release|Any CPU + {AAAC063A-C133-47AF-885D-8F6EBA608EC8}.Release|Any CPU.Build.0 = Release|Any CPU + {B887FEC4-2151-6199-35E5-688C1052BC06}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {B887FEC4-2151-6199-35E5-688C1052BC06}.Debug|Any CPU.Build.0 = Debug|Any CPU + {B887FEC4-2151-6199-35E5-688C1052BC06}.Release|Any CPU.ActiveCfg = Release|Any CPU + {B887FEC4-2151-6199-35E5-688C1052BC06}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(NestedProjects) = preSolution + {58F20140-729B-41E0-91F0-7004C4E0CB1E} = {B02251C3-B01E-40EB-B145-2B03F25FE653} + {6679B13D-BA2B-43C8-A548-6C6D22E19BE1} = {9EBF2BF0-C968-4029-B21D-214D195EA148} + {D72C8232-24ED-4EDD-ABDB-16194681D9F2} = {FE323E78-E865-46E2-859A-E4F6FB312C0F} + {F4AF2603-C020-4A57-A428-AF3EFED21544} = {76F6CBAF-FE81-4B56-B0DB-DE6FD7174771} + {087ADE61-3D39-4884-8258-40D7A7DD833F} = {FE323E78-E865-46E2-859A-E4F6FB312C0F} + {166B8503-54F0-452F-88C5-1430BF05A604} = {FE323E78-E865-46E2-859A-E4F6FB312C0F} + {F7B0F06D-56CE-4F4A-8EF9-ED6EC3D77EE7} = {76F6CBAF-FE81-4B56-B0DB-DE6FD7174771} + {A2E4B91C-3B7F-4CB1-B482-BE40F7709EB5} = {FE323E78-E865-46E2-859A-E4F6FB312C0F} + {29A1AE2B-D47D-41DD-9824-279475D9B6C2} = {B02251C3-B01E-40EB-B145-2B03F25FE653} + {0DE47D02-2BBE-4352-9E38-79A374F9C41E} = {76F6CBAF-FE81-4B56-B0DB-DE6FD7174771} + {34D7A843-55CB-4A3A-B268-2D4ABB7044D3} = {B02251C3-B01E-40EB-B145-2B03F25FE653} + {4CD48B4A-6297-49FC-90AC-5DF9213C1527} = {61643BA1-BE82-4430-A3D3-CB7A16E747E3} + {695560CE-C6C3-4FCD-A488-09F06E608297} = {61643BA1-BE82-4430-A3D3-CB7A16E747E3} + {F3AF01F6-24E8-4129-80B6-84AC070B5C7D} = {61643BA1-BE82-4430-A3D3-CB7A16E747E3} + {61026689-70A0-403E-B616-DFAEEF259444} = {38A0A11F-72BD-4512-A4A9-AC953936C09F} + {DA24CBE9-E85F-4F0D-88D0-0EE5681B91D4} = {90126655-7A34-4F5B-A41A-50A468F4632D} + {58E2E0C3-059A-4B00-BCC1-66FE78946A9E} = {90126655-7A34-4F5B-A41A-50A468F4632D} + {8C2280F2-1E08-4022-B26B-59622DD8B126} = {90126655-7A34-4F5B-A41A-50A468F4632D} + {9F596D8D-5CDB-4830-B73C-26C33C0227D7} = {90126655-7A34-4F5B-A41A-50A468F4632D} + {A4127F6F-A282-47F3-BAFE-6A154F994B4E} = {C6CAFEE8-7779-4F48-BEA1-D59D3CD91A56} + {E84C0368-0D02-4284-A3CB-110B14FA8314} = {8F8DCFBC-A0DC-4E40-93C8-B4FB99FBD757} + {3F3A6387-DD5F-40A6-89D1-92653E4872D3} = {8F8DCFBC-A0DC-4E40-93C8-B4FB99FBD757} + {3F25D072-7A7E-419D-8425-6F2C7CF42BFD} = {8F8DCFBC-A0DC-4E40-93C8-B4FB99FBD757} + {A7D359D9-654A-4FAF-9BC2-DA9667EF8756} = {8F8DCFBC-A0DC-4E40-93C8-B4FB99FBD757} + {A8392FEA-CC1F-4630-85A0-E6BA97AD87D7} = {83EF0BE8-E57C-499D-ABC8-019A7F68F407} + {69FC508E-6FE7-4C01-942F-F3BF0F3C68E3} = {83EF0BE8-E57C-499D-ABC8-019A7F68F407} + {DB318A8A-4E80-4D70-A53C-1E69310C5E49} = {8F8DCFBC-A0DC-4E40-93C8-B4FB99FBD757} + {83AC12EE-E6B5-45FA-AADF-68AB652CC804} = {013E98B4-42CE-4009-BC62-2588ED9028CD} + {46780AD4-62F3-4AB4-9B3C-6A8AB305C260} = {013E98B4-42CE-4009-BC62-2588ED9028CD} + {8585C44C-5093-4A32-AABA-9EC7B8A6118C} = {013E98B4-42CE-4009-BC62-2588ED9028CD} + {EFC27293-4DBB-4D58-85E4-4B94A8F50C8B} = {013E98B4-42CE-4009-BC62-2588ED9028CD} + {930BA3F9-160A-4EB6-80DC-AABFDE3BB919} = {013E98B4-42CE-4009-BC62-2588ED9028CD} + {64F80A63-FF29-4B66-89EB-3F94A0F33E3B} = {38A0A11F-72BD-4512-A4A9-AC953936C09F} + {AAAC063A-C133-47AF-885D-8F6EBA608EC8} = {013E98B4-42CE-4009-BC62-2588ED9028CD} + {B887FEC4-2151-6199-35E5-688C1052BC06} = {9EBF2BF0-C968-4029-B21D-214D195EA148} + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {21F77282-91E7-4304-B1EF-FADFA4F39E37} + EndGlobalSection +EndGlobal diff --git a/src/Bicep.Testing/TestConfigurations.cs b/src/Bicep.Testing/TestConfigurations.cs index b936fc70290..4e04eacf05c 100644 --- a/src/Bicep.Testing/TestConfigurations.cs +++ b/src/Bicep.Testing/TestConfigurations.cs @@ -21,6 +21,11 @@ public static class TestConfigurations .WithAnalyzersDisabled( UseRecentApiVersionRule.Code, UseRecentModuleVersionsRule.Code, - NoHardcodedOutputsRule.Code) + NoHardcodedOutputsRule.Code, + UseDescriptionParametersRule.Code, + UseDescriptionVarsRule.Code, + UseDescriptionOutputRule.Code, + UseDescriptionTypeRule.Code, + UseDescriptionTypePropertyRule.Code) .Build(); } From 86d52220f700ec39a2af1d022243e616556bfff3 Mon Sep 17 00:00:00 2001 From: John Date: Fri, 7 Aug 2026 19:28:56 +0200 Subject: [PATCH 10/11] Fixed failing test --- .../LinterRuleTests/WhatIfShortCircuitingRuleTests.cs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/WhatIfShortCircuitingRuleTests.cs b/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/WhatIfShortCircuitingRuleTests.cs index 191aef21440..013d9259eb3 100644 --- a/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/WhatIfShortCircuitingRuleTests.cs +++ b/src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/WhatIfShortCircuitingRuleTests.cs @@ -76,6 +76,7 @@ public void WhatIfShortCircuiting_NoDiagnostics() [ ("createSA.bicep", SAModuleContent), ("main.bicep", """ + @description('Parameter description.') param input string module creatingSA 'createSA.bicep' = { params: { From 0c9d61bef843398951be93294c2dc741a79c1f3b Mon Sep 17 00:00:00 2001 From: John Date: Mon, 10 Aug 2026 20:30:11 +0200 Subject: [PATCH 11/11] Renamed linter rules for parity --- .../Linter/Rules/UseDescriptionOutputRule.cs | 2 +- .../Linter/Rules/UseDescriptionParametersRule.cs | 2 +- .../Rules/UseDescriptionTypePropertyRule.cs | 2 +- .../Linter/Rules/UseDescriptionTypeRule.cs | 2 +- src/vscode-bicep/schemas/bicepconfig.schema.json | 16 ++++++++-------- 5 files changed, 12 insertions(+), 12 deletions(-) diff --git a/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionOutputRule.cs b/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionOutputRule.cs index f608a6f8457..90d983459d6 100644 --- a/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionOutputRule.cs +++ b/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionOutputRule.cs @@ -7,7 +7,7 @@ namespace Bicep.Core.Analyzers.Linter.Rules; public sealed class UseDescriptionOutputRule : UseDescriptionRuleBase { - public new const string Code = "use-description-output"; + public new const string Code = "use-description-outputs"; public UseDescriptionOutputRule() : base( code: Code, diff --git a/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionParametersRule.cs b/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionParametersRule.cs index 3305e22d1d0..fd493808e42 100644 --- a/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionParametersRule.cs +++ b/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionParametersRule.cs @@ -7,7 +7,7 @@ namespace Bicep.Core.Analyzers.Linter.Rules; public sealed class UseDescriptionParametersRule : UseDescriptionRuleBase { - public new const string Code = "use-description-parameters"; + public new const string Code = "use-description-params"; public UseDescriptionParametersRule() : base( code: Code, diff --git a/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionTypePropertyRule.cs b/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionTypePropertyRule.cs index 4b5a61b5a79..783ccdf81e6 100644 --- a/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionTypePropertyRule.cs +++ b/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionTypePropertyRule.cs @@ -9,7 +9,7 @@ namespace Bicep.Core.Analyzers.Linter.Rules; public sealed class UseDescriptionTypePropertyRule : UseDescriptionRuleBase { - public new const string Code = "use-description-type-property"; + public new const string Code = "use-description-type-properties"; private const string AdditionalPropertiesName = "*"; diff --git a/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionTypeRule.cs b/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionTypeRule.cs index 55a115590db..c81f7b0d745 100644 --- a/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionTypeRule.cs +++ b/src/Bicep.Core/Analyzers/Linter/Rules/UseDescriptionTypeRule.cs @@ -8,7 +8,7 @@ namespace Bicep.Core.Analyzers.Linter.Rules; public sealed class UseDescriptionTypeRule : UseDescriptionRuleBase { - public new const string Code = "use-description-type"; + public new const string Code = "use-description-types"; public UseDescriptionTypeRule() : base( code: Code, diff --git a/src/vscode-bicep/schemas/bicepconfig.schema.json b/src/vscode-bicep/schemas/bicepconfig.schema.json index 2a24fe0a8b3..dc4e6c9c24f 100644 --- a/src/vscode-bicep/schemas/bicepconfig.schema.json +++ b/src/vscode-bicep/schemas/bicepconfig.schema.json @@ -765,40 +765,40 @@ } ] }, - "use-description-output": { + "use-description-outputs": { "allOf": [ { - "description": "Outputs should have non-empty descriptions. Defaults to 'Off'. See https://aka.ms/bicep/linter-diagnostics#use-description-output" + "description": "Outputs should have non-empty descriptions. Defaults to 'Off'. See https://aka.ms/bicep/linter-diagnostics#use-description-outputs" }, { "$ref": "#/definitions/rule-def-level-off" } ] }, - "use-description-parameters": { + "use-description-params": { "allOf": [ { - "description": "Parameters should have non-empty descriptions. Defaults to 'Off'. See https://aka.ms/bicep/linter-diagnostics#use-description-parameters" + "description": "Parameters should have non-empty descriptions. Defaults to 'Off'. See https://aka.ms/bicep/linter-diagnostics#use-description-params" }, { "$ref": "#/definitions/rule-def-level-off" } ] }, - "use-description-type": { + "use-description-type-properties": { "allOf": [ { - "description": "User-defined types should have non-empty descriptions. Defaults to 'Off'. See https://aka.ms/bicep/linter-diagnostics#use-description-type" + "description": "Properties of user-defined types should have non-empty descriptions. Defaults to 'Off'. See https://aka.ms/bicep/linter-diagnostics#use-description-type-properties" }, { "$ref": "#/definitions/rule-def-level-off" } ] }, - "use-description-type-property": { + "use-description-types": { "allOf": [ { - "description": "Properties of user-defined types should have non-empty descriptions. Defaults to 'Off'. See https://aka.ms/bicep/linter-diagnostics#use-description-type-property" + "description": "User-defined types should have non-empty descriptions. Defaults to 'Off'. See https://aka.ms/bicep/linter-diagnostics#use-description-types" }, { "$ref": "#/definitions/rule-def-level-off"