Add support for version in bicepconfig.json

Author: anthony-c-martin

src/Bicep.Cli/Commands/RootCommand.cs

@@ -4,6 +4,8 @@
 using System.IO.Compression;
 using Bicep.Cli.Arguments;
 using Bicep.Core.Exceptions;
+using Bicep.Core.Utils;
+using Environment = System.Environment;
 
 namespace Bicep.Cli.Commands
 {
@@ -265,10 +267,11 @@ private void PrintThirdPartyNotices()
 
         private static string GetVersionString()
         {
-            var versionSplit = ThisAssembly.AssemblyInformationalVersion.Split('+');
+            var version = BicepVersion.Instance.Value;
+            var commitHash = BicepVersion.Instance.CommitHash;
 
             // <major>.<minor>.<patch> (<commmithash>)
-            return $"{versionSplit[0]} ({(versionSplit.Length > 1 ? versionSplit[1] : "custom")})";
+            return $"{version} ({(commitHash is {} ? commitHash : "custom")})";
         }
 
         private static void WriteEmbeddedResource(TextWriter writer, string streamName)

src/Bicep.Cli/Rpc/CliJsonRpcServer.cs

@@ -13,6 +13,7 @@
 using Bicep.Core.Syntax;
 using Bicep.Core.Text;
 using Bicep.Core.TypeSystem;
+using Bicep.Core.Utils;
 using Bicep.Core.Workspaces;
 using Newtonsoft.Json.Serialization;
 using StreamJsonRpc;
@@ -42,7 +43,7 @@ public async Task<VersionResponse> Version(VersionRequest request, CancellationT
         await Task.Yield();
 
         return new(
-            ThisAssembly.AssemblyInformationalVersion.Split('+')[0]);
+            BicepVersion.Instance.Value);
     }
 
     /// <inheritdoc/>

src/Bicep.Core.IntegrationTests/BicepConfigTests.cs

@@ -0,0 +1,53 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using Bicep.Core.Diagnostics;
+using Bicep.Core.UnitTests.Assertions;
+using Bicep.Core.UnitTests.FileSystem;
+using Bicep.Core.UnitTests.Utils;
+using Bicep.Core.Utils;
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Bicep.Core.IntegrationTests;
+
+[TestClass]
+public class BicepConfigTests
+{
+    [TestMethod]
+    public async Task Version_mismatch_should_block_compilation()
+    {
+        var result = await CompilationHelper.RestoreAndCompile(
+          ("main.bicep", new("""
+output foo string = ''
+""")), ("../bicepconfig.json", new("""
+{
+  "bicep": {
+    "version": "0.0.1"
+  }
+}
+""")));
+
+        var configPath = InMemoryFileResolver.GetFileUri("/path/bicepconfig.json");
+        result.ExcludingLinterDiagnostics().Should().HaveDiagnostics([
+            ("BCP409", DiagnosticLevel.Error, $"""Bicep version "{BicepVersion.Instance.Value}" was used for compilation, but version "0.0.1" is required in configuration file "{configPath.LocalPath}"."""),
+        ]);
+    }
+
+    [TestMethod]
+    public async Task Correct_version_should_permit_compilation()
+    {
+        var result = await CompilationHelper.RestoreAndCompile(
+          ("main.bicep", new("""
+output foo string= ''
+""")), ("../bicepconfig.json", new($$"""
+{
+  "bicep": {
+    "version": "{{BicepVersion.Instance.Value}}"
+  }
+}
+""")));
+
+        result.Should().NotHaveAnyDiagnostics();
+    }
+}

src/Bicep.Core.UnitTests/BicepTestConstants.cs

@@ -103,6 +103,7 @@ public static RootConfiguration CreateMockConfiguration(Dictionary<string, objec
                 ["analyzers"] = new Dictionary<string, object>(),
                 ["experimentalFeaturesEnabled"] = new Dictionary<string, bool>(),
                 ["formatting"] = new Dictionary<string, bool>(),
+                ["bicep"] = new Dictionary<string, bool>(),
             };
 
             if (customConfigurationData is not null)

src/Bicep.Core.UnitTests/Configuration/ConfigurationManagerTests.cs

@@ -117,7 +117,8 @@ public void GetBuiltInConfiguration_NoParameter_ReturnsBuiltInConfigurationWithA
           "insertFinalNewline": true,
           "indentSize": 2,
           "width": 120
-        }
+        },
+        "bicep": {}
       }
       """);
         }
@@ -198,7 +199,8 @@ public void GetBuiltInConfiguration_DisableAllAnalyzers_ReturnsBuiltInConfigurat
           "insertFinalNewline": true,
           "indentSize": 2,
           "width": 120
-        }
+        },
+        "bicep": {}
       }
       """);
         }
@@ -304,7 +306,8 @@ public void GetBuiltInConfiguration_DisableAnalyzers_ReturnsBuiltInConfiguration
           "insertFinalNewline": true,
           "indentSize": 2,
           "width": 120
-        }
+        },
+        "bicep": {}
       }
       """);
         }
@@ -481,7 +484,8 @@ public void GetBuiltInConfiguration_EnableExperimentalFeature_ReturnsBuiltInConf
                 "insertFinalNewline": true,
                 "indentSize": 2,
                 "width": 120
-            }
+            },
+            "bicep": {}
             }
             """);
         }
@@ -729,6 +733,9 @@ public void GetConfiguration_ValidCustomConfiguration_OverridesBuiltInConfigurat
         "insertFinalNewline": true,
         "indentSize": 2,
         "width": 80
+        },
+        "bicep": {
+          "version": "1.2.3"
         }
     }
     """
@@ -846,6 +853,9 @@ public void GetConfiguration_ValidCustomConfiguration_OverridesBuiltInConfigurat
           "insertFinalNewline": true,
           "indentSize": 2,
           "width": 80
+        },
+        "bicep": {
+          "version": "1.2.3"
         }
       }
       """);

src/Bicep.Core.UnitTests/Configuration/RootConfigurationTests.cs

@@ -23,6 +23,7 @@ public void RootConfiguration_LeadingTildeInCacheRootDirectory_ExpandPath(string
                 cacheRootDirectory,
                 BicepTestConstants.BuiltInConfiguration.ExperimentalFeaturesEnabled,
                 BicepTestConstants.BuiltInConfiguration.Formatting,
+                BicepTestConstants.BuiltInConfiguration.Bicep,
                 BicepTestConstants.BuiltInConfiguration.ConfigFileUri,
                 BicepTestConstants.BuiltInConfiguration.DiagnosticBuilders);
 

src/Bicep.Core.UnitTests/Diagnostics/LinterRuleTests/UseRecentApiVersionRuleTests.cs

@@ -130,6 +130,7 @@ original.ExperimentalFeaturesEnabled with
                     Extensibility = true,
                 },
                 original.Formatting,
+                original.Bicep,
                 null,
                 null);
         }

src/Bicep.Core.UnitTests/Utils/BicepVersionTests.cs

@@ -0,0 +1,22 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+using Bicep.Core.Utils;
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Bicep.Core.UnitTests.Utils;
+
+[TestClass]
+public class BicepVersionTests
+{
+    [TestMethod]
+    public void BicepVersion_should_return_assembly_info()
+    {
+        var result = BicepVersion.Instance;
+        result.Value.Should().MatchRegex(@"^[0-9]+\.[0-9]+\.[0-9]+");
+        if (result.CommitHash is {})
+        {
+            result.CommitHash.Should().MatchRegex(@"^[0-9a-f]{7,40}$");
+        }
+    }
+}

src/Bicep.Core/Configuration/AnalyzersConfigurationExtensions.cs

@@ -46,6 +46,7 @@ public static RootConfiguration WithAnalyzersConfiguration(this RootConfiguratio
                 current.CacheRootDirectory,
                 current.ExperimentalFeaturesEnabled,
                 current.Formatting,
+                current.Bicep,
                 current.ConfigFileUri,
                 current.DiagnosticBuilders);
 

src/Bicep.Core/Configuration/BicepConfigurationSection.cs

@@ -0,0 +1,21 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System.Text.Json;
+using Bicep.Core.Extensions;
+
+namespace Bicep.Core.Configuration;
+
+public record BicepConfiguration(
+    string? Version);
+
+public class BicepConfigurationSection : ConfigurationSection<BicepConfiguration>
+{
+    public BicepConfigurationSection(BicepConfiguration data)
+        : base(data)
+    {
+    }
+
+    public static BicepConfigurationSection Bind(JsonElement element)
+        => new(element.ToNonNullObject<BicepConfiguration>());
+}

src/Bicep.Core/Configuration/ConfigurationManager.cs

@@ -102,6 +102,7 @@ private static RootConfiguration WithLoadDiagnostics(RootConfiguration configura
                     configuration.CacheRootDirectory,
                     configuration.ExperimentalFeaturesEnabled,
                     configuration.Formatting,
+                    configuration.Bicep,
                     configuration.ConfigFileUri,
                     diagnostics);
             }

src/Bicep.Core/Configuration/ExperimentalFeaturesExtensions.cs

@@ -15,6 +15,7 @@ public static RootConfiguration WithExperimentalFeaturesConfiguration(this RootC
                 current.CacheRootDirectory,
                 featuresEnabled,
                 current.Formatting,
+                current.Bicep,
                 current.ConfigFileUri,
                 current.DiagnosticBuilders);
 

src/Bicep.Core/Configuration/ExtensionsConfigurationExtensions.cs

@@ -24,6 +24,7 @@ public static RootConfiguration WithExtensions(this RootConfiguration rootConfig
             rootConfiguration.CacheRootDirectory,
             rootConfiguration.ExperimentalFeaturesEnabled,
             rootConfiguration.Formatting,
+            rootConfiguration.Bicep,
             rootConfiguration.ConfigFileUri,
             rootConfiguration.DiagnosticBuilders);
     }
@@ -39,6 +40,7 @@ public static RootConfiguration WithImplicitExtensions(this RootConfiguration ro
             rootConfiguration.CacheRootDirectory,
             rootConfiguration.ExperimentalFeaturesEnabled,
             rootConfiguration.Formatting,
+            rootConfiguration.Bicep,
             rootConfiguration.ConfigFileUri,
             rootConfiguration.DiagnosticBuilders);
     }

src/Bicep.Core/Configuration/RootConfiguration.cs

@@ -28,6 +28,8 @@ public class RootConfiguration
 
         public const string FormattingKey = "formatting";
 
+        public const string BicepKey = "bicep";
+
         public RootConfiguration(
             CloudConfiguration cloud,
             ModuleAliasesConfiguration moduleAliases,
@@ -37,6 +39,7 @@ public RootConfiguration(
             string? cacheRootDirectory,
             ExperimentalFeaturesEnabled experimentalFeaturesEnabled,
             FormattingConfiguration formatting,
+            BicepConfigurationSection bicep,
             Uri? configFileUri,
             IEnumerable<DiagnosticBuilder.DiagnosticBuilderDelegate>? diagnosticBuilders)
         {
@@ -48,6 +51,7 @@ public RootConfiguration(
             this.CacheRootDirectory = ExpandCacheRootDirectory(cacheRootDirectory);
             this.ExperimentalFeaturesEnabled = experimentalFeaturesEnabled;
             this.Formatting = formatting;
+            this.Bicep = bicep;
             this.ConfigFileUri = configFileUri;
             this.DiagnosticBuilders = diagnosticBuilders?.ToImmutableArray() ?? [];
         }
@@ -60,11 +64,12 @@ public static RootConfiguration Bind(JsonElement element, Uri? configFileUri = n
             var cacheRootDirectory = element.TryGetProperty(CacheRootDirectoryKey, out var e) ? e.GetString() : default;
             var experimentalFeaturesEnabled = ExperimentalFeaturesEnabled.Bind(element.GetProperty(ExperimentalFeaturesEnabledKey));
             var formatting = FormattingConfiguration.Bind(element.GetProperty(FormattingKey));
+            var bicep = BicepConfigurationSection.Bind(element.GetProperty(BicepKey));
 
             var extensions = ExtensionsConfiguration.Bind(element.GetProperty(ExtensionsKey));
             var implicitExtensions = ImplicitExtensionsConfiguration.Bind(element.GetProperty(ImplicitExtensionsKey));
 
-            return new(cloud, moduleAliases, extensions, implicitExtensions, analyzers, cacheRootDirectory, experimentalFeaturesEnabled, formatting, configFileUri, diagnosticBuilders);
+            return new(cloud, moduleAliases, extensions, implicitExtensions, analyzers, cacheRootDirectory, experimentalFeaturesEnabled, formatting, bicep, configFileUri, diagnosticBuilders);
         }
 
         public CloudConfiguration Cloud { get; }
@@ -83,6 +88,8 @@ public static RootConfiguration Bind(JsonElement element, Uri? configFileUri = n
 
         public FormattingConfiguration Formatting { get; }
 
+        public BicepConfigurationSection Bicep { get; }
+
         public Uri? ConfigFileUri { get; }
 
         public ImmutableArray<DiagnosticBuilder.DiagnosticBuilderDelegate> DiagnosticBuilders { get; }
@@ -122,6 +129,9 @@ public string ToUtf8Json()
                 writer.WritePropertyName(FormattingKey);
                 this.Formatting.WriteTo(writer);
 
+                writer.WritePropertyName(BicepKey);
+                this.Bicep.WriteTo(writer);
+
                 writer.WriteEndObject();
             }
 

src/Bicep.Core/Configuration/bicepconfig.json

@@ -65,5 +65,6 @@
     }
   },
   "experimentalFeaturesEnabled": {},
-  "formatting": {}
+  "formatting": {},
+  "bicep": {}
 }

src/Bicep.Core/Diagnostics/DiagnosticBuilder.cs

@@ -1820,6 +1820,13 @@ public Diagnostic MicrosoftGraphBuiltinDeprecatedSoon(ExtensionDeclarationSyntax
             public Diagnostic NameofInvalidOnUnnamedExpression() => CoreError(
                 "BCP408",
                 $"The \"{LanguageConstants.NameofFunctionName}\" function can only be used with an expression which has a name.");
+
+            public Diagnostic InvalidBicepVersion(string? configFilePath, string expectedVersion, string actualVersion) => CoreError(
+                "BCP409",
+                configFilePath switch {
+                    {} => $"""Bicep version "{actualVersion}" was used for compilation, but version "{expectedVersion}" is required in configuration file "{configFilePath}".""",
+                    _ => $"""Bicep version "{actualVersion}" was used for compilation, but version "{expectedVersion}" is required.""",
+                });
         }
 
         public static DiagnosticBuilderInternal ForPosition(TextSpan span)

src/Bicep.Core/Emit/EmitLimitationCalculator.cs

@@ -37,7 +37,8 @@ public static EmitLimitationInfo Calculate(SemanticModel model)
             ForSyntaxValidatorVisitor.Validate(model, diagnostics);
             FunctionPlacementValidatorVisitor.Validate(model, diagnostics);
             IntegerValidatorVisitor.Validate(model, diagnostics);
-
+            
+            BlockIncorrectBicepVersion(model, diagnostics);
             DetectDuplicateNames(model, diagnostics, resourceScopeData, moduleScopeData);
             DetectIncorrectlyFormattedNames(model, diagnostics);
             DetectUnexpectedResourceLoopInvariantProperties(model, diagnostics);
@@ -61,6 +62,16 @@ public static EmitLimitationInfo Calculate(SemanticModel model)
             return new(diagnostics.GetDiagnostics(), moduleScopeData, resourceScopeData, paramAssignments);
         }
 
+        private static void BlockIncorrectBicepVersion(SemanticModel model, IDiagnosticWriter diagnostics)
+        {
+            var actualVersion = ThisAssembly.AssemblyInformationalVersion.Split('+')[0];
+            if (model.Configuration.Bicep.Data.Version is {} expectedVersion &&
+                expectedVersion != actualVersion)
+            {
+                diagnostics.Write(TextSpan.TextDocumentStart, x => x.InvalidBicepVersion(model.Configuration.ConfigFileUri?.LocalPath, expectedVersion, actualVersion));
+            }
+        }
+
         private static void DetectDuplicateNames(SemanticModel semanticModel, IDiagnosticWriter diagnosticWriter, ImmutableDictionary<DeclaredResourceMetadata, ScopeHelper.ScopeData> resourceScopeData, ImmutableDictionary<ModuleSymbol, ScopeHelper.ScopeData> moduleScopeData)
         {
             // TODO generalize or move into Az extension

src/Bicep.Core/Utils/BicepVersion.cs

@@ -0,0 +1,19 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+namespace Bicep.Core.Utils;
+
+public record BicepVersion(
+    string Value,
+    string? CommitHash)
+{
+    public static readonly BicepVersion Instance = GetVersion();
+
+    private static BicepVersion GetVersion()
+    {
+        var split = ThisAssembly.AssemblyInformationalVersion.Split('+');
+        
+        return new(
+            split[0],
+            split.Length > 1 ? split[1] : null);
+    }
+}

src/Bicep.Core/Utils/Environment.cs

@@ -9,4 +9,4 @@ public class Environment : IEnvironment
 
     public IEnumerable<string> GetVariableNames()
         => System.Environment.GetEnvironmentVariables().Keys.OfType<string>();
-}
+}